内置函数
abs() 取绝对值
all() 直接将可迭代对象里面的所有的值进行布尔运算,所有都是真才为真 相当于and
any() 与all相似，但是只有一个为真，结果就是真 相当于or
bin() 把十进制转换成二进制
hex() 十进制转换成十六进制
oct() 十进制转换成8进制
bool() 将内容转换成布尔值
bytes() 把一个字符串转换成字节的形式 bytes(‘panzhenwei’,encoding = ‘utf-8’)
大概的作用是panzhenwei.encode(‘utf-8’)的作用是一样的，不过后者只有字符串才有的功能
chr() 按照ascii 的顺序进行转换，显示指定内容在ascii对应的东西、
enumerate(索引，可迭代对象，start) 枚举可迭代对象的索引与元素以元组的形式输出
start 默认为0 如果设置了相关的 int数据类型的话，索引位置输出为元素索引下标+strat的值，之后才以输入： 输出如下：（元素索引下标+start, 元素）
ord() 与chr 相反，输入ascii 表的内容，输出对应的数字
dir() 打印某个对象下面都有什么方法只是查看到 的作用
divmod（10,3） eg 查找到的内容有10条的记录，每页放3条记录，但是能够放多少页如果不为0则需要多分一页
eval() 将字符串还原为原来的内容，也可以把字符串中的表达式进行运算
hash() 计算某个东西的哈希值，只能是对不可变数据类型进行哈希
pow(x,y，z=None) 计算x 的y次方是多少 前面得出的结果后取余
eg:当z = 2 的时候, x 的y次方等于999999 之后将999999 %2 输出的结果就是输入z=2 的结果没有对z进行设置的话，那么默认只是进行了次方的运算
reversed() 将可迭代的东西进行翻转，返回的是一个迭代器
round() 进行四舍五入的计算
set() 将可迭代的东西转换成集合
slice(3:4:2) 设定切片的模板
s = selice(3:4:2)
a= [1,2,3，4,5,6,7,8]
a[s]这就是切片，但是如果只是想使用模板的某个部分直接使用相关的部分就行
eg:a[s.start] a[s.stop] 或者是a[a.step]
sorted(可迭代对象，key=None, reversed =False) 默认是升序
lst = [1,2,3,4]
eg:sorted(lst key = lambda x : x+y )
str（ ） 转换成字符串类型
sum（） 计算一个可迭代对象的和
type() 查看指定内容的数据类型
vars( ) 如果没有指定参数的话，作用相当于locals（）.
字符串类型代码的执行
eval() 用来执行一个字符串表达式，，并返回最终结果，如果只是可迭代对象，可以将其还原为原来的数据类型
print(eval("2+2"))s
exec() 执行字符串类型的代码
exec("""
for i in range(10):
print(i)
""")
compile(要执行的字符串代码，‘存放字符串代码的文件路径’，执行该函数的模式)
'''
参数说明:
1. resource 要执⾏行行的代码, 动态代码⽚片段
2. 文件名, 代码存放的⽂文件名, 当传⼊入了了第⼀一个参数的时候, 这个参数给空就可以了了
3. 模式, 取值有3个,
1. exec: ⼀一般放⼀一些流程语句句的时候
2. eval: resource只存放⼀一个求值表达式.
3. single: resource存放的代码有交互的时候. mode应为single
'''
如果字符串中的代码中没有任何的返回值的话，可以通过使用exec的模式
code = 'for i in range(10):print(i)'
c = compile(code,'',mode = 'exec')
exec(c)
如果字符窜中执行的结果中含有返回值的话，可以通过使用eval的模式
code1 = '2+3+4+5'
c = compile(code1 ,'',mode='eval')
print(eval(c))
小结：
有返回值的字符串形式的代码用eval(). 没有返回值的字符串形式的代码用exec(). 一般很少用到compile()
# 字符串串
print(format('test', '<20')) # 左对齐
print(format('test', '>20')) # 右对齐
print(format('test', '^20')) # 居中
# 数值
print(format(3, 'b')) # 二进制
print(format(97, 'c')) # 转换成unicode字符
print(format(11, 'd')) # 十进制
print(format(11, 'o')) # 八进制
print(format(11, 'x')) # 十六进制(⼩小写字⺟母)
print(format(11, 'X')) # 十六进制(⼤大写字⺟母)
print(format(11, 'n')) # 和d一样
print(format(11)) # 和d一样
# 浮点数
print(format(123456789, 'e')) # 科学计数法. 默认保留6位小数
print(format(123456789, '0.2e')) # 科学计数法. 保留2位小数(⼩小写)
print(format(123456789, '0.2E')) # 科学计数法. 保留2位小数(⼤大写)
print(format(1.23456789, 'f')) # 小数点计数法. 保留6位小数
print(format(1.23456789, '0.2f')) # 小数点计数法. 保留2位小数
print(format(1.23456789, '0.10f')) # 小数点计数法. 保留10位小数
print(format(1.23456789e+10000, 'F')) # 小数点计数法.
如果有参数的话，就相当于object.__dict__ 但是前提是参数具有__dict__的属性
def test():
gg = 'cisco'
print(locals())
结果是将相关的变量以字典的形式进行输出
max() 取最大值的详细用法
例如：people=[
{'name':'alex','age':1000},
{'name':'wupei','age':10000},
{'name':'yuanhao','age':9000},
{'name':'linhaifeng','age':18},
] 取出年龄最大的值
max(people,key=lambda dic:dic[‘age’]) key= 指定了比较的规则
相当于
ret=[]
for item in people:
ret.append(item['age'])
print(ret)
max(ret)
min() 取最小值
内置函数map(函数，可迭代对象) 处理序列中的每个元素，得到的结果是迭代器的内存地址，可以通过使用list()转换成列表，该“列表”
的元素个数即位置与原来的一样
# 通过lambda 控制需求，将传进去的可迭代对象进行加工作用相当于
内置函数map()
# 内置函数map(函数，可迭代对象) 使用该函数返回的是一个可迭代对象的内存地址，可以通过使用list()将该内存地址直接转换成列表
#在python 2 中map的处理结果就是一个列表
# def add_one():
# return x+1
#处理序列中的每个元素，得到的结果是一个‘列表’，该‘列表’元素个数及位置与原来一样
# map()
nam = [1,2,3,4]
def map_test(func,array):
ret = []
for i in array:
res = func(i)
ret.append(res)
return ret
print(map_test(lambda
x:x+1 ,nam))
callable 判断一个东西是否能够像函数一样被调用
zip 拉链函数，水桶效应
lis1 = [1,2,3,4]
lis2 = ['一','二','三']
lis3 =['壹','贰','叁']
z = zip(lis1,lis2,lis3)
print(z) #<zip object at 0x0000004D1DBD8F88>
for i in z:
print(i)
结果
内置函数map(函数，可迭代对象序列) 迭代第二个参数，将每一个元素作为函数的参数进行计算，得到的结果是迭代器的内存地址，可以通过使用list()转换成列表，该“列表”的元素个数即位置与原来的一样
def func():
return x+1
基本原理如下
nam = [1,2,3,4]
def map_test(func,array):
ret = []
for i in array:
res = func(i)
ret.append(res)
return ret
print(map_test(lambda
x:x+1 ,nam))
内置函数 filter（func
or None,iterable,）
如果第一个参数没有设置函数（默认不设置），只是含有第二个参数的话，遍历第二个参数中的每个元素，判断每个元素得到的布尔值，如果是Ture就保留下来（得到的是一个可迭代的内存地址—迭代器）
如果第一个元素设置了函数，就会将第二个参数的里面的元素迭代出来作为函数的参数进行计算，如果是True的话，就会被留下来
people=[
{'name':'alex','age':1000},
{'name':'wupei','age':10000},
{'name':'yuanhao','age':9000},
{'name':'linhaifeng','age':18},
]
print(list(filter(lambda p:p['age']<=18,people)))
大概的功能如下：
def func(n)：
return n.endswith(‘sb’)
sb = ['gg_sb','cc_sb','zhengchanren']
filter() 函数的原理如下：
def filter_test(func,array):
ret= []
for
i in array:
if func(i):
ret.append(i)
return
ret
a = filter_test(lambda n:n.endswith('sb'),sb)
print(a)
reduce（函数，可迭代序列，起始值） 函数 处理一个序列，然后把序列进行合并的操作
#reduce（）:处理一个序列，然后把序列进行合并操作
from functools import reduce
print(reduce(lambda x,y:x+y,range(100),100))
print(reduce(lambda x,y:x+y,range(1,101)))
在python3 中要使用reduce函数，在导入相关的模块
num_1 = [1,2,3,4]
def reduce_test(func,array,init = None):
if init
== None:
res = array.pop(0)
else:
res = init
for i in array:
res=func(res,i)
return res
print(reduce_test(lambda
x,y:x+y,num_1,100))
面向对象使用的内置函数
1.issubclass:判断面向对象中a是否是b的子类
#判断面向对象中a是否是b的子类 class Base: pass class Foo(Base): pass class Bar(Foo): pass print(issubclass(Foo,Base))#Ture print(issubclass(Bar,Base))#Ture 可以向上查找，即父类的父类
2.type :查看对象是哪个类创建的
class Teacher: pass t = Teacher() print(type(t)) #<class '__main__.Teacher'>表示的是Teacher的类创建的 # 实际应用如下： def cal(a,b): if (type(a) == int or type(a) == float) and (type(b) == int or type(b) == float): print(a+b) else: print('输入有误，请输入符合类型是数字：')
3.isinstance判断一个对象是否是一个家族体系中的（只能从本身向祖宗的方向进行判断）
#isinstance判断一个对象是否是一个家族体系中的（只能从本身向祖宗的方向进行判断） class Animal: pass class Cat(Animal): pass class BlueCat(Cat): pass gg = Cat() print(isinstance(gg,Cat))#True print(isinstance(gg,Animal))#True print(isinstance('gg',BlueCat))#False
isinstance也具有issubclass的功能，不过没有issubclass精确
print(isinstance('1',str))#True print(isinstance(1,int))#True
内置函数大概思维导图
https://www.processon.com/mindmap/5bdc01dde4b0fc2dc1a768cb