导图社区 Python从入门到实践——基础知识
- 44
- 3
- 举报
Python从入门到实践——基础知识
这份思维导图主要按照《python从入门到实践》的大纲来做出来的，并在相关内容的解释处加入了相关代码，欢迎大家一起学习！
编辑于2023-02-17 19:17:21 四川省
- Python从入门到实践——基础知识
这份思维导图主要按照《python从入门到实践》的大纲来做出来的，并在相关内容的解释处加入了相关代码，欢迎大家一起学习！
- 职能地图-Java
职能地图-Java，干货分享~Java语言技术，java技术扩展，数据结构，维优，个人职能，技术面试知识点总结。
- JAVA企业级开发
当今大型软件系统的开发多采用企业级的开发模式，而Java语言也是目前较为流行的企业级开发语言之一。针对Java企业级开发，涉及的知识点和技术栈较为丰富，包括但不限于Java EE、Spring框架、Hibernate框架、Maven、Git、Jenkins等等。这份思维导图以Java企业级开发为主题，通过图解的形式将涉及的知识点进行了梳理和整理，从Java EE体系结构、Servlet、JSP、Spring框架、Hibernate框架、Maven等基础知识开始讲解，逐步深入到SpringMVC、
Python从入门到实践——基础知识
社区模板帮助中心，点此进入>>
- Python从入门到实践——基础知识
这份思维导图主要按照《python从入门到实践》的大纲来做出来的，并在相关内容的解释处加入了相关代码，欢迎大家一起学习！
- 职能地图-Java
职能地图-Java，干货分享~Java语言技术，java技术扩展，数据结构，维优，个人职能，技术面试知识点总结。
- JAVA企业级开发
当今大型软件系统的开发多采用企业级的开发模式，而Java语言也是目前较为流行的企业级开发语言之一。针对Java企业级开发，涉及的知识点和技术栈较为丰富，包括但不限于Java EE、Spring框架、Hibernate框架、Maven、Git、Jenkins等等。这份思维导图以Java企业级开发为主题，通过图解的形式将涉及的知识点进行了梳理和整理，从Java EE体系结构、Servlet、JSP、Spring框架、Hibernate框架、Maven等基础知识开始讲解，逐步深入到SpringMVC、
- 相似推荐
- 大纲
Python从入门到实践——基础知识
变量和简单数据类型
变量
变量的命名和使用
变量名只能包含字母、数字和下划线。变量名能以字母或下划线打头，但不能以数字打头。例如，可将变量命名为message_1 ，但不能将其命名为1_message
变量名不能包含空格，但能使用下划线来分隔其中的单词。例如，变量名greeting_message 可行，但变量名greeting message 会引发错误
不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print
变量名应既简短又具有描述性。例如，name 比n 好，student_name 比s_n好，name_length 比length_of_persons_name 好。
慎用小写字母l 和大写字母O ，因为它们可能被人错看成数字1和0
使用变量时避免命名错误
变量是标签
字符串
字符串 就是一系列字符。在Python中，用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引
使用方法修改字符串的大小写
name = 'ada lovelace' print(name.title()) 输出 Ada Lovelace
首字母大写
title()
title() 指定的操作。每个方法后面都跟着一对圆括号，这是因为方法通常需要额外的信息来完成其工作。这种信息是在圆括号内提供的。函数title() 不需要额外的信息，因此它后面的圆括号是空的
全部大写
upper()
全部小写
lower()
在字符串中使用变量
要在字符串中插入变量的值，可在前引号前加上字母f，再将要插入的变量放在花括号内。这样，当Python显示字符串时，将把每个变量都替换为其值。 first_name = "Ada" last_name = "lovelace" full_name = f"{first_name} {last_name}" print(full_name)
f字符串
格式： f"~~~~" 变量用{~}括起来，字符串直接写，见下例 first_name = "Ada" 1 = "lovelace" full_name = f"Hello, {first_name} {last_name}" print(full_name) first_name和last_name是变量，Hello，是字符串
format（设置格式）的简写，因为Python通过把花括号内的变量替换为其值来设置字符串的格式
要使用方法format() ，可在圆括号 内列出要在字符串中使用的变量。对于每个变量，都通过一对花括号来引用。这样 将按顺序将这些花括号替换为圆括号内列出的变量的值，如下所示 full_name = "{} {}".format(first_name, last_name)
使用制表符或换行符来添加空白
制表符
\t
print("python") print("\tpython") 输出 python python
换行符
\n
print("Languages:\nPython\nC\nJavaScript") 输出 Languages: Python C JavaScript
删除空白
❶ >>> favorite_language = ' python ' ❷ >>> favorite_language.rstrip() ' python' ❸ >>> favorite_language.lstrip() 'python ' ❹ >>> favorite_language.strip() 'python'
删除字符串末尾空白
rstrip()
删除字符串开头空白
lstrip()
删除字符串两端空白
strip()
使用字符串时避免语法错误
数
整数
加（+）减（-）乘（*）除（/）运算
使用两个乘号表示乘方运算
支持运算次序，因此可在同一个表达式中使用多种运算。还可以使用圆括号来修改运算次序，让Python按你指定的次序执行运算
浮点数
Python将所有带小数点的数称为浮点数
整数和浮点数
将任意两个数相除时，结果总是浮点数，即便这两个数都是整数且能整除
数中的下划线
书写很大的数时，可使用下划线将其中的数字分组，使其更清晰易读
同时给多个变量赋值
例：x, y, z = 0, 0, 0
常量
常量类似于变量，但其值在程序的整个生命周期内保持不变。Python没有内置的常量类型，但Python程序员会使用全大写来指出应将某个变量视为常量，其值应始终不变
Python之禅
The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren't special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it. Although that way may not be obvious at first unless you're Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, it's a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea -- let's do more of those!
列表
列表是什么
用方括号（[ ]）表示列表，并用逗号分隔其中的元素 例： bicycles = ['trek', 'cannondale', 'redline', 'specialized'] print(bicycles) 输出： ['trek', 'cannondale', 'redline', 'specialized']
访问列表元素
索引
bicycles = ['trek', 'cannondale', 'redline', 'specialized'] print(bicycles[0]) 输出： trek
索引从0而不是1开始
使用列表中的各个值
bicycles = ['trek', 'cannondale', 'redline', 'specialized'] message = f'My first bicycle was a {bicycles[1].title()}' print(message) My first bicycle was a Cannondale
修改、添加和删除元素
修改列表元素
motorcycles = ['honda','yamaha','suzuki'] print(motorcycles) motorcycles[0] = 'ducati' print(motorcycles) 输出： ['honda', 'yamaha', 'suzuki'] ['ducati', 'yamaha', 'suzuki']
在列表中添加元素
在列表末尾添加元素
motorcycles = ['honda','yamaha','suzuki'] print(motorcycles) motorcycles.append('ducati') print(motorcycles)
元素附加（append）
在列表中插入元素
motorcycles = ['honda','yamaha','suzuki'] motorcycles.insert(0,'ducati') print(motorcycles)
insert()
从列表中删除元素
del语句
motorcycles = ['honda','yamaha','suzuki'] print(motorcycles) del motorcycles[0] print(motorcycles) 输出： ['honda', 'yamaha', 'suzuki'] ['yamaha', 'suzuki']
删除并提取列表最后一个元素
pop()
例子1： motorcycles = ['honda','yamaha','suzuki'] print(motorcycles) poped_motorcycles = motorcycles.pop() print(motorcycles) print(poped_motorcycles) 输出： ['honda', 'yamaha', 'suzuki'] ['honda', 'yamaha'] suzuki 例子2： motorcycles = ['honda','yamaha','suzuki'] last_owned = motorcycles.pop() print(f"The last motorcycle I owned was a {last_owned.title()}.") 输出： The last motorcycle I owned was a Suzuki.
弹出列表中任何位置处的元素
pop(索引)
motorcycles = ['honda','yamaha','suzuki'] last_owned = motorcycles.pop(0) print(f"The last motorcycle I owned was a {last_owned.title()}.") 输出： The last motorcycle I owned was a Honda.
根据值删除元素
remove()
motorcycles = ['honda','yamaha','suzuki'] print(motorcycles) motorcycles.remove('suzuki') print(motorcycles) 输出： ['honda', 'yamaha', 'suzuki'] ['honda', 'yamaha']
组织列表
使用方法sort()对列表永久排序
cars = ['bmw', 'audi', 'toyota', 'subaru'] cars.sort() print(cars) cars.sort(reverse = True) print(cars) 输出： ['audi', 'bmw', 'subaru', 'toyota'] ['toyota', 'subaru', 'bmw', 'audi']
使用函数sorted()对列表临时排序
cars = ['bmw', 'audi', 'toyota', 'subaru'] print("Here is the original list:") print(cars) print("\nHere is the sorted list:") print(sorted(cars)) print("\nHere is the original list again:") print(cars) 输出： Here is the original list: ['bmw', 'audi', 'toyota', 'subaru'] Here is the sorted list: ['audi', 'bmw', 'subaru', 'toyota'] Here is the original list again: ['bmw', 'audi', 'toyota', 'subaru']
倒着打印列表
reverse()
cars = ['bmw', 'audi', 'toyota', 'subaru'] print(cars) cars.reverse() print(cars) 输出： ['bmw', 'audi', 'toyota', 'subaru'] ['subaru', 'toyota', 'audi', 'bmw']
确定列表的长度
len()
>>>cars = ['bmw', 'audi', 'toyota', 'subaru'] >>>len(cars) 4
使用列表时避免索引错误
操作列表
遍历整个列表
magicians = ['alice', 'david', 'carolina'] for magician in magicians: print(magician)
深入研究循环
编写for 循环时，可以给依次与列表中每个值相关联的临时变量指定任意名称。然而，选择描述单个列表元素的有意义名称大有裨益
在for循环中执行更多操作
magicians = ['alice', 'david', 'carolina'] for magician in magicians: print(f"{magician.title()}, that was a great trick!")
在for循环结束后执行一些操作
magicians = ['alice', 'david', 'carolina'] for magician in magicians: print(f"{magician.title()}, that was a great trick!") print(f"I can't wait to see your next trick, {magician.title()}.\n") print("Thank you, everyone. That was a great magic show!") Alice, that was a great trick! I can't wait to see your next trick, Alice. David, that was a great trick! I can't wait to see your next trick, David. Carolina, that was a great trick! I can't wait to see your next trick, Carolina. Thank you, everyone. That was a great magic show!
在for循环后面，没有缩进的代码都只执行一次，不会重复执行
避免缩进错误
忘记缩进
忘记缩进额外的代码行
不必要的缩进
循环后不必要的缩进
遗漏了冒号
创建数值列表
使用函数range()
for value in range(1,5): print(value) 输出： 1 2 3 4
函数range()让Python从指定的第一个值开始数，并在到达你指定的第二个值时停止
使用range()创建数字列表
可使用函数list()将range()的结果直接转换为列表
numbers = list(range(1,6)) print(numbers) 输出： [1, 2, 3, 4, 5]
使用range()时，可以指定步长
numbers = list(range(2,11,2)) print(numbers) 输出： [2, 4, 6, 8, 10]
range(起始数，终止数，步长)
对数字列表执行简单的统计计算
>>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] >>> min(digits) 0 >>> max(digits) 9 >>>sum(digits) 45
列表解析
squares = [value**2 for value in range(1,11)] print(squares) 输出： [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 要使用这种语法，首先指定一个描述性的列表名，如squares 。然后，指定一个左方括号，并定义 一个表达式，用于生成要存储到列表中的值。在这个示例中，表达式为value**2 ，它计算平方值。接下来，编写一个for 循环，用于给表达式提供值，再加上右方括号。在这个示例中，for 循环为 for value in range(1,11) ，它将值1～10提供给表达式value**2 。请注意，这里的for 语句末尾没有冒号
使用列表的一部分
切片
players = ['charles', 'martina', 'michael', 'florence', 'eli'] print(players[0:3]) 输出： ['charles', 'martina', 'michael']
遍历切片
players = ['charles', 'martina', 'michael', 'florence', 'eli'] print("Here are the first three players on my team:") for player in players[:3]: print(player.title()) 输出： Here are the first three players on my team: Charles Martina Michael
复制列表
my_foods = ['pizza', 'falafel', 'carrot cake'] friend_foods = my_foods[:] print("my favorite foods are:") print(my_foods) print("\nmy friend's favorite foods are:") print(friend_foods) 输出： my favorite foods are: ['pizza', 'falafel', 'carrot cake'] my friend's favorite foods are: ['pizza', 'falafel', 'carrot cake']
元组
列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的 ，而不可变的列表被称为元组
定义元组
元组看起来很像列表，但使用圆括号而非中括号来标识。定义元组后，就可使用索引来访问其元素，就像访问列表元素一样
遍历元组中的所有值
修改元组变量
虽然不能修改元组的元素，但可以给存储元组的变量赋值。因此，如果要修改前述矩形的尺寸，可重新定义整个元组
设置代码格式
if语句
一个简单示例
cars = ['audi', 'bmw', 'bench', 'toyota'] for car in cars: if car == 'bmw': print(car.upper()) else: print(car.title()) 输出： Audi BMW Bench Toyota
条件测试
检查是否相等
’=‘将参数的值设置~~
'=='检查参数的值是否为~~
检查是否相等时注意大小写
在Python中检查是否相等时区分大小写
检查是否不相等
要判断两个值是否不等，可结合使用惊叹号和等号（!= ），其中的惊叹号表示不
数值比较
检查多个条件
and
or
检查特定值是否包含在列表中
in
检查特定值是否不包含在列表中
not in
布尔表达式
布尔值通常用于记录条件，布尔表达式的结果要么为True ，要么为False
if语句
简单的if语句
age = 19 if age >= 18: print("You are old enough to vote!") print("Have you registered to vote yet?") 输出： You are old enough to vote! Have you registered to vote yet?
if-else语句
age = 17 if age >= 18: print("You are old enough to vote!") print("Have you registered to vote yet?") else: print("Sorry, you are too young to vote.") print("Please register to vote as soon as you turn 18!") 输出： Sorry, you are too young to vote. Please register to vote as soon as you turn 18!
if-elif-else结构
age = 12 if age price = 0 elif age price = 25 else: price = 40 print(f'Your admission cost is ${price}.') 输出： Your admission cost is $25.
检查超过两个的情形
使用多个elif代码块
省略else代码块
age = 12 if age price = 0 elif age price = 25 elif age price = 40 elif age >= 65: price = 20 print(f"Your admission cost is ${price}.") 输出： Your admission cost is $25.
else 是一条包罗万象的语句，只要不满足任何if 或elif 中的条件测试，其中的代码就会执行。这 可能引入无效甚至恶意的数据。如果知道最终要测试的条件，应考虑使用一个elif 代码块来代替 else 代码块。这样就可以肯定，仅当满足相应的条件时，代码才会执行
测试多个条件
requested_toppings = ['mushrooms', 'extra cheese'] if 'mushrooms' in requested_toppings: print("Adding mushrooms.") if 'pepperoni' in requested_toppings: print("Adding pepperoni.") if 'extra cheese' in requested_toppings: print("Adding extra cheese.") print("\nFinished making your pizza!") 输出： Adding mushrooms. Adding extra cheese. Finished making your pizza!
如果只想执行一个代码块，就使用if-elif-else 结构；如果要执行多个代码块，就使用一系列独立的if 语句
字典
一个简单的字典
外星人 = {'颜色': '绿色', '分数':'5'} print(外星人['颜色']) print(外星人['分数']) 输出： 绿色 5
字典用放在花括号（{ }）中的一系列键值对表示
使用字典
添加键值对
alien_0 = {'color': 'green', 'points': 5} print(alien_0) alien_0['x_position'] = 0 alien_0['y_position'] = 25 print(alien_0) 输出： {'color': 'green', 'points': 5} {'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}
指定字典名、用方括号括起的键和相关联的值
修改字典中的值
外星人 = {'x坐标': 0,'y坐标': 25, '速度':'中速'} print(f"初始x坐标：{外星人['x坐标']}") if 外星人['速度'] == '低速': x增量 = 1 elif 外星人['速度'] == '中速': x增量 = 2 else: x增量 = 3 外星人['x坐标'] = 外星人['x坐标'] + x增量 print(f"新x坐标:{外星人['x坐标']}") 输出： 初始x坐标：0 新x坐标: 2
要修改字典中的值，可依次指定字典名、用方括号括起的键，以及与该键相关联的新值
删除键值对
外星人 = {'x坐标': 0,'y坐标': 25, '速度':'中速'} print(外星人) del 外星人['速度'] print(外星人) 输出： {'x坐标': 0, 'y坐标': 25, '速度': '中速'} {'x坐标': 0, 'y坐标': 25}
可使用del语句将相应的键值对彻底删除
由类似对象组成的字典
最喜欢的语言 = { '喜羊羊' : 'python', '美羊羊' : 'c语言', '沸羊羊' : '阿里嘎多美羊羊桑', '懒羊羊' : 'c++', '慢羊羊' : 'ruby', } 语言 = 最喜欢的语言['沸羊羊'].title() print(f'沸羊羊最喜欢的语言是"{语言}".') 输出： 沸羊羊最喜欢的语言是"阿里嘎多美羊羊桑".
将一个较大的字典放在了多行中
每个键都是一个被调查者的名字，而每个值都是被调查者喜欢的语言。确定需要使用多行来定义字典时，要在输入左花括号后按回车键。在下一行缩进四个空格，指定第一个键值对，并在它后面加上一个逗号。此后再按回车键时，文本编辑器将自动缩进后续键值对，且缩进量与第一个键值对相同。 定义好字典后，在最后一个键值对的下一行添加一个右花括号，并缩进四个空格，使其与字典中的键对齐。一种不错的做法是，在最后一个键值对后面也加上逗号，为以后在下一行添加键值对做好准备。
使用get()来访问值
alien_0 = {'color': 'green', 'speed': 'slow'} point_value = alien_0.get('points', 'No point value assigned.') print(point_value) 输出： No point value assigned.
遍历字典
遍历所有键值对
最喜欢的语言 = { '喜羊羊' : 'python', '美羊羊' : 'c语言', '沸羊羊' : '阿里嘎多美羊羊桑', '懒羊羊' : 'c++', '慢羊羊' : 'ruby', } for 名字,语言 in 最喜欢的语言.items(): print(f"{名字}最喜欢的语言是'{语言}'") 输出： 喜羊羊最喜欢的语言是'python' 美羊羊最喜欢的语言是'c语言' 沸羊羊最喜欢的语言是'阿里嘎多美羊羊桑' 懒羊羊最喜欢的语言是'c++' 慢羊羊最喜欢的语言是'ruby'
要编写遍历字典的for 循环，可声明两个变量，用于存储键值对中的键和值
for k, v in user_0.items() for 语句的第二部分包含字典名和方法items()，它返回一个键值对列表。接下来，for 循环依次将每个键值对赋给指定的两个变量
方法items()
遍历字典中的所有键
favorite_languages = { 'jen': 'python', 'sarah': 'c', 'edward': 'ruby', 'phil': 'python', } friends = ['phil', 'sarah'] for name in favorite_languages.keys(): print(f"Hi {name.title()}.") if name in friends: language = favorite_languages[name].title() print(f"\t{name.title()}, I see you love {language}!") 输出： Hi Jen. Hi Sarah. Sarah, I see you love C! Hi Edward. Hi Phil. Phil, I see you love Python!
方法keys()来遍历字典中的所有键
遍历字典时，会默认遍历所有的键。因此，如果将代码中的： for name in favorite_languages.keys(): 替换为 for name in favorite_languages: 输出将不变。 显式地使用方法keys() 可让代码更容易理解，你可以选择这样做，但是也可以省略它。
按特定顺序遍历字典中的所有键
favorite_languages = { 'jen': 'python', 'sarah': 'c', 'edward': 'ruby', 'phil': 'python', } for name in sorted(favorite_languages.keys()): print(f"{name.title()}, thank you for taking the poll.") 输出： Edward, thank you for taking the poll. Jen, thank you for taking the poll. Phil, thank you for taking the poll. Sarah, thank you for taking the poll.
调用函数sorted()
遍历字典中的所有值
使用方法values() 来返回一个值列表，不包含任何键
这种做法提取字典中所有的值，而没有考虑是否重复。涉及的值很少时，这也许不是问题，但如果被 调查者很多，最终的列表可能包含大量重复项。为剔除重复项，可使用集合（set）。 favorite_languages = { --snip-- } print("The following languages have been mentioned:") for language in set(favorite_languages.values()): print(language.title()) 输出： The following languages have been mentioned: Python C Ruby
嵌套
字典列表
alien_0 = {'color': 'green', 'points': 5} alien_1 = {'color': 'yellow', 'points': 10} alien_2 = {'color': 'red', 'points': 15} aliens = [alien_0, alien_1, alien_2] for alien in aliens: print(alien) 输出： {'color': 'green', 'points': 5} {'color': 'yellow', 'points': 10} {'color': 'red', 'points': 15}
在字典中存储列表
# 存储所点比萨的信息 pizza = { 'crust': 'thick', 'toppings': ['mushrooms', 'extra cheese'], } # 概述所点的比萨。 print(f"You ordered a {pizza['crust']}-crust pizza ""with the following toppings:") for topping in pizza['toppings']: print('\t'f"{topping}") 输出： You ordered a thick-crust pizza with the following toppings: mushrooms extra cheese
在字典中存储字典
users = { 'aeinstein': { 'first': 'albert', 'last': 'einstein', 'location': 'princeton', }, 'mcurie': { 'first': 'marie', 'last': 'curie', 'location': 'paris', }, } for username, user_info in users.items(): print(f"\nUsername: {username}") full_name = f"{user_info['first']} {user_info['last']}" location = user_info['location'] print(f"\tFull name: {full_name.title()}") print(f"\tLocation: {location.title()}") 输出： Username: aeinstein Full name: Albert Einstein Location: Princeton Username: mcurie Full name: Marie Curie Location: Paris
测试代码
测试函数
import unittest from name_function import get_formatted_name class NamesTestCase(unittest.TestCase): """Tests for 'name_function.py'.""" def test_first_last_name(self): """Do names like 'Janis Joplin' work?""" formatted_name = get_formatted_name('janis', 'joplin') self.assertEqual(formatted_name, 'Janis Joplin') def test_first_last_middle_name(self): """Do names like 'Wolfgang Amadeus Mozart' work?""" formatted_name = get_formatted_name( 'wolfgang', 'mozart', 'amadeus') self.assertEqual(formatted_name, 'Wolfgang Amadeus Mozart') if __name__ == '__main__': unittest.main()
单元测试和测试用例
可通过的测试
未通过的测试
测试未通过时怎么办
添加新测试
测试类
import unittest from survey import AnonymousSurvey class TestAnonymousSurvey(unittest.TestCase): """Tests for the class AnonymousSurvey""" def setUp(self): """ Create a survey and a set of responses for use in all test methods. """ question = "What language did you first learn to speak?" self.my_survey = AnonymousSurvey(question) self.responses = ['English', 'Spanish', 'Mandarin'] def test_store_single_response(self): """Test that a single response is stored properly.""" self.my_survey.store_response(self.responses[0]) self.assertIn(self.responses[0], self.my_survey.responses) def test_store_three_responses(self): """Test that three individual responses are stored properly.""" for response in self.responses: self.my_survey.store_response(response) for response in self.responses: self.assertIn(response, self.my_survey.responses) if __name__ == '__main__': unittest.main()
各种断言方法
一个要测试的类
测试AnonymousSurvey类
方法setUp()
文件和异常
从文件中读取数据
读取整个文件
with open("pi_digits.txt") as file_object: contents = file_object.read() print(contents.rstrip())
rstrip() 是一个字符串方法，用于去除字符串右侧的空白字符（包括空格、制表符、换行符等）。与之对应的是 lstrip() 方法，用于去除字符串左侧的空白字符，而 strip() 方法则同时去除字符串两端的空白字符。
文件路径
with open('text_files/filename.txt') as file_object: 这行代码让Python到文件夹python_work下的文件夹text_files中去查找指定的.txt文件
逐行读取
filename = 'pi_digits.txt' with open(filename) as file_object: for line in file_object: print(line.rstrip())
创建一个包含文件各行内容的列表
filename = 'pi_digits.txt' with open(filename) as file_object: lines = file_object.readlines() for line in lines: print(line.rstrip())
使用文件的内容
filename = 'pi_digits.txt' with open(filename) as file_object: lines = file_object.readlines() pi_string = '' for line in lines: pi_string += line.strip() print(pi_string) print(len(pi_string)) 输出： 3.141592653589793238462643383279 32
strip() 方法是用来去掉字符串两端的空白字符（包括空格、制表符和换行符）的。如果在调用 strip() 时没有传递参数，那么默认会去除字符串两端的空白字符，如果指定了参数，则会去除指定的字符
包含一百万位的大型文件
filename = 'pi_million_digits.txt' with open(filename) as file_object: lines = file_object.readlines() pi_string = '' for line in lines: pi_string += line.strip() print(f"{pi_string[:52]}...") print(len(pi_string)) 输出： 3.14159265358979323846264338327950288419716939937510... 1000002
圆周率值中包含你的生日吗
filename = 'pi_million_digits.txt' with open(filename) as file_object: lines = file_object.readlines() pi_string = '' for line in lines: pi_string += line.strip() birthday = input("Enter your birthday, in the form mmddyy: ") if birthday in pi_string: print("Your birthday appears in the first million digits of pi!") else: print("Your birthday does not appear in the first million digits of pi.") 输出： Enter your birthday, in the form mmddyy: 010119 Your birthday appears in the first million digits of pi!
写入文件
写入空文件
filename = 'programming.txt' with open(filename, 'w') as file_object: file_object.write("I love programing.")
写入多行
filename = 'programming.txt' with open(filename, 'w') as file_object: file_object.write("I love programing.\n") file_object.write("I love creating new games.")
附加到文件
filename = 'programming.txt' with open(filename, 'a') as file_object: file_object.write("I also love finding meaning in large datasets.\n") file_object.write("I love creating apps that can run in a browser.\n")
异常
看书p174-181
处理ZeroDivisionError异常
使用try-except代码块
使用异常避免崩溃
else代码块
处理FileNotFoundError异常
分析文本
使用多个文件
静默失败
决定报告哪些错误
存储数据
使用json.dump()和json.load()
import json numbers = [2, 3, 5, 7, 11, 13] filename = 'numbers.json' with open(filename, 'w') as f: json.dump(numbers, f) import json filename = 'numbers.json' with open(filename) as f: numbers = json.load(f) print(numbers) 讲解： json.dump() 方法将 Python 对象转换为 JSON 格式，并将其写入文件中。它接受两个参数：一个是要写入文件的 Python 对象，另一个是文件对象。 json.load() 方法则从 JSON 格式的文件中读取数据并将其转换为 Python 对象。它接受一个文件对象，并返回一个 Python 对象。
保存和读取用户生成的数据
重构
import json def get_stored_username(): """Get stored username if available.""" filename = 'username.json' try: with open(filename) as f: username = json.load(f) except FileNotFoundError: return None else: return username def get_new_username(): """Prompt for a new username.""" username = input("What is your name? ") filename = 'username.json' with open(filename, 'w') as f: json.dump(username, f) return username def greet_user(): """Greet the user by name.""" username = get_stored_username() if username: print(f"Welcome back, {username}!") else: username = get_new_username() print(f"We'll remember you when you come back, {username}!") greet_user()
类
创建和使用类
class Dog: """A simple attempt to model a dog.""" def __init__(self, name, age): """Initialize name and age attributes.""" self.name = name self.age = age def sit(self): """Simulate a dog sitting in response to a command.""" print(f"{self.name} is now sitting.") def roll_over(self): """Simulate rolling over in response to a command.""" print(f"{self.name} rolled over!") my_dog = Dog('Willie', 6) your_dog = Dog('Lucy', 3) print(f"My dog's name is {my_dog.name}.") print(f"My dog is {my_dog.age} years old.") my_dog.sit() print(f"\nYour dog's name is {your_dog.name}.") print(f"Your dog is {your_dog.age} years old.") your_dog.sit() 输出： My dog's name is Willie. My dog is 6 years old. Willie is now sitting. Your dog's name is Lucy. Your dog is 3 years old. Lucy is now sitting.
创建Dog类
方法__init__()
在 Python 中定义类的方法时，self 是一个特殊的参数，它指代类的实例对象本身。在类中定义方法时，需要将 self 作为第一个参数传递，这样 Python 才能正确地将实例对象传递给方法。 在 __init__ 方法中，self 表示正在被创建的实例对象。通过 self 参数，我们可以将 __init__ 方法中创建的实例变量绑定到实例对象上，从而可以在类的其他方法中访问和修改这些变量。 如果在定义类方法时忘记了将 self 作为第一个参数，那么 Python 将无法正确地将实例对象传递给方法，从而导致代码执行出错。
代码详解
这段代码定义了一个名为 Dog 的类，用于模拟一只狗。在类中定义了三个方法，__init__()、sit() 和 roll_over()，其中 __init__() 方法是一个特殊方法，用于初始化类实例的属性。 在这个类中，我们使用 self 来引用对象实例本身，这个对象实例包含了名为 name 和 age 的属性。通过调用 my_dog = Dog('Willie', 6)，我们创建了一个名为 my_dog 的对象实例，并将其存储在变量 my_dog 中。然后我们可以使用点号 . 来访问 my_dog 的属性和方法，例如 my_dog.name 和 my_dog.age，以及 my_dog.sit() 和 my_dog.roll_over()。 在这个例子中，我们创建了一个名为 my_dog 的对象实例，并调用了它的两个属性 name 和 age，分别输出了 Willie 和 6。这个类中的方法 sit() 和 roll_over() 分别模拟了狗坐下和打滚的动作，调用这两个方法时，我们可以看到输出语句的内容。 self的作用 self 在 Python 类中是一个特殊的变量，它指代类的实例（即通过类创建出来的对象）。在上面的代码中，self 在 Dog 类的三个方法中被使用。 在 __init__ 方法中，self 用来表示被创建的对象本身。当我们通过 my_dog = Dog('Willie', 6) 创建一个 Dog 类的实例时，self 就指代了这个新创建的对象。self.name = name 将创建的实例的 name 属性设为 name 参数的值，self.age = age 则将创建的实例的 age 属性设为 age 参数的值。 在 sit 和 roll_over 方法中，self 用来引用调用这个方法的对象本身。例如，当我们调用 my_dog.sit() 时，self 指代的就是 my_dog 这个实例，而 f"{self.name} is now sitting." 就会输出 Willie is now sitting.。这种方式让方法能够访问实例的属性，从而使方法能够操作实例的状态。
使用类和实例
给属性指定默认值
#创建一个名为odometer_reading 的属性，并将其初始值设置为0 class Car: """A simple attempt to represent a car.""" def __init__(self, make, model, year): """Initialize attributes to describe a car.""" self.make = make self.model = model self.year = year self.odometer_reading = 0 def get_descriptive_name(self): """Return a neatly formatted descriptive name.""" long_name = f"{self.year} {self.make} {self.model}" return long_name.title() def read_odometer(self): """Print a statement showing the car's mileage.""" print(f"This car has {self.odometer_reading} miles on it.") my_new_car = Car('Audi', 'a4', 2019) print(my_new_car.get_descriptive_name()) my_new_car.read_odometer() 输出： 2019 Audi A4 This car has 0 miles on it.
修改属性的值
class Car: """A simple attempt to represent a car.""" def __init__(self, make, model, year): """Initialize attributes to describe a car.""" self.make = make self.model = model self.year = year self.odometer_reading = 0 def get_descriptive_name(self): """Return a neatly formatted descriptive name.""" long_name = f"{self.year} {self.make} {self.model}" return long_name.title() def read_odometer(self): """Print a statement showing the car's mileage.""" print(f"This car has {self.odometer_reading} miles on it.") def update_odometer(self, mileage): """ Set the odometer reading to the given value. Reject the change if it attempts to roll the odometer back. """ if mileage >= self.odometer_reading: self.odometer_reading = mileage else: print("You can't roll back an odometer!") def increment_odometer(self, miles): """Add the given amount to the odometer reading.""" self.odometer_reading += miles my_used_car = Car('subaru', 'outback', 2015) print(my_used_car.get_descriptive_name()) my_used_car.update_odometer(23_500) my_used_car.read_odometer() my_used_car.increment_odometer(100) my_used_car.read_odometer() 输出： 2015 Subaru Outback This car has 23500 miles on it. This car has 23600 miles on it.
直接修改属性的值
通过方法修改属性的值
通过方法对属性的值进行递增
+=是一个复合赋值运算符，用于将左侧变量的值与右侧的值相加并将结果赋值给左侧变量。例如，a += b等同于a = a + b
继承
class Car: """A simple attempt to represent a car.""" def __init__(self, make, model, year): self.make = make self.model = model self.year = year self.odometer_reading = 0 def get_descriptive_name(self): long_name = f"{self.year} {self.make} {self.model}" return long_name.title() def read_odometer(self): print(f"This car has {self.odometer_reading} miles on it.") def update_odometer(self, mileage): if mileage >= self.odometer_reading: self.odometer_reading = mileage else: print("You can't roll back an odometer!") def increment_odometer(self, miles): self.odometer_reading += miles class ElectricCar(Car): """Represent aspects of a car, specific to electric vehicles.""" def __init__(self, make, model, year): """ Initialize attributes of the parent class. Then initialize attributes specific to an electric car. """ super().__init__(make, model, year) self.battery_size = 75 def describe_battery(self): """Print a statement describing the battery size.""" print(f"This car has a {self.battery_size}-kWh battery.") my_tesla = ElectricCar('tesla', 'model s', 2019) print(my_tesla.get_descriptive_name()) my_tesla.describe_battery() 输出： 2019 Tesla Model S This car has a 75-kWh battery.
子类的方法__init__()
看书p149-151
给子类定义属性和方法
看书p151-152
重写父类的方法
看书p152
将实例用作属性
看书p152-154 class Car: """A simple attempt to represent a car.""" def __init__(self, make, model, year): self.make = make self.model = model self.year = year self.odometer_reading = 0 def get_descriptive_name(self): long_name = f"{self.year} {self.make} {self.model}" return long_name.title() def read_odometer(self): print(f"This car has {self.odometer_reading} miles on it.") def update_odometer(self, mileage): if mileage >= self.odometer_reading: self.odometer_reading = mileage else: print("You can't roll back an odometer!") def increment_odometer(self, miles): self.odometer_reading += miles class Battery: """A simple attempt to model a battery for an electric car.""" def __init__(self, battery_size=75): """Initialize the battery's attributes.""" self.battery_size = battery_size def describe_battery(self): """Print a statement describing the battery size.""" print(f"This car has a {self.battery_size}-kWh battery.") def get_range(self): """Print a statement about the range this battery provides.""" if self.battery_size == 75: range = 260 elif self.battery_size == 100: range = 315 print(f"This car can go about {range} miles on a full charge.") class ElectricCar(Car): """Represent aspects of a car, specific to electric vehicles.""" def __init__(self, make, model, year): """ Initialize attributes of the parent class. Then initialize attributes specific to an electric car. """ super().__init__(make, model, year) self.battery = Battery() def describe_battery(self): """Print a statement describing the battery size.""" print(f"This car has a {self.battery_size}-kWh battery.") my_tesla = ElectricCar('tesla', 'model s', 2019) print(my_tesla.get_descriptive_name()) my_tesla.battery.describe_battery() my_tesla.battery.get_range() 输出： 2019 Tesla Model S This car has a 75-kWh battery. This car can go about 260 miles on a full charge.
套娃
导入类
看书p155-160
导入单个类
在一个模块中存储多个类
从一个模块中导入多个类
导入整个模块
导入模块中的所有类
在一个模块中导入另一个模块
使用别名
自定义工作流程
Python标准库
Python标准库 是一组模块，我们安装的Python都包含它
函数
定义函数
def 问候(): '''显示简单的问候语''' print("你好!") 问候() 输出： 你好！
向函数传递信息
def greet_user(username): """显示简单的问候语。""" print(f"Hello, {username.title()}!") greet_user('jesse') 输出： Hello, Jesse!
实参和形参
在函数greet_user() 的定义中，变量username 是一个形参 （parameter），即函数完成工作所需的信息。在代码greet_user('jesse') 值'jesse' 是一个实参 （argument），即调用函数时传递给函数的信息。调用函数时，将要让函数使用的信息放在圆括号内。在greet_user('jesse') 中，将实参'jesse' 传递给了函数greet_user() ，这个值被赋给了形参username
传递实参
位置实参
调用函数时，Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，最简单的关联方式是基于实参的顺序。这种关联方式称为位置实参： def describe_pet(animal_type, pet_name): """显示宠物的信息。""" print(f"\nI have a {animal_type}.") print(f"My {animal_type}'s name is {pet_name.title()}.") describe_pet('hamster', 'harry') 输出： I have a hamster. My hamster's name is Harry.
多次调用函数
位置实参的顺序很重要
关键字实参
def describe_pet(animal_type, pet_name): """显示宠物的信息。""" print(f"\nI have a {animal_type}.") print(f"My {animal_type}'s name is {pet_name.title()}.") describe_pet(animal_type='hamster', pet_name='harry')
默认值
错误示范： def describe_pet(animal_type = 'dog', pet_name): """显示宠物的信息。""" print(f"\nI have a {animal_type}.") print(f"My {animal_type}'s name is {pet_name.title()}.") describe_pet(pet_name='harry') 输出： File "C:\Users\国重B403\Desktop\python从入门到实践\8.1fuction.py", line 19 def describe_pet(animal_type = 'dog', pet_name): ^^^^^^^^ SyntaxError: non-default argument follows default argument 解释： 在这个函数的定义中，修改了形参的排列顺序。因为给animal_type 指定了默认值，无须 通过实参来指定动物类型，所以在函数调用中只包含一个实参——宠物的名字。然而，Python依然将 这个实参视为位置实参，因此如果函数调用中只包含宠物的名字，这个实参将关联到函数定义中的第 一个形参。这就是需要将pet_name 放在形参列表开头的原因 正确示范： def describe_pet(pet_name, animal_type = 'dog'): """显示宠物的信息。""" print(f"\nI have a {animal_type}.") print(f"My {animal_type}'s name is {pet_name.title()}.") describe_pet(pet_name='harry') 输出： I have a dog. My dog's name is Harry. 使用这个函数的最简单方式是在函数调用中只提供小狗的名字： describe_pet('willie') 如果要描述的动物不是小狗，可使用类似于下面的函数调用： describe_pet(pet_name='harry', animal_type='hamster')
等效的函数调用
请看下面对函数describe_pet() 的定义，其中给一个形参提供了默认值： def describe_pet(pet_name, animal_type='dog'): 下面对这个函数的所有调用都可行： # 一条名为Willie的小狗。 describe_pet('willie') describe_pet(pet_name='willie') # 一只名为Harry的仓鼠。 describe_pet('harry', 'hamster') describe_pet(pet_name='harry', animal_type='hamster') describe_pet(animal_type='hamster', pet_name='harry')
避免实参错误
返回值
返回简单值
def get_formatted_name(first_name, last_name): """返回整洁的姓名。""" full_name = f"{first_name} {last_name}" return full_name.title() musician = get_formatted_name('jimi', 'hendrix') print(musician) 输出： Jimi Hendrix
return 语句是 Python 函数中的一个关键字，用于指定函数返回的值。在这段代码中，return 语句的作用是将整洁的姓名作为函数的返回值返回。
让实参变成可选的
def get_formatted_name(first_name, last_name, middle_name=''): """Return a full name, neatly formatted.""" if middle_name: full_name = f"{first_name} {middle_name} {last_name}" else: full_name = f"{first_name} {last_name}" return full_name.title() musician = get_formatted_name('jimi', 'hendrix') print(musician) musician = get_formatted_name('john', 'hooker', 'lee') print(musician) 输出： Jimi Hendrix John Lee Hooker
返回字典
def build_person(first_name, last_name, age=None): """Return a dictionary of information about a person.""" person = {'first': first_name, 'last': last_name} if age: person['age'] = age return person musician = build_person('jimi', 'hendrix', age=27) print(musician) 输出： {'first': 'jimi', 'last': 'hendrix', 'age': 27} 在函数定义中，新增了一个可选形参age ，并将其默认值设置为特殊值None （表示变量没有值）。可将None 视为占位值。在条件测试中，None 相当于False 。如果函数调用中包含形参age 的值，这个值将被存储到字典中。在任何情况下，这个函数都会存储人的姓名，但可进行修改，使其同时存储有关人的其他信息。
结合使用函数和while循环
def get_formatted_name(first_name, last_name): """Return a full name, neatly formatted.""" full_name = f"{first_name} {last_name}" return full_name.title() # This is an infinite loop! while True: print("\nPlease tell me your name:") print("(enter 'q' at any time to quit)") f_name = input("First name: ") if f_name == 'q': break l_name = input("Last name: ") if l_name == 'q': break formatted_name = get_formatted_name(f_name, l_name) print(f"\nHello, {formatted_name}!") 输出： Please tell me your name: (enter 'q' at any time to quit) First name: veneno Last name: sian Hello, Veneno Sian! Please tell me your name: (enter 'q' at any time to quit) First name: q
传递列表
def greet_users(names): """Print a simple greeting to each user in the list.""" for name in names: msg = f"Hello, {name.title()}!" print(msg) usernames = ['hannah', 'ty', 'margot'] greet_users(usernames) 输出： Hello, Hannah! Hello, Ty! Hello, Margot!
在函数中修改列表
def print_models(unprinted_designs, completed_models): """ Simulate printing each design, until none are left. Move each design to completed_models after printing. """ while unprinted_designs: current_design = unprinted_designs.pop() print(f"Printing model: {current_design}") completed_models.append(current_design) def show_completed_models(completed_models): """Show all the models that were printed.""" print("\nThe following models have been printed:") for completed_model in completed_models: print(completed_model) unprinted_designs = ['phone case', 'robot pendant', 'dodecahedron'] completed_models = [] print_models(unprinted_designs, completed_models) show_completed_models(completed_models) 输出： Printing model: dodecahedron Printing model: robot pendant Printing model: phone case The following models have been printed: dodecahedron robot pendant phone case
禁止函数修改列表
要将列表的副本传递给函数，可以像下面这样做： function_name(list_name_[:]) 切片表示法[:] 创建列表的副本。在之前的例子中，如果不想清空未打印的设计列表，可像下面这样调用print_models() ： print_models(unprinted_designs[:], completed_models)
切片表示法[:]创建列表的副本
传递任意数量的实参
#形参名*toppings 中的星号让Python创建一个名为toppings 的空元组 def make_pizza(*toppings): """Summarize the pizza we are about to make.""" print(f"\nMaking a pizza with the following toppings:") for topping in toppings: print(f"- {topping}") make_pizza('pepperoni') make_pizza('mushrooms', 'green peppers', 'extra cheese') 输出： Making a pizza with the following toppings: - pepperoni Making a pizza with the following toppings: - mushrooms - green peppers - extra cheese
结合使用位置实参和任意数量实参
def make_pizza(size, *toppings): """Summarize the pizza we are about to make.""" print(f"\nMaking a {size}-inch pizza with the following toppings:") for topping in toppings: print(f"- {topping}") make_pizza(16, 'pepperoni') make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese') 输出： Making a 16-inch pizza with the following toppings: - pepperoni Making a 12-inch pizza with the following toppings: - mushrooms - green peppers - extra cheese
你经常会看到通用形参名*args ，它也收集任意数量的位置实参
使用任意数量的关键字实参
def build_profile(first, last, **user_info): """Build a dictionary containing everything we know about a user.""" user_info['first_name'] = first user_info['last_name'] = last return user_info user_profile = build_profile('albert', 'einstein', location= 'princeton', field= 'physics') print(user_profile) 输出： {'location': 'princeton', 'field': 'physics', 'first_name': 'albert', 'last_name': 'einstein'} 解释： 这段代码定义了一个名为 build_profile 的函数，它接受三个参数 first、last 和 **user_info。前两个参数是字符串类型，代表用户的名字和姓氏，第三个参数 **user_info 是一个字典，用于存储用户的其他信息。函数会将 first 和 last 参数添加到 user_info 字典中，并将 user_info 字典作为返回值返回。 然后，在代码的第 6 行，我们使用 build_profile 函数，并传递了三个参数，前两个是字符串类型的 'albert' 和 'einstein'，表示用户的名字和姓氏，第三个参数 location= 'princeton' 和 field= 'physics' 则代表用户的其他信息，将这些信息封装成字典传递给函数。 函数将用户的名字和姓氏添加到 user_info 字典中，并将整个字典作为函数的返回值返回。在第 7 行，我们将函数的返回值存储在变量 user_profile 中，并在第 8 行打印这个变量的值，即包含用户信息的字典。输出的结果为 {'location': 'princeton', 'field': 'physics', 'first_name': 'albert', 'last_name': 'einstein'}，说明函数正确地将用户的信息存储在字典中并返回。 注意： 在这个例子中，我们使用了 **user_info 的语法，将所有未命名的关键字参数收集到一个名为 user_info 的字典中。因此，当我们在调用 build_profile 函数时使用关键字参数 location= 'princeton'，Python 会将其转换为一个字典项，这个字典项的键是字符串 location，对应的值是字符串 princeton。在函数体中，我们可以通过 user_info['location'] 的方式来访问这个键值对的值。
你经常会看到形参名**kwargs ，它用于收集任意数量的关键字实参
将函数存储在模块中
导入整个模块
这部分看书比较好，p134-p135
编写一条import 语句并在其中指定模块名，就可在程序中使用该模块中的所有函数
如果使用这种import 语句导入了名为module_name.py的整个模块，就可使用下面的语法来使用其中任何一个函数：module_name.function_name()
导入特定的函数
还可以导入模块中的特定函数，这种导入方法的语法如下：from module_name import function_name
通过用逗号分隔函数名，可根据需要从模块中导入任意数量的函数：from module_name import function_0, function_1, function_2
使用这种语法时，调用函数时无须使用句点。由于在import 语句中显式地导入了函数make_pizza() ，调用时只需指定其名称即可
使用as给函数指定别名
指定别名的通用语法如下：from module_name import function_name as fn
使用as给模块指定别名
给模块指定别名的通用语法如下：import module_name as mn
导入模块中的所有函数
from module_name import *
函数编写指南
给形参指定默认值时，等号两边不要有空格：
def function_name(parameter_0, parameter_1='default value')
对于函数调用中的关键字实参，也应遵循这种约定：
function_name(value_0, parameter_1='value')
用户输入和while循环
函数input()的工作原理
编写清晰的程序
prompt = "If you tell us who you are, we can personalize the messages you see." prompt += "\nWhat is your first name? " name = input(prompt) print(f"\nHello, {name}!") 输出： If you tell us who you are, we can personalize the messages you see. What is your first name? lrk Hello, lrk!
一种创建多行字符串的方式。第一行将消息的前半部分赋给变量prompt 中。在第二行中，运算符+= 在前面赋给变量prompt 的字符串末尾附加一个字符串
使用int()来获取数值输入
height = input("How tall are you, in inches? ") height = int(height) if height >= 48: print("\nYou're tall enough to ride!") else: print("\nYou'll be able to ride when you're a little older.") 输出： How tall are you, in inches? 36 You'll be able to ride when you're a little older.
求模运算符
处理数值信息时，求模运算符（%）是个很有用的工具，它将两个数相除并返回余数
while循环简介
使用while循环
current_number = 1 while current_number print(current_number) current_number += 1 输出： 1 2 3 4 5
让用户选择何时退出
提示 = "\n我会复述你告诉我的话：" 提示 += "\n输入'终止'来结束程序！" 话 = "" while 话 != '终止': 话 = input(提示) if 话 != '终止': print(话) 输出： 我会复述你告诉我的话： 输入'终止'来结束程序！天才 天才 我会复述你告诉我的话： 输入'终止'来结束程序！终止
定义了一个退出值 ，只要用户输入的不是这个值，程序就将接着运行
使用标志
提示 = "\n我会复述你告诉我的话：" 提示 += "\n输入'终止'来结束程序！" 标志 = True while 标志: 话 = input(提示) if 话 == '终止': 标志 = False else: print(话) 输出： 我会复述你告诉我的话： 输入'终止'来结束程序！嘿呀嘿呀 嘿呀嘿呀 我会复述你告诉我的话： 输入'终止'来结束程序！终止
让程序在标志为True 时继续运行，并在任何事件导致标志的值为False 时让程序停止运行。这样，在while 语句中就只需检查一个条件：标志的当前值是否为True 。然后将所有其他测试（是否发生了应将标志设置为False 的事件）都放在其他地方，从而让程序更整洁
使用break退出循环
提示 = "\n我会复述你告诉我的话：" 提示 += "\n输入'终止'来结束程序！" while True:#以while True打头的循环将不断运行，直到遇到break语句 话 = input(提示) if 话 == '终止': break else: print(话) 输出： 我会复述你告诉我的话： 输入'终止'来结束程序！嘿呀嘿呀 嘿呀嘿呀 我会复述你告诉我的话： 输入'终止'来结束程序！终止
在循环中使用continue
current_number = 0 while current_number current_number += 1 if current_number % 2 == 0: continue print(current_number) 输出： 1 3 5 7 9
执行continue 语句，让Python忽略余下的代码，并返回循环的开头
避免无限循环
如果程序陷入无限循环，可按Ctrl + C，也可关闭显示程序输出的终端窗口
使用while循环处理列表和字典
在列表之间移动元素
未命名用户 = ['喜羊羊','美羊羊','沸羊羊'] 确认用户 = [] while 未命名用户: 当前用户 = 未命名用户.pop() print(f"正在确认用户：{当前用户}") 确认用户.append(当前用户) print(f"\n下列用户已确认：") for 确认用户a in 确认用户: print(确认用户a) 输出： 正在确认用户：沸羊羊 正在确认用户：美羊羊 正在确认用户：喜羊羊 下列用户已确认： 沸羊羊 美羊羊 喜羊羊
利用pop()和append()
删除为特定值的所有列表元素
pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat'] print(pets) while 'cat' in pets: pets.remove('cat') print(pets) 输出： ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat'] ['dog', 'dog', 'goldfish', 'rabbit']
关键代码：while 'cat' in pets
在这个 while 循环中，每次循环都只判断列表中是否还有 'cat' 元素，如果有则执行循环体，将第一个 'cat' 元素从列表中删除，如果没有则跳过循环体，继续执行后面的代码。在执行循环体中的 pets.remove('cat') 代码时，只会将列表中的第一个 'cat' 元素移除，不会将所有 'cat' 元素都移除。因此，在列表中存在其他元素时，循环会继续执行，只是每次循环中都只会处理一个 'cat' 元素。 如果列表中存在 'dog' 元素，那么当程序执行到 'dog' 时，它会被略过，直接执行循环体之后的代码，因为 while 循环只检查列表中是否还有 'cat' 元素，和 'dog' 元素无关。所以，这个 while 循环不会一直检查下去，而是在遇到列表中不存在的元素或者列表中不存在 'cat' 元素时终止。
使用用户输入来填充字典
responses = {} polling_active = True while polling_active: name = input("\nWhat is your name? ") response = input("Which mountain would you like to climb? ") responses[name] = response repeat = input("Would you like to let another person respond? (yes / no) ") if repeat == 'no' : polling_active = False print("\n--- Poll Results ---") for name, response in responses.items(): print(f"{name} would like to climb {response}. ") 输出： What is your name? lrk Which mountain would you like to climb? HuangShan Would you like to let another person respond? (yes / no) yes What is your name? lyf Which mountain would you like to climb? TaiShan Would you like to let another person respond? (yes / no) no --- Poll Results --- lrk would like to climb HuangShan. lyf would like to climb TaiShan.