您的位置：首页 > 其它

知识点总结（基础篇）

2019-06-10 21:29 134 查看

知识点总结1

PEP8 规范每一级缩进使用4个空格。空格是首选的缩进方式。行限制的最大字符数为79 使用下划线分隔的小写字母类名一般使用首字母大写的约定异常名后面加上“Error”后缀全局变量前加下划线的方式（表明这些全局变量是模块内非公有）。函数名应该小写 None这样的单例对象进行比较的时候应该始终用 is 或者 is not 使用with 表达式来确保这个资源使用完后被清理干净。用try/finally也可以 10 1
```
每一级缩进使用4个空格。
```
2
```
空格是首选的缩进方式。
```
3
```
行限制的最大字符数为79
```
4
```
使用下划线分隔的小写字母
```
5
```
类名一般使用首字母大写的约定
```
6
```
异常名后面加上“Error”后缀
```
7
```
全局变量前加下划线的方式（表明这些全局变量是模块内非公有）。
```
8
```
函数名应该小写
```
9
```
None这样的单例对象进行比较的时候应该始终用 is 或者 is not
```
10
```
使用with 表达式来确保这个资源使用完后被清理干净。用try/finally也可以
```
python递归的最大层数
998层获取：sys.getrecursionlimit() 设置：sys.setrecursionlimit(3000) 3 1
```
 998层
```
2
```
 获取：sys.getrecursionlimit()
```
3
```
 设置：sys.setrecursionlimit(3000)
```
ascil,unicode,utf-8,gbk的区别
ASCII 码一共规定了128个字符的编码 Unicode 当然是一个很大的集合，现在的规模可以容纳100多万个符号 UTF-8 就是在互联网上使用最广的一种 Unicode 的实现方式。其他实现方式还包括 UTF-16（字符用两个字节或四个字节表示）和 UTF-32（字符用四个字节表示），不过在互联网上基本不用。重复一遍，这里的关系是，UTF-8 是 Unicode 的实现方式之一。 GBK是在国家标准GB2312基础上扩容后兼容GB2312的标准（好像还不是国家标准）。GBK编码专门用来解决中文编码的，是双字节的。不论中英文都是双字节的 4 1
```
ASCII 码一共规定了128个字符的编码
```
2
```
Unicode 当然是一个很大的集合，现在的规模可以容纳100多万个符号
```
3
```
UTF-8 就是在互联网上使用最广的一种 Unicode 的实现方式。其他实现方式还包括 UTF-16（字符用两个字节或四个字节表示）和 UTF-32（字符用四个字节表示），不过在互联网上基本不用。重复一遍，这里的关系是，UTF-8 是 Unicode 的实现方式之一。
```
4
```
GBK是在国家标准GB2312基础上扩容后兼容GB2312的标准（好像还不是国家标准）。GBK编码专门用来解决中文编码的，是双字节的。不论中英文都是双字节的
```
and or
v1 = 1 or 3 # v1=1 v1 = 1 and 3 # v1=3 v1 = 0 and 2 and 1 # v1 = 0 v1 = 0 and 2 or 1 # v1 = 1 v1 = 0 and 2 or 1 or 4 # v1 =1 v1 = 0 or False and 1 # v1 = False 6 1
```
v1 = 1 or 3 # v1=1
```
2
```
v1 = 1 and 3  # v1=3
```
3
```
v1 = 0 and 2 and 1   # v1 = 0
```
4
```
v1 = 0 and 2 or 1   # v1 = 1
```
5
```
v1 = 0 and 2 or 1 or 4  # v1 =1
```
6
```
v1 = 0 or False and 1  # v1 = False
```
三元运算符
为真时的结果 if 判断条件 else 为假时的结果（注意，没有冒号） a = 4 r = a if a>2 else 0 4 1
```
为真时的结果 if 判断条件 else 为假时的结果（注意，没有冒号）
```
2
3
```
a = 4
```
4
```
r = a if a>2 else 0
```
a = 1,b=2 交换值
a,b = b,a 1 1
```
a,b = b,a
```
xrange 和 range的区别
python2： range返回真实的列表，有时会很长，占用空间 xrange返回一个列表生成器，每次遍历内部会调用.next()函数拿到下一个元素 python3： range就是python2中的xrange 5 1
```
python2：
```
2
```
range返回真实的列表，有时会很长，占用空间
```
3
```
xrange返回一个列表生成器，每次遍历内部会调用.next()函数拿到下一个元素
```
4
```
python3：
```
5
```
range就是python2中的xrange
```
文件操作 xreadlines,readlines
<open file './test.txt', mode 'r' at 0x7f024288fe40> # xreadlines 返回一个生成器 ['1111111\n', '222222\n', '333333\n', '4444444\n', '5555555\n', '6666666\n', '7777777\n', '88888888\n'] # readlines 返回一个列表 2 1
```
<open file './test.txt', mode 'r' at 0x7f024288fe40>        # xreadlines 返回一个生成器
```
2
```
['1111111\n', '222222\n', '333333\n', '4444444\n', '5555555\n', '6666666\n', '7777777\n', '88888888\n']   # readlines  返回一个列表
```
布尔值为False的常见值
int : 0 list:[] tuple:() dict:{} None 1 1
```
int : 0    list:[]  tuple:() dict:{}  None
```

