【修仙】第一卷 初出茅庐 第十九章 迭代器

前倾提要

三元表达式

作用

主要用于二选一的情况 能够减少代码量 但不建议嵌套

语法结构

结果1 if 条件 else 结果2
条件成立时输出结果1 条件不成立输出结果2

# 举例
res = 10 if 5 > 10 else 20
print(res)  # 20

各种生成式

列表生成式

语法：[数据相关梳理 for i in 数据类型 if 条件]

# 举例
l1 = [1, 2, 3, 4, 5, 6, 7]
l2 = [i + 2 for i in l1 if i != 1]
print(l2)  # [4, 5, 6, 7, 8, 9]

字典生成式

集合生成式

匿名函数

匿名函数定义

没有名字的函数
主要用于简单的业务逻辑处理 减少代码编写

匿名函数关键字

lambda

语法结构

lambda 形参: 返回值

# 举例
res = lambda x: x+1
res1 = res()
print(res1)  # 2

# lambda x: x+1 可以看做
# def func(x): return x+1

重要内置函数

max

求最大值 可以通过匿名函数取出字典中 V 的最大值

l1 = [2, 1, 4, 3, 7, 6, 8, 1]
print(max(l1))  # 8
d1 = {'jason': 200, 'tony':50, 'zoy': 20}
print(max(d1))  # zoy
print(max(d1, key=lambda k:d1.get(k)))  # jason

min

求最小值 操作类似最大值

sum

求和

l1 = [2, 1, 4, 3, 7, 6, 8, 1]
print(sum(l1))  # 32

map

映射 将后面数据集的数一个个传入前面的方法进行操作

l1 = [1, 2, 3, 4, 5, 6, 7]
res = map(lambda x: x+10, l1)
print(list(res))  # [11, 12, 13, 14, 15, 16, 17]

filter

过滤 将数据过滤

l1 = [1, 2, 3, 4, 5, 6, 7]
res = filter(lambda x: x!=3, l1)
print(list(res))  #" [1, 2, 4, 5, 6, 7]"

reduce

求和

from functools import reduce
l1 = [1, 2, 3, 4, 5, 6, 7]
res = reduce(lambda x, y: x + y, l1)
print(res)  # 28

zip

链表连接

l1 = [1, 2, 3, 4]
l2 = ['jason', 'kevin', 'tony', 'jerry']
res = zip(l1, l2)
print(list(res))  # [(1, 'jason'), (2, 'kevin'), (3, 'tony'), (4, 'jerry')]
l3 = [5, 6, 7]
res = zip(l1, l2, l3)
print(list(res))  # [(1, 'jason', 5), (2, 'kevin', 6), (3, 'tony', 7)]

今日内容

目录

• 常见内置函数
• 可迭代对象
• 迭代器对象
• for循环的本质

常见内置函数

内置函数定义

提前定义好的 可直接使用的 很多内置函数都有很好用的功能

abs() 求绝对值

print(abs(-13))  # 13
print(abs(13))  # 13
print(abs(-9))  # 9

all() 与 any()

# all()  判断容器类型中所有的数据是否都为True 可以看做全部数据进行and
l1 = [1, 2, 3, 4, 0]
l2 = [1, 2, 3, 4]
print(all(l1))  # False
print(all(l2))  # True
# any()  判断容器类型中是否存在数据为True 可以看做去全部数据进行or
print(any(l1))  # True
print(any(l2))  # True
l3 = [0, 0, 0, 0, None, False]
print(any(l3))  # False

bin() oct() hex() 十进制转其他进制

print(bin(10))  # 0b1010
print(oct(10))  # 0o12
print(hex(10))  # 0xa

int() 其他进制转10进制

print(int(0b1010))
print(int(0o12))
print(int(0xa))

bytes() 类型转换 配合 str()

s = '你好啊'
res = bytes(s, 'utf8')  # 等价于 res = s.encode('ustf')
res1 = str(res, 'utf8')  # 等价于 res1 = res.decode('utf8')

callable() call 在IT专业名词翻译成 调用>>>:加括号 可以判断数据是否可以调用

name = 'jason'
def index(): pass
print(callable(name))  # False
print(callable(index))  # True

chr() ord() 根据ASCII码表 实现字符与数字的转换

print(chr(65))  # A
print(char(97))  # a
print(ord('A'))  # 65
print(ord('a'))  # 97

dir() 获取对象内部可以用句点符获取的数据或方法

s = '123'
print(dir(s))  # 结果有点多 自己试

divmod() 获取除法运算后的整数和余数 常用与分页

res = divmod(99, 10)
print(res)  # (9, 9)
# 用于分页
real_num, more = divmod(898, 10)
if more:
    real_num += 1
print(f'总页数为：{real_num}')

