Python学习笔记 - 知识部分

第 1 章

安装python环境（win）

1. 下载Python并安装

链接: Python官网
直接下载最新版

安装最后后有一个”Disable path length limit" 点击后选择“是”。
安装完毕，点击close关闭窗口即可

2. 验证是否安装成功
   打开cmd，输入python回车。
   显示出Python版本即为安装成功。

下载Python IDE-PyCharm

IDE：集成开发环境（IDE，Integrated Development Environment ）是用于提供程序开发环境的应用程序，一般包括代码编辑器、编译器、调试器和图形用户界面等工具。集成了代码编写功能、分析功能、编译功能、调试功能等一体化的开发软件服务套。所有具备这一特性的软件或者软件套（组）都可以叫集成开发环境。

PyCharm：PyCharm 是一款由 JetBrains 开发的高性能、跨平台的 Python IDE。它具有许多高级功能，如代码折叠、自动完成、调试、版本控制等。

链接: JetBrains官网

1. 下载PyCharm
   链接: PyCharm下载地址
   Professional版本收费，加载Community版本。

2. 安装插件 更改设置

• 安装汉化插件 Plagins-Marketplace-搜索Chinese-找到简体中文语言包-安装后重启PyCharm
• 自定义-所有设置-Python解释器-添加解释器-系统解释器-选择Python安装路径下的Python.exe

3. 创建新工程
   打开PyCharm，点击加号创建工程。
4. 创建.py文件
   鼠标右键点击项目目录-新建-Python文件-输入文件名-Python文件
5. 运行代码
   右键代码输入区域-运行

第 2 章 基本语法

2.1 字面量

常用值（数据）的类型

2.2 注释

在程序代码中对程序代码进行解释说明的文字。
注释不会被执行，编写注释的主要目的是阐述代码要做什么，以及是如何做的。增加代码的可读性，也可以让自己在回看代码时更好的理解自己的代码。
格式：

# 我是一行注释
print("我是会被执行的代码")

""" 
多行注释
可以换行 
用三个双引号引起来
"""

2.3 变量

格式：变量名=变量值

变量的命名（函数名、类名同理）

• Python中通常使用数字、小写字母和下划线命名，并且不要用数字打头。例：message_1。
• 不要使用Python关键字和函数名作变量名，如print。
• 变量名应简短且具有描述性。
• 避免使用小写字母l和大写字母O，可能会被错认成数字1和0。
• 避免拼写错误。

Python关键字

变量是标签

变量常被描述为可用于存储值的盒子。但更易于理解的定义是，变量是可以赋给值的标签，也可以说变量指向特定的值。

2.4 数据类型

• 获取数据的类型： type()

  print(type("Axi1208"))
  print(type(123))
  print(type(11.123))
  
  # 输出结果
  <class 'str'>
  <class 'int'>
  <class 'float'>
  

• 数据类型转换：int(x)、float(x)、str(x)
  所有数据类型都可以转为字符串，只有内容为数字的字符串可以转为数（整数、浮点数）

  # 整数转浮点数
  num1 = float(11)
  print(type(num1), num1)
  
  # 浮点数转整数 会丢失精度
  num2 = int(11.123)
  print(type(num2), num2)
  
  # 输出结果
  <class 'float'> 11.0
  <class 'int'> 11
  

2.6 运算符

2.6.1 算数运算符

2.6.2 赋值运算符

2.6.3 复合赋值运算符

2.7 字符串

2.7.1 定义

"This is a string."
'This is also a string.'
str = """This is a string."""

""" 
当有变量接收被三引号引起的内容时，类型为字符串
没有变量接收时，就是多行注释。
"""

# 当字符串中包含单引号、双引号时，可以用反斜杠转义
name = "\"hello"
print(name) 
# 输出结果： "hello

2.7.2 字符串拼接

• 简单拼接
  通过“+”号连接字符串变量或字符串字面量。
  注：无法和非字符串类型进行拼接。

• 在字符串中使用变量
  在前引号前加上字母f，再将要插入的变量放入花括号内。

  first_name = "ada"
  last_name = "lovelace"
  full_name = f"{first_name} {last_name}"
  print(full_name)
  
  # 输出结果
  ada lovelace
  

  f字符串还可以复合使用

  first_name = "ada"
  last_name = "lovelace"
  full_name = f"{first_name} {last_name}"
  print(f"Hello, {full_name.title()}!")
  
  #输出结果
  Hello, Ada Lovelace!
  

  还可以使用f字符串来创建消息，再把整条消息赋给变量

  first_name = "ada"
  last_name = "lovelace"
  full_name = f"{first_name} {last_name}"
  message = f"Hello, {full_name.title()}!"
  print(message)
  
  #输出结果
  Hello, Ada Lovelace!
  

• 使用%进行拼接

2.7.3 一些方法

修改字符串的大小写

name = "Ada Lovelace"
print(name.upper())
print(name.lower())
print(name.title()) # 所有单词首字母大写，其余字母小写。
# 输出结果
DA LOVELACE
ada lovelace

转义符

1.\n:换行
2.\t:制表符
3.\r:覆盖
4.\b:删除
5.:两个反斜杠表示一个
6.原字符:使转义字符不起作用，写在前面，用r或R
示例1：

print("我的名字叫"AXI"") # 报错

