第三十七次总结：迭代器

普通排序

排序小结

由小到大，由大到小

使用sort或者sorted排序

默认是由小到大进行排序

如果希望由大到小排序

加上 reverse=True 参数

 

是否改变身身

如果排序用的是方法（方法就是对象的技能）

自身发生改变，理解为变身

如果排序用的是公有排序函数

不改变自身，有返回值

 

列表排序

列表对象自带的排序技能

# 列表排序
list_age = [14, 18, 19, 7, 6]
​
# 有两种排序方式
# 1，使用列表对象自带的排序方法，无返回值，改变自身
res_list = list_age.sort()
print(res_list, 'res')
print(list_age)

 

.使用公共的一个函数处理

# 2,使用一个公共排序函数，有返回值，返回值就是排序好的结果。不改变列表对象本身
res_list = sorted(list_age)
print(res_list, 'res')
print(list_age, 'self')

 

 

元组排序

使用公共的排序函数

# 元组排序
tuple_age = (14, 18, 19, 7, 6)
​
print(type(tuple_age))
​
res = sorted(tuple_age)
print(res)

 

 

列表包字典排序

 

• 列表包字典，根据字典中的某一个键值对进行排序

  • 【{用户等级键值对，充值金额键值对}】

  • 玩游戏，等级

  • 充值金额

  • 在线时长排序

 

使用列表自带的排序方法

dict_list = [
    {"name":"张飞", "attack": 90, "age": 33},
    {"name":"刘备", "attack": 80, "age": 40},
    {"name":"诸葛亮", "attack": 30, "age": 28},
    {"name":"吕布", "attack": 98, "age": 29}
]
​
# 按照功击力进行排名(由高到低）
# 1,使用列表自带的排序技能，列表的sort方法
dict_list.sort(key=lambda e:e["attack"], reverse=True)
print(dict_list)
​
for hero_dict in dict_list:
    print(hero_dict)

 

使用公共的排序函数来实现

特点：使用公有函数排序

不会改变被排序的对象本身

会获得一个返回值

返回值就是我们需要的内容

 

dict_list = [
    {"name":"张飞", "attack": 90, "age": 33},
    {"name":"刘备", "attack": 80, "age": 40},
    {"name":"诸葛亮", "attack": 30, "age": 28},
    {"name":"吕布", "attack": 98, "age": 29}
]
​
# 按照年龄由小到大排序
res_data = sorted(dict_list, key= lambda e:e["age"])  # key理解为依据
print(res_data)
​
for hero_dict in res_data:
    print(hero_dict)

 

 

三元表达式

用法

当我们需要的数据，是会根据一种条件获得两种不同的结果的时候，可以使用三元表达式

变量 = 条件为真时的值 if 条件 else 条件为假时的值

 

# 使用if语句完成
# 比较两个数，如果前者比后者大，返回1，否则 -1
​
res = 1 if 7 > 5 else -1
​
print(res)

效果等同

if 3 > 5:
    res = 1
else:
    res = -1
​
print(res)

 

 

列表生成式

通过一种公式，一步到位生成列表的数据

 

初级的列表生成式

变量 = [临时变量 for 临时变量 in 容器]

 

推演一下列表生成式的细致步骤

for i in [1, 2, 3]:
    print(i)

结果，依次会是

1

2

3

 

列表生成式

res_list = [i for i in [1, 2, 3]]

 

 

进阶列表生成式

变量 = [要存的数据 for 临时变量 in 容器]

 

 

列表生成式与普通列表的生成比对

下面的代码是一样的

# res_list = ["hoho"+str(i) for i in [1,2,3,4]]
# print(res_list)
​
效果等同于
​
​
res_list = []
for i in [1,2,3,4]:
    temp = "hoho" + str(i)
    res_list.append(temp)
​
print(res_list)

 

 

列表生成式再进阶

 

列表 = [要存的数据 for 临时变量 in 容器 if 条件]

 

# 需求：
# 使用列表生成式完成由字符串成员10-20的可以被3整除的数，字符串类型
​
res_list = [str(i) for i in range(11,21) if i%3 == 0]
print(res_list)

 

 

验证对象与类的关系

isinstance（对象名, 类名）

验证对象的祖辈类是否是这个类

如果是，则为True，不是为False

 

class Animal:
    pass
​
​
class Cat(Animal):
    pass
​
t = Cat()
r = isinstance(t, Animal)
# isinstance(孩子，祖辈)
​
print(r)

 

命名规范

以is开头的，一般代表是不是

以has开的头，一般代表有没有

带有able的词，一般代表着具有某种能力的

 

 

迭代器

可迭代

如果生成对象的类中有 __iter__ 方法，那么它可迭代

可迭代，表明可以被for循环遍历

 

自定义了一个类

让类中包含 __iter__ 方法

让这个类实例化生成了一个对象

验证

该对象是否是可迭代类所关联的对象

 

from collections import Iterable
​
class Cat:
    def __iter__(self):
        pass
​
t = Cat()
​
r = isinstance(t, Iterable)
print(r)

 

 

迭代器协议

1，类中提供一个__next__方法

要么返回一个数据

要么抛出一个异常，StopIteration类

raise StopIteration('迭代器没有数据了')

2，类中需要有一个__iter__方法

 

如果类中尊循了上面的两个要求

那么该类所创建出来的对象，就是迭代器对象

 

 

迭代器对象与可迭代对象

可迭代的对象，不一定可以遍历。 __iter__
迭代器，一定可以迭代。  __iter__  __next__

 

列表的遍历了解

列表可以遍历，原因之一，它是可迭代的

列表对象拥有__iter__方法

 

列表可以遍历，原因二，有一个对象可以为它提供数据支持

我们通过调用列表的iter方法发现，得到的结果，是一个具有next`方法的对象

 

 

如何让一个自定义的对象被for遍历

对象是一个可迭代的对象

创建对象的类中要有__iter__方法

__iter__需要返回一个迭代器

迭代器是提供数据一个容器

迭代器的类中，要有__next__方法

由该方法提供数据

迭代器中要有__iter__方法

__iter__方法可以什么都不做的

 

根据上面的要求

我们可以直接一步到位的创建一个可以被遍历的对象

 

类中定义一个__next__方法

根据不同的情况，返回不同的数据

如果情况可以，返回数据

如果情况不可以，抛出错误 StopIteration类的错误

 

类中定义一个__iter__方法

该方返回自已类创建的对象，即self

 

 

异常的复习

最常用的万能异常捕捉

try:
    print(m)
# except 类型 as 提示变量
except Exception as t:
    print(t)
​
print('跳过刚刚代码了')

 

万能捕捉简化版

try:
    print(m)
except:
    pass
​
print('跳过刚刚代码了')

 

创建异常对象

异常类名（提示语句str）

例如

ne = NameError("名字错了小伙子")

 

抛出异常

raise 异常对象

raise 英 [reɪz] 美 [reɪz] v. 提升;举起;提起;(使)直立，站立;增加，提高(数量、水平等) n. 高地;上升;加薪

 

ne = NameError("名字错了小伙子")  # 创建了一个异常对象
raise ne
print('正常的代码')

抛出异常后，后面的代码就不再执行了