大家好，给大家分享一下大学python题库及答案解析，很多人还不知道这一点。下面详细解释一下。现在让我们来看看！
前言
1python的创造者是“龟叔”Guido van Rossum
2python语言的缺点
| 运行速度慢 | python是解释型语言（不同于编译型），代码需要翻译成CPU所能理解的机器码。但是，不影响用户交互，因为比如python需要0.1,C需要0.001s，而网络需要1s，1.1s和1.001s没有什么区别 |
| 代码不能加密 | python只能发布源代码，而C语言是可以只发布.exe文件 |
3解释器
| CPython | 官方自带的解释器python画四瓣花图形。是用C语言开发的。在命令行下运行python就是启动CPython解释器。 |
| IPython | 在CPython的基础之上发展而来的，只是在交互性方面有所增强 |
| PyPy | 采用JIT技术，对python进行动态编译，主要的目的是提高执行速度 |
| Jython | 可以在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行 |
| IronPython | 在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码 |
4命令行模式与交互模式
| 命令模式 | 直接打开cmd。效果为C:\> _ |
| 交互模式 | 在cmd中输入python。效果为>>> _ |
5如何执行python文件？
在命令模式下在hello.py目录learn下执行以下语句。在交互模式中直接输入代码执行
C:\learn> python hello.py
6python常用的库以及用法
| 科学计算 | Numpy，Scipy |
| 数据分析 | Pandas |
| 画图 | matplotlib |
| 数据挖掘 | scikit-learn，nltk，pytorch/tensorflow（深度学习） |
| 游戏 | Pygame/Bigworld |
| 图像 | PIL |
| 机器人控制 | PyRO |
基础语法
1输入与输出
输出：print（）
print('hello,world')
print('The quick brown fox', 'jumps over', 'the lazy dog')注意，如果采用第二种方式，print()会依次打印每个字符串，遇到逗号“,”会输出一个空格
输入：input（）
#注意，是字符串输入
name = input()
#可以是有提示的输入
name = input('please enter your name: ')
print('hello,', name)
#输入两个整数
a,b=map(int,input().split())
#输入两个字符串
a,b=input().split()2数据类型
| 数据类型 | 注意点 |
| 整数 | 1十六进制如 oxff01 2_的使用：100000000=100_000000,这是因为方便看0的个数 3没有大小限制 4 3**5=243，表示3^5 |
| 浮点数 | 1如1.23e8 2没有大小限制，超出范围就是inf（无限大） |
| 字符串 | 1" "与' '：两个都可以使用，但是如果字符串内有'的时候，需要用" "如"I‘m OK’" 2在1的情况也可以用转义字符来解决，如'I\'m OK' 3如果字符串中有很多的字符需要转义，但是我想''中的部分不允许被转义，可以使用r''如下图 4一行内如果有很多的换行符不方便使用，可以使用'''...'''如下图 5不可变有序 |
| 布尔值 | 1True和False 2运算法：and or not |
| 空值 | None |
| 列表， 字典， 自定义数据类型 | list可变有序 s = ['python', 'java', ['asp', 'php'], 'scheme'] tuple不可变有序 t = (1, 2) dict可变无序 d={'Anne':96,'Bob':84,'Candy':87} set可变不可变均可无序 s = set([1, 1, 2, 2, 3, 3]) |
| 变量 | 1 变量名可以是大小写、数字和 _ ，不能用数字开头 2 变量的类型可以反复赋值，以及不同的数据类型。这种变量本身类型不固定的语言称之为动态语言 3 a=‘ABC’，内存做了两件事情，就是创建一个‘ABC’的字符串和创建一个a的变量，并将a指向'ABC' |
| 常量 | 1 Python中没有完全的常量，一般用大写字符表示 |
| 全局变量 | 1 global 全局变量 |
总结：字符串和元组合是不可变的，字符串、元组、列表是有序的
print('\\\t\\')
print(r'\\\t\\')
print('''line1
line2
line3''')
3运算符号
| / | 结果一定是浮点数 |
| // | 结果一定是整数，向下取整 |
| % | 结果一定是整数 |
结论：//和%的结果一定是整数，因此其运算结果一定是精确的
优先级
4字符编码
| ASCII | 1个字节，只能是常用的几个符号 |
| Unicode | 2~6个字节，与ASCII的联系在于，用来表示ASCII是有两个字节，其中前面一个字节是全0,主要作用是显示给用户看 |
| UTF-8 | 综合了ASCII和Unicode的字节长度，比较灵活，比如英文为1个字节，汉字是3个字节，从而节省空间，主要作用是保存 |
| 字符 | ASCII | Unicode | UTF-8 |
|---|---|---|---|
| A | 01000001 | 00000000 01000001 | 01000001 |
| 中 | x | 01001110 00101101 | 11100100 10111000 10101101 |
内存：Unicode
外存/浏览器源码/传输数据：UTF-8
5字符串
使用Unicode进行编码
| ord（） | 字符转化为Unicode码，如ord（‘A’） |
| chr（） | Unicode码转化为字符，如chr（''66） |
| int（） | 字符数字转化为数值 |
| encode() | 字符转化为指定编码的bytes类型，如'ABC'.encode('ascii')，'中文’.encode('utf-8') |
| decode() | 字符转化为指定编码的str类型，如b'ABC'.decode('ascii',errors='ignore')#ignore的意思是少量的无效字符忽略，当然也可以不加的 |
| len() | bytes类型计算字节数，str类型计算字符数 |
| 字符串名[::-1] | 倒序 |
| .islower() | 判断是否全部是小写 |
| 转化为小写 | s.lower() |
| 转化为大写 | s.upper() |
| 首单词大写 | s.title(） |
| 首字符串字母大写 | s.capitalize() |
>>> 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'
注意：我们从网络或磁盘上读取了字节流，用的就是bytes，由于我们在操作字符串的时候经常遇到str和bytes的互相转化，为了避免乱码，应该坚持使用UTF-8来进行转化，就是encode和decode后面的参数是utf-8。
str是不可变对象
>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
#上面的实际是创建了一个新的对象
>>> a
'abc'解释：对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。
python中的不变对象有：str None
取出特定字符之间的子字符串
#此处为取出[ ]之间的字符串
m=re.findall(r"\[(.+?)\]",L)6格式化
和c语言的输出一样的
%x 十六进制整数
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.627特殊数据类型list
列表：一种集合
里面的元素数据类型可以不一样，而且可以套娃，例如
s = ['python', 'java', ['asp', 'php'], 'scheme']
#即为
p = ['asp', 'php']
s = ['python', 'java', p, 'scheme']| len（） | 如len（classmates） |
| a[-1] a[-2] | 获取最后第一个元素 ~二~ |
| insert（） | 插入指定位置如a.insert(1,'jack')，插入到下标为1的位置 |
| append（） | 末尾追加元素如a.append('Anne') |
| extend（） | 末尾追加元素列表如a.extend(['Anne','Bob']) |
| pop（） | 删除尾部的元素如a.pop() 删除指定位置的元素如a.pop(4) |
| a[2]='dudu' | 替换指定位置的元素 |
| sort（） | 正序排序，如a.sort() 使用lamda自定义排序，如l.sort(key=lambda x:x[1]) |
| reverse（） | 倒序排序，如a.reverse（） |
| index（） | 获取某个元素的下标如l.index('Anne') |
| count（） | 一个元素出现的次数如l.count('Anne') |
| 列表加法 | 合并追加 [1,2,3]+[5,3] >>> [1,2,3,5,3] |
| 列表乘法 | 重复几次 [1,2,3]*2 >>> [1,2,3,1,2,3] |
实现二维数组
l1=[]
i=0
while i<5:
l1.append([])
i+=1
l1.append('你好')与random库结合使用
L=[3,4,1,3,4,5,1]
#在列表中随机抽取一个对象
random.choice(L)
#列表打乱
random.shuffle(L)8特殊数据类型tuple
区别于list：初始化后不可修改
#没有元素时
t = ()
#1个元素
t = (1,)
#2个元素时候
t = (1, 2)注意：如果是1个元素，t=(1)是错误的，因为这样既可以表示tuple又可以表示数学计算的小括号，python默认是后者，因此上述式子相当于t=1
不变指的是指的对象不变，对象的内容有可能变的，那就是list，如下
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])9特殊数据类型set
与list相比，只是内部不可以重复
一般是用来当作去重工具使用
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3} #print的结果也是{}| 增 | s.add(5) |
| 删 | s.remove(4) |
| 并/交 | & | |
10特殊数据类型dict
字典：存储方式：键-值，方便快速查找。很类似一个二维数组或者指针数组
d={'Anne':96,'Bob':84,'Candy':87}
print(d['Anne'])| 判断键是否存在 | 1方式一:in 方式二:get() 2自定义返回值 print(d.get('Bobc','sorry')) |
| 增 | 1直接d['Duduo']=88 |
| 删 | d.pop('Bob') |
| 获 | d['Anne'] |
区别：与list相比，其查找插入的速度快，不会随着元素的增加而变慢，但是需要占用大量的内存
11条件控制语句
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>注意：python判断从上至下，一旦一个判断是True，下面的就不会执行了，比如上面的结果是adult
简写形式，类似于switch
if x:
print('True')12循环
for...in循环：一般用于遍历
names = ['Michael', 'Bob', 'Tracy']
for name in names:
print(name)计算1+2+3+...+100
#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)))
while循环
sum=0
n=100
while n>0:
sum+=n
n-=1
print(sum)当然，break和continue也同样适用
13数据类型转换
基本数据类型转化
>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
Falsestr list dict 类型转化
#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)
尤其注意list-->dict的时候
zip的底层原理是遍历赋值，如果l1有重复的字段那就赋l2最后一个值
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( ',' )函数
1将一个函数名赋值到一个变量
>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
12自定义函数
格式 def 函数名(参数)：
函数体
def my_abs(x):
if x >= 0:
return x
else:
return -x
#使用三元表达式
def my_abs(x):
return x if x>=0 eles -x注意：如果没有写return，实际也会有return的，也就是None
3空函数
pass：什么都不做，一般用作现在还没想好怎么写，但是先让程序跑起来
def nop():
pass
if age >= 18:
pass4返回多个值
def hello(x,y):
return x,y
print(hello(1,2))
#结果为(1,2)
a,b=hello(1,2)
#获取返回值由结果(1,2)可以知道其实际返回的就是一个tuple
5默认参数的函数
背景：如果我想用同一个函数的不同参数，系统会报错说参数不对。
做法：设置默认参数默认，必选参数在前，变化大的参数在后，例如下
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s因此power(5)等价于power(5,2),而且不影响power(5,4)的使用
改变默认参数方法
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']
但是这样每次add都会多一个END，我想每次只输出一个END该怎么办呢？
---使用None这个不变对象
def add(L=None)
if L is None:
L=[]
L.append('END')
return L6可变参数函数*--可扩展变值
在变量前面加上*
比如要用 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]7关键字参数**--可扩展变值和名称，选填
#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'])8命名关键字参数*--不可扩展值和名称，必填
//只接收city和job作为关键字参数。
def person(name, age, *, city, job):
print(name, age, city, job)
person('Jack', 24, city='Beijing', job='Engineer')实际应用类似于问卷调查中的是否有其他想法，而且要求是必填的
与关键字参数的不同在于它的关键字的不能扩展也不能修改名字
9小总结
*argc和**kw是python的习惯写法
| 可变参数 | *args，接收、存储的是一个tuple |
| list或tuple func(*(1, 2, 3)) | |
| 关键字参数 | **kw，接收、存储的是一个dict |
| 直接传入 func(a=1, b=2) dict func(**{'a': 1, 'b': 2}) |
10递归函数
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可能会发生栈溢出，可以使用尾递归优化来解决
11 Iterable
可迭代对象，看能否直接用for循环
isinstance(~,Iterable)，结果如下
| 集合数据 | list、tuple、dict、set、str |
| generator | 生成器、带yield的函数 |
区别：生成器表达式和列表解析的区别
l=["a"for i in range(10)]
w=(“a” for i in range(10))
- 列表解析式的返回结果是一个list而生成器表达式的返回是一个generator
- generator是每次读取部分数据，而list是一次性读取所有的数据，因此在数据量大的时候list会非常的浪费内容
- 生成器最外层是（），列表最外层是[ ]
- 生成器只能遍历一次，列表可以遍历无数次
12常用技巧
| 切片 | 获取特定位置的元素 | 取后10个元素：L【-10：】 每3个取一个：L【：：3】 前10个每2个取一个L【：10：2】 tuple和str也可以用 （0,1,2,3,4）【：3】 'ABCDEFG' 【：3】 |
| 迭代 | for in | dict迭代 迭代key for key in d： 迭代value for values in d.values() 迭代key和value for k,v in d.items() 迭代字符串 for ch in 'ABC' 判断能否迭代 isinstance([1,2,3],Iterable) List实现索引+元素 for i,v in enumerate([1,2,3]) |
| 列表生成器 | 列表数据进行处理 [表达式 for 条件] | 1到10的数 [i for i in range(1,11)] x^x的偶数 [x*x for x in range(1,10) if x%2==0] 全排列 [m+n for m in 'ABC' for n in '123'] for 前面可以有else，但是表示的是表达式，for后面的是过滤条件，不能有else
|
| 生成器 | 根据算法推算出下一个元素，比[]的优势在于不需要大量的存储空间 | g=(x*x for x in range(1,11)) for n in g: print(n) |
#切片实现去除字符串首尾的空格
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)函数式编程
1高阶函数
变量既可以指向一个对象也可以指向一个函数，所以函数名可以看成指向一个函数的变量
如def add() m=add
高阶函数：函数的参数可以是另一个函数名
2 map函数
作用，将数值集进行函数计算返回数值集，返回一个generator对象
格式：map(f,l) ：f为函数，l为Iterable可循环对象
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]))
3 reduce函数
相当于一个递归函数，每次将前两个参数进行函数计算
#将数字字符串转化为数字
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'))4 filter()函数
作用：过滤序列
格式：fileter(f,l)f为一个函数，l为Iterable
区别：map主要用于计算，filter主要用于过滤
底层逻辑：将每个Iterable进行计算，True留False丢
5 sorted()函数
实现排序
#正常排序
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.sort（）和sorted（L）函数的区别
L=[1,5,4,54,5]
#sort必须要单独的一行进行排序，print(L.sort())的输出是None
L.sort()
print(L)
print(sorted(L))6匿名函数lambda
作用：表示是一个表达式，也可认为是不需要命名函数的名字，随时随用。如下
list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))这样我们就不需要单独的写一个函数出来
当然，既然是匿名函数，他本质上还是一个函数，所以也可以赋值给变量上，如下
f = lambda x: x * x总结：可以拿来当做一个工具，和列表表达式一起结合使用
7库
注意：上述的几个函数在Python3中需要导入库functools
8装饰器Decorator
pass
9偏函数
pass
模块
一个.py文件就是一个模块
mycompany.web也是一个模块，它的文件名叫做__init__.py。每个包下面都有这个模块，如果没有的话，python就会把它当做普通的目录而不是一个包。
常见的标准模块：string、os、sys、time、re、random（random、randint、uniform等）、math（sqrt、sin、cos、exp、log）
面向对象编程OOP
1 三大特性：封装+继承+多态
2类
#这里的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)
注意类的写法和初始化
3访问限制--封装
目的：为了安全性，或者说更方便的扩展类的属性一些操作，而使实例化对象不能使用如对象.Name或者对象.__Name的方式来直接访问
做法：就是在属性的前面加上__
如果需要访问，就建立一个set和get的方法如下
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注意：如果你使用了如Student.__Name="大白菜",随后进行打印这个东西，结果是大白菜的，但是，实际上是没有对它内部的属性进行修改，底层逻辑是创建了一个新的对象
其实私有化的变量也是可以取到的，只要用如s1._Studeng__name
因此，Python中没有完全的私有，它只是制定了一个规则让你获取属性更加困难
4继承和多态
如类class Student(object):中将object修改为父类即可
class Timer(object):
def run(self):
print('Start...')注意：由于python有动态变量的特征，所以它不管你有什么类，只要你这个类中有相同的名字的方法，你都可以作为超类，这种特性叫做鸭子类型（只要你长的像鸭子，可以游泳，可以走路，那你就是一个类鸭子）。
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的方法，所以也可以传入进来
5 获取用户对象信息
| 判断变量/函数类型 | type() | 返回Class类型 |
| 判断类类型 | isinstance() | 返回True或False |
| 得到一个对象的所有属性和方法 | dir() | 返回list，里面都是str |
| 判断有没有某个属性或者方法 | hasattr() | 返回True或False |
#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'吗？注意：
1 能用type()判断的都可以用isinstance()进行判断
2 isinstance判断的是该类以及其父类（注意逻辑关系）
6 添加类属性和实例属性
#类属性
class Teacher(object):
name="teacher"
实例属性
t=Teacher()
t.sex='男'注意，类属性和属性的名称最好不要一样的。实例属性想要什么就加什么，动态性嘛
7 添加类方法和实例方法
#定义一个方法，导入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_age8 __slots__
作用：表示实例的属性和方法有哪些
#表示只能添加名字是name和set_age的属性或者方法
class Student(object):
__slots__ =('set_age','name')注意：子类可以定义的属性是自身的__slots__和父类的__slots__
9 @property修饰器
目的：
1 可以直接用student1.score的方法，又可以对条件进行赋值
2 设置读写权限
3 使得私有变量的书写更加简洁
#注意，第一个@是可读，第二个@是可写，使用这个还是需要初始化的
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('测试失败!')解释为什么在变量前面都要加_，因为这样表示的是私有属性，一般来说需要通过set和get方法来进行操作，但是这样实例化后进行操作比较复杂，我还是想用原来的student.name来进行操作，所以@propert可以实现这点
10 多重继承
做法：只要将object设置为多个父类对象如
class Dog(Mammal, Runnable):
pass11 枚举类
作用：除了简单的枚举之外，更重要的是可以当做常量
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=912 元类
除了使用常规的创建类外，使用type()也可以创建类
def fn(self):
print("I'm an animal")
Animal=type('Animal',(object,),dict(myself=fn))
dog=Animal()
dog.myself()
type()中的三个参数分别为
1 类名字
2 继承的父类，注意一个父类的时候tuple()的写法
3 方法
13 metaclass元类
作用：创建类的模板，也就是说根据metaclass创建类，根据类创建实例对象
pass（一般用不太到，太难了）
14 zip函数
作用：将n个列表合成一个n列的矩阵
a=[1,23,4,5]
b=['e','y','r','d']
for x,y in zip(a,b):
print(x,y)
错误调试
1 错误处理
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')
注意：错误是有继承关系的，所有的错误都继承自BaseException，当有多个错误抛出的时候，要注意后面的错误是不是上面错误的子类，因为，父类会抛出子类的错误。
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...')当然，当有多层嵌套的时候，我们不需要在每个模块都写上try catch，只要在关键的地方写上就可以了。如果说
2 错误抛出assert
def foo(s):
n = int(s)
assert n != 0, 'n is zero!'
return 10 / n其实和print或者return没有什么区别，实现的效率也不是很高
3 logging
import logging
logging.basicConfig(level=logging.INFO)
s = '0'
n = int(s)
logging.info('n = %d' % n)
print(10 / n)第二行的意思是输出哪种级别的错误，错误有debug，info，warning，error
logging还有一个好处在于可以指定文件夹用作你输出的地方
IO编程
1 文件读取
底层原理：现在的操作系统都不允许程序本身能够读取文件，python程序也是如此，它发了一个请求指令给OS，让OS去读取文件。随后python从OS那获取文件内容
#使用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)
2 文件写入
#重写或创建文件
#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!')注意：只要加了'w'或'a'，文件如果没有的话会自动创建
3 StringIO
不是以文件的形式存在，而是以字符串的形式存在
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())4 BytesIO
以字节的形式存在
from io import BytesIO
f = BytesIO()
#注意这里必须要加上encode，不加上就是一个str不符合标准
f.write('中文'.encode('utf-8'))
print(f.getvalue())
5 序列化，形成JSON格式
import json
d = dict(name='Bob', age=20, score=88)
m=json.dumps(d)
print(m)对类进行JSON格式化
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格式常用内置模块
pickle
作用：实现对象序列化
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()shutil
作用：文件的复制压缩等
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","./")
os
#遍历一个文件夹下的所有文件
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])
colections
作用：与集合相关
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()
datetime
作用：与时间日期相关
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}'
| * | 任意个字符 |
| + | 至少一个字符 |
| ？ | 0或1个字符 |
| {n} | n个字符 |
| {m,n} | m到n个字符 |
高级匹配
#匹配字母或者下划线开头，19个字符的字符串
[a-zA-Z\_][0-9a-zA-Z\_]{0, 19}| A|B | 匹配A或B |
| ^ | 开头 |
| $ | 结尾 |
| [ ] | 匹配集合内 |
| [^ ] | 除了集合外 |
| ( ) | 表达式分组 |
re模块
方式一：使用compile得到regex正则表达式对象，后用regex.~（字符串）
方式二：直接re.~(正则表达式，字符串)
说白了就是字符串写一行还是写两行
re.match是从字符串开头开始匹配，如果成功返回对象，如果失败返回None
re.search是扫描整个字符串，返回第一个匹配的对象
re.findall是扫描整个字符串，返回所有匹配的对象
返回的对象都是_sre.SRE_Match，可以使用m.group()来获取具体值
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)
其他内容
环境配置：配置清华镜像源
pip install pip -U
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
Pycharm中的快捷键
| double Shift | 万能搜素 |
| Ctrl+Alt+L | 格式化 |
| Ctrl+Alt+N | 跳转到某个页面 |
| Ctrl+E | 最近文件 |
| Crtl+Shift+F | 搜索本页面内的某内容 |
| Ctrl+Shift+R | 替代 |
| Ctrl+Shift+A 输入split v | 分屏 |
4162
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