正解：

print("我的名字叫\"AXI\"") # 我的名字叫"AXI"

示例1、2

print("我的名字叫"，"AXI") # 我的名字叫 AXI

print("我的名字叫\n"，"AXI") # 我的名字叫
						    # AXI

print("我的名字叫\t"，"AXI") # 我的名字叫    AXI

示例3

print("hello\rpython") # python 把\r后面的内容覆盖\r前面的内容

示例4

print("hello\bpython") # hellpython \b等于键盘backspace

示例5

print("\\") # \ 写两个斜杠代表一个斜杠

示例6

print(r"我的名字叫\n"，"AXI") # 我的名字叫\nAXI

删除空白

– 删除末尾空白 rstrip()
– 删除开头空白 lstrip()
– 删除首尾空白 strip()
以上方法都不会改变原字符串。

2.8 数

2.8.1 整数（int）

在Python中，可对整数执行加（+ ）减（- ）乘（* ）除（/ ）运算。
在终端会话中，Python直接返回运算结果。Python使用两个乘号表示乘方运算：

>>> 3 ** 2
9
>>> 3 ** 3
27
>>> 10 ** 6
1000000

2.8.2 浮点数（float）

Python将所有带小数点的数称为浮点数 。
与其他语言相似，浮点数运算存在一些精度问题。

2.8.3 整数和浮点数

将任意两个数相除时，结果总是浮点数，即便这两个数都是整数且能整除：

>>> 4/2
2.0

在其他任何运算中，如果一个操作数是整数，另一个操作数是浮点数，结果也总是浮点数：

>>> 1 + 2.0
3.0
>>> 2 * 3.0
6.0
>>> 3.0 ** 2
9.0

无论是哪种运算，只要有操作数是浮点数，Python默认得到的总是浮点数，即便结果原本为整数也是如此。

2.8.4 数中的下划线

当书写很大的数时，可以用下划线将数字进行分组。但对于Python而言，储存时1000和1_000没有什么不同。这种表示法适用于整数和浮点数，但只有Python 3.6和更高的版本支持。

2.8.5 常量

常量 类似于变量，但其值在程序的整个生命周期内保持不变。Python没有内置的常量类型，但Python程序员会使用全大写来指出应将某个变量视为常量，其值应始终不变：
在代码中，要指出应将特定的变量视为常量，可将其字母全部大写。

2.9 数据输入

print()，可以将内容输出。
与之对应，Python中还有一个input语句，用来获取键盘输入。

print("你叫什么名字？")
name = input()
print(f"你好,{name}！")

当程序输出“你叫什么名字？”后，可以键入内容。并且将其值赋给name变量，并继续执行下一条语句。
函数input() 接受一个参数——要向用户显示的提示（prompt）或说明，让用户知道该如何做。

name = input("你叫什么名字？")
print(f"你好,{name}！")

获取的内容默认为字符串，可以用方法转换数据类型。

第 3 章 列表

3.1 列表是什么

列表 由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0～9或所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有任何关系。列表通常包含多个元素，因此给列表指定一个表示复数的名称（如letters 、digits或names ）是个不错的主意。
在Python中，用方括号（[] ）表示列表，并用逗号分隔其中的元素。下面是一个简单的列表示例：

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles) 
# ['trek', 'cannondale', 'redline', 'specialized']

3.1.1 访问列表元素

列表是有序集合，因此要访问列表的任意元素，通过索引访问即可。

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[0])
# trek

索引 由0开始。Python中将索引指定为-1，可以返回最后一个列表元素。-2为倒数第二个元素，以此类推。

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[-1])
# specialized

3.1.2 使用列表中的值

你可以像使用其他变量一样使用列表中的各个值。例如，可以使用f字符串根据列表中的值来创建消息。

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
message = f"My first bicycle was a {bicycles[0].title()}."
print(message)
# My first bicycle was a Trek.

3.2 修改、添加和删除元素

3.2.1 在列表中添加元素

• 在末尾添加元素： append()

  motorcycles = []
  motorcycles.append('honda')
  motorcycles.append('yamaha')
  motorcycles.append('suzuki')
  print(motorcycles)
  # ['honda', 'yamaha', 'suzuki']
  

• 在列表中插入元素：insert()

  motorcycles = ['honda', 'yamaha', 'suzuki']
  motorcycles.insert(0, 'ducati')
  print(motorcycles)
  # ['ducati', 'honda', 'yamaha', 'suzuki']
  

  第一个参数表示插入的位置（索引），
  第二个参数表示插入的值。

3.2.2 从列表中删除元素

• 通过索引删除元素：del()

  motorcycles = ['honda', 'yamaha', 'suzuki']
  print(motorcycles)
  
  del motorcycles[0]
  print(motorcycles)
  
  # ['honda', 'yamaha', 'suzuki']
  # ['yamaha', 'suzuki']
  

  该方法返回处理后的列表。

• 弹出元素：pop()

  motorcycles = ['honda', 'yamaha', 'suzuki']
  print(motorcycles)
  
  popped_motorcycle = motorcycles.pop()
  print(motorcycles)
  print(popped_motorcycle)
  
  # ['honda', 'yamaha', 'suzuki']
  # ['honda', 'yamaha']
  # suzuki
  

  该方法返回“被弹出”的值。
  如果不填入参数，则弹出列表最后一个元素；
  若填入索引，pop()方法可以弹出列表任意位置的元素。

  motorcycles = ['honda', 'yamaha', 'suzuki']
  first_owned = motorcycles.pop(0)
  print(f"The first motorcycle I owned was a {first_owned.title()}.")
  # The first motorcycle I owned was a Honda.
  

