内置函数、可迭代对象、迭代器对象

1.重要内置函数

1.zip:组成一个新的列表，列表中的元素是几个列表当中各元素组成的元组

1.1 几个列表数据值个数相等时:
l1 = [11, 22, 33, 44, 55]
l2 = ['jason', 'kevin', 'oscar', 'jerry', 'tony']
l3 = [1, 2, 3, 4, 5]
res = zip(l1, l2)
print(list(res))  # [(11, 'jason'), (22, 'kevin'), (33, 'oscar'), (44, 'jerry'), (55, 'tony')]
res1 = zip(l1, l2, l3)
print(list(res1))  # [(11, 'jason', 1), (22, 'kevin', 2), (33, 'oscar', 3), (44, 'jerry', 4), (55, 'tony', 5)]

1.2 几个列表数据值个数不相等时:
l1 = [11, 22, 33, 44, 55]
l2 = ['jason', 'kevin', 'oscar', 'jerry']
l3 = [1, 2, 3, 4, 5]
res = zip(l1, l2)
print(list(res))  # [(11, 'jason'), (22, 'kevin'), (33, 'oscar'), (44, 'jerry')]

2.filter:函数会遍历列表lst, 用lambda表达式来判断所遍历到的数据是否符合要求
l1 = [11, 32, 423, 12, 45, 32, 456, 34, 654]
res = filter(lambda x:x>100, l1)
print(list(res))  # [423, 456, 654]

l1 = [11, 32, 423, 12, 45, 32, 456, 34, 654]
res = filter(lambda  a:a > 10 and a <100, l1)
print(list(res))  # [11, 32, 12, 45, 32, 34]

3.sorted:对列表中的数据值进行排序，默认升序
l1 = [11, 32, 423, 12, 45, 32, 456, 34, 654]
res = sorted(l1) 
print(res)  # [11, 12, 32, 32, 34, 45, 423, 456, 654]
"""
排序也可以用列表的内置方法，list.sort()(如果是降序要在括号内加上reverse = True)
"""
l1.sort()
print(l1)  # [11, 12, 32, 32, 34, 45, 423, 456, 654]
l1.sort(reverse=True)
print(l1)  # [654, 456, 423, 45, 34, 32, 32, 12, 11]

2.常见的内置函数

1.abs():绝对值
print(abs(-25))  # 25
print(abs(30))  # 30

2.all():结果是一个布尔值，括号内跟一个列表，列表中全为True结果才是True，有一个为False结果就为False(类似and、'与')
print(all([1, 23, 4, 3, 2]))  # True
print(all([0, 1, 3]))  # False
print(all(['jason', 'jerry', '']))  # False

3.any():结果是一个布尔值，括号内跟一个列表，列表中全为False结果才是False，有一个为True结果就为True(类似and、'或')
print(any([1, 2, 0]))  # True
print(any([0, None, '']))  # False
"""
布尔值为False的数据类型:0、None、空字符串、空列表、空字典
"""

4.bin():转二进制 
oct():转八进制
hex():转十六进制
int():转十进制，括号内第二个参数要注明几进制

print(bin(10))  # 0b1010
print(oct(10))  # 0o12
print(hex(10))  # 0xa
print(int('0xa', 16))  # 10

5.bytes():也可以用s.encode('utf8')
s = '十一后连上七天班'
print(s.encode('utf8'))  # b'\xe5\x8d\x81\xe4\xb8\x80\xe5\x90\x8e\xe8\xbf\x9e\xe4\xb8\x8a\xe4\xb8\x83\xe5\xa4\xa9\xe7\x8f\xad'
print(bytes(s, 'utf8'))  # b'\xe5\x8d\x81\xe4\xb8\x80\xe5\x90\x8e\xe8\xbf\x9e\xe4\xb8\x8a\xe4\xb8\x83\xe5\xa4\xa9\xe7\x8f\xad'

6.callible():判断名字是否可以调用(内置函数可以、定义的函数的也可以)
name = 'jason'
print(callable(name))  # False
def index(a):
    a + 1
print(callable((index)))  # True
print(callable(print))  # True
                      
7.chr()、ord():基于ASCII码表切换数字与字母，chr():数字转字母,ord():字母转数字
print(chr(68))  # D
print(ord('A'))  # 65
"""
ASCII码表数字与字母切换:A-Z:65-90,a-z:97-122
"""

8.dir():返回括号内对象能够调用的名字
print(dir([]))  # 查询列表
print(dir('hello'))  # 查询字符串能调用的属性
print(dir(''))  # 查询字符串能调用的属性

9.divmod():括号内后面跟两个参数，第一个数被除数，第二个是除数，返回一个元祖，第一个是整除数，第二个是余数。
print(divmod(35, 2))  # (17, 1)
page_num, more = divmod(12652, 25)
if more:
    page_num += 1
print('总页码为:', page_num)  # 总页码为: 507

10.emumerate():字典生成式
放在字典里，字典的K是索引值(可以指定只是位置)，字典的V是字符串的字符。
d1 = {i:j for i, j in enumerate('halle world')}
print(d1)  # {0: 'h', 1: 'a', 2: 'l', 3: 'l', 4: 'e', 5: ' ', 6: 'w', 7: 'o', 8: 'r', 9: 'l', 10: 'd'}

