python提供的强大的内置函数，接下来我们看一看这些函数都有哪些作用。
abs()求绝对值。
print(abs(-1))abs
print(abs(0))
运行结果
1
0
all()传递可迭代对象，可迭代对象每个值得bool值都为Ture返回Ture，有一个为False，结果返回False。
print(all(i for i in range(10)))#Falseall()
print(all(i for i in range(1,10)))#True
sum()将对象转为可迭代对象求和。
res=sum(i for i in range(3))sum()
print(res)#3
any()传递可迭代对象，可迭代对象中有一个值的bool值为Ture返回Ture，所有值都为False，结果返回False。
print(any([]))#Falseany()
print(any([None,0,'',{},1]))#True
bin()将传入值转化为二进制。
print(bin(3))#0b11bin()
bool()返回bool值。
print(bool(0))#Falsebool()
print(bool(None))#False
print(bool(''))#False
bytes()把字符串转为字节模式。
print(bytes('hello',encoding='utf-8'))#b'hello'bytes()
callable()能否被调用，返回bool值。
def test():callable()
pass
print(callable(test))#True
print(callable(sum))#True
chr()与ord()ASCII码对应关系。
print(chr(67))#Cchr()ord()
print(chr(65))#A
print(ord('A'))#65
classmethod，staticmethod，property面向对象三贱客。
classmethod
class people:classmethod
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:staticmethod
country = 'china'
@staticmethod
# 静态方法使用装饰器方式绑定，并且作用和普通函数一样并不会自动传递self
def getCountry():
return people.country
print(people.getCountry())
运行结果：
china
property
class people:property
__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)complex()
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)int()isinstance()
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))list()
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}dict()
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))frozenset()
dir()对象下面有哪些可调用方法。
divmod()返回元组，tuple(x//y,x%y)，前端分页功能。
print(divmod(100,33))#(3, 1)divmod()
enumerate()迭代器
for i in enumerate(['a','b','c','d']):enumerate()
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():globals()locals()
x = 1
y = 2
print(locals()) #打印局部作用域中的名字
print(globals()) #打印全局作用域中的名字
hash()得到哈希值，用来校验数据完整性，不可逆推。
s='hello'hash()
print(hash(s))#-6379790348615061731
s='h'
print(hash(s))#5735203904575971755
help()获取帮助。
hex()转16进制
print(hex(10))#0xahex()
print(hex(11))#0xb
id()查看唯一标识身份号，is就是判断id是否相同。
print(id('asdf'))id()
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]zip()
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]sorted()
print(sorted(l)) #返回值是列表，默认是升序
print(sorted(l,reverse=True)) #降序排列
map()映射,右边每一个数都根据左边的规则映射出一个新的列表。
l=[1,2,3,7,5]map()
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 #合并from functools import reduce
l=list(range(100))
print(l)
print(reduce(lambda x,y:x+y,l,100))#5050#reduce可以传多个值
filter过滤
name_l=[filter
{'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')__import__
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']