一、内置函数
list() 将一个可迭代对象转化为列表
字典转为列表：会将所有键转化为列表
字符串转为列表：键每个字符转化为列表
s = 'abc'
dic = {'a':1,'b':2,'c':3}
print(list(s)) # 字符串的字符逐个转为列表
print(list(dic)) # 将字典的键转为列表
# 结果
['a', 'b', 'c']
['a', 'b', 'c']
tuple() 将一个可迭代对象转化为元组
字典转为元组：会将所有键转化为元组
字符串转为元组：键每个字符转化为元组
s = 'abc'
dic = {'a':1,'b':2,'c':3}
print(tuple(s)) # 字符串的字符逐个转为元组
print(tuple(dic)) # 将字典的键转为列表
# 结果
('a', 'b', 'c')
('a', 'b', 'c')
slice() 实现切片对象
制作了切片的规则，方便其他的切片可以调用
调用方法跟切片相似，列表[切片对象]
li = [i for i in range(1,11)]
section = slice(0,9,2)
print(li[section])
# 结果
[1, 3, 5, 7, 9]
str() 将数据类型转化为字符串
s = str(123456789)
print(s,type(s))
# 结果
123456789 <class 'str'>
可以将bytes类型的字符转为str，需要加编码encoding
s = str(b'xe4xbdxa0xe5xa5xbd',encoding='utf-8')
print(s)
# 结果
你好
format() 与数据相关，一般用于科学计算
print(format('右对齐','>20')) # 第一参数是任何类型，第二参数>右对齐和字符串的长度
print(format('左对齐','<20')) # 第一参数是任何类型，第二参数<左对齐和字符串的长度
print(format('居中','^20')) # 第一参数是任何类型，第二参数^居中和字符串的长度
# 结果
右对齐
左对齐
居中
print(format(99,'b')) # 第一参数转化为二进制
print(format(99,'d')) # 第一参数转化为十进制
print(format(99,'o')) # 第一参数转化为八进制
print(format(99,'x')) # 第一参数转化为十六进制，小写字母表示
print(format(99,'X')) # 第一参数转化为十六进制，大写字母表示
print(format(99,'n')) # 第一参数转化为十进制
print(format(99,'c')) # 第一参数转化为unicode字符
print(format('123')) # 默认
# 结果
1100011
99
143
63
63
99
c
123
bytes() 将unicode转化为bytes类型
格式：bytes(字符串,encoding=编码)
s = '哈哈哈'
b = bytes(s,encoding='utf-8')
print(b)
# 结果
b'xe5x93x88xe5x93x88xe5x93x88'
将整型转化为bytes类型（不能加encoding）
b = bytes(10)
print(b,type(b))
# 结果
b'x00x00x00x00x00x00x00x00x00x00' <class 'bytes'>
将可迭代对象转化为bytes类型（不能加encoding）
b = bytes([1,2,3])
print(b,type(b))
# 结果
b'x01x02x03' <class 'bytes'>
bytearray() 返回一个新字节数组
可以将字符串转化为unicode码，通过切片或者索引替换值，改变原来的值，id不变
ret1 = bytearray('你好',encoding='utf-8')
print(id(ret1)) # 2082285910312
print(ret1) # bytearray(b'xe4xbdxa0xe5xa5xbd')
print(ret1[:3]) # bytearray(b'xe4xbdxa0')
ret1[:3] = b'xe6x82xa8' # 通过切片替换值
print(ret1) # bytearray(b'xe6x82xa8xe5xa5xbd')
print(id(ret1)) # 2082285910312
memoryview() 函数返回给定参数的内存查看对象(Momory view)。
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
v = memoryview(bytearray('abc',encoding='utf-8'))
print(v[0]) # 97
print(v[-1]) # 99
ret2 = memoryview(bytes('你好',encoding='utf-8'))
print(id(ret2)) # 1745227157576
print(ret2) # <memory at 0x0000019657A51048>
print(bytes(ret2).decode('utf-8')) # 你好
ord() 输入字符找该字符编码的位置，unicode的字符编码或者ascii的字符编码
print(ord('好')) # 22909
chr() 输入位置数字找出对应的字符，unicode的字符编码或者ascii的字符编码，跟ord相反
print(chr(22909)) # 好
ascii 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 x, u 或 U 编码的字符
print(ascii('a')) # 'a'
print(ascii('好')) # 'u597d'
repr() 返回一个对象的string形式
dic = {'baidu':'baidu.com','google':'google.com'}
print(repr(dic),type(repr(dic))) # {'baidu': 'baidu.com', 'google': 'google.com'} <class 'str'>
s = 'google'
print(repr(s)) # 'google'
用途：① 研究json pickle序列化模块，特殊字符串与python字符串的区别
② 格式化输出 %r
print("I'll do a %r search" % ('Google'))
# 结果
I'll do a 'Google' search
dict() 创建一个字典
dic = dict(zip(['a','b','c'],[1,2,3]))
# {'a': 1, 'b': 2, 'c': 3}
set() 创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
li = frozenset([1,2,3,4,5])
# frozenset({1, 2, 3, 4, 5})
len() 返回对象中元素的个数
print(len([i for i in range(10)]))
# 10
sorted() 对所有可迭代的对象进行排序操作
通过原对象排序后形成新的对象，对原对象无影响
默认按对象的元素的索引0的元素排序
dic = {'b':1,'c':3,'a':2}
print(sorted(dic))
# 结果
['a', 'b', 'c']
参数key可以添加函数来比较。
dic = {'b':1,'c':3,'a':2}
def func(x): # 字典的是传入键
return dic[x] # 返回键对应的值
print(sorted(dic,key=func,reverse=True)) # 通过函数的返回值来排序，reverse是倒序
# 结果
['c', 'a', 'b']
all() 可迭代对象里的元素全是True才返回True
any() 可迭代对象里的元素有一个True就返回True
li = [1,2,3,'',()]
print(all(li))
print(any(li))
# 结果
False
True
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
拉链方法：以长度最短的可迭代对象为主，写多个可迭代对象，将纵向组成一个个元组，按顺序排列；组合是一个迭代器。
li = [1,2,3,4,5]
tu = ('a','b','c')
dic = {'i':10,'k':20,'j':30}
print(zip(li,tu,dic)) # <zip object at 0x000002452FD4AFC8> 迭代器
for i in zip(li,tu,dic):
print(i)
# 结果
(1, 'a', 'i')
(2, 'b', 'k')
(3, 'c', 'j')
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
类似于筛选模式下的列表推导式
格式：filter(function or None, iterable)
def func(x):return x % 2 == 1
l1 = [i for i in range(10)]
f1 = filter(func,l1)
print(f1) # <filter object at 0x0000026A61F47908> 迭代器
print(list(f1)) # [1, 3, 5, 7, 9]
# 结果
<filter object at 0x0000026A61F47908>
[1, 3, 5, 7, 9]
map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
类似于列表推导式的循环模式，根据提供的函数对指定序列做映射
def func(x):return pow(x,3)
li = [1,3,5,8,9]
l2 = map(func,li)
print(l2) # <map object at 0x0000022EE54A7A20> 迭代器
print(list(l2)) # [1, 27, 125, 512, 729]
# 结果
<map object at 0x0000022EE54A7A20>
[1, 27, 125, 512, 729]
重点掌握：print、min、max、sum、map、sorted、reversed、filter、zip
有key的内置函数：min、max、map、sorted、filter、zip
二、匿名函数
lambda 表达式 就是匿名函数，一行函数
普通函数，有且只有返回值的函数才可以使用匿名函数进行简化，一行函数。
匿名函数一般不单独使用，多余内置函数配合使用。
格式：
func = lambda x:x*2
函数名 = lambda 参数 ：返回值
func = lambda x : pow(x,3)
print(func(2)) # 8
匿名函数的返回值可以放三元运算
func = lambda x : x > 13 and x or x**2
print(func(10)) # 100
三、递归函数
函数的自我调用，就称为递归函数。
递归能解决的函数也能解决，而且递归算法解题的运行效率较低。
使用递归函数一定要用 return
# 求 8！
def func(x):
if x == 1:
return x
return x * func(x-1)
print(func(8))
python默认递归深度有限制的，默认998次，以免消耗尽内存
def func(x):
print(x)
x += 1
return func(x)
func(1)
# 结果
1
2
...
...
...
996
997
998
Traceback (most recent call last):
File "D:/Day14/review.py", line 256, in <module>
func(1)
File "D:/Day14/review.py", line 255, in func
return func(x)
File "D:/Day14/review.py", line 255, in func
return func(x)
File "D:/Day14/review.py", line 255, in func
return func(x)
[Previous line repeated 993 more times]
File "D:/Day14/review.py", line 253, in func
print(x)
RecursionError: maximum recursion depth exceeded while calling a Python object
可以对深度进行修改，导入sys模块
import sys
sys.setrecursionlimit(100000)
def func(x):
print(x)
x += 1
return func(x)
func(1)
# 结果
1
2
3
...
...
...
3219
3220
3221