• 根据值删除元素：remove()

  motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
  print(motorcycles)
  
  motorcycles.remove('ducati')
  print(motorcycles)
  
  # ['honda', 'yamaha', 'suzuki', 'ducati']
  # ['honda', 'yamaha', 'suzuki']
  

  注：方法remove() 只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来确保将每个值都删除。

3.3 组织列表

3.3.1 使用sort()对列表永久排序

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()
print(cars)

# ['audi', 'bmw', 'subaru', 'toyota']

3.3.2 使用函数sorted() 对列表临时排序

cars = ['bmw', 'audi', 'toyota', 'subaru']
print("这是原本的列表：")
print(cars)

print("\n这是临时排序过的列表:")
print(sorted(cars))

print("\n这是原本的列表:")
print(cars)

# 输出结果
这是原本的列表：
['bmw', 'audi', 'toyota', 'subaru']
这是临时排序过的列表:
['audi', 'bmw', 'subaru', 'toyota']
这是原本的列表:
['bmw', 'audi', 'toyota', 'subaru']

也就是说，sorted()方法不改变原列表。

3.3.3 永久倒序列表 reverse()

cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)

cars.reverse()
print(cars)

# ['bmw', 'audi', 'toyota', 'subaru']
# ['subaru', 'toyota', 'audi', 'bmw']

3.3.4 获取列表的长度 len()

cars = ['bmw', 'audi', 'toyota', 'subaru']
print(len(cars))
# 4

第 4 章 操作列表

4.1 遍历列表

通过for循环

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician)

# 输出结果
alice
david
carolina

刚开始使用循环时请牢记，对列表中的每个元素，都将执行循环指定的步骤，而不管列表包含多少个元素。如果列表包含一百万个元素，Python就重复执行指定的步骤一百万次，且通常速度非常快。
另外，编写for 循环时，可以给依次与列表中每个值相关联的临时变量指定任意名称。然而，选择描述单个列表元素的有意义名称大有裨益。例如，对于小猫列表、小狗列表和一般性列表，像下面这样编写for 循环的第一行代码是不错的选择：

for cat in cats:
for dog in dogs:
for item in list_of_items:

4.1.2 在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()}")
    
# 输出结果
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

注意 在for循环中的语句都要进行缩进。第一行不缩进会产生报错。
若想退出for循环，在for循环的下一个语句不缩进即可。

4.3 创建数值列表

列表非常适合用于存储数字集合，而Pythonᨀ供了很多工具，可帮助你高效地处理数字列表。

4.3.1 range()

Python函数range() 让你能够轻松地生成一系列数。

for value in range(1, 5):
    print(value)
# 输出结果
1
2
3
4

4.3.2 使用range() 创建数字列表

numbers = list(range(1, 6))
print(numbers)
# [1, 2, 3, 4, 5]

第一个参数为初始值，
第二个参数为终值（不包含），
还有第三个参数，为步长。

# 打印1~10的偶数
even_numbers = list(range(2, 11, 2))
print(even_numbers)
# [2, 4, 6, 8, 10]

4.3.3 对数字列表执行简单的统计计算

• min() 找到列表的最小值
• max() 找到列表的最大值
• sum() 求出列表值的总和

4.3.4 列表解析

创建平方数列表最朴实的写法：

squares = []
for value in range(1,11):
    squares.append(value**2)
print(squares)
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

使用列表解析可以简化为：

squares = [value**2 for value in range(1, 11)]
print(squares)
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

4.4 使用列表的一部分

处理列表的部分元素，Python称之为切片。

4.4.1 切片

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[0:3])
# ['charles', 'martina', 'michael']

listname[初始索引:结束索引（不包含）]
若没有指定初始索引，则从列表开头开始。
没有指定结束索引，则切片到末尾。
如果想输出列表末尾几个元素，可以使用负数索引，如player[-3:]，一直代表列表最后个元素。

4.4.2 复制列表

切片是获取部分或全部列表，并返回一个浅拷贝。
因此，当你想复制列表可以这样做：

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]

my_foods.append('cannoli')
friend_foods.append('ice cream')

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', 'cannoli']

My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake', 'ice cream']

4.5 元组

有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的 ，而不可变的列表被称为元组 。

4.5.1 定义元组

元组看起来很像列表，但使用圆括号而非中括号来标识。定义元组后，就可使用索引来访问其元素，就像访问列表元素一样。

dimensions = (200, 50)
print(dimensions[0])
print(dimensions[1])

# 输出结果
200
50

若试图修改元组中的值，会报错。
严格地说，元组是由逗号标识的，圆括号只是让元组看起来更整洁、更清晰。如果你要定义只包含一个元素的元组，必须在这个元素后面加上逗号：

my_t = (3,)

4.5.2 修改元组变量

无法修改元组的元素，但可以给存储元组的变量赋值。

第 5 章 if语句

5.1 简单示例

cars = ['audi', 'bmw', 'subaru', 'toyota']

