【Python考试资源】包含重点知识、坑点知识，期末考试看这一份就够了

C:\learn> python hello.py

print('hello,world')
print('The quick brown fox', 'jumps over', 'the lazy dog')

#注意，是字符串输入
name = input()
#可以是有提示的输入
name = input('please enter your name: ')
print('hello,', name)
#输入两个整数
a,b=map(int,input().split())
#输入两个字符串
a,b=input().split()

print('\\\t\\')
print(r'\\\t\\')
print('''line1
line2
line3''')

>>> len('中文')
2
>>> len('中文'.encode('utf-8'))
6
>>> len('ABC')
3
>>> len(b'ABC')
3
#大小写转换
w = "100hello WORLD"
w.upper()
Out[72]: '100HELLO WORLD'
w.lower()
Out[73]: '100hello world'
w.title()
Out[74]: '100Hello World'
w.capitalize()
Out[75]: '100hello world'

>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
#上面的实际是创建了一个新的对象
>>> a
'abc'

#此处为取出[ ]之间的字符串   
m=re.findall(r"\[(.+?)\]",L)

print('%s has %d dollars'%('Tom',100))
print('%s'%(3))#这里的3有没有'都是可以的，因为s是可以自动转化整数为字符串
#指定输出几位以及输出的几位前面需不需要补上0
print('%2d-%02d' % (3, 1))
#输出的小数点数量
print('%.2f' % 3.1415926)
#输出带%的时候
print('%d %%' % (7))

#format()
>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
'Hello, 小明, 成绩提升了 17.1%'
#f-string
>>> r = 2.5
>>> s = 3.14 * r ** 2
>>> print(f'The area of a circle with radius {r} is {s:.2f}')
The area of a circle with radius 2.5 is 19.62

s = ['python', 'java', ['asp', 'php'], 'scheme']
#即为
p = ['asp', 'php']
s = ['python', 'java', p, 'scheme']

l1=[]
i=0
while i<5:
    l1.append([])
    i+=1
l1.append('你好')

L=[3,4,1,3,4,5,1]
#在列表中随机抽取一个对象
random.choice(L)
#列表打乱
random.shuffle(L)

#没有元素时
t = ()
#1个元素
t = (1,)
#2个元素时候
t = (1, 2)

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

>>> s = set([1, 1, 2, 2, 3, 3])
>>> s      
{1, 2, 3}       #print的结果也是{}

d={'Anne':96,'Bob':84,'Candy':87}
print(d['Anne'])

age = 20
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')
if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

if x:
    print('True')

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

#range(n)是自动生成0~n的整数序列
#range(101)是从0到100，总共101个数字
sum = 0
for x in range(101):
    sum = sum + x
print(sum)
#配合list使用
ls1=[i for i in range(1,101)]
print(sum(ls1))
#输出0~100的整数
print(list(range(101)))

sum=0
n=100
while n>0:
    sum+=n
    n-=1
print(sum)

>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False

#list-->str
s = ''.join(l)
#list-->dict
l1 = ['a', 'b', 'c']
l2 = [1, 2, 3]
dict(zip(l1,l2))
#str-->list
l=s.split(',')适合都是逗号或者空格的
或者
l=list(s)
#str-->dict
s = '{"id": 1, "name": "li"}'  
d = eval(s)
#dict-->list
d = {'a': 1, 'b': 2, 'c': 3}
list(d)
## ['a', 'b', 'c']
list(d.keys())
## ['a', 'b', 'c']
list(d.values())
## [1, 2, 3]
#dict-->str
str(d)

l1 = ['a', 'b', 'a']
l2 = [1, 2, 3]
dict(zip(l1,l2))
## {'a': 3, 'b': 2}
dict(zip(l2,l1))
## {1: 'a', 2: 'b', 3: 'a'}

#str类型头尾去掉符号
str2.strip( ',' )

>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
#使用三元表达式
def my_abs(x):
    return x if x>=0 eles -x

def nop():
    pass
if age >= 18:
    pass

def hello(x,y):
    return x,y
print(hello(1,2))
#结果为(1,2)
a,b=hello(1,2)
#获取返回值

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

power(6,n=8)

def add(L=[])
    L.append('END')
    return L
#对象不是L的情况
>>>add([1,2,4])
[1,2,4,'END']
>>>add([2,2,2])
[2,2,2,'END']
#对象是L的情况
>>>add()
['END']
>>>add()
['END','END']

