超简单的Python教程系列——第7篇:循环和迭代器

超简单的Python教程系列——第7篇:循环和迭代器

还记得你上次丢东西是什么时候吗?

你可能会翻遍你的房子。一个一个房间地查找,而你周围的人问一些毫无意义的问题,比如“你最后一次是放在哪里的?” (说真的,如果我知道的话,我就不会找他们了!)如果优化一下你的搜索方式的话就会变得很轻松,但是你的房子房间没有排序……或者特别有条理,如果你和我一样的话,你就是被线性搜索困住了。

在编程中,就像在现实生活中一样,我们通常不会拿到任何有意义的顺序数据。一般都从一团糟开始,我们必须在上面执行任务。搜索无序数据可能是第一个浮现在脑海中的例子,但你可能还想做数百件其他事情:将所有华氏温度记录转换为摄氏温度,找到所有数据点的平均值,等等。

“是的,这就是循环的用途!”

但这是 Python。它的循环在一个完全不同的层次上。他们太好用了。

循环概述

让我们把无聊的东西扔掉,好吗?

在 Python 中,与大多数语言一样,有两个基本的循环:​​while​​​和​​for​​。

while

​while​​循环是非常基本的。

clue = None
while clue is None:
clue = searchLocation()

​clue is None​​在这种情况下,只要循环条件的计算结果为​​True​​,就会执行循环的代码。

在 Python 中,我们还有几个有用的关键字:​​break​​立即停止循环,同时​​continue​​跳到循环的下一次迭代

​break​​最有用的方面之一是如果我们想要运行相同的代码,直到用户提供有效的输入。

while True:
try:
age = int(input("Enter your age: "))
except ValueError:
print(f"Please enter a valid integer!")
else:
if age > 0:
break

一旦我们遇到该​​break​​语句,我们就退出循环。当然,上面是一个较复杂的例子,但它证明了这一点。你还经常看到​​while True:​​在游戏循环中使用。

注意:如果你曾经使用过任何语言的循环,那么你已经熟悉了无限循环(死循环)。这通常是由​​while​​​条件计算结果为​​True​​​ 并且循环中没有​​break​​语句引起的。

for

来自 Java、C++ 或许多类似的 ALGOL 风格的语言,你可能熟悉三方​​for​​循环:​​for i := 1; i < 100; i := i + 1​​。 我不了解你,但当我第一次遇到这种情况时,它吓坏了我。我现在对它很满意,但它不具备 Python 的优雅简洁。

Python 的​​for​​循环看起来大不相同。与上述伪代码等效的 Python 代码是...

for i in range(1,100):
print(i)

range()是 Python 中一个特殊的“函数”,它返回一个序列。(从技术上讲,它根本不是一个函数。)

这是 Python 令人印象深刻的地方——它迭代了一种特殊类型的序列,称为iterable,我们稍后会谈到。

目前,最容易理解的是我们可以迭代一个顺序数据结构,比如一个数组(在 Python 中称为“列表”)。

因此,我们可以这样做...

places = ['Nashville', 'Norway', 'Bonaire', 'Zimbabwe', 'Chicago', 'Czechoslovakia']
for place in places:
print(place)

print("...and back!")

我们得到这个...

Nashville
Norway
Bonaire
Zimbabwe
Chicago
Czechoslovakia
...and back!

for...else

Python 在其循环中还有另一个独特的小技巧:​​else​​子句!循环完成后,没有遇到​​break​​语句,就会运行​​else​​。但是,如果手动中断循环,它将​​else​​完全跳过。

places = ['Nashville', 'Norway', 'Bonaire', 'Zimbabwe', 'Chicago', 'Czechoslovakia']
villain_at = 'Mali'

for place in places:
if place == villain_at:
print("Villain captured!")
break
else:
print("The villain got away again.")