for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title())
        
# 输出结果
Audi
BMW
Subaru
Toyota

5.2 条件测试

5.2.1 比较运算符

5.2.2 检查是否相等时忽略大小写

在Python使用相等运算符时是大小写敏感的，若想忽略大小写可以使用lower()方法处理后再比较。并且lower()也不会修改原本的变量。

5.2.3 检查多个条件

使用 and 和 or 连接条件。
使用and时，条件都满足才返回True，
使用or时，只要有一个条件满足则为True。

5.2.4 检查特定值是否包含在列表中

使用 in。

>>> requested_toppings = ['mushrooms', 'onions', 'pineapple']
>>> 'mushrooms' in requested_toppings
True
>>> 'pepperoni' in requested_toppings
False

使用 not in 可以检查特定值是否不包含在列表中。

5.3 if语句

5.3.1 简单的if语句

if conditional_test:
    do something

与for循环语句相同，if内的语句要缩进。

5.3.2 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!

5.3.3 if-elif-else 结构

在现实世界中，很多情况下需要考虑的情形超过两个。例如，来看一个根据年龄段收费的游乐场：

• 4岁以下免费；
• 4～18岁收费25美元；
• 18岁（含）以上收费40美元。

如果只使用一条if 语句，该如何确定门票价格呢？下面的代码确定一个人所属的年龄段，并打印一条包含门票价格的消息：

age = 12
if age < 4:
	print("Your admission cost is $0.")
elif age < 18:
	print("Your admission cost is $25.")
else:
	print("Your admission cost is $40.")
# Your admission cost is $25.

当有一个条件满足时，代码块就会被执行。剩下的代码块会被跳过。
可根据需要使用任意数量的elif 代码块。
Python并不要求if-elif 结构后面必须有else 代码块。有些情形下可以省略else代码块。

第 6 章 字典

Python中的字典可以将相关信息关联起来，并且可储存的信息量极狐不受限制。

6.1 简单示例

来看一个包含外星人的游戏，这些外星人的颜色和分数各不相同。
下面是一个简单的字典，存储了有关特定外星人的信息：

alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color'])
print(alien_0['points'])

# 输出结果
green
5

6.2 使用字典

在Python中，字典 是一系列键值对 。每个键 都与一个值相关联，你可使用键来访问相关联的值。与键相关联的值可以是数、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。

在Python中，字典用放在花括号（{} ）中的一系列键值对表示，如前面的示例所示。

6.2.1 访问字典中的值

alien_0 = {'color': 'green'}
print(alien_0['color'])
# green

6.2.2 添加键值对

6.2.2 增改删查

• 增

  字典名['新键名'] = 对应的值
  

注 字典中元素的排列顺序和定义时相同。

• 改

  字典名['已存在的键'] = 新值
  

• 删 del

  del 字典名['指定键']
  

• 查 访问值
  – 通过键名访问

  print(字典名['指定键'])
  

  查找不到的时候会报错。

  – 通过get()访问

  alien_0 = {'color': 'green', 'speed': 'slow'}
  point_value = alien_0.get('points', 'No point value assigned.')
  print(point_value)
  # No point value assigned.
  

  第一个参数为指定键名，
  第二个参数为指定的键不存在时要返回的值，是可选的。

6.3 遍历字典

6.3.1 遍历所有键值对

与列表类似

user_0 = {
	'username': 'efermi',
	'first': 'enrico',
	'last': 'fermi',
	}
for key, value in user_0.items():
	print(f"\nKey: {key}")
	print(f"Value: {value}")
	
# 输出结果
Key: username
Value: efermi

Key: first
Value: enrico

Key: last
Value: fermi

要编写遍历字典的for 循环，可声明两个变量，用于存储键值对中的键和值。这两个变量可以使用任意名称。
for 语句的第二部分包含字典名和方法items() ，它返回一个键值对列表。

6.3.2 遍历字典中的所有键

favorite_languages = {
	'jen': 'python',
	'sarah': 'c',
	'edward': 'ruby',
	'phil': 'python',
	}
for name in favorite_languages.keys():
	print(name.title())
	
# 输出结果
Jen
Sarah
Edward
Phil

其中方法keys()可以省略。方法keys() 并非只能用于遍历：实际上，它返回一个列表，其中包含字典中的所有键。

6.3.3 遍历字典中的所有值

将keys()替换为**values()**即可。
这种做法提取字典中所有的值，而没有考虑是否重复。为剔除重复项，可使用集合（set）。集合 中的每个元素都必须是独一无二的：

 for language in set(favorite_languages.values()):
	print(language.title())

注意 可使用一对花括号直接创建集合，并在其中用逗号分隔元素。集合和字典很容易混淆，因为它们都是用一对花括号定义的。当花括号内没有键值对时，定义的很可能是集合。不同于列表和字典，集合不会以特定的顺序存储元素。

第 7 章 while循环

for 循环用于针对集合中的每个元素都执行一个代码块，而while循环则不断运行，直到指定的条件不满足为止

7.1 使用while 循环

current_number = 1
while current_number <= 5:
	print(current_number)
	current_number += 1

7.1.1 让用户选择何时退出

prompt = "\nTell me something, and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program. "
message = ""
while message != 'quit':
	message = input(prompt)
	if message != 'quit':
		print(message)