也可不放在字典里，分别打印i,j:
for i,j in enumerate('hello'):
    print(i, j)

11.eval()、exec():识别字符串中的代码并执行
"""
eval()和exec()直接执行前面不需要加print,加print除了打印字符串中的列表外会返回一个None
"""   
s = "print('哈哈哈')"
eval(s)  # 哈哈哈
exec(s)  # 哈哈哈

print(eval(s))  # 哈哈哈 None
print(exec(s))  # 哈哈哈 None

"""
eval()和exec()区别:eval()只能识别简单的代码，具有逻辑性的不行，exec()可以
"""
s = 'for i in range(20):print(i)'
exec(s)  # 打印0-20数字
eval(s)  # 报错

12.id():获取内存地址
    
13.input():获取用户输入
    
14.instance():第一个参数为数据值，第二个为数据类型，输出结果为布尔值，只能判断整形
print(isinstance(1, int))  # True

15.map():映射,按照指定的方式对列表中的数据进行处理，输出一个新列表，方式用lambda(匿名函数)或自定义函数来定义
l1 = [1, 2, 3, 4, 5]
res = map(lambda x:x+1, l1)
print(list(res))  # [2, 3, 4, 5, 6]

16.max()/min():
16.1.输出列表中的最大(最小值)
l1 = [1, 23, 4, 3, 2]
print(max(l1))  # 23

16.2.比较字典中的数据值
dict = {
    'jason': 100000,
    'jerry': 5000,
    'oscar': 10000,
    'kitty': 20000
}

 dict = {
    'jason': 100000,
    'jerry': 5000,
    'oscar': 10000,
    'kitty': 20000
}
def index(a):
    return dict.get(a)
res = max(dict, key=index)  # 传了函数修改了比较的依据，如果不传则会按照字符编码顺序比较
print(res)  # jason

15.open():打开文件
语法结构:
文本模式:with open (r'文件路径', 'r/w/a', encoding='utf8')

二进制模式:with open (r'文件路径', 'rb/wb/ab')

16.pow():幂指数
print(pow(2, 4)) # 16

17.range():用来确定范围的函数
range(1,10):打印1-9
range(10):打印0-9
range(1, 10, 2):间隔为2
"""
python2中的xrange和python3中的range用for循环输出一个范围都会展开每个数字，python2中是一个范围，不会展开
"""

18.round():'五舍六入'
print(round(4.2))  # 4
print(round(4.5))  # 4
print(round(4.6))  # 5

19.sum():求和:列表、集合、元组都适用
l1 = [1, 2, 3, 4]
t1 = (1, 2, 3, 4)
s1 = {1, 2, 3, 4}
print(sum(l1))  # 10
print(sum(t1))  # 10
print(sum(s1))  # 10

3.可迭代对象

1.可迭代对象:对象内有__iter__方法的都称为可迭代对象
"""
1.内置方法  通过点的方式能够调用的方法
2.__iter__  双下iter方法
"""

2.可迭代对象的范围:
    是可迭代对象的数据类型:
        str、list、dict、tuple、set、文件对象
"""
for循环支持的数据类型:str、list、dict、tuple、set,文件也支持for循环
"""
        
    不是可迭代对象:
        int、float、bool

3.可迭代的含义:
	迭代:更新换代 eg:手机app更新
	可迭代对象在python中可以理解为是否支持for循环

4.迭代器对象

1.迭代器对象:
    是由可迭代对象调用__iter__方法产生
    迭代器对象判断的本质是看是否有__iter__和__next__(两者必须都有)
    
2.迭代器对象的作用
	提供了一种不依赖于索引取值的方式，正因为有迭代的存在，我们的字典，集合才能否被for循环
    
3.迭代器对象实操
s = 'hello'
res = s.__iter__()
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())  # 会依次打印'hello'
print(res.__next__())  # 再执行会报错，而for循环不会
"""
__next__取不到值会直接报错
"""
print(s.__iter__().__next__())
print(s.__iter__().__next__())
print(s.__iter__().__next__())
print(s.__iter__().__next__())
print(s.__iter__().__next__())  # hhhhh
"""
会连打5个h，因为每次调用可迭代对象并且变成迭代器对象，所以每次都会重新执行
"""

4.注意事项:
    可迭代对象调用__iter__会成为迭代器对象，迭代器对象如果还调用__iter__不会有任何变化，还是迭代器对象本身

5.for循环本质:

for 变量名 in 可迭代对象:
    循环体代码
"""
1.先将in后面的可迭代对象用__iter__转变成迭代器对象
2.依次让迭代器调用__next__取值
3.一旦__next__取不到值报错，for循环会自动捕捉并处理，所以我们不会看到for循环报错
"""

6.异常捕获/处理

1.异常
	异常就是代码运行报错 行业俗语叫bug
	代码运行中一旦遇到异常会直接结束整个程序的运行 我们在编写代码的过程中药尽可能避免
2.异常分类
	语法错误
    	不允许出现 一旦出现立刻改正 否则提桶跑路
	逻辑错误
    	允许出现的 因为它一眼发现不了 代码运行之后才可能会出现
3.异常结构
	错误位置
 	错误类型
 	错误详情