当前位置:

首页 > 编程开发 > Python中的循环和迭代器:如何使用?

Python中的循环和迭代器:如何使用?

循环概述在Python中,与大多数语言一样,有两个基本的循环:while和for。whilewhile循环是非常基本的。clue=NonewhileclueisNone:clue=searchLocation()clueisNone在这种情况下,只要循环条件的计算结果为True,就会执行循环的代码。在Python中,我们还有几个有用的关键字:break立即停止循环,同时continue跳到循环的下一次迭代。break最有用的方面之一是如果我们想要运行相同的代码,直到用户提供有效的输入。whileTrue:

本文目录

    循环概述

    在 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)方法,它应该返回Trueor 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 = ""
            else:
                if name in self._classified:
                    name = ""
            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))
    >>> 
    print(roster.lookup_agent(1495263))
    >>> 

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

    但是,我们不想直接访问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
    本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
    作者最新文章
    编程开发 Python
    相关文章 更多
    python删除一个列表里的重复元素的方法与代码示例
    python删除一个列表里的重复元素的方法与代码示例

    学习如何使用Python高效删除列表中的重复元素。本文提供5种常见方法的代码示例,涵盖保持顺序与不保持顺序的场景,适合初学者和进阶开发者参考。

    Python写接口的步骤及完整代码示例
    Python写接口的步骤及完整代码示例

    详细讲解使用Python编写Web接口的核心步骤与完整代码示例,涵盖环境准备、路由定义、数据校验、服务启动及调试测试方法。

    codex怎么读取word文档及docx文件操作教程
    codex怎么读取word文档及docx文件操作教程

    介绍如何利用编程工具读取和解析Word文档(docx格式),涵盖基础文本提取代码示例、结构化数据处理逻辑,以及处理复杂排版时的技术局限与替代方案。

    怎么在Python中调用C语言代码提升性能
    怎么在Python中调用C语言代码提升性能

    详细讲解在Python中调用C语言代码提升性能的完整实践指南,包含原理分析、编译步骤、ctypes与CFFI具体实现、性能对比及常见陷阱。

    Python与C语言的性能差异及底层原理
    Python与C语言的性能差异及底层原理

    深入解析Python与C语言在执行效率上的数量级差异,从编译机制、变量内存布局、动态类型推断到GIL锁,系统阐明底层核心原理。

    Python和C语言哪个更适合编程入门
    Python和C语言哪个更适合编程入门

    客观对比Python与C语言在心智负担、底层机制与学习反馈上的核心差异,提供清晰有据的选择标准与切实的入门学习路径。

    selenium上传文件教程本地文件路径设置方法
    selenium上传文件教程本地文件路径设置方法

    深入解析Selenium处理文件上传的技术细节,涵盖标准HTML控件的路径直接注入法与非标准控件的系统级模拟方案,提供Windows与Linux环境下的路径设置最佳实践及常见异常排查。

    大数据开发语言选型:Java对比Scala与Python的优缺点及适用场景
    大数据开发语言选型:Java对比Scala与Python的优缺点及适用场景

    针对大数据工程场景,系统对比Java、Scala与Python在执行性能、生态结合、开发效率和维护成本上的核心差异,给出清晰的架构选型依据与落地方案。

    langgraph python guide中文入门教程详解
    langgraph python guide中文入门教程详解

    本篇LangGraph Python中文入门教程详解,系统梳理StateGraph状态机定义、节点编写、边与条件路由、检查点持久化(MemorySaver)等核心机制,提供从环境安装到完整循环智能体构建的代码示例与实操指导。

    Windows 安装 Python:从官方入口到虚拟环境的可复现实践
    Windows 安装 Python:从官方入口到虚拟环境的可复现实践

    面向后端开发者,基于 Python 官方文档说明如何在 Windows 上安装 Python、创建 venv 虚拟环境及使用 pip 管理依赖。包含可复制命令、验证方法及工具选择边界,避免常见配置误区。

    查看更多
    精品专题 更多
    装机必备
    装机必备

    正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

    Windows
    Windows

    正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

    PDF教程
    PDF教程

    正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

    Mac软件 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    Aperty macOS版
    Aperty macOS版
    macOS

    Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

    WINDOWS 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    PixTV 网页版
    PixTV 网页版
    Windows

    PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。