7.1.2 flag

在要求很多条件都满足才继续运行的程序中，可定义一个变量，用于判断整个程序是否处于活动状态。这个变量称为标志 （flag），充当程序的交通信号灯。可以让程序在标志为True 时继续运行，并在任何事件导致标志的值为False 时让程序停止运行。这样，在while 语句中就只需检查一个条件：标志的当前值是否为True。然后将所有其他测试（是否发生了应将标志设置为False 的事件）都放在其他地方，从而让程序更整洁。

7.1.3 使用break退出循环

要立即退出while 循环，不再运行循环中余下的代码，也不管条件测试的结果如何，可使用 break 语句。

prompt = "\nPlease enter the name of a city you have visited:"
prompt += "\n(Enter 'quit' when you are finished.) "
while True:
	city = input(prompt)
	if city == 'quit':
		break
	else:
		print(f"I'd love to go to {city.title()}!")

# 输出
Please enter the name of a city you have visited:
(Enter 'quit' when you are finished.) New York
I'd love to go to New York!

Please enter the name of a city you have visited:
(Enter 'quit' when you are finished.) quit

注意 在任何Python循环中都可使用break 语句。例如，可使
用break 语句来退出遍历列表或字典的for 循环。

7.2.4 在循环中使用continue

要 返回循环开头 ，并根据条件测试结果决定是否继续执行循环，可使用 continue 语句，它不像break 语句那样不再执行余下的代码并退出整个循环。

current_number = 0
while current_number < 10:
	current_number += 1
	if current_number % 2 == 0:
		continue
	print(current_number)

7.2.5 避免无限循环

如果程序陷入无限循环，可按Ctrl + C，也可关闭显示程序输出的终端窗口。确认程序至少有一个这样的地方能让循环条件为False ，或者让 break 语句得以执行。

7.3 使用while循环处理列表和字典

for 循环是一种遍历列表的有效方式，但不应在for 循环中修改列表，否则将导致Python难以跟踪其中的元素。要在遍历列表的同时对其进行修改，可使用while 循环。通过将while 循环同列表和字典结合起来使用，可收集、存储并组织大量输入，供以后查看和显示。

7.3.1 在列表之间移动元素

有一个包含未验证用户的列表，在验证后将其添加到已验证用户列表中：

# 首先，创建一个待验证用户列表
# 和一个用于存储已验证用户的空列表。
unconfirmed_users = ['alice', 'brian', 'candace']
confirmed_users = []
# 验证每个用户，直到没有未验证用户为止。
# 将每个经过验证的用户都移到已验证用户列表中。
while unconfirmed_users:
	current_user = unconfirmed_users.pop()
	print(f"Verifying user: {current_user.title()}")
	confirmed_users.append(current_user)
# 显示所有已验证的用户。
print("\nThe following users have been confirmed:")
for confirmed_user in confirmed_users:
	print(confirmed_user.title())
	
# 输出结果
Verifying user: Candace
Verifying user: Brian
Verifying user: Alice

The following users have been confirmed:
Candace
Brian
Alice

7.3.2 删除为特定值的所有列表元素

remove()与while结合使用

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']

7.3.3 使用用户输入来填充字典

可使用while 循环ᨀ示用户输入任意多的信息。例如对用户的年龄进行调查：

responses = {}
# 设置一个标志，指出调查是否继续。
polling_active = True
while polling_active:
	# 提示输入被调查者的名字和回答。
	name = input("\n你叫什么名字？")
	response = input("你今年多大了？")
	# 将回答存储在字典中。
	responses[name] = response
	# 看看是否还有人要参与调查。
	repeat = input("还有需要调查的人吗？ (yes/ no) ")
	if repeat == 'no':
		polling_active = False
# 调查结束，显示结果。
print("\n--- Poll Results ---")
for name, response in responses.items():
	print(f"{name}今年{response}岁了。")

# 输出结果
你叫什么名字？AXI
你今年多大了？23
还有需要调查的人吗？ (yes/ no) yes

你叫什么名字？小明的爷爷
你今年多大了？99
还有需要调查的人吗？ (yes/ no) no

--- Poll Results ---
AXI今年23岁了。
小明的爷爷今年99岁了。

第 8 章 函数

函数是带名字的代码块，用于完成具体的工作。要执行函数定义的特定任务，可调用 该函数。需要在程序中多次执行同一项任务时，无须反复编写完成该任务的代码，只需要调用执行该任务的函数，让Python运行其中的代码即可。你将发现，通过使用函数，程序编写、阅读、测试和修复起来都更加容易。

8.1 定义函数

❶ def greet_user():
❷ """显示简单的问候语。"""
❸ print("Hello!")
❹ greet_user()

❶ 使用 def 函数名(): 定义函数
紧跟在def greet_user(): 后面的所有缩进行构成了函数体。
❷ 文本是称为文档字符串 （docstring）的注释，描述了函数是做什么的。
❸ 代码行print(“Hello!”) 是函数体内的唯一一行代码，
因此greet_user() 只做一项工作：打印Hello! 。
❹ 由于这个函数不需要任何信息，调用它时只需输入greet_user() 即可。和预期一样，它打印Hello! ：

Hello!

8.1.1 参数

在函数名后面的括号中添加参数名，就可以让函数接受指定的任何值。

