六、内置函数
截止到python版本3.6.2，现在python一共为我们提供了68个内置函数。在「 6.1 内置函数列表 」中的顺序是按照首字母的排列顺序来的。它们就是python提供给你直接可以拿来使用的所有函数。
某个方法属于某个数据类型的变量，就用.调用
如果某个方法不依赖于任何数据类型，就直接调用 --- 内置函数和自定义函数
6.1 内置函数列表
你会发现都混乱的堆在一起的68个函数，它们就是python提供给你直接可以拿来使用的所有函数。
| Built-in Functions | ||||
|---|---|---|---|---|
| abs() | dict() | help() | min() | setattr() |
| all() | dir() | hex() | next() | slice() |
| any() | divmod() | id() | object() | sorted() |
| ascii() | enumerate() | input() | oct() | staticmethod() |
| bin() | eval() | int() | open() | str() |
| bool() | exec() | isinstance() | ord() | sum() |
| bytearray() | filter() | issubclass() | pow() | super() |
| bytes() | float() | iter() | print() | tuple() |
| callable() | format() | len() | property() | type() |
| chr() | frozenset() | list() | range() | vars() |
| classmethod() | getattr() | locals() | repr() | zip() |
| compile() | globals() | map() | reversed() | import() |
| complex() | hasattr() | max() | round() | |
| delattr() | hash() | memoryview() | set() |
在「杂乱无序」的时候，我们「分门别类」的学习，会「事半功倍」的
6.2. 作用域相关
1. globals()、locals()
'''
# 基于字典的形式获取局部变量和全局变量
globals() 获取全局变量的字典
locals(） 获取执行本方法所在命名空间内的局部变量字典
'''
6.3. 迭代器、生成器
1. range()、next()、iter()
# 实例 01. range 不是一个可迭代对象
print('__next__' in dir(range(1,10)))
# False
6.4. 其它
1. 查询方法：dir()
一个查询方法，获得一个对象所具备的方法列表，不长写在代码中，常用来获取帮助，判断
2. 帮助：help()
帮助函数，没有返回值，函数直接打印
help(str)
# 获取和 str 相关的使用方法
3. 调用相关：callable()
拿过来一个名字，判断一个函数是否能够被调用
# 只能看函数，不能看关键字
print(callable(print)) # True
a = 1
print(callable(a)) # False
4. 模块相关：import() 缺
5. 文件操作相关：open()
文件相关
6. 内存相关：id()、hash()
hash：把可 hash 的数据转换成一串数字
7. 输入输出 input()、print()
print()语法
def print(self, *args, sep=' ', end='
', file=None): # known special case of print
"""
print(value, ..., sep=' ', end='
', file=sys.stdout, flush=False)
file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件
sep: 打印多个值之间的分隔符，默认为空格
end: 每一次打印的结尾，默认为换行符
flush: 立即把内容输出到流文件，不作缓存
"""
实操
每一次 print 自动换行
'''
# 指定结尾符号
print('print 01',end='
')
# 指定输出多个值之间的分隔符
print(1,2,3,4,5,sep='_%_')
# 指定打印内容到文件句柄
f = open('aa.txt','w')
print('print 03',file=f)
'''
提高：打印进度条
import time
for i in range(0,101,2):
time.sleep(0.1)
char_num = i//2 #打印多少个'*'
per_str = '
%s%% : %s
' % (i, '*' * char_num) if i == 100 else '
%s%% : %s'%(i,'*'*char_num)
print(per_str,end='', flush=True)
#小越越 ：
可以把光标移动到行首但不换行
# progress Bar 模块
8. 字符串类型代码的执行：eval()、exec()、single、compile
# 相同之处
exec("print(123,'by exec')")
eval("print(123,'by eval')")
# 123 by exec
# 123 by eval
# 不同之处
print(eval('1+2+3+4')) # 10 , 返回结果
print(exec('1+2+3+4')) # None , 没有返回值
'''
exec 和 eval 都可以执行字符串类型的代码
适用场景：
eval：
- 只能用在你明确知道你要执行的代码是什么
- 有结果的简单计算
exec:
- 没有返回结果
- 简单流程控制
'''
实例：exec()
# 实例 01
code = '''
for i in range(10):
print(i*'*')
'''
exec(code)
9. compile
将字符串类型的代码编译。diamante 对象能够通过 exec 语句来执行或者 eval 进行求值
'''
参数说明：
1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。
2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
- 当传入了source参数时，filename参数传入空字符即可。
3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。
- 当source中包含流程语句时，model应指定为‘exec’；
- 当source中只包含一个简单的求值表达式，model应指定为‘eval’；
- 当source中包含了交互式命令语句，model应指定为'single'。
'''
小结
# exec ，流程
code1 = 'for i in range(0,3):print(i)'
comple1 = compile(code1,'','exec')
exec(comple1)
# eval ，计算
code1 = '1+2+3+4'
comple1 = compile(code1,'','eval')
print(eval(comple1))
# single ，交互
code3 = 'name = input("please input your name:")'
compile3 = compile(code3,'','single')
exec(compile3)
print(name)
6.5. 基础数据类型——数字相关（14）
'''
数据类型相关：bool,int,float,complex
- 只在数据类型强制转换时使用
进制转换相关：bin，oct，hex
-
数学运行：abs，divmod，min，max，sum，round，pow
'''
1. divmod() 除余
网站内容分页
print(divmod(7,2))
(3, 1) # 结果
2. round() 小数精确
3. pow() 幂运算
4. sum() 和
5. min() 最小值
# 根据特定条件，查找值
print(min(1,2,3,-4,key=abs))
6. max() 最大值
print(max(1,2,3,-4,key=abs))
6.6. 基础数据类型——和数据结构相关
1. 序列相关 list、tuple
2. reversed() 反转
'''
list:
tuple:
'''
# reversed() 获得一个逆序列表迭代器,不修改原列表
l = [1,2,3,4,5]
print(type(reversed(l))) # <class 'list_reverseiterator'>
print(list(reversed(l))) # [5, 4, 3, 2, 1]
l.reverse() # 直接修改原列表，可以用这个方法
3. slice() 生成切片规则
l = (1,2,3,23,213,24,54,98)
sli = slice(1,5,2)
# 调用定义的切片规则
print(l[sli])
# 直接切片
print(l[1:5:2])
5.2 字符串相关
| str | format | bytes |
|---|---|---|
| bytearray | memoryview | ord |
| chr | ascii | repr |
1. format()
'''
1. 将一个数值进行格式化显示。
2. 如果参数format_spec未提供，则和调用str(value)效果相同，转换成字符串格式化。
3. 对于不同的类型，参数format_spec可提供的值都不一样
'''
# 1,2
print(type(format(1)))
'''
格式化输出
'''
#字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
print(format('test', '<20'))
print(format('test', '>20'))
print(format('test', '^20'))
#整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
>>> format(3,'b') #转换成二进制
'11'
>>> format(97,'c') #转换unicode成字符
'a'
>>> format(11,'d') #转换成10进制
'11'
>>> format(11,'o') #转换成8进制
'13'
>>> format(11,'x') #转换成16进制 小写字母表示
'b'
>>> format(11,'X') #转换成16进制 大写字母表示
'B'
>>> format(11,'n') #和d一样
'11'
>>> format(11) #默认和d一样
'11'
#浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
>>> format(314159267,'e') #科学计数法，默认保留6位小数
'3.141593e+08'
>>> format(314159267,'0.2e') #科学计数法，指定保留2位小数
'3.14e+08'
>>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示
'3.14E+08'
>>> format(314159267,'f') #小数点计数法，默认保留6位小数
'314159267.000000'
>>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数
'3.141593'
>>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数
'3.14159267'
>>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数
'3.1415926700'
>>> format(3.14e+1000000,'F') #小数点计数法，无穷大转换成大小字母
'INF'
#g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
>>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
'3e-05'
>>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
'3.1e-05'
>>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点
'3.14e-05'
>>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写
'3.14E-05'
>>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
'3'
>>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点
'3.1'
>>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点
'3.14'
>>> format(0.00003141566,'.1n') #和g相同
'3e-05'
>>> format(0.00003141566,'.3n') #和g相同
'3.14e-05'
>>> format(0.00003141566) #和g相同
'3.141566e-05'
2. bytes()
'''
应用场景：
1. 网络编程
2. 文件存储
3. 照片和视频也是二进制存储的
4. html 网页爬取到的也是
'''
# 2. unicode 转换
print(bytes('你好',encoding='GBK'))
print(bytes('你好',encoding='utf-8'))
print(bytes('你好',encoding='GBK').decode('GBK'))
print(bytes('你好',encoding='utf-8').decode('utf-8'))
# 1：把gbk 编码的你好，重新编译成 utf-8
a = bytes('你好',encoding='GBK')
b = a.decode('GBK')
c = bytes(b,encoding='utf-8')
d = c.decode('utf-8')
print(a,b,c,d)
3. bytearray()
'''
byte 类型的一个数组
- 修改的时候，可以修改字节，比较麻烦
- 在修改字符串的时候，转换成字节的形式，可以节省内存
'''
b_array = bytearray('你好',encoding='utf-8')
print(b_array)
print(b_array[0])
4. memoryview()
编码转换
'''
ord：字符按照 unicode 转数字
chr：数字按照 unicode 转字符
ascii：是 ascii 码的输出原始内容，不是的输出一个byte串
'''
print(ascii('你'))
print(ascii('a'))
5. repr() 暂缺
把准备输出的内容，原封不动的打印出来，和字符串格式和输出中的%r等价
5.3 数据集合 dict()、set()、forzenset()
5.3 相关内置函数
| len() | enumerate() | all() | any() |
|---|---|---|---|
| zip() | filter() | map() | sorted() |
1. all()、any()
**判断可迭代对象，是否存在 bool 值为 False 
# all 有一个是假，--> False
print(all(['a','',123]))
print(all(['a',123]))
print(all([0,123]))
# any 有一个为真， --> True
print(any(['a','',123]))
print(any(['a',123]))
print(any([0,123]))
2. zip() 拉链函数
l = [1,2,3]
l2 = ['a','b','c','d']
l3 = ('*','**',[1,2])
d = {'k1':2,'k2':3}
for i in zip(l,l2,l3,d):
print(i)
输出结果：
'''
(1, 'a', '*', 'k1')
(2, 'b', '**', 'k2')
'''
# 结论：
1. 以最小单元为基准，一次聚合成一列表，每一项是一个元组
2. 字典以 key 聚合
3. filter() 、map()
过滤函数，根据函数条件来判断可迭代对象是否满足，返回 bool 值，为真时新增至一个迭代器
'''
filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，
filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
'''
def is_odd(x):
return x %2 == 1
l = filter(is_odd,[1,3,4,6,7,9,12,17])
print(list(l))
# 把可迭代的每一个值，当做参数，传入到函数中，根据返回的结果(bool)确认是不是在删选的范围之内
# 循环可迭代内容，做判断，True 组成一个新的可迭代器
# 等价于 如下列表推导式
# [i for i in [1,3,4,6,7,9,12,17] if i %2 == 1]
# 利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：
def is_not_empty(s):
return s and len(s.strip()) > 0
print(list(filter(is_not_empty, ['test', None, '', 'str', ' ', 'END'])))
# map 函数
ret = map(abs,[-1,4,-5,8])
print(ret)
for i in ret:
print(i)
# 把可迭代的值，一次通过 abs 来执行，返回一个迭代器地址
'''
小结：
filter
- 执行了 fileter 之后的结果 <= 执行之前的个数，
- filter 只管筛选，不会改变原来的值，截取一部分
map()
- 执行前后元素个数不变
- 值可能发生改变
'''
4. sorted()
排序方法，保留原列表
# 生成一个新的列表，开辟新的内存空间
l = [1,-3,5,6,-9]
print(sorted(l),l,sorted(l,reverse=True))
# [-9, -3, 1, 5, 6] [1, -3, 5, 6, -9][6, 5, 1, -3, -9]
print(sorted(l,key=abs,reverse=True)) # 根据绝对值，从大到小排列，key = 排序规则
# [-9, 6, 5, -3, 1]
'''
练习题 01：根据裂变元素的长度排序
# l = ['sdf',{'ssdf':123,'a':3}]
# print(sorted(l,key=len)) # 有问题，数字不能进行排序
l = [1,112,'sd3f',{'ssdf':123,'a':3},(1,2,3,4)]
def func(x):
if type(x) == int or type(x)==bool or type(x) == float or type(x) ==complex:
return len(str(x))
else:
return len(x)
print(sorted(l,key=func,reverse=True))
'''
# 在元列表的基础上进行排序，列表的排序方法
l = [1,-3,5,6,-9]
l.sort()
print(l)
l.sort(key=abs)
print(l)