enumerate() 枚举

name_list = ['jason', 'tony', 'kevin', 'jerry']
# 需求：循环打印出列表中的数据以及对应的索引值
count = 0
for i in name_list:
    print(count, i)
    count += 1
# 运行结果
# 0 jason
# 1 kevin
# 2 oscar
# 3 jerry

# 使用enumerate()
for i, j in enumerate(name_list):
    print(i, j)

# 运行结果
# 0 jason
# 1 kevin
# 2 oscar
# 3 jerry

eval() exec() 能够识别字符串中pyton语句并执行 其中eval()只能识别简单代码 exec()可以识别复杂代码

s = 'print(123)'
eval(s)  # 123
s = 'for i in range(10):print(i, end=" ")'
exec(s)  # 0 1 2 3 4 5 6 7 8 9

hash() 返回一串随机的数字(哈希值)

print(hash('jason'))  # -3519093933572877535

help() 查看帮助信息

help(len)
# 运行结果
# Help on built-in function len in module builtins:
# 
# len(obj, /)
#     Return the number of items in a container.

isinstance() 判断某个数据是否属于某个数据类型

s = 'jason'
print(isinstance(s, str))  # True
print(isinstance(s, int))  # False

pow() 幂指函数

print(pow(2, 10))  # 1024  既 2的10次方

round() 四舍五入 有偏差 可以查百度看看详细说明 但我懒

print(round(98.3))  # 98
print(round(98.5))  # 98
print(round(98.6))  # 99
print(round(5.5))  # 6

可迭代对象

如何理解迭代

迭代就是更新换代 每次迭代都基于上一次的成果
手机上的软件更新 专业上来讲>>>:软件版本迭代

迭代代码演示

# 不属于迭代的情况
n = 0
while n < 10:
    print(n)

# 属于迭代的情况
n = 0
while n < 10:
    print(n)
    n += 1

如何判断可迭代对象

"""
可迭代对象可以通过 句点符 调用__iter__方法
__XXX__ 读作双下XXX方法 不要读成杠杠XXX杠杠 很low
"""
"""
通过调用内置函数得知
可迭代对象
    字符串 列表 字典 元组 集合 文件
不是可迭代对象
    整型 浮点型 布尔值 函数名
可迭代对象能够支持for循环取值 并且提供了一种不依赖于索引取值的方式
"""

迭代器对象

作用

迭代器对象给我们提供了一种不依赖于索引值的取值方式
正是有迭代器对象的存在 我们才可以从字典、集合这些无序排序的容器类型中获取数据

如何判断迭代器对象

内置有__iter__ 和__next__ 的对象都称为迭代器对象

可迭代对象 与迭代器对象的关系

可迭代对象调用__iter__就会变成迭代器对象
迭代器对象无论调用多少次__iter__都还是本身

迭代器对象取值

l1 = [1, 2, 3, 4, 5]
# l1 并没有 __next__ 方法 因为它是可迭代对象
res = l1.__iter__()  # 使用__iter__将可迭代对象转化为迭代器对象 并赋值给res
print(res.__next__())  # 1  使用__next__就可以取出下一个数据

# 不使用for循环 依次打印列表中所有数据
l1 = [1, 2, 3, 4, 5]
res = l1.__iter__()
n = 0
while n < len(l1):
    print(res.__next__())
    n += 1

# 运行结果
# 1
# 2
# 3
# 4
# 5

迭代器反复使用

l1 = [1, 2, 3, 4, 5]
print(l1.__iter__().__next__())  # 1  每次都是产生一个新的迭代器对象
print(l1.__iter__().__next__())  # 1
print(l1.__iter__().__next__())  # 1
print(l1.__iter__().__next__())  # 1
print(l1.__iter__().__next__())  # 1
res = l1.__iter__()
print(res.__iter__().__next__())  # 1 产生迭代器对象后 无论调用几次__iter__还是本身
print(res.__iter__().__next__())  # 2
print(res.__iter__().__next__())  # 3
print(res.__iter__().__next__())  # 4
print(res.__iter__().__next__())  # 5

双下方法的另一种方法

res = l.__iter__()  # 可以简写 res = iter(l)
res.__next__()  # 可以简写 next(res)
# 不推荐

迭代器对象的特殊性

迭代器对象 通过打印操作无法直接看出内部的情况
这个时候能帮你节省空间
相当于一个工厂 需要数据时 一个个取出

for循环的本质

语法结构

for 变量名 in 可迭代对象:
for循环代码体
1.for循环 会自动将后面的可迭代对象调用__iter__转换为迭代器对象
2.之后每次循环调用__next__方法
3.最后没有值__next__会报错 for循环能过自动处理该错误 让循环自动结束 既之后要学到的异常捕获