目录
Python
内置函数(常用)
2. all() 函数用于判断给定的参数中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True；空元组、空列表返回值为True。
print( all( [0.1,1,-1] ) ) # 返回 True
print( all( (None,1) ) ) # 返回 False（其中一个元素为None）
print( all( [0,1,-1] ) ) # 返回 False（其中一个元素为0）
print( all( [" ","a",""] ) ) # 返回 False(第三个元素为空)
3. any() 函数用于判断给定的参数是否全部为False，是则返回False，如果有一个为True，则返回True。 元素除了是 0、空、False外都算 TRUE。
复制代码
# 参数全部不为 0、空、FALSE
print(any("-45")) # True
print(any(["-45"])) # True
print( any( ("0","ab","") ) ) # True（注意：第一个参数0加了双引号，表示为一个字符串）
# 参数全部为 0、空、False
print( any( (0,"") ) ) # False
print( any( (0,"",False) ) ) # False
10. dir()函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
复制代码
print( dir() ) # 获得当前模块的属性列表
# 返回：['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
print( dir([]) ) # 查看列表的方法
# 返回：['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__',
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__',
'__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse',
'sort']
14. exec() 执行储存在字符串或文件中的Python语句，相比于eval，exec可以执行更复杂的Python代码。
exec("print('Hello World')") # 执行简单的字符串
# Hello World
复制代码
exec("for i in range(5): print('iter time is %d'%i)") # 执行复杂的for循环
# iter time is 0
# iter time is 1
# iter time is 2
# iter time is 3
# iter time is 4
22. help() 函数用于查看函数或模块用途的详细说明。
help('sys') # 查看 sys 模块的帮助
help('str') # 查看 str 数据类型的帮助
a = [1,2,3]
help(a) # 查看列表 list 帮助信息
help(a.append) # 显示list的append方法的帮助
27. isinstance() 函数来判断一个对象是否是一个已知的类型，返回布尔值。类似 type()。
复制代码
a = 2
print(isinstance(a,int)) # True
print(isinstance(a,str)) # False
print(isinstance(a,(str,tuple,dict))) # False
print(isinstance(a,(str,tuple,int))) # 是元组其中的一个则返回True
复制代码
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
示例：
复制代码
1 class A:
2 pass
3
4 class B(A):
5 pass
6
7 print(isinstance(A(),A)) # True
8 print( type(A()) == A ) # True
9
10 print(isinstance(B(),A)) # True
11 print( type(B()) == A ) # False --type()不考虑继承关系
28. issubclass()用于判断参数class是否是类型参数classinfo的子类，是则返回True，否则返回False。
语法：issubclass(class,classinfo)。
复制代码
1 class a:
2 pass
3 class b(a): # b继承了a，即b是a的子类
4 pass
5
6 print(issubclass(a,b)) # 判断 a 是 b 的子类？
7 # False
8 print(issubclass(b,a)) # 判断 b 是 a 的子类？
9 # True
复制代码
48. sorted() 函数对所有可迭代的对象进行排序（默认升序）操作。
复制代码
# 对列表进行排序
print(sorted([1,2,5,30,4,22])) # [1, 2, 4, 5, 22, 30]
# 对字典进行排序
dict = {23:42,1:0,98:46,47:-28}
print( sorted(dict) ) # 只对key排序
# [1, 23, 47, 98]
print( sorted(dict.items()) ) # 默认按key进行排序
# [(1, 0), (23, 42), (47, -28), (98, 46)]
print( sorted(dict.items(),key=lambda x:x[1]) ) # 用匿名函数实现按value进行排序
# [(47, -28), (1, 0), (23, 42), (98, 46)]
复制代码
复制代码
# 利用key进行倒序排序
test1 = [1,2,5,30,4,22]
r_list = sorted(test1,key=lambda x:x*-1)
print(r_list) # [30, 22, 5, 4, 2, 1]
# 要进行反向排序，也可以通过传入第三个参数 reverse=True：
test2 = [1,2,5,30,4,22]
print(sorted(test2,reverse=True)) # [30, 22, 5, 4, 2, 1]
内置函数
1. abs()函数返回数字的绝对值。
print( abs(-45) ) # 返回 45
print("abs(0.2):",abs(0.2)) # 返回 abs(0.2): 0.2
2. all() 函数用于判断给定的参数中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True；空元组、空列表返回值为True。
print( all( [0.1,1,-1] ) ) # 返回 True
print( all( (None,1) ) ) # 返回 False（其中一个元素为None）
print( all( [0,1,-1] ) ) # 返回 False（其中一个元素为0）
print( all( [" ","a",""] ) ) # 返回 False(第三个元素为空)
3. any() 函数用于判断给定的参数是否全部为False，是则返回False，如果有一个为True，则返回True。 元素除了是 0、空、False外都算 TRUE。
复制代码
# 参数全部不为 0、空、FALSE
print(any("-45")) # True
print(any(["-45"])) # True
print( any( ("0","ab","") ) ) # True（注意：第一个参数0加了双引号，表示为一个字符串）
# 参数全部为 0、空、False
print( any( (0,"") ) ) # False
print( any( (0,"",False) ) ) # False
复制代码
4. bin()函数返回一个整数int或者长整数long int的二进制表示。
print( bin(10) ) # 0b1010
print( bin(133) ) # 0b10000101
5. bool() 函数用于将给定参数转换为布尔类型，如果参数不为空或不为0，返回True；参数为0或没有参数，返回False。
复制代码
print( bool(10) ) # True
print( bool([0]) ) # True
print( bool(["123","s",0]) ) # True
print( bool(0) ) # False
print( bool() ) # False
复制代码
6. bytearray()方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256（即0-255）。即bytearray()是可修改的二进制字节格式。
1 b = bytearray("abcd",encoding="utf-8")
2 print(b[0]) # 返回数字97，即把“abcd”的“a"对应的ascii码打印出来了
3 b[0] = 99 # 把字符串第一个字节修改为99（即对应字母为“c”）
4 print(b) # 返回：bytearray(b'cbcd')---第一个字节a已被修改为c
7. callable()函数用于检查一个对象是否可调用的。对于函数、方法、lambda函式、类以及实现了 __call__ 方法的类实例, 它都返回 True。（可以加括号的都可以调用）
1 def sayhi():pass # 先定义一个函数sayhi()
2 print( callable( sayhi ) ) # True
1 a = 1
2 print( callable( a ) ) # False
8. chr()函数用一个范围在range(256)内（即0～255）的整数作参数，返回一个对应的ASCII数值。
# 把数字98在ascii码中对应的字符打印出来
print( chr(98) ) # 返回：b
9. dict()函数用来将元组/列表转换为字典格式。
复制代码
print(dict(a='a', b='b', t='t'))
# 返回：{'b': 'b', 'a': 'a', 't': 't'}
print(dict( [ ('one',1),('two',2),('three',3) ] ) ) # 可迭代对象方式来构造字典
# 返回：{'two': 2, 'one': 1, 'three': 3}
print(dict(zip(["1","2","3"],["a","b","c"]))) # 映射函数方式来构造字典
# 返回：{'2': 'b', '3': 'c', '1': 'a'}
复制代码
10. dir()函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
复制代码
print( dir() ) # 获得当前模块的属性列表
# 返回：['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
print( dir([]) ) # 查看列表的方法
# 返回：['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__',
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__',
'__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse',
'sort']
复制代码
11. divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组（商x，余数y）。
print( divmod(5,2) ) # 返回：(2, 1)
print( divmod(5,1) ) # 返回：(5, 0)
print( divmod(5,3) ) # 返回：(1, 2)
12. enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。Python 2.3. 以上版本可用，2.6 添加 start 参数。
1 seasons = ['Spring', 'Summer', 'Fall', 'Winter']
2 print(list(enumerate(seasons)))
# 返回：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
1 print(list(enumerate(seasons, start=1)) ) # 下标从 1 开始
# 返回：[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
13. eval() 函数用来执行一个字符串表达式，并返回表达式的值。
print(eval('3 * 2')) # 6
1 x = 7
2 print(eval('3 + x')) # 10
14. exec() 执行储存在字符串或文件中的Python语句，相比于eval，exec可以执行更复杂的Python代码。
exec("print('Hello World')") # 执行简单的字符串
# Hello World
复制代码
exec("for i in range(5): print('iter time is %d'%i)") # 执行复杂的for循环
# iter time is 0
# iter time is 1
# iter time is 2
# iter time is 3
# iter time is 4
复制代码
15. filter()用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，可用list()来转换为列表。
注意： filter()接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回True或 False，最后将返回 True 的元素放到新列表中。
复制代码
res = filter(lambda n:n>5,range(10)) # 过滤掉0-9中不符合n>5的数据
for i in res: # 循环打印符合n>5的数据
print(i)
# 5
# 6
# 7
# 8
# 9
复制代码
16. format()是一种格式化字符串的函数 ，基本语法是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数，位置可以不按顺序。
复制代码
# 位置映射
print( "{}{}".format('a','1') )
# a1
print('name:{n},url:{u}'.format(n='alex',u='www.xxxxx.com'))
# name:alex,url:www.xxxxx.com
复制代码
复制代码
# 元素访问
print( "{0[0]},{0[1]}".format(('baidu','com')) ) # 按顺序
# baidu,com
print( "{0[2]},{0[0]},{0[1]}".format(('baidu','com','www')) ) # 不按顺序
# www,baidu,com
复制代码
17. float() 函数用于将整数和字符串转换成浮点数。
复制代码
print(float(1))
# 1.0
print(float(0.1))
# 0.1
print(float('123'))
# 123.0
复制代码
18. frozenset() 返回一个冻结的集合（一个无序的不重复元素序列），冻结后集合不能再添加或删除任何元素。
复制代码
1 a = frozenset(range(10)) # 先创建一个冻结集合
2 print(a)
3 # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
4
5 del a[0] # 试图删除冻结集合a中的元素，报错
6 # TypeError: 'frozenset' object doesn't support item deletion
复制代码
1 b = frozenset("happy") # 将字符串转换成一个集合
2 print(b)
3 # frozenset({'a', 'h', 'p', 'y'}) # 无序不重复
1 c = frozenset() # 创建一个空集合
2 print(c)
3 # frozenset() # 如果不提供任何参数，默认会生成空集合
19. globals() 函数会以字典格式返回当前位置的全部全局变量。
复制代码
print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
# {'__file__': 'C:/Users/Administrator/PycharmProjects/test/day4/内置函数-globals().py', '__spec__': None, '__doc__': None, '__package__': None,
'a': 'append', '__cached__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000000666B00>,
'__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__'}
复制代码
20. hasattr() 函数用于判断对象是否包含对应的属性。如果对象有该属性返回 True，否则返回 False。
复制代码
1 class t:
2 a = 1
3 b = 2
4 c = 3
5
6 p = t()
7 print(hasattr(p,'a')) # True
8 print(hasattr(p,'b')) # True
9 print(hasattr(p,'x')) # False
复制代码
21. hash() 用于获取一个对象（数字或者字符串等）的哈希值。不能直接应用于 list、set、dictionary。
注意：在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。
print(hash(1)) # 1
print(hash(20000)) # 20000
print(hash('123')) # -6436280630278763230
print(hash('ab12')) # 5468785079765213470
print(hash('ab12')) # 5468785079765213470
22. help() 函数用于查看函数或模块用途的详细说明。
help('sys') # 查看 sys 模块的帮助
help('str') # 查看 str 数据类型的帮助
a = [1,2,3]
help(a) # 查看列表 list 帮助信息
help(a.append) # 显示list的append方法的帮助
23. hex() 函数用于将一个整数转换为十六进制数。返回一个字符串，以0x开头。
print(hex(1)) # 0x1
print(hex(-256)) # -0x100
print(type(hex(-256))) #<class 'str'>
24. id()函数用于获取对象的内存地址。
复制代码
a = "123" # 字符串
print(id(a)) # 13870392
b = [1,2,3] # 列表
print(id(b)) # 7184328
c = {'num1':1,'num2':2,'num3':3} # 字典
print(id(c)) # 6923656
复制代码
25. input() 函数接受一个标准输入数据，返回为 string 类型。这个函数是最最常用的了。在Python3.x中 raw_input() 和 input() 进行了整合，仅保留了input( )函数。
复制代码
a = '123456'
b = input("username:")
if b == a : # 如果b的输入数据等于a存储的数据，打印”right“
print("right")
else: # 否则打印”wrong“
print("wrong")
复制代码
26. int() 函数用于将一个字符串或数字转换为整型。
print(int()) # 不传入参数时，得到结果0
print(int(0.5)) # 去掉小数部分，得到结果0
print(int(3)) # 得到结果3
print(int('0xa',16)) # 十六进制数“0xa”转换成十进制整数，得到结果10
print(int('00010',2)) # 二进制数“00010”转换成十进制整数，得到结果2
27. isinstance() 函数来判断一个对象是否是一个已知的类型，返回布尔值。类似 type()。
复制代码
a = 2
print(isinstance(a,int)) # True
print(isinstance(a,str)) # False
print(isinstance(a,(str,tuple,dict))) # False
print(isinstance(a,(str,tuple,int))) # 是元组其中的一个则返回True
复制代码
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
示例：
复制代码
1 class A:
2 pass
3
4 class B(A):
5 pass
6
7 print(isinstance(A(),A)) # True
8 print( type(A()) == A ) # True
9
10 print(isinstance(B(),A)) # True
11 print( type(B()) == A ) # False --type()不考虑继承关系
复制代码
28. issubclass()用于判断参数class是否是类型参数classinfo的子类，是则返回True，否则返回False。
语法：issubclass(class,classinfo)。
复制代码
1 class a:
2 pass
3 class b(a): # b继承了a，即b是a的子类
4 pass
5
6 print(issubclass(a,b)) # 判断 a 是 b 的子类？
7 # False
8 print(issubclass(b,a)) # 判断 b 是 a 的子类？
9 # True
复制代码
29. iter() 函数用来生成迭代器。list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器，然后可以对获取到的迭代器不断用next()函数来获取下条数据。iter()函数实际上就是调了可迭代对象的 __iter__ 方法。
# 注意：当已经迭代完最后一个数据之后，再次调用next()函数会抛出 StopIteration的异常，来告诉我们所有数据都已迭代完成。
复制代码
1 it = [1,2,3]
2 it_list = iter(it)
3
4 print(next(it_list))
5 # 1
6 print(next(it_list))
7 # 2
8 print(next(it_list))
9 # 3
10 print(next(it_list))
11 # StopIteration
复制代码
30. len() 方法返回对象（字符、列表、元组等）长度或元素个数。
复制代码
# len()方法返回对象（字符、列表、元组等）长度或元素个数。
print(len('1234')) # 字符串，返回字符长度4
print(len(['1234','asd',1])) # 列表，返回元素个数3
print(len((1,2,3,4,50))) # 元组，返回元素个数5
print(len(12)) # 注意：整数类型不适用，否则报错
# TypeError: object of type 'int' has no len()
复制代码
31. list() 方法用于将元组转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
print( list((1,2,3))) # [1, 2, 3]
32. map()接收函数f和list，并通过把函数f依次作用在list的每个元素上，得到一个新的list并返回。
复制代码
1 res = map(lambda n: n*2,[0,1,2,3,4,5]) # 使用 lambda 匿名函数
2 for i in res:
3 print(i)
4
5 # 返回以下数据：
6 # 0
7 # 2
8 # 4
9 # 6
10 # 8
11 # 10
复制代码
复制代码
1 # 提供了两个列表，对相同位置的列表数据进行相加
2
3 a = map(lambda x,y : x+y,[1,2,3,4,5],[2,4,6,8,10])
4 for i in a:
5 print(i)
6
7 # 返回以下数据：
8 # 3
9 # 6
10 # 9
11 # 12
12 # 15
复制代码
33. max()函数返回给定参数的最大值，参数可以为序列。
复制代码
print("max(10,20,30):" , max(10,20,30) )
# max(10,20,30): 30
print("max(10,-2,3.4):" , max(10,-2,3.4) )
# max(10,-2,3.4): 10
print("max({'b':2,'a':1,'c':0}):" , max({'b':2,'a':1,'c':0}) ) # 字典，默认按key排序
# max({'b':2,'a':1,'c':0}): c
复制代码
34. min()函数返回给定参数的最小值，参数可以为序列。
复制代码
print("min(10,20,30):" , min(10,20,30) )
# min(10,20,30): 10
print("min(10,-2,3.4):" , min(10,-2,3.4) )
# min(10,-2,3.4): -2
print("min({'b':2,'a':1,'c':0}):" , min({'b':2,'a':1,'c':0}) ) # 字典，默认按key排序
# min({'b':2,'a':1,'c':0}): a
复制代码
35. next() 返回迭代器的下一个项目。
复制代码
1 # 首先获得Iterator对象:
2 it = iter([1,2,3,4,5])
3
4 # 循环:
5 while True:
6 try:
7 # 获得下一个值:
8 x = next(it)
9 print(x)
10 except StopIteration:
11 break
12 # 遇到StopIteration就退出循环
复制代码
36. oct() 函数将一个整数转换成八进制字符串。
print( oct(10) ) # 0o12
print( oct(255) ) # 0o377
print( oct(-6655) ) # -0o14777
37. open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
f = open("test1.txt","w",encoding="utf-8") # 创建一个file
print(f.write("abc"))
f = open("test1.txt","r",encoding="utf-8") # 读取文件数据
print(f.read())
38. ord()函数是chr()的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的ASCII数值，或者Unicode数值，如果所给的 Unicode 字符超出了定义范围，则会引发一个 TypeError 的异常。
# 把字符 b（长度为1的字符串）作为参数在ascii码中对应的字符打印出来
print( ord('b') ) # 返回：98
print( ord('%') ) # 返回：37
39. pow()函数返回x的y次方的值。
注意：pow()通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。
复制代码
# 通过内置的方法直接调用
print( pow(2,2) ) # 2的二次方
# 4
print( pow(2,-2) ) # 2的负二次方
# 0.5
复制代码
复制代码
1 # 导入math模块
2
3 import math
4
5 print(math.pow(3,2)) # 3的负二次方
6 # 9.0
复制代码
40. print()用于打印输出，最常见的一个函数。print 在Python3.x是一个函数，但在Python2.x版本只是一个关键字。
print( abs(-45) ) # 45
print("Hello World!") # Hello World!
print([1,2,3]) # [1, 2, 3]
41. range() 函数可创建一个整数列表，一般用在 for 循环中。语法：range(start, stop[, step])
复制代码
for i in range(10):
print(i) # 依次打印数字0-9
for a in range(0,10,2): # 步长为2
print(a) # 打印0,2,4,6,8
for b in range(10, 0, -2): # 步长为-2
print(b) # 打印10,8,6,4,2
复制代码
42. reduce() 函数会对参数序列中元素进行累积。在Python3 ，reduce()被放置在functools模块里，如果想要使用它，需要先引入functools模块。
复制代码
import functools
a = functools.reduce(lambda x,y:x+y,[1,2,3])
print(a) # 6 ， 即从1加到3
b = functools.reduce(lambda x,y:x+y,range(10))
print(b) # 45 ， 即从0加到9
复制代码
43. repr() 函数将对象转化为供解释器读取的形式。返回一个对象的 string 格式。
复制代码
r = repr((1,2,3))
print( r ) # (1, 2, 3)
print( type(r) ) # <class 'str'>
dict = repr({'a':1,'b':2,'c':3})
print( dict ) # {'c': 3, 'a': 1, 'b': 2}
print( type(dict) ) # <class 'str'>
复制代码
44. reversed() 函数返回一个反转的迭代器。 reversed(seq)要转换的序列，可以是 tuple, string, list 或 range。
复制代码
rev = reversed( [1,2,3,4,5] ) # 列表
print(list(rev))
# [5, 4, 3, 2, 1]
rev1 = reversed( "school" ) # 元组
print(tuple(rev1))
# ('l', 'o', 'o', 'h', 'c', 's')
rev2 = reversed(range(10)) # range
print(list(rev2))
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
复制代码
45. round() 方法返回浮点数x的四舍五入值。（除非对精确度没什么要求，否则尽量避开用round()函数）
复制代码
print( round(4.3)) # 只有一个参数时，默认保留到整数
# 4
print( round(2.678,2)) # 保留2位小数
# 2.68
print( round(5/3,3)) # 运算表达式并保留3位小数
# 1.667
复制代码
46. set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
1 a = set('school')
2 print(a) # 重复的被删除，得到结果：{'o', 'c', 's', 'l', 'h'}
复制代码
1 b = set([1,2,3,4,5])
2 c = set([2,4,6,8,10])
3
4 print(b & c) # 交集，得到结果为{2, 4}
5 print(b | c) # 并集，得到结果为{1, 2, 3, 4, 5, 6, 8, 10}
6 print(b - c) # 差集，得到结果为{1, 3, 5}
复制代码
47. slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
a = slice("school")
print(a) # slice(None, 'school', None)
48. sorted() 函数对所有可迭代的对象进行排序（默认升序）操作。
复制代码
# 对列表进行排序
print(sorted([1,2,5,30,4,22])) # [1, 2, 4, 5, 22, 30]
# 对字典进行排序
dict = {23:42,1:0,98:46,47:-28}
print( sorted(dict) ) # 只对key排序
# [1, 23, 47, 98]
print( sorted(dict.items()) ) # 默认按key进行排序
# [(1, 0), (23, 42), (47, -28), (98, 46)]
print( sorted(dict.items(),key=lambda x:x[1]) ) # 用匿名函数实现按value进行排序
# [(47, -28), (1, 0), (23, 42), (98, 46)]
复制代码
复制代码
# 利用key进行倒序排序
test1 = [1,2,5,30,4,22]
r_list = sorted(test1,key=lambda x:x*-1)
print(r_list) # [30, 22, 5, 4, 2, 1]
# 要进行反向排序，也可以通过传入第三个参数 reverse=True：
test2 = [1,2,5,30,4,22]
print(sorted(test2,reverse=True)) # [30, 22, 5, 4, 2, 1]
复制代码
49. str() 函数将对象转化为string格式。
1 a = str((1,2,3))
2 print(a) # 打印a，得到结果(1, 2, 3)
3 print(type(a)) # 打印a的类型，得到结果 <class 'str'>
50. sum()函数对参数进行求和计算。
print( sum([1,2,3]) ) # 6
print( sum([1,2,3],4) ) # 列表计算总和后再加4，得到结果10
print( sum( (1,2,3),4 ) ) # 元组计算总和后再加4，得到结果10
51. tuple()函数将列表转换为元组。
# 注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
print( tuple([1, 2, 3])) # (1,2,3)
52. type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
print(type(1)) # <class 'int'>
print(type("123")) # <class 'str'>
print(type([123,456])) # <class 'list'>
print(type( (123,456) ) ) # <class 'tuple'>
print(type({'a':1,'b':2}) ) # <class 'dict'>
53. zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。可以使用 list() 转换来输出列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。利用 * 号操作符，可以将元组解压为列表。
复制代码
1 a = [1,2,3]
2 b = [4,5,6]
3 c = [7,8,9,10]
4
5 for i in zip(a,b):
6 print(i)
7
8 # 返回结果：
9 # (1, 4)
10 # (2, 5)
11 # (3, 6)
12
13 print(list(zip(a,b))) # list() 转换为列表
14 # [(1, 4), (2, 5), (3, 6)]
15
16 print(list(zip(b,c))) # 元素个数与最短的列表一致
17 # [(4, 7), (5, 8), (6, 9)]
18
19 a1,a2 = zip(*zip(a,b)) # 用zip(*)解压
20 print(list(a1)) # [1, 2, 3]
21 print(list(a2)) # [4, 5, 6]
复制代码
54. __import__() 函数用于动态加载类和函数。如果一个模块经常变化就可以使用 __import__() 来动态载入。
__import__('decorator')
# 返回结果如下：
# in the bar
# the func run time is 3.000171661376953
# 首先获得Iterator对象:
it = iter([1,2,3,4,5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration:
break
# 遇到StopIteration就退出循环
文件操作
总结Python中的open()方法
复制代码
message= {'企业即时通信': 'aaa', '企业名称': 'bbb'}
with open("..\\r.txt", "a", encoding="utf-8") as f:
f.write(json.dumps(message, ensure_ascii=False)+'\n')
f.close()
复制代码
opne()的第一个参数是路径+文件名，第二个参数是mode打开模式，也就是说你要只读，还是只写，还是读写，第三个参数是编码格式。
Mode打开模式的值：
Mode
描述
r
只读，待打开文件必须存在
w
只写，如果待打开文件已存在，会先清空，不存在则创建
a
只写，如果文件已存在，不会清空，接着往后追加
r+
读写，文件必须存在
w+
读写，如果待打开文件已存在，会先清空，不存在则创建
a+
读写，如果文件已存在，不会清空，接着往后追加
如果想写入的是图片或者视频音频等，那么你需要用二进制形式写入，也就是在mode的后面加一个b,比如下面这段就是将photo这张图写入a.png
复制代码
import requests
photo = requests.get("https://mail.263.net/custom_login/images/domain_logo.png")
with open("..\\a.png", "wb") as f:
f.write(photo.content) # photo.content是photo这张图的二进制写法
f.close()
复制代码
with open("..\\a.png","r+b") as ff:
pngdata = ff.read()
print(pngdata) #打印出来的和photo.content内容一样
注意为什么我要用with open as这种方式打开文件：
因为如果不使用这种方式，使用最简单的 f = open(“a.png”)，必须记得写f.close().而且如果a.png没有找到，会报IOError，这个时候f.close()就调用不到，如果想要无论有没有打开文件都执行关闭文件，就要手动加上try finally…
With open as就不会这么麻烦，会自动帮我们调用f.close()，所以代码中可以不必写f.close()。
事例中的json.dumps(message, ensure_ascii=False)这句话，因为我的message是一个字典，如果要把message写入文件，需要转为字符串，所以使用json.dumps()方法，如果想要将dict类型写入json文件也必须用这个方法转换一下，而ensure_ascii=False这个参数是为了写入汉字的时候就是写入汉字，而不是ucs2编码。
oop理解
类_方法，只能类内部，外部调用
类__方法,只能在类内部调用
而其他方法可以被对象调用
装饰器
#装饰器
什么是装饰器？
指的定义一个函数，该函数是用来为其他函数添加额外的功能
为什么要用装饰器
装饰器就是在不修改被装饰器对象源代码以及调用方式的前提下为被装饰对象添加新功能
如何用
import time
# 装饰器
def timmer(func):
def wrapper(*args, **kwargs):
start = time.time()
res = func(*args, **kwargs)
stop = time.time()
print(stop - start)
return res
return wrapper
# 在被装饰对象正上方的单独一行写@装饰器名字
@timmer # 等于index=timmer(index)
def index(x, y, z):
time.sleep(3)
print('index %s %s %s' % (x, y, z))
@timmer # home=timmer(ome)
def home(name):
time.sleep(2)
print('welcome %s to home page' % name)
index(x=1, y=2, z=3)
home('egon')
GIL全局解释器锁
//GIL全局解释器锁
1.GIL不是python的特点而是CPython解释器的特点
2.GIL是保证解释器级别的数据的安全
3.GIL会导致同一个进程下的多个线程的无法同时执行即无法利用多核优势(******)
4.针对不同的数据还是需要加不同的锁处理
5.解释型语言的通病:同一个进程下多个线程无法利用多核优势
//解决GIL锁
1.使用其它语言，例如C,Java
2.使用其它解释器，如java的解释器jpython
3.使用多进程
魔法方法
#魔法方法
__init__:实例化会触发，给类加上属性
__str__:打印对象会触发
__call__:对象()触发，类也是对象 类(),类的实例化过程调用元类的__call__
__new__:在类实例化会触发，它比__init__早（造出裸体的人，__init__穿衣服）
__del__:del 对象，对象回收的时候触发
__setattr__,__getattr__:(.拦截方法)，当对象.属性--》赋值会调用setattr，如果是取值会调用getattr
__getitem__,__setitem__:([]拦截)
__enter__和__exit__ 上下文管理器
Monkey Patch
在程序开始的时候替换掉原来的方法
如：
import json
import ujson
#意义上ujson更快，用ujson.dumpa替换json.dumps
json.dumps=ujson.dumps
json.loads=ujson.loads
lambda
#lambda匿名函数
什么是匿名函数
匿名就是没有名字
lambda x,y,z=1:x+y+z #与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字，冒号后是一个表达式，匿名函数不需要用return，后面的表达式就是返回值
func=lambda x,y,z=1:x+y+z
func(1,2,3)
#让其有名字就没有意义
常用模块
os
os 常用方法
os.remove(‘path/filename’) 删除文件
os.rename(oldname, newname) 重命名文件
os.walk() 生成目录树下的所有文件名
os.chdir('dirname') 改变目录
os.mkdir/makedirs('dirname')创建目录/多层目录
os.rmdir/removedirs('dirname') 删除目录/多层目录
os.listdir('dirname') 列出指定目录的文件
os.getcwd() 取得当前工作目录
os.chmod() 改变目录权限
os.path.basename(‘path/filename’) 去掉目录路径，返回文件名
os.path.dirname(‘path/filename’) 去掉文件名，返回目录路径
os.path.join(path1[,path2[,...]]) 将分离的各部分组合成一个路径名
os.path.split('path') 返回( dirname(), basename())元组
os.path.splitext() 返回 (filename, extension) 元组
os.path.getatime\ctime\mtime 分别返回最近访问、创建、修改时间
os.path.getsize() 返回文件大小
os.path.exists() 是否存在
os.path.isabs() 是否为绝对路径
os.path.isdir() 是否为目录
os.path.isfile() 是否为文件
sys
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.modules.keys() 返回所有已经导入的模块列表
sys.exc_info() 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息
sys.exit(n) 退出程序，正常退出时exit(0)
sys.hexversion 获取Python解释程序的版本值，16进制格式如：0x020403F0
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.maxunicode 最大的Unicode值
sys.modules 返回系统导入的模块字段，key是模块名，value是模块
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
sys.stdout 标准输出
sys.stdin 标准输入
sys.stderr 错误输出
sys.exc_clear() 用来清除当前线程所出现的当前的或最近的错误信息
sys.exec_prefix 返回平台独立的python文件安装的位置
sys.byteorder 本地字节规则的指示器，big-endian平台的值是'big',little-endian平台的值是'little'
sys.copyright 记录python版权相关的东西
sys.api_version 解释器的C的API版本
configparser
import configparser
config=configparser.ConfigParser()
config.read('test.ini')
1、获取sections
print(config.sections())
2、获取某一section下的所有options
print(config.options('section1'))
3、获取items
print(config.items('section1'))
4、
res=config.get('section1','user')
print(res,type(res))
res=config.getint('section1','age')
print(res,type(res))
res=config.getboolean('section1','is_admin')
print(res,type(res))
res=config.getfloat('section1','salary')
print(res,type(res))
hashlib
1、什么是哈希hash
hash一类算法，该算法接受传入的内容，经过运算得到一串hash值
hash值的特点：
I 只要传入的内容一样，得到的hash值必然一样
II 不能由hash值返解成内容
III 不管传入的内容有多大，只要使用的hash算法不变，得到的hash值长度是一定
2、hash的用途
用途1：特点II用于密码密文传输与验证
用途2：特点I、III用于文件完整性校验
3、如何用
import hashlib
m=hashlib.md5()
m.update('hello'.encode('utf-8'))
m.update('world'.encode('utf-8'))
res=m.hexdigest() # 'helloworld'
print(res)
m1=hashlib.md5('he'.encode('utf-8'))
m1.update('llo'.encode('utf-8'))
m1.update('w'.encode('utf-8'))
m1.update('orld'.encode('utf-8'))
res=m1.hexdigest()# 'helloworld'
print(res)
模拟撞库
cryptograph='aee949757a2e698417463d47acac93df'
import hashlib
# 制作密码字段
passwds=[
'alex3714',
'alex1313',
'alex94139413',
'alex123456',
'123456alex',
'a123lex',
]
dic={}
for p in passwds:
res=hashlib.md5(p.encode('utf-8'))
dic[p]=res.hexdigest()
# 模拟撞库得到密码
for k,v in dic.items():
if v == cryptograph:
print('撞库成功，明文密码是：%s' %k)
break
//提升撞库的成本--密码加盐
import hashlib
m=hashlib.md5()
m.update('天王'.encode('utf-8'))
m.update('alex3714'.encode('utf-8'))
m.update('盖地虎'.encode('utf-8'))
print(m.hexdigest())
suprocess
//subprocess 模块首先推荐使用的是它的 run 方法，更高级的用法可以直接使用 Popen 接口。
//run 方法语法格式如下：
subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, capture_output=False, shell=False, cwd=None, timeout=None, check=False, encoding=None, errors=None, text=None, env=None, universal_newlines=None)
//args：表示要执行的命令。必须是一个字符串，字符串参数列表。
//stdin、stdout 和 stderr：子进程的标准输入、输出和错误。其值可以是 subprocess.PIPE、subprocess.DEVNULL、一个已经存在的文件描述符、已经打开的文件对象或者 None。subprocess.PIPE 表示为子进程创建新的管道。subprocess.DEVNULL 表示使用 os.devnull。默认使用的是 None，表示什么都不做。另外，stderr 可以合并到 stdout 里一起输出。
//timeout：设置命令超时时间。如果命令执行时间超时，子进程将被杀死，并弹出 TimeoutExpired 异常。
//check：如果该参数设置为 True，并且进程退出状态码不是 0，则弹 出 CalledProcessError 异常。
//encoding: 如果指定了该参数，则 stdin、stdout 和 stderr 可以接收字符串数据，并以该编码方式编码。否则只接收 bytes 类型的数据。
//shell：如果该参数为 True，将通过操作系统的 shell 执行指定的命令。
//Popen 是 subprocess的核心，子进程的创建和管理都靠它处理。
import subprocess
obj=subprocess.Popen('echo 123 ; ls / ; ls /root',shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
print(obj)
res=obj.stdout.read()
print(res.decode('utf-8'))
err_res=obj.stderr.read()
print(err_res.decode('utf-8'))
常用参数：
args：shell命令，可以是字符串或者序列类型（如：list，元组）
bufsize：缓冲区大小。当创建标准流的管道对象时使用，默认-1。
0：不使用缓冲区
1：表示行缓冲，仅当universal_newlines=True时可用，也就是文本模式
正数：表示缓冲区大小
负数：表示使用系统默认的缓冲区大小。
stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
preexec_fn：只在 Unix 平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
shell：如果该参数为 True，将通过操作系统的 shell 执行指定的命令。
cwd：用于设置子进程的当前目录。
env：用于指定子进程的环境变量。如果 env = None，子进程的环境变量将从父进程中继承。