python提供的强大的内置函数，接下来我们看一看这些函数都有哪些作用。
abs()求绝对值。
print(abs(-1)) print(abs(0)) 运行结果 1 0
all()传递可迭代对象，可迭代对象每个值得bool值都为Ture返回Ture，有一个为False，结果返回False。
print(all(i for i in range(10)))#False print(all(i for i in range(1,10)))#True
sum()将对象转为可迭代对象求和。
res=sum(i for i in range(3)) print(res)#3
any()传递可迭代对象，可迭代对象中有一个值的bool值为Ture返回Ture，所有值都为False，结果返回False。
print(any([]))#False print(any([None,0,'',{},1]))#True
bin()将传入值转化为二进制。
print(bin(3))#0b11
bool()返回bool值。
print(bool(0))#False print(bool(None))#False print(bool(''))#False
bytes()把字符串转为字节模式。
print(bytes('hello',encoding='utf-8'))#b'hello'
callable()能否被调用，返回bool值。
def test(): pass print(callable(test))#True print(callable(sum))#True
chr()与ord()ASCII码对应关系。
print(chr(67))#C print(chr(65))#A print(ord('A'))#65
classmethod，staticmethod，property面向对象三贱客。
classmethod
class people: country = 'china' # 类方法，用classmethod来进行修饰 @classmethod def getCountry(cls): #类方法自动将类作为cls传递进函数内 return cls.country @classmethod def setCountry(cls, country): cls.country = country p = people() print(p.getCountry()) # 可以用过实例对象引用 print(people.getCountry()) # 可以通过类对象引用 p.setCountry('japan') print(p.getCountry()) 运行结果： china china japan
staticmethod
class people: country = 'china' @staticmethod # 静态方法使用装饰器方式绑定，并且作用和普通函数一样并不会自动传递self def getCountry(): return people.country print(people.getCountry()) 运行结果： china
property
class people: __name = 'jeff' __age = 12 def set(self): print(self.__name) print(self.__age) p = people() #print(p.__name,p.__age) #AttributeError: 'people' object has no attribute '__name' p.set() 运行结果; jeff 12
complex()复数，定义复数
x=complex(1-2j) print(x.real)#1.0 print(x.imag)#-2.0 x=1-2j print(x.real)#1.0 print(x.imag)#-2.0
数据类型
int()整型，isinstance()判断数据类型
num=1 #num=int(1) print(type(num)) #查看num的类型<class 'int'> print(isinstance(num,int)) #判断num是否为int类型True print(num is 1) #is 是身份运算，根据id去判断身份Tr
float()把数转换成浮点类型。
str()转化为字符串。
list()把任何iterable转化为列表。
x=list(i for i in range(10)) print(x)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
tuple()转化为元组。
dict()
d={'a':1}
d=dict(x=1,y=2,z=3)
print(d)#{'z': 3, 'x': 1, 'y': 2}
set()转化为集合，是可迭代对象，可转化为list。
frozenset()不可变集合
s={1,2,3,4,4}
print(s)
s.add(5)
print(s)#set可以增但是不可变集合都不可以
f=frozenset({1,2,3,4})
print(type(f))
dir()对象下面有哪些可调用方法。
divmod()返回元组，tuple(x//y,x%y)，前端分页功能。
print(divmod(100,33))#(3, 1)
enumerate()迭代器
可以传两个参数enumerate(序列，起始值)，起始值默认是从0开始（不写就是从0开始）。
for i in enumerate(['a','b','c','d']): print(i) 运行结果： (0, 'a') (1, 'b') (2, 'c') (3, 'd') for i in enumerate({'x':1,'y':2}): print(i) 运行结果： (0, 'y') (1, 'x')
format()格式化输出
globals()获取全局变量的字典,locals()获取执行本方法所在命名空间内的局部变量的字典.
def func(): x = 1 y = 2 print(locals()) #打印局部作用域中的名字 print(globals()) #打印全局作用域中的名字
hash()得到哈希值，用来校验数据完整性，不可逆推。
s='hello' print(hash(s))#-6379790348615061731 s='h' print(hash(s))#5735203904575971755
help()获取帮助。
hex()转16进制
print(hex(10))#0xa print(hex(11))#0xb
id()查看唯一标识身份号，is就是判断id是否相同。
print(id('asdf')) a=1 b=2 print(id(a)) print(id(b)) print(a is b) x='a' y='a' print(id(x)) print(id(y)) print(x is y)
input()输入
iter()把可迭代对象转化为迭代器。
len()统计长度
max(),min()最大最小值
zip()拉链函数？zip把传入的两个参数转为可迭代对象，两边各next()放到一个元组。
l1=[1,2,3,4] s='hel' for i in zip(l1,s): print(i) 运行结果： (1, 'h') (2, 'e') (3, 'l')
sorted()把可迭代对象next一遍然后升序放到列表里。
l=[3,4,1,0,9,10] print(sorted(l)) #返回值是列表，默认是升序 print(sorted(l,reverse=True)) #降序排列
map()映射,右边每一个数都根据左边的规则映射出一个新的列表。
l=[1,2,3,7,5] m=map(lambda item:item**2,l) print(m)#<map object at 0x00000000027CDD68> print(list(m))#print(list(m))
from functools import reduce #合并
from functools import reduce #合并 l=list(range(100)) print(l) print(reduce(lambda x,y:x+y,l,100))#5050#reduce可以传多个值
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)#左边返回值ture过滤出来 print(list(f))#[{'name': 'dragonFire', 'age': 1000}, {'name': 'gaoluchuan', 'age': 9000}, {'name': 'fsw', 'age': 10000}]
oct()八进制
open()取得文件句柄
pow(x,y,z),x**y%z
range()获得可迭代对象
rper()也是显示，str更人性化
reversed()反转顺序
slice()切片，一般也不用这个
vars() 返回局部名称空间的名字，字典形式。
__import__将字符串导入
__import__('time')
compile()把字符串编译成字节码在运行。
exec()执行代码或编译后的字符串,无返回值
eval() 将字符串中表达式转换为python表达式,有返回值
round(x,[,n]) 四舍五入取x的值，n表示取小数点几位
最后简单给这些函数进行分类。
运算类：
| 函数名 | 函数功能 | 备注 |
|---|---|---|
| abs(x) | 求绝对值 | 1、参数可以是整型，也可以是复数2、若参数是复数，则返回复数的模 |
| complex([real[, imag]]) | 创建一个复数 | |
| divmod(a, b) | 分别取商和余数 | 注意：整型、浮点型都可以 |
| float([x]) | 将一个字符串或数转换为浮点数。 | 如果无参数将返回0.0 |
| int([x[, base]]) | 将一个字符转换为int类型 | base表示进制 |
| long([x[, base]]) | 将一个字符转换为long类型 | |
| pow(x, y[, z]) | 返回x的y次幂 | |
| range([start], stop[, step]) | 产生一个序列 | 默认从0开始 |
| round(x[, n]) | 四舍五入 | |
| sum(iterable[, start]) | 对集合求和 | |
| oct(x) | 将一个数字转化为8进制 | |
| hex(x) | 将整数x转换为16进制字符串 | |
| chr(i) | 返回整数i对应的ASCII字符 | |
| bin(x) | 将整数x转换为二进制字符串 | |
| bool([x]) | 将x转换为Boolean类型 |
数据类型类：
| 函数名称 | 函数功能 | 备注 |
|---|---|---|
| basestring() | str和unicode的超类 | 不能直接调用，可以用作isinstance判断 |
| format(value [, format_spec]) | 格式化输出字符串 | 格式化的参数顺序从0开始，如“I am {0},I like {1}” |
| unichr(i) | 返回给定int类型的unicode | |
| enumerate(sequence [, start = 0]) | 返回一个可枚举的对象 | 该对象的next()方法将返回一个tuple |
| iter(o[, sentinel]) | 生成一个对象的迭代器，第二个参数表示分隔符 | |
| max(iterable[, args…][key]) | 返回集合中的最大值 | |
| min(iterable[, args…][key]) | 返回集合中的最小值 | |
| dict([arg]) | 创建数据字典 | |
| list([iterable]) | 将一个集合类转换为另外一个集合类 | |
| set() | set对象实例化 | |
| frozenset([iterable]) | 产生一个不可变的set | |
| str([object]) | 转换为string类型 | |
| sorted(iterable[, cmp[, key[, reverse]]]) | 队集合排序 | |
| tuple([iterable]) | 生成一个tuple类型 | |
| xrange([start], stop[, step]) | xrange()函数与range()类似，但xrnage()并不创建列表，而是返回一个xrange对象 | 它的行为与列表相似，但是只在需要时才计算列表值，当列表很大时，这个特性能为我们节省内存 |
可迭代类型操作：
| callable(object) | 检查对象object是否可调用 | 1、类是可以被调用的2、实例是不可以被调用的，除非类中声明了call方法 |
| classmethod() | 注解，用来说明这个方式是个类方法 | 类方法即可被类调用，也可以被实例调用，类方法类似于Java中的static方法，类方法中不需要有self参数 |
| compile(source, filename, mode[, flags[, dont_inherit]]) | 将source编译为代码或者AST对象 | 代码对象能够通过exec语句来执行或者eval()进行求值。 |
| dir([object]) | 1、不带参数时，返回当前范围内的变量、方法和定义的类型列表；2、带参数时，返回参数的属性、方法列表。3、如果参数包含方法dir()，该方法将被调用。当参数为实例时。4、如果参数不包含dir()，该方法将最大限度地收集参数信息delattr(object, name) 删除object对象名为name的属性 | |
| eval(expression [, globals [, locals]]) | 计算表达式expression的值 | |
| execfile(filename [, globals [, locals]]) | 用法类似exec()，不同的是execfile的参数filename为文件名，而exec的参数为字符串。 | |
| filter(function, iterable) | 构造一个序列，等价于[ item for item in iterable if function(item)] | 1、参数function：返回值为True或False的函数，可以为None2、参数iterable：序列或可迭代对象 |
| getattr(object, name [, defalut]) | 获取一个类的属性 | |
| globals() | 返回一个描述当前全局符号表的字典 | |
| hasattr(object, name) | 判断对象object是否包含名为name的特性 | |
| hash(object) | 如果对象object为哈希表类型，返回对象object的哈希值 | |
| id(object) | 返回对象的唯一标识 | |
| isinstance(object, classinfo) | 判断object是否是class的实例 | |
| issubclass(class, classinfo) | 判断是否是子类 | |
| len(s) | 返回集合长度 | |
| locals() | 返回当前的变量列表 | |
| map(function, iterable, …) | 遍历每个元素，执行function操作 | |
| memoryview(obj) | 返回一个内存镜像类型的对象 | |
| next(iterator[, default]) | 类似于iterator.next() | |
| object() | 基类 | |
| property([fget[, fset[, fdel[, doc]]]]) | 属性访问的包装类，设置后可以通过c.x=value等来访问setter和getter | |
| reduce(function, iterable[, initializer]) | 合并操作，从第一个开始是前两个参数，然后是前两个的结果与第三个合并进行处理，以此类推 | |
| reload(module) | 重新加载模块 | |
| setattr(object, name, value) | 设置属性值 | |
| repr(object) | 将一个对象变换为可打印的格式 | |
| slice（） | ||
| staticmethod | 声明静态方法，是个注解 | |
| super(type[, object-or-type]) | 引用父类 | |
| type(object) | 返回该object的类型 | |
| vars([object]) | 返回对象的变量，若无参数与dict()方法类似 | |
| bytearray([source [, encoding [, errors]]]) | 返回一个byte数组 | 1、如果source为整数，则返回一个长度为source的初始化数组；2、如果source为字符串，则按照指定的encoding将字符串转换为字节序列；3、如果source为可迭代类型，则元素必须为[0 ,255]中的整数；4、如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray. |
| zip([iterable, …]) |
I/O操作：
| 函数名称 | 函数功能 | 备注 |
|---|---|---|
| file(filename [, mode [, bufsize]]) | file类型的构造函数，作用为打开一个文件，如果文件不存在且mode为写或追加时，文件将被创建。 | 添加‘b’到mode参数中，将对文件以二进制形式操作。添加‘+’到mode参数中，将允许对文件同时进行读写操作1、参数filename：文件名称。2、参数mode：’r’（读）、’w’（写）、’a’（追加）。3、参数bufsize：如果为0表示不进行缓冲，如果为1表示进行行缓冲，如果是一个大于1的数表示缓冲区的大小 。 |
| input([prompt]) | 获取用户输入 | 推荐使用raw_input，因为该函数将不会捕获用户的错误输入 |
| open(name[, mode[, buffering]]) | 打开文件 | |
| 打印函数 | ||
| raw_input([prompt]) | 设置输入 | 输入都是作为字符串处理 |
匿名函数
比较几位老师的工资，谁的工资最高。
salaries={ 'egon':3000, 'alex':100000000, 'wupeiqi':10000, 'yuanhao':250 }
直接使用max()得到的是key的最大值，比较values得到的又是最多的钱，如何比较的是钱而得到的是这个钱对应的key呢。
def get_value(k): return salaries[k] print(max(salaries,key=get_value))#alex
max在这里，把传入值变成可迭代对象，每次取一个值传入右边的函数再比较，最后得出最大值输出的到最大值的人。
这里我们定义的get_value函数很简单，只有单一功能，完全没有必要，我们可以使用简单的lambda来一步完成。
lambda k:salaries[k]
匿名函数的调用。
f=lambda k:salaries[k] #匿名函数也可以赋值一个名字，但是这便违反了匿名的初衷 print(f)#<function <lambda> at 0x0000000001D0CBF8> print(f('egon'))#3000
解决上面的问题也更简便。
print(max(salaries,key=lambda k:salaries[k]))#alex print(min(salaries,key=lambda k:salaries[k]))#yuanhao
zip()函数
print(salaries.keys(),salaries.values()) z=zip(salaries.values(),salaries.keys()) print(z) print(max(z))#取出最大的元组 for i in z: print(i)
sorted()
print(sorted(salaries)) #默认是按照字典salaries的key去排序的 print(sorted(salaries,key=lambda x:salaries[x])) print(sorted(salaries,key=lambda x:salaries[x],reverse=True)) 运行结果： ['alex', 'egon', 'wupeiqi', 'yuanhao'] ['yuanhao', 'egon', 'wupeiqi', 'alex'] ['alex', 'wupeiqi', 'egon', 'yuanhao']