python内置了一系列的常用函数，以便于我们使用，python英文官方文档详细说明：https://docs.python.org/3/library/functions.html
1. abs() 获取绝对值
abs(-10)
--->10 abs(10)
--->10abs(0)
--->0a = -10
a.__abs__()
--->10
2. all() 参数为可迭代对象，迭代对象为空时，返回True.如果迭代对象的所有元素都为真，那么返回True，否则返回False.
all(['python',123])
--->Trueall([])
--->Trueall([0])
--->Falseall(" ")
--->Trueall(1,' ',2,None)
--->False
3.any() 参数为可迭代对象，参数为空时返回True
print(any([None,0,' ',{},1]))
--->Trueprint(any(' '))
--->True
4.sum() 求和
res=sum(i for i in range(5)) #(i for i in range(5))为生成器表达式
print(res)
--->12
5.bin() 将参数转化为二进制
print(bin(3))
--->0b11
6.bool() 布尔函数，返回bool值，False或True
print(bool(0))
--->Falseprint(bool(None))
--->Falseprint(bool(' '))
--->False
7. ascii() 调用对象的__repr__()方法，获得该方法的返回值.
8.bytes() 将一个字符串转化为字节类型
print(bytes('hello',encoding='utf8'))
--->b'hello's = 'python'
print(bytes(s, encoding='utf-8'))
--->b'python'a = '王'
print(bytes(a, encoding='utf-8'))
--->b'\xe7\x8e\x8b'
9.str() 将字符类型/数值类型等转换为字符串类型
print(str(b'\xe7\x8e\x8b', encoding='utf-8')) # 字节转换为字符串
--->'王'str(1) # 整数转换为字符串
--->'1'
10.chr() 查看十进制数对应的ASCII字符
print(chr(67))
--->Cprint(chr(65))
--->A
11.ord() 查看某个ASCII对应的十进制数
print(ord('A'))
--->65
12.callabe() 判断对象是否可以被调用，能被调用的对象就是一个callables对象，比如函数和带有__call__()的实例
def test():
pass
print(callable(test))
--->Trueprint(callable(sum))
--->True
13. classmethod() 用来指定一个方法为类的方法，由类直接调用执行，只有一个cls参数,执行雷的方法时，自动将调用该方法的类赋值给cls.没有此参数指定的类的方法为实例方法
class Province:
country = "中国" def __init__(self, name):
self.name = name @classmethod
def show(cls): # 类方法，由类调用，最少要有一个参数cls，调用的时候这个参数不用传值，自动将类名赋值给cls
print(cls)# 调用方法
Province.show()
14.complie() 将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译
1 compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
2 将source编译为代码或者AST对象。代码对象能过通过exec语句来执行或者eval()进行求值。
3 参数source：字符串或者AST（abstract syntax trees）对象。
4 参数filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
5 参数model：指定编译代码的种类。可以指定'exec', 'eval', 'single'。
6 参数flag和dont_inherit：这两个参数为可选参数。
s = "print('helloworld')"
print(compile(s, "<string>", "exec"))
---><code object <module> at 0x000001C648038390, file "<string>", line 1>
15.complex()
1 创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数是字符串，则不需要指定第二个参数。
2 参数real：int，long，float或字符串。
3 参数imag：int，long，float。
x=complex(1-2j)
print(x.real)
--->1.0print(x.imag)
--->2.0
16. delattr() 删除对象的属性
17.int() #数据类型，整型
int
num=1 #num=int(1)
print(type(num)) #查看num的类型
---> <class 'int'>print(isinstance(num,int)) #判断num是否为int类型print(num is 1) #is 是身份运算，根据id去判断身份
18. float() 讲一个字符串或整数转换为浮点数
print(float())
--->0.0print(float('123'))
--->123.0print(float(1))
--->1.0print(float('a'))Traceback (most recent call last):
File "<pyshell#45>", line 1, in <module>
float('a')
ValueError: could not convert string to float: 'a'
19.list() 参数为可迭代对象
list
x=[]
x=list(i for i in range(10)) #生成器表达式，以元组的形式呈现
print(x)
--->[0,1,2,3,4,5,6,7,8,9]列表构造函数
list([iterable])
list的构造函数。参数iterable是可选的，它可以是序列，支持编译的容器对象，或iterator对象。
该函数创建一个元素值，顺序与参数iterable一致的列表。如果参数iterable是一个列表，将创建
列表的一个拷贝并返回，就像语句iterables[:]。
20.tuple() 元组
21.dict() 创建数据字典
d={'a':1}
d=dict(x=1,y=2,z=3)
print(d)
--->{'y':2,'x':1,'z':3}print(dict()) 空字典
--->{}print(dict(one = 1, two =2))
--->{'one': 1, 'two': 2}print(dict({'one':1 ,'two':2}))
--->{'one': 1, 'two': 2}
22.set() 集合
s={1,2,3,4,4}
print(s)
--->{1,2,3,4}s.add(5)
print(s)
--->{1,2,3,4,5}
23.frozenset() 不可变集合
frozenset([iterable])
set和frozenset最本质的区别是前者是可变的，后者是不可变的。当集合对象会被改变时（例如删除，添加元素），只能使用set，
一般来说使用fronzet的地方都可以使用set。
参数iterable：可迭代对象。
f=frozenset({1,2,3,4})
print(type(f))
---> <class 'frozenset'>
24.dir() 不带参数时返回当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表
print(dir())
--->['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'li', 'li1', 'li2', 'li_1'] >>> dir(list) ['__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']print(dir(sum)) #输出sum下有哪些可被sum调用的方法。（对象.方法），sum.方法
25.divmod() 分别取商和余数.二个参数x和y，输出元组（x//y,x%y）
print(divmod(100,33))
--->(3,1)
26. enumerate() 返回一个可以枚举的对象，该对象的next()方法将返回一个元组
for i in enumerate(['a','b','c','d']):
print(i)
--->(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(0, 'x')
(1, 'y')for i in enumerate({'x':1,'y':2}):
print(i)
---->(0, 'x')
(1, 'y')
27.eval() 将字符串str中的表达式提取出来并运行
s = "1+2*3"
print(type(s))
---> <class 'str'>print(eval(s))
---> 7
28.exec() 执行字符串或complie方法编译过的字符串，没有返回值
29.filter() 过滤器，构造一个序列，等价于[ item for item in iterables if function(item)]，在函数中设定过滤条件，逐一循环迭代器中的元素，将返回值为True时的元素留下，形成一个filter类型数据
filter(function, iterable)
参数function：返回值为True或False的函数，可以为None。
参数iterable：序列或可迭代对象。
def bigerthan5(x):
return x > 5
print(filter(bigerthan5, [3, 4, 5, 6, 7, 8]))
---> [6, 7, 8]
30.format() 格式化输出字符串，format(value, format_spec)实质上是调用了value的__format__(format_spec)方法
print("I am {0}, I like {1}!".format("xu", "moon"))
--->'I am xu, I like moon!'
31.getattr() 获取对象的属性
getattr(object, name [, defalut])
获取对象object名为name的特性，如果object不包含名为name的特性，将会抛出AttributeError异常；如果不包含名为name的特性
且提供default参数，将返回default。
参数object：对象
参数name：对象的特性名
参数default：缺省返回值print(getattr(list, 'append'))
---> <method 'append' of 'list' objects>mylist = [3, 4, 5]
append(mylist, 6)
print(mylist)
--->[3, 4, 5, 6]print(getattr(list, 'add'))
--->Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: type object 'list' has no attribute 'add'print(getattr(list, 'add', 'NoMethod'))
---> 'NoMethod'
32.globals() 返回一个描述当前全局变量的字典
a = 1
print(globals())
---> {'__loader__': <class '_frozen_importlib.BuiltinImporter'>, 'a': 1, '__builtins__': <module 'builtins' (built-in)>, '__doc__': None, '__name__': '__main__', '__package__': None, '__spec__': None}
33.hasattr()
hasattr(object，name)
判断对象object是否包含名为name的特性（hasattr是通过调用getattr(object，name)）是否抛出异常来实现的。
参数object：对象
参数name：特性名称print(hasattr(list, 'append'))
---> Trueprint(hasattr(list, 'add'))
---> False
34.hash() 哈希值
hash(object)
hash是一种算法，二个数值相等hash值是确定的唯一的，常用来校验数据。
hash值不能逆推。
如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数，在字典查找中，哈希值用于快递比价字典的键。
两个数值如果相等，则哈希值也相等。
35.hex() 十进制转化为十六进制
print(hex(10))
---> 0xa
36. id() 查看唯一标识的身份
37. help() 返回对象的帮助文档
38. input() 获取用户输入内容
39. isinstance() 检查对象是否是类的对象，返回True或False
isinstance(obj, cls)
检查obj是否是类cls的对象, 返回True 或 False
class Foo(object):
pass
obj = Foo()
isinstance(obj, Foo)
40. issubclass() 检查一个类是否是另一个类的子类。返回True或False
issubclass(sub, super)
检查sub类是否是super类的派生类（子类）。返回True 或 Falseclass Foo(object):
passclass Bar(Foo):
passissubclass(Bar, Foo)
41. iter()
iter(o[, sentinel])
返回一个iterator对象。该函数对于第一个参数的解析依赖于第二个参数。
如果没有提供第二个参数，参数o必须是一个集合对象，支持遍历功能（__iter__()方法）或支持序列功能（__getitem__()方法），
参数为整数，从零开始。如果不支持这两种功能，将触发TypeError异常。
如果提供了第二个参数，参数o必须是一个可调用对象。在这种情况下创建一个iterator对象，每次调用iterator的next()方法来无
参数的调用o，如果返回值等于参数sentinel，触发StopIteration异常，否则将返回该值。
42. len() 返回对象长度，参数可以是序列类型（字符串，元组或列表）或映射类型（如字典）
43. locals() 打印当前可用的局部变量的字典
不要修改locals()返回的字典中的内容；改变可能不会影响解析器对局部变量的使用。
在函数体内调用locals()，返回的是自由变量。修改自由变量不会影响解析器对变量的使用。
不能在类区域内返回自由变量。
44. lambda匿名函数
因为lambda函数没有函数名，引用计数为0，内存会被清理，所有匿名函数常与内置函数一起使用。
求出工资最高的
salaries={'egon':3000,'alex':1000000,'wupeiqi':10000,'yuanhao':2500}
def get_value(k):
return salaries[k]
print(max(salaries))
---->yuanhaoprint(max(salaries,key=get_value)) #迭代输出key,调用get_value函数，参数为key,得到每个人工资， max再进行比较工资，打印最大的人名key值
--->alex 使用匿名函数求出工资最高的
f=lambda k:salaries[k] #匿名函数不写函数名，返回值为salaries[k]
print(f) #f 相当于函数名
-----> <function <lambda> at 0x0000000002823A60>print(f('egon'))
---->3000print(max(salaries,key=lambda k:salaries[k])) #求出最高工资的人
---->alexprint(min(salaries,key=lambda k:salaries[k])) #求出最低工资的人
---->yuanhao
45. zip() ‘拉链’，一对一的
l1=[1,2,3]
s="hel"
for i in zip(l1,s): #zip(l1,s)为可迭代的
print(i)
---->(1, 'h')
(2, 'e')
(3, 'l')l1=[1,2,3,4],s不变，输出结果也同上；l1不变，s="hell",输出结果也同上。
因为zip()函数为一一对应的
用zip函数求最高工资的人
salaries={'egon':3000,'alex':1000000,'wupeiqi':10000,'yuanhao':2500}
print(salaries.keys(),salaries.values())#dict_keys(['egon', 'alex', 'wupeiqi', 'yuanhao']) dict_values([3000, 1000000, 10000, 2500])
z=zip(salaries.keys(),salaries.values())
print(z)
----> <zip object at 0x00000000027F3C08>for i in z:
print(i) ---->('egon', 3000)
('alex', 1000000)
('wupeiqi', 10000)
('yuanhao', 2500)z=zip(salaries.values(),salaries.keys()) #工资value和人名key互换位置
print(max(z))
---->(1000000, 'alex')z=zip(salaries.values(),salaries.keys()) #因为已经迭代完成了，所以要重新迭代
print(min(z))
---->(2500, 'yuanhao')
46. sorted() 返回列表，列表包含所有的元素，按升序排列
l=[3,4,1,0,9,10]
print(sorted(l))
---->[0, 1, 3, 4, 9, 10]s="hello abc"
print(sorted(s))
----->[' ', 'a', 'b', 'c', 'e', 'h', 'l', 'l', 'o']#降序 reverse 反转
print(sorted(l,reverse=True))
---->[10, 9, 4, 3, 1, 0]
salaries={'egon':3000,'alex':1000000,'wupeiqi':10000,'yuanhao':2500}
print(sorted(salaries)) #默认是按照字典salaries的key去排序的
----->['alex', 'egon', 'wupeiqi', 'yuanhao']
排序且修改
l=[3,2,0,10]
l=sorted(l)
print(l)
--->[0, 2, 3, 10]
47. map() 映射，第一个参数为函数，第二个参数为可迭代对象
l=[1,2,3,4,7,5]
x=[i**2 for i in l]
print(x)
---->[1, 4, 9, 16, 49, 25]#上述用map函数实现
#迭代取l 的值，传递给lamba函数
m=map(lambda item:item**2,l)
print(m)
----><map object at 0x00000000021DC3C8>for i in m:
print(i)
--->1 4 9 16 49 25for 循环也可用print(list(m))来实现，不过要重新迭代
m=map(lambda item:item**2,l)
print(list(m))
---->[1, 4, 9, 16, 49, 25]
map(function, iterable,...)
对于参数iterable中的每个元素都应用fuction函数，并将结果作为列表返回。
如果有多个iterable参数，那么fuction函数必须接收多个参数，这些iterable中相同索引处的元素将并行的作为function函数的参数。
如果一个iterable中元素的个数比其他少，那么将用None来扩展改iterable使元素个数一致。
如果有多个iterable且function为None，map()将返回由元组组成的列表，每个元组包含所有iterable中对应索引处值。
参数iterable必须是一个序列或任何可遍历对象，函数返回的往往是一个列表(list)。li = [1,2,3]
data = map(lambda x :x*100,li)
print(type(data))
data = list(data)
print(data)运行结果：<class 'map'>
[100, 200, 300]
48.max() 返回给定元素里最大值
max(iterable [,args...][, key])
如果只提供iterable参数，函数返回可遍历对象（如：字符串，元组或列表）中最大的非空元素。
如果提供多个参数，那么返回值最大的那个参数。
可选参数key是单参数的排序函数。
如果提供key参数，必须是以命名的形式，如：max(a, b, c, key = fun)
49.min() 返回给定元素里最小值
min(iterable [,args...][, key])
如果只提供iterable参数，函数返回可遍历对象（如：字符串，元组或列表）中最小的非空元素。
如果提供多个参数，那么返回值最小的那个参数。
可选参数key是单参数的排序函数。
如果提供key参数，必须是以命名的形式，如：max(a, b, c, key = fun)
50.object()
1 获取一个新的，无特性(geatureless)对象。Object是所有类的基类。它提供的方法将在所有的类型实例中共享。
2 该函数时2.2.版本新增，2.3版本之后，该函数不接受任何参数。
51.open() 打开文件
open(filename [, mode [, bufsize]])
打开一个文件，返回一个file对象。 如果文件无法打开，将处罚IOError异常。
应该使用open()来代替直接使用file类型的构造函数打开文件。
参数filename表示将要被打开的文件的路径字符串；
参数mode表示打开的模式，最常用的模式有：'r'表示读文本，'w'表示写文本文件，'a'表示在文件中追加。
Mode的默认值是'r'。
当操作的是二进制文件时，只要在模式值上添加'b'。这样提高了程序的可移植性。
可选参数bufsize定义了文件缓冲区的大小。0表示不缓冲；1表示行缓冲；任何其他正数表示使用该大小的缓冲区；
负数表示使用系统默认缓冲区大小，对于tty设备它往往是行缓冲，而对于其他文件往往完全缓冲。如果参数值被省却。
使用系统默认值。
52.print() 输出函数
python2中的print语句被python3中的print()函数取代。
如何限制print的默认换行：
1. python2版本下，在print输出的最后加一个逗号','
2. python3.4以后，print(value, ...,sep='',end='\n',file=sys.stdout,flush=False),将end设为空即可。
53.range() 根据需要生成一个指定范围的数字，可以提供你需要的控制来迭代指定的次数
用于创建包含连续算术值的列表(list)。常用于for循环。参数必须是普通整数。
参数step默认值为1，参数start的默认值为0。
全参数调用该函数将返回一个普通整数列表。
step 可以是正整数或者负整数。不可以为0，否则将处罚ValueError异常。
range(3)代表0,1,2.等价于range(0,3)
print(range(0,10,2)) #第一个参数是起始数，第二个是终止数(不包含这个)，第三个数步数
---->[0,2,4,6,8]
55. repr() 将任意值转换为字符串，供计时器读取的形式
返回一个对象的字符串表示。有时可以使用这个函数来访问操作。
对于许多类型来说，repr()尝试返回一个字符串，eval()方法可以使用该字符串产生对象；
否则用尖括号括起来的，包含类名称和其他二外信息的字符串被返回。
56.reversed() 反转，逆序对象，反着排序。
返回一个逆序的iterator对象。参数seq必须是一个包含__reversed__()方法的对象或支持序列操作(__len__()和__getitem__())
该函数是2.4中新增的
print(list(reversed([1,3,5,9])))
----->[9,5,3,1]
57.round() 四舍六入五留双，五留双留离整数最近的偶数
print(round(10.3))
----> 10print(round(10.5))
----> 10print(round(10.6))
----> 11print(round(10.9))
----> 11print(round(11.5))
----> 12
58.pow() 幂函数
print(pow(3,2)) #3**2
---->9print(pow(3,2,2)) #3**2%2
---->1
59. reduce() 合并，第一个参数为函数，第二个参数为可迭代对象。第三个参数可有可无，默认初始值。
from functools import reduce #合并
l=list(range(100))
print(l)
---->[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]print(reduce(lambda x,y:x+y,l,100))
i=iter(l)
# 100 next(i) --->100,0----->x,y-x+y-->100
# 100 next(i)---->100,1----->x,y--x+y-->101
# 101 next(i)----->101,2
---->5050
60. filter 过滤
name_l=[
{'name':'egon','age':18},
{'name':'dragonFire','age':1000},
{'name':'gaoluchuan','age':9000},
{'name':'fsw','age':10000},
]f=filter(lambda d:d['age'] > 100,name_l)
print(f)
-----><filter object at 0x00000000027DCCF8>print(list(f)) #与map函数不同的是其返还的是查询的内容
---->[{'name': 'dragonFire', 'age': 1000},{'name': 'gaoluchuan', 'age': 9000},{'name': 'fsw', 'age': 10000}]for i in f: print(i)
---->{'name': 'dragonFire', 'age': 1000}
{'name': 'gaoluchuan', 'age': 9000}
{'name': 'fsw', 'age': 10000}
61.oct() 十进制转化为八进制
print(oct(10))
---->0o12
62.slice 切片
l=[1,2,3,4,5]
print(l[2:4])
--->[3,4]s=slice(2,4)
print(l[s])
---->[3,4]
63. vars 没有参数时和locals()一样，有参数得到字典
64. __import__
import time
#print(time) ----><module 'time' (built-in)>
time.sleep(3)
上述代码等价于下面代码内容
m=__import__('time')
#print(m) ----><module 'time' (built-in)>
m.sleep(3)