def add(L=None)
    if L is None:
        L=[]
    L.append('END')
    return L

比如要用 a^2+b^2+c^2+...
def add(*numbers):
    sum=0
    for n in numbers:
        sum+=n*n
    return sum
#不变参数的list和tuple也可以变成可变参数，只要在其前面加上*
num=[1,2,3,4]
add[*num]

#name和sex是必选项，00是可选项，也可以进行扩充
#一般用与可选项与必选项
def person(name,sex,**oo):
    print('name:',name,'sex:',sex,'other',oo)
person('a','b',city='北京',age='7')
>>> name: a sex: b other {'city': '北京', 'age': '7'}
#另外一种表现形式，就是将**oo单独拉出来
ok={'city:':'Beijing','age:':'7'}
person('a','b',city=ok['city'],age=ok['age'])

//只接收city和job作为关键字参数。
def person(name, age, *, city, job):
    print(name, age, city, job)
person('Jack', 24, city='Beijing', job='Engineer')

n!
def fact(n):
    if n==1:
        return 1
    else:
        return n*fact(n-1)

#汉诺塔问题
def move(n,a,b,c):
    if n==1:
        print(a,'-->',c)
    else:
        move(n-1,a,c,b)#将A上面的n-1个移动到b
        move(1,a,b,c)#将A底层的1个移动到c
        move(n-1,b,a,c)#将b上面的n-1个移动到c

#切片实现去除字符串首尾的空格
def trim(s):
    l=len(s)
    if s==l*(' '):
        return ''
    else:
        while s[0]==' ':
            s=s[1:]
        while s[-1]==' ':
            s=s[:-1]
        return 
#list表达式
#100以内数字，奇数为负数，偶数为0
[-x if x%2==1  else 0 for x in range(1,11)]
#generator函数实现斐波那契数列
def fib(max):
    n,a,b=0,0,1
    while n<max:
        yield b
        a,b=b,b+a
        n+=1
    return 'done'
print([x for x in fib(6)])
#注意，如果直接输出fib(5)的话会返回一个generator对象
#实际上，每次执行时遇到yield停止，然后下一次的执行送yield的下面开始的
#有yield的标志都是generator函数
#杨辉三角
def triangles():
    l=[1]
    while(True):
        yield l
        x=[0]+l
        y=l+[0]
        l=[x[i]+y[i] for i in range(len(x))]
n = 0
results = []
for t in triangles():
    results.append(t)
    n = n + 1
    if n == 10:
        break
for t in results:
    print(t)

def f(x):
    return x*x
r=map(f,[1,2,3,4,5])
l=list(r)  #list()函数让Iterator对象变成list
print(l)
#也可以实现与list列表生成器的功能
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

#将数字字符串转化为数字
from functools import reduce
d = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def strtoint(s):
    def fn(x,y):
        return x*10+y
    def charmnum(s):
        return d[s]
    return reduce(fn,map(charmnum,s))#首先将s遍历使用charmnum变成数字list，随后递归相加
print(strtoint('123412'))

#正常排序
sorted(L)
#倒序
sorted(L,reverse=True)
#按照特定内容排序，特定内容可理解为函数，然后对数值有一个返回
#如按照绝对值排序
sorted(L,key=abs)
#按照分数排序
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_score(t):
    return t[1]
L2 = sorted(L, key=by_score)
print(L2)

L=[1,5,4,54,5]
#sort必须要单独的一行进行排序，print(L.sort())的输出是None
L.sort()
print(L)
print(sorted(L))

list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

f = lambda x: x * x

#这里的Object指的是父类对象，如果没有继承的话还是要写Object的
class Student(object):
#注意，这里的__init__是初始化方法，第一个永远是self，实例化的时候不需要写上self
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def print_score(self):
        print('%s: %s' % (self.name, self.score))
bart = Student('Bart Simpson', 59)

class Student(object):
    def __init__(self, name, score):
        self.__name = name
        self.__score = score
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score

class Timer(object):
    def run(self):
        print('Start...')

class Duck:
    def quack(self):
        print("嘎嘎嘎嘎。。。。。")
class Bird:
    def quack(self):
        print("bird imitate duck....")
class geese:
    def quack(self):
        print("doge imitate duck....")
def in_the_forest(duck):
    duck.quack()
duck = Duck()
bird = Bird()
doge = geese()
for x in [duck, bird, doge]:
    in_the_forest(x)