由于“Mali”不在列表中,因此我们看到了“The villain got away again.”的消息。但是,如果我们将值更改​​villain_at​​​为​​Norway​​,我们将看到“Villain captured!” ,而看不到了“The villain got away again.”。

存在do...whiel吗?

Python 没有​​do...while​​​循环。如果你正在寻找这样的循环方式,典型的 Python 是使用​​while True:​​​带内部​​break​​条件的 ,就像我们之前演示的那样。

数据结构(容器)

Python 有许多保存数据的容器或数据结构。我们不会深入讨论其中的任何一个,但我想快速浏览一下最重要的部分:

list

list是一个可变序列(其实就是一个数组)。

它是用方括号定义的​​[ ]​​,你可以通过索引访问它的元素。

foo = [2, 4, 2, 3]

print(foo[1])
>>> 4

foo[1] = 42
print(foo)
>>> [2, 42, 2, 3]

尽管对它没有严格的技术要求,但典型的约定是列表只包含相同类型的元素(“同质”)。

tuple

tuple是一个不可变的序列。一旦你定义了它,你在技术上就不能改变它(回想一下之前不变性的含义)。这意味着在定义tuple后,你不能在tuple中添加或删除元素。

一个tuple是在括号中定义的​​( )​​,你可以通过索引访问它的元素。

foo = (2, 4, 2, 3)

print(foo[1])
>>> 4

foo[1] = 42
>>> TypeError: 'tuple' object does not support item assignment

与列表不同,标准约定允许tuple包含不同类型的元素(“异构”)。

set

set是一个无序的可变集合,保证没有重复。记住“无序”很重要:不能保证单个元素的顺序!

一个集合在花括号中定义​​{ }​​,但如果你想要一个空集合,你可以使用​​foo = set()​​, 或者​​foo = {}​​创建一个空的​​dict​​. 你不能通过索引访问它的元素,因为它是无序的。

foo = {2, 4, 2, 3}

print(foo)
>>> {2, 3, 4}

print(foo[1])
>>> TypeError: 'set' object does not support indexing

对于要添加到集合中的对象,它也必须是可散列的(hash)。一个对象是可散列的,如果:

  1. 它定义了方法__hash__(),该方法将哈希值(hash)作为整数返回。(见下文)
  2. 它定义了__eq__()比较两个对象的方法。

对于同一个对象(值),一个有效的散列值(hash)应该总是相同的,并且它应该是合理的唯一的,因此另一个对象返回相同的散列是不常见的。(两个或多个具有相同哈希值的对象称为哈希冲突,它们仍然会发生。)

dict

dict(字典)是键值数据结构。

它在花括号中定义​​{ }​​​,​​:​​​用于分隔键和值。它是无序的,所以你不能通过索引访问它的元素;但是你可以通过​​[ ]​​加键值访问元素。