def greet_user(username):
	"""显示简单的问候语。"""
	print(f"Hello, {username.title()}!")
greet_user('jesse')

# Hello, Jesse!

8.1.2实参和形参

在函数 greet_user() 的定义中，变量 username 是一个形参（parameter），即函数完成工作所需的信息。在代码 greet_user(‘jesse’) 中，值 ‘jesse’ 是一个实参（argument），即调用函数时传递给函数的信息。
在greet_user(‘jesse’)中，将实参 ‘jesse’ 传递给了函数greet_user() ，这个值被赋给了形参username。

8.2 传递实参

1. 位置实参
   按照形参的位置直接传入内容。

2. 关键字形参
   传递给函数的名称值对。
   例：

   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')
   

   注意 使用关键字实参时，务必准确指定函数定义中的形参
   名。

8.2.3 默认值

可以在定义函数形参时设定默认值。当调用函数时，未传入实参，则使用默认值作为实参。

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('willie')

# 输出结果
I have a dog.
My dog's name is Willie.

注意 使用默认值时，必须先在形参列表中列出没有默认值的形参，再列出有默认值的实参。这让Python依然能够正确地解读位置实参。
也就是说 先列出必填的参数，再列出可选的参数。

8.3 返回值

函数并非总是直接显示输出，它还可以处理一些数据，并返回一个或一组值。函数返回的值称为返回值。在函数中，可使用return语句将值返回到调用函数的代码行。

8.3.1 例子

def get_formatted_name(first_name, last_name, middle_name=''):
	"""返回姓名。"""
	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

8.4 传递任意数量的实参

Python允许函数从调用语句中收集任意数量的实参。
例：

def user_info(*users):
    """打印用户名"""
    print(users)

user_info('mike')
user_info('tom', 'peter', 'lee')

# 输出结果
('mike',)
('tom', 'peter', 'lee')

形参名*users中的星号让Python创建一个名为users的空元组，并将收到的所有值都封装到这个元组中。函数体内的函数调用print() 通过生成输出，注意，Python将实参封装到一个元组中，即便函数只收到一个值。

任意数量实参可以和位置实参结合使用。

8.5 将函数存储在模块中

将函数存储在称为模块 的独立文件中，再将模块导入 到主程序中。提升代码的可复用性，使开发者更专注于高层逻辑。

8.5.1 导入整个模块

import python文件名

import module_name

# 使用
module_name.function_name()

8.5.2 导入特定的函数

from python文件名 import 函数名

from module_name import function_0, function_1, function_2

# 使用
function_name()

8.5.3 使用as 给函数指定别名

from python文件名 import 函数名 as 别名

from module_name import function_name as fn
fn()

8.5.4 使用as 给模块指定别名

import module_name as mn

8.6.5 导入模块中的所有函数

from module_name import *

第 9 章 类

面向对象编程 是最有效的软件编写方法之一。在面向对象编程中，你编写表示现实世界中的事物和情景的类，并基于这些类来创建对象。编写类时，你定义一大类对象都有的通用行为。基于类创建对象 时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。
根据类来创建对象称为实例化 ，这让你能够使用类的实例。

9.1 创建和使用类

使用类几乎可以模拟任何东西。下面来编写一个表示小狗的简单类Dog ，它表示的不是特定的小狗，而是任何小狗。对于大多数宠物狗，我们都知道些什么呢？它们都有名字和年龄。我们还知道，大多数小狗还会蹲下和打滚。由于大多数小狗都具备上述两项信息（名字和年龄）和两种行为（蹲下和打滚），我们的Dog 类将包含它们。这个类让Python知道如何创建表示小狗的对象。编写这个类后，我们将使用它来创建表示特定小狗的实例。

9.1.1 创建Dog 类

根据Dog 类创建的每个实例都将存储名字和年龄，我们赋予了每条
小狗蹲下（sit() ）和打滚（roll_over() ）的能力：

class Dog:
    """一次模拟小狗的简单尝试。"""
    
    def __init__(self, name, age):
        """初始化属性name和age。"""
        self.name = name
        self.age = age
        
    def sit(self):
        """模拟小狗收到命令时蹲下。"""
        print(f"{self.name} is now sitting.")
        
    def roll_over(self):
        """模拟小狗收到命令时打滚。"""
        print(f"{self.name} rolled over!")

在Python中，首字母大写的名称指的是类。
方法__init__()
类中的函数称为方法。init() 是一个特殊方法，每当你根据Dog 类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。两侧有两个下划线的方法会被自动调用。
我们将方法__init__() 定义成包含三个形参：self 、name 和age 。在这个方法的定义中，形参self 必不可少，而且必须位于其他形参的前面。
Python调用这个方法来创建Dog 实例时，将自动传入实参self 。每个与实例相关联的方法调用都自动传递实参self ，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。
每当根据Dog 类创建实例时，都只需给最后两个形参（name和age ）提供值。
以self 为前缀的变量可供类中的所有方法使用，可以通过类的任何实例来访问。

9.1.2 根据类创建实例

下面来创建一个表示特定小狗的实例：

class Dog:
	--snip--
	
my_dog = Dog('Willie', 6)

print(f"My dog's name is {my_dog.name}.")
print(f"My dog is {my_dog.age} years old.")
my_dog.sit()
my_dog.roll_over()