本来forest要求的对象只能是鸭子，但是其他类都有鸭子中quack的方法，所以也可以传入进来

#type()
>>> type('str')
<class 'str'>
#判断是函数类型怎么办？导入types包，用里面的函数
>>> type(fn)==types.FunctionType
True
>>> type(abs)==types.BuiltinFunctionType
True
>>> isinstance(h, Dog)
True
#还可以用来判断是某些类中的一种
>>> isinstance([1, 2, 3], (list, tuple))
True
>>> getattr(obj, 'z', 404) # 获取属性'z'，如果不存在，返回默认值404
404
hasattr(obj, 'y') # 有属性'y'吗？同时，也包含有方法'y'吗？

#类属性
class Teacher(object):
    name="teacher"
实例属性
t=Teacher()
t.sex='男'

#定义一个方法，导入MethodType方法，随后调用Method方法
from types import MethodType
class Student(object):
    pass
s=Student()
def set_age(self, age,name):
    self.age = age
    self.name=name
s.set_age = MethodType(set_age, s)
s.set_age = 25,'dudu'
print(s.set_age)
#类绑定方法
Student.set_age=set_age

#表示只能添加名字是name和set_age的属性或者方法
class Student(object):
    __slots__ =('set_age','name')

#注意，第一个@是可读，第二个@是可写，使用这个还是需要初始化的
class Screen(object):
    def __init__(self, width):
        self._width = width
    @property
    def width(self):
        return self._width
    @width.setter
    def width(self,values):
        self._width=values
    @property
    def height(self):
        return self._height
    @height.setter
    def height(self,values):
        self._height=values
    @property
    def resolution(self):
        return self._width * self._height
s = Screen(1024)
s.height = 768
print('resolution =', s.resolution)
if s.resolution == 786432:
    print('测试通过!')
else:
    print('测试失败!')

class Dog(Mammal, Runnable):
    pass

from enum import Enum, unique
@unique
class Weekday(Enum):
    Sun = 0 # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6
#这样可以访问该变量
print(Weekday.Wed.value)
#变量是不可改变的，以下内容是错误的
Weekday.Wed.value=9

def fn(self):
    print("I'm an animal")
Animal=type('Animal',(object,),dict(myself=fn))
dog=Animal()
dog.myself()

a=[1,23,4,5]
b=['e','y','r','d']
for x,y in zip(a,b):
    print(x,y)

try:
    print('try...')
    r = 10 / int('2')
    print('result:', r)
except ValueError as e:
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
else:
    print('no error!')
finally:
    print('finally...')
print('END')

def foo(s):
    return 10 / int(s)
def bar(s):
    return foo(s) * 2
def main():
    try:
        bar('0')
    except Exception as e:
        print('Error:', e)
    finally:
        print('finally...')

def foo(s):
    n = int(s)
    assert n != 0, 'n is zero!'
    return 10 / n

import logging
logging.basicConfig(level=logging.INFO)
s = '0'
n = int(s)
logging.info('n = %d' % n)
print(10 / n)

#使用try finally，目的是就算读取错了也可以关闭文件
try:
    f = open('/path/to/file', 'r')
    print(f.read())
finally:
    if f:
        f.close()
#使用with，比较推荐，也不需要写close()
with open('/path/to/file', 'r') as f:
    print(f.read())
#读取一行
f.readline()
#读取全部，返回列表形式，每个元素就是一行内容
f.readlines()
#读取5个字节
f.read(5)
#读取视频、图片等二进制文件，使用open(~,'rb')
 f = open('test.jpg', 'rb')
#读取gbk文件和忽略错误
f = open('gbk.txt', 'r', encoding='gbk', errors='ignore')
#使用readline循环遍历一个文件
with open('./t1.txt') as f:
    while (True):
        line = f.readline()
        if not line:
            break
        print(line)

#重写或创建文件
#w是写文本，wb是写二进制文件
with open('test.txt', 'w') as f:
    f.write('\nHello, world!')
#内容追加,使用'a'
with open('test.txt', 'a') as f:
    f.write('\nHello, world!')

from io import StringIO
f=StringIO()
f.write("hello")
f.write("world")
print(f.getvalue())
>>> helloworld
#注意，直接使用f.read()是没有用的
#只有当有初始化形式的时候才可以使用read()
ff=StringIO("hello zjsu")
print(ff.getvalue())