foo = {'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4}

print(foo['b'])
>>> 2

foo['b'] = 42
print(foo)
>>> {'a': 1, 'b': 42, 'c': 3, 'd': 4}

只有可散列的对象可以用作字典键。(有关​​set​​哈希性的更多信息,请参阅官网的部分。)

其他

除了基础之外,Python 还提供了额外的容器/数据结构。可以在内置模块collections中找到它们。

拆包

有一个重要的 Python 语法我们还没有讨论过,但很快就会派上用场。我们可以将容器中的每个元素分配给一个变量!这称为拆包

当然,我们需要确切地知道我们要拆包多少才能结束,否则我们会得到一个​​ValueError​​的异常。

让我们看一个使用tuple元组的基本示例。

fullname = ('Carmen', 'Sandiego')
first, last = fullname
print(first)
>>> Carmen
print(last)
>>> Sandiego

看第二行代码,我们可以列出多个要分配的变量,用逗号分隔。Python 将拆分等号右侧的容器,将每个值按从左到右的顺序分配给一个变量。

注意:记住,​​set​​是无序的!虽然你可以在技术上使用集合来执行此操作,但你无法确定将什么值分配给什么变量。不保证按顺序进行分配,集合的值的分配顺序通常是偶然的!

in

Python 提供了一个关键字​​in​​ ,用于检查是否在容器中找到了特定元素。

places = ['Nashville', 'Norway', 'Bonaire', 'Zimbabwe', 'Chicago', 'Czechoslovakia']

if 'Nashville' in places:
print("Music city!")

这适用于许多容器,包括列表、元组、集合,甚至是字典键(但不是字典值)。

如果你希望你的自定义类之一支持​​in​​​运算符,你只需要定义​​__contains__(self, item)​​​方法,它应该返回​​True​​​or ​​False​​。

迭代器

Python 的循环是配合我之前提到的迭代器一起使用前面提到的数据结构都是是可以使用迭代器迭代的对象。

好的,让我们从头开始。Python 容器对象,例如 ​​list​​,也是一个可迭代对象,因为它的​​__iter__()​​方法,返回一个迭代器对象。

方法​​__next__()​​也是一个迭代器​,在容器迭代器的情况下,返回下一项。即使是无序的容器,例如​​set()​​,也可以使用迭代器进行遍历。

当​​__next__()​​不能返回任何其他内容时,它会抛出一个名为StopIteration的特殊异常​。这可以使用​​try...except​​捕获异常。

让我们再看一下​​for​​​遍历 ​​list​​ 的循环,例如...

dossiers = ['The Contessa', 'Double Trouble', 'Eartha Brute', 'Kneemoi', 'Patty Larceny', 'RoboCrook', 'Sarah Nade', 'Top Grunge', 'Vic the Slick', 'Wonder Rat']

for crook in dossiers:
print(crook)

​dossiers​​是一个​​list​​对象,它是一个可迭代的对象。当 Python 到达​​for​​循环时,它会做三件事:

  1. 调用iter(dossiers),依次执行dossiers.__iter__()。这将返回一个我们将调用的迭代器对象list_iter。这个迭代器对象将被循环使用。
  2. 对于循环的每次迭代,它都会调用next(list_iter),执行list_iter.__next__()并将返回的值分配给crook
  3. 如果迭代器抛出了特殊异常StopIteration,则循环结束,退出。

​while True:​​如果我在循环中重写该逻辑可能会更容易理解......

list_iter = iter(dossiers)
while True:
try:
crook = next(list_iter)
print(crook)
except StopIteration:
break

如果你尝试这两个循环,你会发现它们做的事情完全相同!

了解​​__iter__()​​,​​__next__()​​和​​StopIteration​​异常的工作原理后,你现在可以使自己的类可迭代!

注意:虽然将迭代器类与可迭代类分开定义都可以,但你不一定必须这样做!只要这两种方法都在你的类中定义,并且​​__next__()​​行为适当,你就可以定义​​__iter__()​​为​​return self​​.

值得注意的是迭代器本身是可迭代的:它们有一个​​__iter__()​​​方法返回​​self​​。

字典案例

假设我们有一本想要使用的字典......

locations = {
'Parade Ground': None,
'Ste.-Catherine Street': None,
'Pont Victoria': None,
'Underground City': None,
'Mont Royal Park': None,
'Fine Arts Museum': None,
'Humor Hall of Fame': 'The Warrant',
'Lachine Canal': 'The Loot',
'Montreal Jazz Festival': None,
'Olympic Stadium': None,
'St. Lawrence River': 'The Crook',
'Old Montréal': None,
'McGill University': None,
'Chalet Lookout': None,
'Île Notre-Dame': None
}

如果我们只想查看其中的每个项目,我们只需使用​​for​​循环。所以,这应该有效,对吧?

for location in locations:
print(location)

哎呀!这只向我们展示了,而不是值。这并不是我们想要的,不是吗?

​dict.__iter__()​​返回一个​​dict_keyiterator​​对象,该对象执行其类名的操作:它遍历键,但不遍历值。

同时获取键和值,我们需要调用​​locations.items()​​返回​​dict_items​​对象。​​dict_items.iter()​​返回 ​​dict_itemiterator​​,它将字典中的每个键值对作为元组返回。

旧版说明:如果你使用的是 Python 2,则应改为调用​​locations.iteritems()​​。

还记得刚才,当我们谈到拆包的时候吗?我们将每一对键值作为一个元组并拆分成两个变量。

for key, value in locations.items():
print(f'{key} => {value}')

打印出以下内容:

Parade Ground => None
Ste.-Catherine Street => None
Pont Victoria => None
Underground City => None
Mont Royal Park => None
Fine Arts Museum => None
Humor Hall of Fame => The Warrant
Lachine Canal => The Loot
Montreal Jazz Festival => None
Olympic Stadium => None
St. Lawrence River => The Crook
Old Montréal => None
McGill University => None
Chalet Lookout => None
Île Notre-Dame => None

现在我们可以处理数据了。例如,我想在另一个字典中记录重要信息。

information = {}

for location, result in locations.items():
if result is not None:
information[result] = location

# Win the game!
print(information['The Loot'])
print(information['The Warrant'])
print(information['The Crook'])

print("Vic the Slick....in jaaaaaaaaail!")

这将找到 Loot、Warrant 和 Crook,并按正确顺序列出它们:

Lachine Canal
Humor Hall of Fame
St. Lawrence River
Vic the Slick....in jaaaaaaaaail!

自定义迭代器

我之前已经提到你可以制作自己的迭代器和迭代器,但现在来实现它!

想象一下,我们想方便保留一个代理列表,以便我们始终可以通过代理编号来识别它们。但是,有些代理是我们不能谈论的。我们可以通过将代理 ID 和名称存储在字典中,然后维护分类代理列表来轻松完成此操作。

注意:请记住,在我们对类的讨论中,Python 中实际上没有私有变量这样的东西。如果你真的打算保密,请使用行业标准的加密和安全实践,或者至少不要将你的 API 暴露给任何 VILE 操作员。;)