# 输出结果
My dog's name is Willie.
My dog is 6 years old.
Willie is now sitting.
Willie rolled over!

9.2 使用类和实例

9.2.1 修改属性的值

我们能以三种方式修改属性的值：直接通过实例进行修改，通过方法进行设置，以及通过方法进行递增（增加特定的值）。下面依次介绍这些方式。

• 直接修改属性的值
  实例名.属性名 = 新值
• 通过方法进行设置
  实例名.类中的方法(新值)
• 以及通过方法进行递增（增加特定的值）
  在类的方法中接受参数并进行递增。

9.3 继承

编写类时，并非总是要从空白开始。如果要编写的类是另一个现成类的特殊版本，可使用继承 。一个类继承 另一个类时，将自动获得另一个类的所有属性和方法。原有的类称为父类 ，而新类称为子类 。子类继承了父类的所有属性和方法，同时还可以定义自己的属性和方法。

9.3.1 子类的方法__init__()

在既有类的基础上编写新类时，通常要调用父类的方法__init__() 。这将初始化在父类__init__() 方法中定义的所有属性，从而让子类包含这些属性。

class Car:
	--snip--

class ElectricCar(Car):
	"""电动汽车的独特之处。"""
	def __init__(self, make, model, year):
	"""
	初始化父类的属性。
	再初始化电动汽车特有的属性。
	"""
	super().__init__(make, model, year) # 关键句
	self.battery_size = 75 # 特有

	def describe_battery(self):
		"""打印一条描述电瓶容量的消息。"""
		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() # 父类的方法

super() 是一个特殊函数，让你能够调用父类的方法。这行代码让Python调用Car 类的方法__init__() ，让ElectricCar 实例包含这个方法中定义的所有属性。父类也称为超类（superclass），名称super 由此而来。

9.3.2 重写父类的方法

在子类中可以重写父类中的方法。即重新定义一次，定义后也是子类特有的方法。

9.3.3 将实例用作属性

使用代码模拟实物时，你可能会发现自己给类添加的细节越来越多：属性和方法清单以及文件都越来越长。在这种情况下，可能需要将类的一部分提取出来，作为一个独立的类。可以将大型类拆分成多个协同工作的小类。
例如，不断给ElectricCar 类添加细节时，我们可能发现其中包
含很多专门针对汽车电瓶的属性和方法。在这种情况下，可将这些
属性和方法ᨀ取出来，放到一个名为Battery 的类中，并将一
个Battery 实例作为ElectricCar 类的属性：

class Car:
	--snip--

class Battery:
	"""一次模拟电动汽车电瓶的简单尝试。"""
	def __init__(self, battery_size=75):
		"""初始化电瓶的属性。"""
		self.battery_size = battery_size
	def describe_battery(self):
		"""打印一条᧿述电瓶容量的消息。"""
		print(f"This car has a {self.battery_size}-kWh battery.")
		
class ElectricCar(Car):
	"""电动汽车的独特之处。"""
	def __init__(self, make, model, year):
		"""
		初始化父类的属性。
		再初始化电动汽车特有的属性。
		"""
		super().__init__(make, model, year)
		self.battery = Battery() #关键句
		
my_tesla = ElectricCar('tesla', 'model s', 2019)

print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()

9.4 导入类

Python允许将类存储在模块中，然后在主程序中导入所需的模块。

9.4.1 导入单个类

from module_name import class_name

9.4.2 在一个模块中存储多个类

虽然同一个模块中的类之间应存在某种相关性，但可根据需要在一个模块中存储任意数量的类。

9.4.3 从一个模块中导入多个类

from module_name import class_name1, class_name2

9.4.4 导入整个模块

import module_name
my_instance = module_name.class_name()

9.4.5 导入模块中的所有类

from module_name import *

**不推荐这种方式。**需要从一个模块中导入很多类时，最好导入整个模块，并使用module_name.ClassName 语法来访问类。这样做时，虽然文件开头并没有列出用到的所有类，但你清楚地知道在程序的哪些地方使用了导入的模块。这也避免了导入模块中的每个类可能引发的名称冲突。

9.4.6 使用别名

from electric_car import ElectricCar as EC

9.5 Python标准库

要了解Python标准库，Python Module of the Week是个不错的网站。请访问该网站并查看其中的目录，找一个你感兴趣的模块进行探索。
链接: Python Module of the Week

第 10 章 文件

10.1 从文件中读取数据

要使用文本文件中的信息，首先需要将信息读取到内存中。为此，你可以一次性读取文件的全部内容，也可以以每次一行的方式逐步读取。

10.1.1 读取整个文件

例：
pi_digits.txt

3.1415926535
  8979323846
  2643383279

下面的程序打开并读取这个文件，再将其内容显示到屏幕上：
file_reader.py

with open('pi_digits.txt') as file_object:
	contents = file_object.read()
print(contents)

• 函数 open() 接受一个参数：要打开的文件的名称。Python在当前执行的文件所在的目录中查找指定的文件。
• 关键字 with 在不再需要访问文件后将其关闭。而非使用close()。使用close()方法可能会导致意外的数据丢失或受损。所以只管打开文件即可，Python会在合适的时候自动关闭。
• 使用方法 read() 读取这个文件的全部内容。
  read() 到达文件末尾时返回一个空字符串，而将这个空字符串显示出来时就是一个行。要删除多出来的空行，可在函数调用print() 中使用rstrip()