from io import BytesIO
f = BytesIO()
#注意这里必须要加上encode，不加上就是一个str不符合标准
f.write('中文'.encode('utf-8'))
print(f.getvalue())

import json
d = dict(name='Bob', age=20, score=88)
m=json.dumps(d)
print(m)

import json
class Student(object):
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score
s = Student('Bob', 20, 88)
print(json.dumps(s, default=lambda obj: obj.__dict__))
#核心思路是先将类实例化，随后将类的各个属性转化为dict类型，最后将其转化为JSON格式

import pickle
class Person:
    def __init__(self,n,a):
        self.name=n
        self.age=a
    def show(self):
        print self.name+"_"+str(self.age)
aa = Person("JGood", 2)
aa.show()
f=open('d:\\p.txt','w')
pickle.dump(aa,f,0)
f.close()
#del Person
f=open('d:\\p.txt','r')
bb=pickle.load(f)
f.close()
bb.show()

path=os.getcwd()
lst=os.listdir(path)
l=[]
for filename in lst:
    if filename.endswith('.py'):
        l.append(filename)
        #复制
        shutil.copy2(filename, "./question11package")
#压缩
shutil.make_archive("./question11package", "zip","./")

#遍历一个文件夹下的所有文件
lst = os.listdir(dirname)
for filename in lst
#找出所有以.py结尾的文件
if f1.endswith('.txt'):
   L.append(f1)
#找出所有的后缀
for filename in lst:
    listfile.append(os.path.splitext(filename)[1])

from collections import namedtuple
#表示一个二维坐标
Point = namedtuple('Point', ['x', 'y'])
p=Point(1,2)
print(p.x)
#表示一个圆
Circle=namedtuple('Circle',['x','y','r'])
p=Circle(4,5,6)
print(p.r)
#实现队列或栈
from collections import deque
q = deque(['a', 'b', 'c'])
#往尾部添删元素,类似于一个栈
q.append('x')
q.pop()
#也可以往头部添删元素,可以实现一个双向列表,也就是一个双向队列
q.appendleft('y')
q.popleft()

from datetime import datetime
# 获取当前datetime
now = datetime.now() 
#str转换为datetime
cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
#日期转str
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M'))
#获取时间戳（从1970年01月01日00时00分00秒到现在的时间）
now=time.time()
#时间的加减，如计算一个月前的时间
prievetime=datetime.date.today()-datetime.timedelta(days=30)

#匹配一个字符串，以三个整数开头+至少一个字符+5到8个字符
'\d{3}\s+\s{5,8}'

#匹配字母或者下划线开头，19个字符的字符串
[a-zA-Z\_][0-9a-zA-Z\_]{0, 19}

re.match(r'^\d{3}\-\d{3,8}$', s)
re.search(r'^\d{3}\-\d{3,8}$', s)
re.findall(r'^\d{3}\-\d{3,8}$', s)

#对带空格的字符串进行去空格并逐词划分
 >>>re.split(r'\s+', 'a b   c')
['a', 'b', 'c']
#对带空格或，或;的字符串进行分割
>>> re.split(r'[\s\,\;]+', 'a,b;; c  d')
['a', 'b', 'c', 'd']

>>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
>>> m
<_sre.SRE_Match object; span=(0, 9), match='010-12345'>
>>> m.group(0)
'010-12345'
>>> m.group(1)
'010'
>>> m.group(2)
'12345'

#贪婪匹配
>>> re.match(r'^(\d+)(0*)$', '102300').groups()
('102300', '')
#非贪婪匹配
>>> re.match(r'^(\d+?)(0*)$', '102300').groups()
('1023', '00')

m=re.findall(r'\w+@\w+.\w+',s)

#普通用法
找到用A天替换所有的a
re.sub('a','A',s)
#用匹配出来的组1替换整个匹配出来的东西
re.sub(r'www\.(.*)\..{3}',r'\1',s)
#使用pat将pat中的条件替换成color
pat=re.compile('(blue|red|white)')
r=pat.sub('color',s)
#自定义函数
#?P<>是固定写法,表示定义了这个组叫什么
import re
def add212(matched):
    intStr=matched.group("number")
    intVal=int(intStr)
    addvalue=intVal+212
    return str(addvalue)
s="hi69@qq.com, werksdf@163.com, sdf@sina.com"
m=re.sub("(?P<number>\d+)",add212,s)
print(m)