对于初学者,这是该类的基本结构:

class AgentRoster:
def __init__(self):
self._agents = {}
self._classified = []

def add_agent(self, name, number, classified=False):
self._agents[number] = name
if classified:
self._classified.append(name)

def validate_number(self, number):
try:
name = self._agents[number]
except KeyError:
return False
else:
return True

def lookup_agent(self, number):
try:
name = self._agents[number]
except KeyError:
name = "<NO KNOWN AGENT>"
else:
if name in self._classified:
name = "<CLASSIFIED>"
return name

我们可以继续测试一下,只是为了后续:

roster = AgentRoster()

roster.add_agent("Ann Tickwitee", 2539634)
roster.add_agent("Ivan Idea", 1324595)
roster.add_agent("Rock Solid", 1385723)
roster.add_agent("Chase Devineaux", 1495263, True)

print(roster.validate_number(2539634))
>>> True
print(roster.validate_number(9583253))
>>> False

print(roster.lookup_agent(1324595))
>>> Ivan Idea
print(roster.lookup_agent(9583253))
>>> <NO KNOWN AGENT>
print(roster.lookup_agent(1495263))
>>> <CLASSIFIED>

太好了,这完全符合预期!现在,如果我们希望能够遍历整个字典怎么办。

但是,我们不想直接访问​​roster._agents​​字典,因为这将忽略这个类的整个“分类”方面。我们如何处理?

正如我之前提到的,我们可以让这个类也作为它自己的迭代器,这意味着它有一个​​__next__()​​方法。在这种情况下,我们只会 return ​​self​​。但是,这里是超简单Python教程,所以让我们跳过烦人步骤,简化内容,实际创建一个单独的迭代器类。

在这个例子中,我实际上将字典变成了一个元组列表,这将允许我使用索引。(请记住,字典是无序的。)我还将计算出有多少代理分类。当然,所有这些逻辑都属于该​​__init__()​​方法:

class AgentRoster_Iterator:

def __init__(self, container):
self._roster = list(container._agents.items())
self._classified = container._classified
self._max = len(self._roster) - len(self._classified)
self._index = 0

要成为迭代器,类必须有​​__next__()​​方法;这是唯一的要求!​请记住,一旦我们没有更多数据要返回,该方法就需要抛出​​StopException​​异常。

我将定义​​AgentRoster_Iterator​​的​​__next__()​​方法如下:

class AgentRoster_Iterator:

# ...snip...

def __next__(self):
if self._index == self._max:
raise StopIteration
else:
r = self._roster[self._index]
self._index += 1
return r

现在我们返回到​​AgentRoster​​类,我们需要在其中添加一个​​__iter__()​​返回迭代器对象的方法。

class AgentRoster:

# ...snip...

def __iter__(self):
return AgentRoster_Iterator(self)

只需要一点点操作,现在我们的​​AgentRoster​​类的行为与循环的预期完全一样!这段代码如下...

roster = AgentRoster()

roster.add_agent("Ann Tickwitee", 2539634)
roster.add_agent("Ivan Idea", 1324595)
roster.add_agent("Rock Solid", 1385723)
roster.add_agent("Chase Devineaux", 1495263, True)

for number, name in roster:
print(f'{name}, id #{number}')

产生的结果如下...

Ann Tickwitee, id #2539634
Ivan Idea, id #1324595
Rock Solid, id #1385723

保持期待

我听到后面的 Pythonista:“等等,等等,我们还不能完成!你甚至还没有接触到列表推导!”

Python 确实在循环和迭代器之上增加了一个额外的级别,它使用了一个名为generator的特殊工具。这种类型的类提供了另一种令人难以置信的工具,称为comprehension,它就像一个用于创建数据结构的完美闭环。

我还故意跳过了​​zip()​​和​​enumerate()​​的优点,这使得循环和迭代更加强大。我会把它们归纳在这里,但我不想让文章太长。我在后面也会谈到这些。

我大概猜到你们中的一些人已经开始期待了,但是很遗憾,你将不得不等到下一篇文章才能了解更多信息。

总结

  • 只要​​while​​其条件评估为 ,循环就会运行​​True​​。
  • 你可以使用关键字跳出循环​​break​​,或使用关键字跳到下一个迭代​​continue​​。
  • ​for​​循环迭代一个可迭代对象(可以迭代的对象),例如一个列表。
  • 该​​range()​​函数返回一个可迭代的数字序列,可以在​​for​​循环中使用,例如​​for i in range(1, 100)​​.
  • Python 没有​​do...while​​循环。使用​​while True:​​带有显式 break 语句的循环。
  • Python 有四种基本的数据结构或容器
  • 列表是可变的、有序的、顺序的结构……基本上是数组。
  • 元组是不可变的、有序的、顺序的结构。思考列表,但不能修改内容。
  • 集合是可变的、无序的结构,保证不会有任何重复的元素。它们只能存储可散列的对象。
  • 字典是存储键值对的可变的、无序的结构。你通过键而不是索引查找项目。只有可散列的对象可以用作键。
  • 你可以使用约定将容器的值拆分为多个变量​​a, b, c = someContainer​​。左边的变量个数和右边容器中的元素个数必须相同!
  • ​in​​你可以使用关键字快速检查元素是否在容器中。如果你希望你的类支持这一点,请定义该​contains()​​方法。
  • Python 的容器是可迭代对象的示例:它们返回可以遍历其内容的迭代器。可迭代对象总是通过其​iter()​​方法返回一个迭代器对象。
  • 迭代器对象总是有一个方法​next()​​,该方法返回一个值。容器迭代器的​next()​​方法将返回容器中的下一个元素。当没有更多可以返回时,迭代器会引发​​StopIteration​​异常。
发表评论

相关文章