字符串、列表、元组、字典每个常用的5个方法 string: string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 string.format() 格式化字符串 string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常. string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串 string.strip([obj]) 在 string 上执行 lstrip()和 rstrip() list: list.append(obj) 在列表末尾添加新的对象 list.count(obj) 统计某个元素在列表中出现的次数 list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 list.insert(index, obj) 将对象插入列表 list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 list.remove(obj) 移除列表中某个值的第一个匹配项 list.reverse() 反向列表中元素 tuple: min(tuple) 返回元组中元素最小值。 tuple(seq) 将列表转换为元组。 len(tuple) 计算元组元素个数。 cmp(tuple1, tuple2) 比较两个元组元素。 dict: dict.clear() 删除字典内所有元素 dict.copy() 返回一个字典的浅复制 dict.fromkeys(seq[, val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值 dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值 dict.has_key(key) 如果键在字典dict里返回true，否则返回false dict.items() 以列表返回可遍历的(键, 值) 元组数组 dict.keys() 以列表返回一个字典所有的键 dict.values() 以列表返回字典中的所有值 dict.update(dict2)把字典dict2的键/值对更新到dict里 34 1

string:

string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

   string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

   string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1

   string.format() 格式化字符串

   string.index(str, beg=0, end=len(string))  跟find()方法一样，只不过如果str不在 string中会报一个异常.

   string.join(seq)  以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

   string.replace(str1, str2,  num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

   string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串

string.strip([obj]) 在 string 上执行 lstrip()和 rstrip()

list:

   list.append(obj)  在列表末尾添加新的对象

   list.count(obj) 统计某个元素在列表中出现的次数

   list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

   list.index(obj) 从列表中找出某个值第一个匹配项的索引位置

   list.insert(index, obj) 将对象插入列表

   list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

   list.remove(obj) 移除列表中某个值的第一个匹配项

   list.reverse() 反向列表中元素

tuple:

   min(tuple) 返回元组中元素最小值。

   tuple(seq) 将列表转换为元组。

   len(tuple) 计算元组元素个数。

cmp(tuple1, tuple2) 比较两个元组元素。

dict:

dict.clear() 删除字典内所有元素

   dict.copy() 返回一个字典的浅复制

   dict.fromkeys(seq[, val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值

   dict.get(key, default=None)  返回指定键的值，如果值不在字典中返回default值

   dict.has_key(key)  如果键在字典dict里返回true，否则返回false

   dict.items() 以列表返回可遍历的(键, 值) 元组数组

   dict.keys() 以列表返回一个字典所有的键

   dict.values() 以列表返回字典中的所有值

   dict.update(dict2)把字典dict2的键/值对更新到dict里

lambda表达式格式以及应用场景 lambda 参数(可以没有):返回值应用场景：不需要被重复调用的函数 3 1
```
lambda 参数(可以没有):返回值
```
2
```
应用场景：
```
3
```
不需要被重复调用的函数
```
*arg和**kwarg作用 *arg会把多出来的位置参数转化为tuple **kwarg会把关键字参数转化为dict def exmaple2(required_arg, *arg, **kwarg): if arg: print "arg: ", arg if kwarg: print "kwarg: ", kwarg exmaple2("Hi", 1, 2, 3, keyword1 = "bar", keyword2 = "foo") >> arg: (1, 2, 3) >> kwarg: {'keyword2': 'foo', 'keyword1': 'bar'} 13 1
```
*arg会把多出来的位置参数转化为tuple
```
2
```
**kwarg会把关键字参数转化为dict
```
3
```
def exmaple2(required_arg, *arg, **kwarg):
```
4
```
   if arg:
```
5
```
     print "arg: ", arg
```
6
7
```
   if kwarg:
```
8
```
     print "kwarg: ", kwarg
```
9
10
```
exmaple2("Hi", 1, 2, 3, keyword1 = "bar", keyword2 = "foo")
```
11
12
```
>> arg:  (1, 2, 3)
```
13
```
>> kwarg:  {'keyword2': 'foo', 'keyword1': 'bar'}
```
is和==的区别
is 判断id是否一样 == 判断值是否相等 2 1
```
is 判断id是否一样
```
2
```
== 判断值是否相等
```
深浅拷贝以及应用场景
浅拷贝指仅仅拷贝数据集合的第一层数据，深拷贝指拷贝数据集合的所有层。所以对于只有一层的数据集合来说深浅拷贝的意义是一样的，比如字符串，数字，还有仅仅一层的字典、列表、元祖等. 直接赋值: 其实就是对象的引用(别名),赋值的两边指向的是同一个对象浅拷贝(copy): 拷贝父对象,不会拷贝对象的内部的子对象深拷贝(deepcopy):拷贝父对象,同时会开辟空间,逐层拷贝内部子对象 5 1
```
浅拷贝指仅仅拷贝数据集合的第一层数据，深拷贝指拷贝数据集合的所有层。所以对于只有一层的数据集合来说深浅拷贝的意义是一样的，比如字符串，数字，还有仅仅一层的字典、列表、元祖等.
```
2
3
```
直接赋值: 其实就是对象的引用(别名),赋值的两边指向的是同一个对象
```
4
```
浅拷贝(copy): 拷贝父对象,不会拷贝对象的内部的子对象
```
5
```
深拷贝(deepcopy):拷贝父对象,同时会开辟空间,逐层拷贝内部子对象
```
Python垃圾回收机制
Python垃圾回收主要以引用计数为主，分代回收为辅。引用计数法的原理是每个对象维护一个ob_ref，用来记录当前对象被引用的次数，也就是来追踪到底有多少引用指向了这个对象，当发生以下四种情况的时候，该对象的引用计数器+1 对象被创建 a=14 对象被引用 b=a 对象被作为参数,传到函数中 func(a) 对象作为一个元素，存储在容器中 List={a,”a”,”b”,2} 与上述情况相对应，当发生以下四种情况时，该对象的引用计数器-1 当该对象的别名被显式销毁时 del a 当该对象的引别名被赋予新的对象， a=26 一个对象离开它的作用域，例如 func函数执行完毕时，函数里面的局部变量的引用计数器就会减一（但是全局变量不会）将该元素从容器中删除时，或者容器被销毁时。当指向该对象的内存的引用计数器为0的时候，该内存将会被Python虚拟机销毁参考：http://python.jobbole.com/87843/ 14 1
```
Python垃圾回收主要以引用计数为主，分代回收为辅。引用计数法的原理是每个对象维护一个ob_ref，用来记录当前对象被引用的次数，也就是来追踪到底有多少引用指向了这个对象，当发生以下四种情况的时候，该对象的引用计数器+1
```
2
```
对象被创建  a=14
```
3
```
对象被引用  b=a
```
4
```
对象被作为参数,传到函数中   func(a)
```
5
```
对象作为一个元素，存储在容器中   List={a,”a”,”b”,2}
```
6
```
与上述情况相对应，当发生以下四种情况时，该对象的引用计数器-1
```
7
8
```
当该对象的别名被显式销毁时  del a
```
9
```
当该对象的引别名被赋予新的对象，   a=26
```
10
```
一个对象离开它的作用域，例如 func函数执行完毕时，函数里面的局部变量的引用计数器就会减一（但是全局变量不会）
```
11
```
将该元素从容器中删除时，或者容器被销毁时。
```
12
```
当指向该对象的内存的引用计数器为0的时候，该内存将会被Python虚拟机销毁
```
13
14
```
参考：http://python.jobbole.com/87843/
```
Python的可变类型和不可变类型可变类型（mutable）：列表，字典变量对应的值中的数据可以被修改，但内存地址保持不变不可变类型（unmutable）：数字，字符串，元组，字符串，int 变量对应的值中的数据是不能被修改，如果修改就会生成一个新的值从而分配新的内存空间 4 1
```
可变类型（mutable）：列表，字典
```
2
```
变量对应的值中的数据可以被修改，但内存地址保持不变
```
3
```
不可变类型（unmutable）：数字，字符串，元组，字符串，int
```
4
```
变量对应的值中的数据是不能被修改，如果修改就会生成一个新的值从而分配新的内存空间
```
求结果：
v = dict.fromkeys(['k1','k2'],[])
v[‘k1’].append(666)
print(v)
v[‘k1’] = 777
print(v) {'k1': [666], 'k2': [666]} {'k1': 777, 'k2': [666]} 解释：初始k1,k2的value都是[]，两个[]实际指向同一个内存地址,[]是可变类型，一个修改另一个也会随之变化，所以k1,k2的value都变成了[666]，而v['k1'] = 777,将k1 vlaue的地址指向了777,而k2的内存地址指向不变 6 1
```
{'k1': [666], 'k2': [666]}
```
2
```
{'k1': 777, 'k2': [666]}
```
3
4
```
解释：初始k1,k2的value都是[]，两个[]实际指向同一个内存地址,[]是可变类型，一个修改另一个也会随之变化，所以k1,k2的value都变成了[666]，
```
5
```
而v['k1'] = 777,将k1 vlaue的地址指向了777,而k2的内存地址指向不变
```
6
filter、map、reduce的作用
filter用法:返回执行结果为TRUE的入参（入参是列表字符元组） print filter(lambda x:x*x-4,range(10)) #结果：[0, 1, 3, 4, 5, 6, 7, 8, 9] map的用法：对列表入参依次执行函数。入参为列表，有多少个列表，就应该有多少个入参。 print map(lambda x:x*x-4,range(10)) #结果：[-4, -3, 0, 5, 12, 21, 32, 45, 60, 77] reduce用法：先把sequence中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给fuction,最终返回一个结果值 print reduce(lambda x,y:x*y-4,range(4)) # 结果：-40 6 1
```
filter用法:返回执行结果为TRUE的入参（入参是列表字符元组）
```
2
```
print filter(lambda x:x*x-4,range(10)) #结果：[0, 1, 3, 4, 5, 6, 7, 8, 9]
```
3
```
map的用法：对列表入参依次执行函数。入参为列表，有多少个列表，就应该有多少个入参。
```
4
```
print map(lambda x:x*x-4,range(10)) #结果：[-4, -3, 0, 5, 12, 21, 32, 45, 60, 77]
```
5
```
reduce用法：先把sequence中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给fuction,最终返回一个结果值
```
6
```
print reduce(lambda x,y:x*y-4,range(4))  # 结果：-40
```
一行代码实现9*9乘法表
print('\n'.join(['\t'.join(["%2s*%2s=%2s"%(j,i,i*j) for j in range(1,i+1)]) for i in range(1,10)])) 1 1
```
print('\n'.join(['\t'.join(["%2s*%2s=%2s"%(j,i,i*j) for j in range(1,i+1)]) for i in range(1,10)]))
```
常用模块 time,os,sys,datetime,hashlib,logging,json,subprocess,random 1 1
```
time,os,sys,datetime,hashlib,logging,json,subprocess,random
```
re的match和search区别
match()函数只检测RE是不是在string的开始位置匹配，search()会扫描整个string查找匹配； 1 1
```
match()函数只检测RE是不是在string的开始位置匹配，search()会扫描整个string查找匹配；
```
什么是正则的贪婪匹配
贪婪匹配：正则表达式一般趋向于最大长度匹配。非贪婪匹配：匹配到结果就好。默认是贪婪模式。在量词后面直接加一个问号？就是非贪婪模式 3 1
```
贪婪匹配：正则表达式一般趋向于最大长度匹配。
```
2
```
非贪婪匹配：匹配到结果就好。
```
3
```
默认是贪婪模式。在量词后面直接加一个问号？就是非贪婪模式
```
求结果： a. [ i % 2 for i in range(10) ] b. ( i % 2 for i in range(10) )
a:[0, 1, 0, 1, 0, 1, 0, 1, 0, 1] b:<generator object <genexpr> at 0x0000008CB5BD7BA0> # 生成器 2 1
```
a:[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
```
2
```
b:<generator object <genexpr> at 0x0000008CB5BD7BA0>  # 生成器
```
求结果： a. 1 or 2 b. 1 and 2 c. 1 < (2==2) d. 1 < 2 == 2 a:1 b:2 c:False d:True # 注意：True表示1，Flase表示0 2 1
```
a:1   b:2 c:False  d:True
```
2
```
# 注意：True表示1，Flase表示0
```
def func(a,b=[]) 这种写法有什么坑
将可变对象作为默认参数，若多次调用时使用默认参数，默认参数会保留上次调用时的状态！ 1 1
```
将可变对象作为默认参数，若多次调用时使用默认参数，默认参数会保留上次调用时的状态！
```
如何实现 “1,2,3” 变成 [‘1’,’2’,’3’]
a = '1,2,3' b= a.split(',') print(b) 3 1
```
a = '1,2,3'
```
2
```
b= a.split(',')
```
3
```
print(b)
```
如何实现[‘1’,’2’,’3’]变成[1,2,3]
a = ['1','2','3'] print([int(i) for i in a]) 2 1
```
a = ['1','2','3']
```
2
```
print([int(i) for i in a])
```
a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 c = [(1,),(2,),(3,) ] 的区别？
a,b 均为整型列表， c为元组列表。 1 1
```
a,b 均为整型列表， c为元组列表。
```
如何用一行代码生成[1,4,9,16,25,36,49,64,81,100]
list1 = [i ** 2 for i in range(1, 11)] print(list1) 2 1
```
list1 = [i ** 2 for i in range(1, 11)]
```
2
```
print(list1)
```
一行代码实现删除列表中重复的值
list2 = [1,2,3,4,4,5,5,6,6,7] print(list(set(list2))) 2 1
```
list2 = [1,2,3,4,4,5,5,6,6,7]
```
2
```
print(list(set(list2)))
```
如何在函数中设置一个全局变量
def f(): global x x = 1 f() print(x) 6 1
```
def f():
```
2
```
   global x
```
3
```
   x = 1
```
4
5
```
f()
```
6
```
print(x)
```
logging模块的作用？以及应用场景
日志存储，异常记录等 1 1
```
日志存储，异常记录等
```

请用代码简答实现stack
栈：先进后出，后进先出用列表来实现： class MyStack(): def __init__(self): self.stack = [] def push(self, item): return self.stack.append(item) def pop(self): return self.stack.pop() def is_empty(self): return False if self.stack else True def size(self): return len(self.stack) def clear(self): self.stack.clear() 22 1

栈：先进后出，后进先出

用列表来实现：

class MyStack():

   def __init__(self):

     self.stack = []

   def push(self, item):

     return self.stack.append(item)

   def pop(self):

     return self.stack.pop()

   def is_empty(self):

     return False if self.stack else True

   def size(self):

     return len(self.stack)

   def clear(self):

     self.stack.clear()

常用字符串格式化哪几种
{}.format() %s %d &f 1 1
```
{}.format() %s %d &f
```
简述生成器、迭代器、可迭代对象以及应用场景生成器: 常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行应用：通过生成器表达器完成对文件的读完跟操作迭代器：可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator (x for x in range(10)) 可迭代对象： list、dict、str 把list、dict、str等可迭代对象变成迭代器可以使用iter()函数： isinstance(iter([]), Iterator) True isinstance(iter('abc'), Iterator) True 11 1
```
生成器: 常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
```
2
```
   应用：通过生成器表达器完成对文件的读完跟操作
```
3
```
迭代器：可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
```
4
```
(x for x in range(10))
```
5
```
可迭代对象：
```
6
```
list、dict、str
```
7
```
把list、dict、str等可迭代对象变成迭代器可以使用iter()函数：
```
8
```
isinstance(iter([]), Iterator)
```
9
```
True
```
10
```
isinstance(iter('abc'), Iterator)
```
11
```
True
```

用Python实现一个二分查找的函数
def BinarySearch(seq, num): if not len(seq): print('list is none') if len(seq) == 1: if seq[0] == num: print('find:{}'.format(num)) else: print('{} not exist'.format(num)) return middle = len(seq) // 2 if seq[middle - 1] == num: print("find:{}".format(num)) elif seq[middle] < num: BinarySearch(seq[middle::], num) else: BinarySearch(seq[0:middle], num) 16 1

def BinarySearch(seq, num):

   if not len(seq):

     print('list is none')

   if len(seq) == 1:

     if seq[0] == num:

      print('find:{}'.format(num))

      else:

      print('{} not exist'.format(num))

      return

   middle = len(seq) // 2

   if seq[middle - 1] == num:

     print("find:{}".format(num))

   elif seq[middle] < num:

     BinarySearch(seq[middle::], num)

   else:

     BinarySearch(seq[0:middle], num)

对闭包的理解
闭包是由函数及其相关的引用环境组合而成的实体(即：闭包=函数+引用环境) 闭包可以根据外部作用域的局部变量来得到不同的结果，这有点像一种类似配置功能的作用，我们可以修改外部的变量，闭包根据这个变量展现出不同的功能。比如有时我们需要对某些文件的特殊行进行分析，先要提取出这些特殊行 2 1
```
闭包是由函数及其相关的引用环境组合而成的实体(即：闭包=函数+引用环境)
```
2
```
闭包可以根据外部作用域的局部变量来得到不同的结果，这有点像一种类似配置功能的作用，我们可以修改外部的变量，闭包根据这个变量展现出不同的功能。比如有时我们需要对某些文件的特殊行进行分析，先要提取出这些特殊行
```
os和sys模块的作用
os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口; sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。 2 1
```
os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;
```
2
```
sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。
```
如何生成一个随机数
random模块 1 1
```
random模块
```
如何使用python删除一个文件
os.remove('path/filename') # 删除文件 1 1
```
os.remove('path/filename') # 删除文件
```
对面向对象的理解
面向对象编程是种具有对象概念的程序编程范型，同时也是一种程序开发的抽象方针。它可能包含数据、属性、代码与方法。对象则指的是类的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的可重用性、灵活性和可扩展性，对象里的程序可以访问及修改对象相关联的数据。在面向对象编程里，计算机程序会被设计成彼此相关的对象。 1 1
```
面向对象编程是种具有对象概念的程序编程范型，同时也是一种程序开发的抽象方针。它可能包含数据、属性、代码与方法。对象则指的是类的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的可重用性、灵活性和可扩展性，对象里的程序可以访问及修改对象相关联的数据。在面向对象编程里，计算机程序会被设计成彼此相关的对象。
```
面向对象中的继承有什么特点
继承更多了是为了多态，也可提升代码的复用程度。特点：在继承中基类的构造（init()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用； Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）； 4 1
```
继承更多了是为了多态，也可提升代码的复用程度。
```
2
```
特点：
```
3
```
在继承中基类的构造（init()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用；
```
4
```
Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）；
```
面向对象深度优先和广度优先是什么
当出现多重继承并产生菱形交叉时查找属性或方法路径顺序。 python2中多继承是深度优先，python3找那个多继承是广度优先 2 1
```
当出现多重继承并产生菱形交叉时查找属性或方法路径顺序。
```
2
```
python2中多继承是深度优先，python3找那个多继承是广度优先
```
面向对象中super的作用
super() 函数是用于调用父类(超类)的一个方法。　　super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。　　MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。　　Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx 4 1
```
super() 函数是用于调用父类(超类)的一个方法。
```
2
```
　　super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
```
3
```
　　MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
```
4
```
　　Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx
```
functools中的函数其作用是什么？
functools模块用于高级函数：作用于或返回其他函数的函数，一般来说，任何可调用对象都可以作为这个模块的用途来处理。 1 1
```
functools模块用于高级函数：作用于或返回其他函数的函数，一般来说，任何可调用对象都可以作为这个模块的用途来处理。
```
列举面向对象中带双下划线的特殊方法，如：__new__、__init__
__init__ 构造方法，当类被实例化的时候执行 __new__ 工厂函数，在类被实例前执行 __del__ 析构方法，当一个对象没有任何引用时执行，用于销毁对象 __call__ 允许一个类的实例像函数一样被调用 4 1
```
__init__ 构造方法，当类被实例化的时候执行
```
2
```
__new__ 工厂函数，在类被实例前执行
```
3
```
__del__ 析构方法，当一个对象没有任何引用时执行，用于销毁对象
```
4
```
__call__ 允许一个类的实例像函数一样被调用
```
如何判断是函数还是方法
区分是否有对象来带调用，有就是方法，没有就是函数 1 1
```
区分是否有对象来带调用，有就是方法，没有就是函数
```
静态方法和类方法区别
在使用静态方法时，类中的self将不会再进行传值，此时，静态方法已经和类没什么关系了。用@staticmethod 声明类方法只能访问类变量，不能访问实例变量。都能被实例和类调用 3 1
```
在使用静态方法时，类中的self将不会再进行传值，此时，静态方法已经和类没什么关系了。 用@staticmethod 声明
```
2
```
类方法只能访问类变量，不能访问实例变量。
```
3
```
都能被实例和类调用
```
列举面向对象中的特殊成员以及应用场景
构造方法 1 1
```
构造方法
```
1、2、3、4、5 能组成多少个互不相同且无重复的三位数
count = 0 for i in range(1, 6): for j in range(1, 6): for k in range(1, 6): if i != j and i != j and j != k: print('{}{}{}'.format(i, j, k)) count += 1 print(count) 8 1
```
count = 0
```
2
```
for i in range(1, 6):
```
3
```
   for j in range(1, 6):
```
4
```
     for k in range(1, 6):
```
5
```
      if i != j and i != j and j != k:
```
6
```
        print('{}{}{}'.format(i, j, k))
```
7
```
        count += 1
```
8
```
print(count)
```
什么是反射？以及应用场景？
getattr() 它接收2个参数，前面的是一个对象或者模块，后面的是一个字符串，注意了！是个字符串例子，用户输入储存在inp中，这个inp就是个字符串，getattr函数让程序去commons这个模块里，寻找一个叫inp的成员（是叫，不是等于），这个过程就相当于我们把一个字符串变成一个函数名的过程。然后，把获得的结果赋值给func这个变量，实际上func就指向了commons里的某个函数。最后通过调用func函数，实现对commons里函数的调用。这完全就是一个动态访问的过程，一切都不写死，全部根据用户输入来变化。 3 1
```
getattr()
```
2
```
它接收2个参数，前面的是一个对象或者模块，后面的是一个字符串，注意了！是个字符串
```
3
```
例子，用户输入储存在inp中，这个inp就是个字符串，getattr函数让程序去commons这个模块里，寻找一个叫inp的成员（是叫，不是等于），这个过程就相当于我们把一个字符串变成一个函数名的过程。然后，把获得的结果赋值给func这个变量，实际上func就指向了commons里的某个函数。最后通过调用func函数，实现对commons里函数的调用。这完全就是一个动态访问的过程，一切都不写死，全部根据用户输入来变化。
```
metaclass作用？以及应用场景
元类就是创建类对象 Django ORM 1 1
```
元类就是创建类对象 Django ORM
```

用尽量多的方法实现单例模式
#1. 装饰器实现 def Singleton(cls): _instance = {} def wrapper(*args, **kwargs): if cls not in _instance: _instance[cls] = cls(*args, **kwargs) return _instance[cls] return wrapper @Singleton class A(object): def __init__(self, a): self.a = a print self.a #2. 重新__new__方法 (有坑，__init__会执行多次) import threading class B(object): lock = threading.Lock() _instance = None def __init__(self): self.b = {} def __new__(cls, *args, **kwargs): if not B._instance: with B.lock: if not B._instance: B._instance = object.__new__(cls) return B._instance #3. 元类实现 class SingletonType(type): def __init__(self, *args, **kwargs): super(SingletonType, self).__init__(*args, **kwargs) def __call__(cls, *args, **kwargs): # 这里的cls，即Foo类 print('cls', cls) obj = cls.__new__(cls, *args, **kwargs) cls.__init__(obj, *args, **kwargs) # Foo.__init__(obj) return obj metaclass = SingletonType class Foo(): # 指定创建Foo的type为SingletonType def __init__(self, name): self.name = name def __new__(cls, *args, **kwargs): return object.__new__(cls) #4.模块实现 a.py class A(object): def __init__(self, a): self.a = a print self.a objA = A('aaa') print(id(objA)) b.py from a import objA print(id(objA)) 70 1

#1. 装饰器实现

def Singleton(cls):

   _instance = {}

   def wrapper(*args, **kwargs):

     if cls not in _instance:

      _instance[cls] = cls(*args, **kwargs)

     return _instance[cls]

   return wrapper

@Singleton

class A(object):

   def __init__(self, a):

     self.a = a

     print self.a

#2. 重新__new__方法  (有坑，__init__会执行多次)

import threading

class B(object):

   lock = threading.Lock()

   _instance = None

   def __init__(self):

     self.b = {}

   def __new__(cls, *args, **kwargs):

     if not B._instance:

      with B.lock:

          if not B._instance:

           B._instance = object.__new__(cls)

     return B._instance

#3. 元类实现

class SingletonType(type):

   def __init__(self, *args, **kwargs):

     super(SingletonType, self).__init__(*args, **kwargs)

   def __call__(cls, *args, **kwargs):  # 这里的cls，即Foo类

     print('cls', cls)

     obj = cls.__new__(cls, *args, **kwargs)

     cls.__init__(obj, *args, **kwargs)  # Foo.__init__(obj)

     return obj

metaclass = SingletonType

class Foo():  # 指定创建Foo的type为SingletonType

   def __init__(self, name):

     self.name = name

   def __new__(cls, *args, **kwargs):

     return object.__new__(cls)

#4.模块实现

a.py

class A(object):

   def __init__(self, a):

     self.a = a

     print self.a

objA = A('aaa')

print(id(objA))

b.py

from a import objA

print(id(objA))

装饰器的写法以及应用场景
#闭包的形式，接受一个函数，返回内部函数，内湖函数中有对接受的函数的处理。装饰器可以在不影响原函数的情况下拓展自定义功能，提代码的复用性。 def output_current_time(func): def warpper(*args,**kargs): import datetime now_time = datetime.datetime.now() print(now_time) res = func() return res return warpper @output_current_time def task(): print('do task') 13 1

#闭包的形式，接受一个函数，返回内部函数，内湖函数中有对接受的函数的处理。装饰器可以在不影响原函数的情况下拓展自定义功能，提代码的复用性。

def output_current_time(func):

   def warpper(*args,**kargs):

     import datetime

     now_time = datetime.datetime.now()

     print(now_time)

     res = func()

     return res

   return warpper

@output_current_time

def task():

   print('do task')

异常处理写法以及如何主动跑出异常
try: 可能出现异常的代码块 except Exception as es: 出现的异常的处理方式主动抛出异常：raise 6 1
```
try:
```
2
```
   可能出现异常的代码块
```
3
```
except Exception as es:
```
4
```
   出现的异常的处理方式
```
5
6
```
主动抛出异常：raise
```
什么是面向对象的mro
python中至少有三种不同的MRO: 经典类(calssic class)，深度优先遍历在python2.2中提出了type和class的统一，出现了一个内建类型以及自定义类的公共祖先object，即新式类(new-style class)预计算 python2.3之后新式类的C3算法，这是python3唯一支持的方式 5 1
```
python中至少有三种不同的MRO:
```
2
3
```
经典类(calssic class)，深度优先遍历
```
4
```
在python2.2中提出了type和class的统一，出现了一个内建类型以及自定义类的公共祖先object，即新式类(new-style class)预计算
```
5
```
python2.3之后新式类的C3算法，这是python3唯一支持的方式
```
isinstance作用以及应用场景
isinstance用于类型判断：接受两个参数：第一个为:object对象，第二个为类型类型比如，要判断3是不是int类型： isinstance(3,int) 如果时返回True，否则返回False 5 1
```
isinstance用于类型判断：
```
2
```
接受两个参数：第一个为:object对象，第二个为类型类型
```
3
```
比如，要判断3是不是int类型：
```
4
```
isinstance(3,int)
```
5
```
如果时返回True，否则返回False
```
写代码并实现：
给定一个整数数和一个目标值，找出数组中和为目标值的两个数, 你可以假设每个输入只对应一种答案，且元素不能被重复利用 # 例子: #nums = [2,7,11,15],target=9 #因为nums[0]+nums[1]=2+7=9 #所以返回[0,1] # code： list1 = [1, 4, 6, 8, 9] target_num = 15 def twoSum(listobj, target_num): d = {} # 用来存放元素与下标的对应关系 for i, v in enumerate(listobj): if target_num - v in d: return [d[target_num - v], i] d[v] = i print(twoSum(list1, target_num)) 18 1
```
# 例子:
```
2
```
#nums = [2,7,11,15],target=9
```
3
```
#因为nums[0]+nums[1]=2+7=9
```
4
```
#所以返回[0,1]
```
5
6
```
# code：
```
7
8
```
list1 = [1, 4, 6, 8, 9]
```
9
```
target_num = 15
```
10
11
```
def twoSum(listobj, target_num):
```
12
```
   d = {}# 用来存放元素与下标的对应关系
```
13
```
   for i, v in enumerate(listobj):
```
14
```
     if target_num - v in d:
```
15
```
      return [d[target_num - v], i]
```
16
```
     d[v] = i
```
17
```
     
```
18
```
print(twoSum(list1, target_num))
```
json序列化时，可以处理的数据类型有哪些？如何定制支持datetime类型
# 可以处理 : list,dict,int,str,float,object # 支持datetime? #关键在于重写JSONEncoder的default方法 import json from json import JSONEncoder from datetime import datetime class ComplexEncoder(JSONEncoder): def default(self, obj): if isinstance(obj, datetime): # 如果obj是datatime类型就将obj格式化为字符串 return obj.strftime('%Y-%m-%d %H:%M:%S') else: # 否则交给父类的delault处理 return super(ComplexEncoder, self).default(obj) d = {'name': 'alex', 'data': datetime.now()} print(json.dumps(d, cls=ComplexEncoder)) 19 1
```
# 可以处理 : list,dict,int,str,float,object
```
2
3
```
# 支持datetime?
```
4
```
#关键在于重写JSONEncoder的default方法
```
5
```
 
```
6
```
import json
```
7
```
from json import JSONEncoder
```
8
```
from datetime import datetime
```
9
10
11
```
class ComplexEncoder(JSONEncoder):
```
12
```
  def default(self, obj):
```
13
```
     if isinstance(obj, datetime): #  如果obj是datatime类型 就将obj格式化为字符串
```
14
```
        return obj.strftime('%Y-%m-%d %H:%M:%S')
```
15
```
      else:  # 否则交给父类的delault处理
```
16
```
      return super(ComplexEncoder, self).default(obj)
```
17
```
     
```
18
```
d = {'name': 'alex', 'data': datetime.now()}
```
19
```
print(json.dumps(d, cls=ComplexEncoder))
```
json序列化时，默认遇到中文会转换成unicode，如果想要保留中文怎么办
# 这是因为json.dumps 序列化时对中文默认使用的ascii编码 jsonData = json.dumps({'name': '小明同学'}, ensure_ascii=False) print(jsonData) 3 1
```
# 这是因为json.dumps 序列化时对中文默认使用的ascii编码
```
2
```
jsonData = json.dumps({'name': '小明同学'}, ensure_ascii=False)
```
3
```
print(jsonData)
```
什么是断言？应用场景
# Python的assert是用来检查一个条件，如果它为真，就不做任何事。如果它为假，则会抛出AssertError并且包含错误信息。例如： x = 23 assert x > 0, "x is not zero or negative" assert x%2 == 0, "x is not an even number" #场景： """ 　　☆防御型的编程　　☆运行时检查程序逻辑　　☆检查约定　　☆程序常量　　☆检查文档 """ # 在unittest中很常用 x 1
```
# Python的assert是用来检查一个条件，如果它为真，就不做任何事。如果它为假，则会抛出AssertError并且包含错误信息。例如：
```
2
```
x = 23
```
3
```
assert x > 0, "x is not zero or negative"
```
4
```
assert x%2 == 0, "x is not an even number"
```
5
6
```
#场景：
```
7
```
"""
```
8
```
　　☆防御型的编程
```
9
```
　　☆运行时检查程序逻辑
```
10
```
　　☆检查约定
```
11
```
　　☆程序常量
```
12
```
　　☆检查文档
```
13
```
"""
```
14
```
# 在unittest中很常用
```
with语句 # with语句的作用是通过某种方式简化异常处理，它是所谓的上下文管理器的一种 # 例如： with open(filepath,'r') as f : ······· # 自动管理文件关闭不用我们先open再close 5 1
```
# with语句的作用是通过某种方式简化异常处理，它是所谓的上下文管理器的一种
```
2
```
# 例如：
```
3
```
with open(filepath,'r')  as f :
```
4
```
  ·······
```
5
```
# 自动管理文件关闭 不用我们先open再close
```
使用代码实现查看列举目录下的所有文件,过滤文件夹 import os for file in os.listdir(): if os.path.isfile(file): print(file) 4 1
```
import os
```
2
```
for file in os.listdir():
```
3
```
  if os.path.isfile(file):
```
4
```
     print(file)
```
简述 yield和yield from关键字
https://www.cnblogs.com/gqtcgq/p/8126124.html # 这篇博客讲的很好 1
```
https://www.cnblogs.com/gqtcgq/p/8126124.html # 这篇博客讲的很好
```

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航