10.1.2 文件路径

• 相对文件路径

with open('text_files/filename.txt') as file_object:

这行代码让Python到文件夹python_work下的文件夹text_files中去查找指定的.txt文件。
注意 显示文件路径时，Windows系统使用反斜杠（\ ）而不是斜杠（/ ），但在代码中依然可以使用斜杠。

• 绝对文件路径

file_path = '/home/ehmatthes/other_files/text_files/_filename_.txt'
with open(file_path) as file_object:

注意 如果在文件路径中直接使用反斜杠，将引发错误，因为反斜杠用于对字符串中的字符进行转义。例如，对于路径"C:\path\to\file.txt" ，其中的\t 将被解读为制表符。
如果一定要使用反斜杠，可对路径中的每个反斜杠都进行转义，如"C:\path\to\file.txt" 。

10.1.3 逐行读取

要以每次一行的方式检查文件，可对文件对象使用for 循环：
file_reader.py

filename = 'pi_digits.txt'
with open(filename) as file_object:
	for line in file_object:
		print(line)
# 结果
3.1415926535

  8979323846
  
  2643383279
  

可以发现，相较于原文件，每一行后都多了一行空白。可以使用rstrip()消除。

10.1.4 创建一个包含文件各行内容的列表

filename = 'pi_digits.txt'
with open(filename) as file_object:
	lines = file_object.readlines()
for line in lines:
	print(line.rstrip())

方法 readlines() 从文件中读取每一行，并将其存储在一个列表中。接下来，该列表被赋给变量lines 。在 with 代码块外，依然可使用这个变量。

10.2 写入文件

10.2.1 写入空文件

要将文本写入文件，你在调用open() 时需要ᨀ供另一个实参，告诉Python你要写入打开的文件。

filename = 'programming.txt'
with open(filename, 'w') as file_object:
	file_object.write("I love programming.")

调用open() 时ᨀ供了两个实参。第一个实参也是要打开的文件的名称。第二个实参（‘w’ ）告诉Python，要以 写入模式 打开这个文件。打开文件时，可指定读取模式 （‘r’）、写入模式 （‘w’ ）、附加模式 （‘a’ ）或读写模式 （‘r+’）。如果省略了模式实参，Python将以默认的只读模式打开文件。
如果要写入的文件不存在，函数open() 将自动创建它。然而，以写入模式（‘w’ ）打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空该文件的内容。
使用文件对象的方法 write() 将一个字符串写入文件。

注意 Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数str() 将其转换为字符串格式。

10.2.2 写入多行

要让每个字符串都单独占一行，需要在方法调用write() 中包含换行符：

filename = 'programming.txt'
with open(filename, 'w') as file_object:
	file_object.write("I love programming.\n")
	file_object.write("I love creating new games.\n")

像显示到终端的输出一样，还可以使用空格、制表符和空行来设置这些输出的格式。

10.2.3 附加到文件

如果要给文件添加内容，而不是覆盖原有的内容，可以以附加模式打开文件。以附加模式打开文件时，Python不会在返回文件对象前清空文件的内容，而是将写入文件的行添加到文件末尾。如果指定的文件不存在，Python将为你创建一个空文件。

with open(filename, 'a') as file_object:

10.3 存储数据

模块 json 让你能够将简单的Python数据结构转储到文件中，并在程序再次运行时加载该文件中的数据。你还可以使用json 在Python程序之间分享数据。更重要的是，JSON数据格式并非Python专用的，这让你能够将以JSON格式存储的数据与使用其他编程语言的人分享。这是一种轻便而有用的格式，也易于学习。
注意 JSON（JavaScript Object Notation）格式最初是为JavaScript开发的，但随后成了一种常见格式，被包括Python在内的众多语言采用。

10.3.1 使用json.dump() 和json.load()

函数json.dump() 接受两个实参：要存储的数据，以及可用于存储数据的文件对象。下面演示了如何使用json.dump() 来存储数字列表：

import json

numbers = [2, 3, 5, 7, 11, 13]

filename = 'numbers.json'
with open(filename, 'w') as f:
	json.dump(numbers, f)

使用json.load() 将列表读取到内存中：

import json

filename = 'numbers.json'
with open(filename) as f:
	numbers = json.load(f)
print(numbers)

10.3.2 保存和读取用户生成的数据

下面写一个程序：

• 提示用户首次运行程序时输入自己的名字，并在再次运行程序时记住他。
  remember_me.py

import json
# 如果以前存储了用户名，就加载它。
# 否则，提示用户输入用户名并存储它。
filename = 'username.json'
try:
    with open(filename) as f:
        username = json.load(f)
except FileNotFoundError:
    username = input("What is your name? ")
    with open(filename, 'w') as f:
        json.dump(username, f)
        print(f"We'll remember you when you come back, {username}!")
else:
    print(f"Welcome back, {username}!")

这个程序运行时，将尝试从文件username.json中获取用户名。因此，首先
编写一个尝试恢复用户名的 try 代码块。如果这个文件不存在，就在except 代码块中提示用户输入用户名，并将其存储到username.json中，以便程序再次运行时能够获取。

本文大部分内容来自于《Python编程从入门到实践(第2版）》