Python 3 教程(w3school)
Python 是一门流行的编程语言。它由 Guido van Rossum 创建，于 1991 年发布。
Python 简介
Python 可以做什么？
- 可以在服务器上使用 Python 来创建 Web 应用程序。
- Python 可以与软件一起使用来创建工作流。
- Python 可以连接到数据库系统。它还可以读取和修改文件。
- Python 可用于处理大数据并执行复杂的数学运算。
- Python 可用于快速原型设计，也可用于生产就绪的软件开发。
为何选择 Python？
- Python 适用于不同的平台（Windows、Mac、Linux、Raspberry Pi 等）。
- Python 有一种类似于英语的简单语法。
- Python 的语法允许开发人员用比其他编程语言更少的代码行编写程序。
- Python 在解释器系统上运行，这意味着代码可以在编写后立即执行。这也意味着原型设计可以非常快。
- Python 可以以程序方式、面向对象的方式或功能方式来处理。
Python 对比其他语言
Python 被认为是一种高级语言，因为它的语法简单，开发人员可以用更少的代码行来完成任务。
Python 被认为是一种解释型语言，因为它的代码在运行时被解释器执行，而不是编译为机器代码。
Python 被认为是一种动态类型语言，因为开发人员不需要声明变量的类型。
Python 被认为是一种跨平台语言，因为它可以在不同的操作系统上运行，例如 Windows、Mac、Linux 等。
Python 是为可读性设计的，与英语有一些相似之处，并受到数学的影响。
Python 使用新行来完成命令，而不像通常使用分号或括号的其他编程语言。
Python 依赖缩进，使用空格来定义范围；例如循环、函数和类的范围。其他编程语言通常使用花括号来实现此目的。
变量
创建变量
- 变量是存放数据值的容器。
- 与其他编程语言不同，Python 没有声明变量的命令。
- 首次为其赋值时，才会创建变量。 变量不需要使用任何特定类型声明，甚至可以在设置后更改其类型。
x = 5 # x is of type int
x = "Steve" # x is now of type str
print(x)变量名称
变量可以使用短名称（如 x 和 y）或更具描述性的名称（age、carname、total_volume）。
Python 变量命名规则：
- 变量名: 必须以字母或下划线字符开头
- 变量名: 称不能以数字开头
- 变量名: 只能包含字母数字字符和下划线（A-z、0-9 和 _）
- 变量名: 称区分大小写（age、Age 和 AGE 是三个不同的变量）
请记住，变量名称区分大小写
- 字符串变量可以使用单引号或双引号进行声明：
x = "Steve"
# is the same as
x = 'Steve'- 向多个变量赋值
- Python 允许您在一行中为多个变量赋值
- 也可以在一行中为多个变量分配相同的值
x, y, z = "Steve", "Bill", "Gates"
print(x)
print(y)
print(z)
# 也可以在一行中为多个变量分配相同的值：
x = y = z = "Orange"
print(x)
print(y)
print(z)- 全局变量 在函数外部创建的变量（如上述所有实例所示）称为全局变量。
全局变量可以被函数内部和外部的每个人使用。
注意：在函数内部创建的变量是局部变量，只能在该函数内部使用。 如果在函数内部创建具有相同名称的变量，则该变量将是局部变量，并且只能在函数内部使用。具有相同名称的全局变量将保留原样，并拥有原始值。
global 关键字
通常，在函数内部创建变量时，该变量是局部变量，只能在该函数内部使用。
要在函数内部创建全局变量，您可以使用 global 关键字。 实例 如果您用了 global 关键字，则该变量属于全局范围： 另外，如果要在函数内部更改全局变量，请使用 global 关键字。
x = "awesome"
def myfunc():
global x
x = "fantastic"
myfunc()
print("Python is " + x)内置数据类型
变量可以存储不同类型的数据，并且不同类型可以执行不同的操作。 Python 默认拥有以下内置数据类型：
| 类型 | 描述 |
|---|---|
| 文本类型 | str |
| 数值类型 | int, float, complex |
| 序列类型 | list, tuple, range |
| 映射类型 | dict |
| 集合类型 | set, frozenset |
| 布尔类型 | bool |
| 二进制类型 | bytes, bytearray, memoryview |
- 获取数据类型 您可以使用 type() 函数获取任何对象的数据类型：
x = 5
print(type(x))数字 Python 中有三种数字类型：
int（有符号整数）
float（浮点数）
complex（复数）
2.1 Int 有符号整数 Int 或整数是完整的数字，正数或负数，没有小数，长度不限。 2.2 Float 浮点数 浮动或“浮点数”是包含小数的正数或负数。 浮点数也可以是带有“e”的科学数字，表示 10 的幂。 2.3 complex 复数 复数用 "j" 作为虚部编写：
2.4 类型转换 您可以使用 int()、float() 和 complex() 方法从一种类型转换为另一种类型： 有时您可能需要为变量指定类型。这可以通过 casting 来完成。 Python 是一门面向对象的语言，因此它使用类来定义数据类型，包括其原始类型。
因此，使用构造函数完成在 python 中的转换：
- int() - 用整数字面量、浮点字面量构造整数（通过对数进行下舍入），或者用表示完整数字的字符串字面量
- float() - 用整数字面量、浮点字面量，或字符串字面量构造浮点数（提供表示浮点数或整数的字符串）
- str() - 用各种数据类型构造字符串，包括字符串，整数字面量和浮点字面量
pyx = int(1) # x 将是 1 y = int(2.5) # y 将是 2 z = int("3") # z 将是 3 x = float(1) # x 将是 1.0 y = float(2.5) # y 将是 2.5 z = float("3") # z 将是 3.0 w = float("4.6")# w 将是 4.6 x = str("S2") # x 将是 'S2' y = str(3) # y 将是 '3' z = str(4.0) # z 将是 '4.0'2.5 随机数 Python 没有 random() 函数来创建随机数，但 Python 有一个名为 random 的内置模块，可用于生成随机数：
pyimport random print(random.randrange(1,10)) # 导入 random 模块，并显示 1 到 9 之间的随机数：
Python 字符串
字符串字面量 python 中的字符串字面量由 单引号 或 双引号 括起。 'hello' 等同于 "hello"。
多行字符串 您可以使用三个引号将多行字符串赋值给变量： 1.1 字符串是数组 像许多其他流行的编程语言一样，Python 中的字符串是表示 unicode 字符的字节数组。 但是，Python 没有字符数据类型，单个字符就是长度为 1 的字符串。 方括号可用于访问字符串的元素。 1.2 裁切 您可以使用裁切语法返回一定范围的字符。 指定开始索引和结束索引，以冒号分隔，以返回字符串的一部分。 1.2.1 负的索引 使用负索引从字符串末尾开始切片： 1.2.2 裁切范围 裁切范围指定开始索引和结束索引，以冒号分隔，以返回字符串的一部分。 如果省略开始索引，则将从字符串的开头开始。 如果省略结束索引，则将切片到字符串的末尾。 1.2.3字符串长度 如需获取字符串的长度，请使用 len() 函数。
pya = "Hello, World!" print(a[1]) print(a[2:5]) # 获取从位置 2 到位置 5（不包括）的字符： print(b[-5:-2]) # 获取从位置 -5（包含）到位置 -2（不包含）的字符： print(len(a)) # 输出字符串的长度：
字符串方法
- Python 有一组可在字符串上使用的内建方法。
- strip() 方法删除开头和结尾的空白字符：
- lower() 返回小写的字符串：
- upper() 方法返回大写的字符串：
- replace() 用另一段字符串来替换字符串：
- split() 方法在找到分隔符的实例时将字符串拆分为子字符串：
- in 或 not in: 如需检查字符串中是否存在特定短语或字符，我们可以使用 in 或 not in 关键字。
- + 如需串联或组合两个字符串，您可以使用 + 运算符。
- format() 方法接受传递的参数，格式化它们，并将它们放在占位符 {} 所在的字符串中：
age = 63
txt = "My name is Bill, and I am {}"
print(txt.format(age)) # 使用 format() 方法将数字插入字符串：
quantity = 3
itemno = 567
price = 49.95
myorder = "I want {} pieces of item {} for {} dollars."
print(myorder.format(quantity, itemno, price)) # format() 方法接受不限数量的参数，并放在各自的占位符中：
myorder = "I want to pay {2} dollars for {0} pieces of item {1}."
print(myorder.format(quantity, itemno, price)) # 您可以使用索引号 {0} 来确保参数被放在正确的占位符中：
# 要多次引用相同的值，请使用索引号：
age = 63
name = "Bill"
txt = "His name is {1}. {1} is {0} years old."
print(txt.format(age, name))
# 命名索引
myorder = "I have a {carname}, it is a {model}."
print(myorder.format(carname = "Porsche", model = "911"))内建方法
注意：所有字符串方法都返回新值。它们不会更改原始字符串。
| 方法 | 描述 |
|---|---|
| capitalize() | 把首字符转换为大写。 |
| casefold() | 把字符串转换为小写。 |
| center() | 返回居中的字符串。 |
| count() | 返回指定值在字符串中出现的次数。 |
| encode() | 返回字符串的编码版本。 |
| endswith() | 如果字符串以指定值结尾，则返回 true。 |
| expandtabs() | 设置字符串的 tab 尺寸。 |
| find() | 在字符串中搜索指定的值并返回它被找到的位置。 |
| format() | 格式化字符串中的指定值。 |
| format_map() | 格式化字符串中的指定值。 |
| index() | 在字符串中搜索指定的值并返回它被找到的位置。 |
| isalnum() | 如果字符串中的所有字符都是字母数字，则返回 True。 |
| isalpha() | 如果字符串中的所有字符都在字母表中，则返回 True。 |
| isdecimal() | 如果字符串中的所有字符都是小数，则返回 True。 |
| isdigit() | 如果字符串中的所有字符都是数字，则返回 True。 |
| isidentifier() | 如果字符串是标识符，则返回 True。 |
| islower() | 如果字符串中的所有字符都是小写，则返回 True。 |
| isnumeric() | 如果字符串中的所有字符都是数，则返回 True。 |
| isprintable() | 如果字符串中的所有字符都是可打印的，则返回 True。 |
| isspace() | 如果字符串中的所有字符都是空白字符，则返回 True。 |
| istitle() | 如果字符串遵循标题规则，则返回 True。 |
| isupper() | 如果字符串中的所有字符都是大写，则返回 True。 |
| join() | 把可迭代对象的元素连接到字符串的末尾。 |
| ljust() | 返回字符串的左对齐版本。 |
| lower() | 把字符串转换为小写。 |
| lstrip() | 返回字符串的左修剪版本。 |
| maketrans() | 返回在转换中使用的转换表。 |
| partition() | 返回元组，其中的字符串被分为三部分。 |
| replace() | 返回字符串，其中指定的值被替换为指定的值。 |
| rfind() | 在字符串中搜索指定的值，并返回它被找到的最后位置。 |
| rindex() | 在字符串中搜索指定的值，并返回它被找到的最后位置。 |
| rjust() | 返回字符串的右对齐版本。 |
| rpartition() | 返回元组，其中字符串分为三部分。 |
| rsplit() | 在指定的分隔符处拆分字符串，并返回列表。 |
| rstrip() | 返回字符串的右边修剪版本。 |
| split() | 在指定的分隔符处拆分字符串，并返回列表。 |
| splitlines() | 在换行符处拆分字符串并返回列表。 |
| startswith() | 如果以指定值开头的字符串，则返回 true。 |
| strip() | 返回字符串的剪裁版本。 |
| swapcase() | 切换大小写，小写成为大写，反之亦然。 |
| title() | 把每个单词的首字符转换为大写。 |
| translate() | 返回被转换的字符串。 |
| upper() | 把字符串转换为大写。 |
| zfill() | 在字符串的开头填充指定数量的 0 值。 |
注释：所有字符串方法都返回新值。它们不会更改原始字符串。
Python 布尔
布尔表示两值之一：True 或 False。
- bool(): 函数可让您评估任何值，并为您返回 True 或 False。
- 大多数值都为 True
- 如果有某种内容，则几乎所有值都将评估为 True。
- 除 空字符串 外，任何字符串均为 True。
- 除 0 外，任何数字均为 True。
- 除 空列表外，任何列表、元组、集合和字典均为 True。
- 实际上，除空值（例如 ()、[]、{}、""、数字 0 和值 None）外，没有多少值会被评估为 False。当然，值 False 的计算结果为 False。
- isinstance() 函数，该函数可用于确定对象是否具有某种数据类型 (Python 还有很多返回布尔值的内置函数)
print(bool("Hello"))
print(bool(10))
x = "Hello"
y = 10
print(bool(x))
print(bool(y))
x = 200
print(isinstance(x, int))运算符
运算符用于对变量和值执行操作。 Python 身份运算符 用于比较两个对象，看它们是否指向内存中的同一位置。
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | 如果两个变量是同一个对象，则返回 true。 | x is y |
| is not | 如果两个变量不是同一个对象，则返回 true。 | x is not y |
| in | 如果对象中存在具有指定值的序列，则返回 True。 | x in y |
| not in | 如果对象中不存在具有指定值的序列，则返回 True。 | x not in y |
集合
集合（数组） Python 编程语言中有四种集合数据类型：
- 列表（List）是一种有序和可更改的集合。允许重复的成员。
- 元组（Tuple）是一种有序且不可更改的集合。允许重复的成员。
- 集合（Set）是一个无序和无索引的集合。没有重复的成员。
- 词典（Dictionary）是一个无序，可变和有索引的集合。没有重复的成员。
列表
列表是一个有序且可更改的集合。在 Python 中，列表用方括号编写。
thislist = ["apple", "banana", "cherry"]
print(thislist[1]) # 您可以通过引用索引号来访问列表项
print(thislist[-1]) # 负索引从末尾开始，-1 表示最后一个项目 负索引表示从末尾开始，-1 表示最后一个项目，-2 表示倒数第二个项目，依此类推。
print(thislist[2:5]) # 指定范围后，返回值将是包含指定项目的新列表。
thislist[1] = "mango"
print(thislist) # 更改第二项：
if "apple" in thislist: # 检查列表中是否存在 “apple”：
print("Yes, 'apple' is in the fruits list")
print(len(thislist)) # 如需确定列表中有多少项，请使用 len() 方法：
thislist.append("orange") # 如需将项目添加到列表的末尾，请使用 append() 方法：
## 复制列表
thislist = ["apple", "banana", "cherry"]
mylist = thislist.copy()
print(mylist)
mylist = list(thislist) # 制作副本的另一种方法是使用内建的方法 list()。
print(mylist)列表方法
Python 有一组可以在列表上使用的内建方法。
| 方法 | 描述 |
|---|---|
| append() | 在列表的末尾添加一个元素 |
| clear() | 删除列表中的所有元素 |
| copy() | 返回列表的副本 |
| count() | 返回具有指定值的元素数量。 |
| extend() | 将列表元素（或任何可迭代的元素）添加到当前列表的末尾 |
| index() | 返回具有指定值的第一个元素的索引 |
| insert() | 在指定位置添加元素 |
| pop() | 删除指定位置的元素 |
| remove() | 删除具有指定值的项目 |
| reverse() | 颠倒列表的顺序 |
| sort() | 对列表进行排序 |
元组（Tuple）
元组是一个有序且不可更改的集合。在 Python 中，元组用圆括号编写。
创建有一个项目的元组
如需创建仅包含一个项目的元组，您必须在该项目后添加一个逗号，否则 Python 无法将变量识别为元组。
thistuple = ("apple",)
print(type(thistuple))
#不是元组
thistuple = ("apple")
print(type(thistuple))注释：
- 您无法删除元组中的项目。
- 元组一旦创建，您就无法向其添加项目。元组是不可改变的。
元组方法
Python 提供两个可以在元组上使用的内建方法。
| 方法 | 描述 |
|---|---|
| count() | 返回元组中指定值出现的次数。 |
| index() | 在元组中搜索指定的值并返回它被找到的位置。 |
集合（Set）
集合是无序和无索引的集合。在 Python 中，集合用花括号编写。
注释： 集合是无序的，因此您无法确定项目的显示顺序。 集合一旦创建，您就无法更改项目，但是您可以添加新项目。
添加项目
- add() 方法 要将一个项添加到集合
- update() 方法 要向集合中添加多个项目
- len() 方法 要确定集合中有多少项
- remove() 或 discard() 要删除集合中的项目 注释：如果要删除的项目不存在，则 discard() 不会引发错误
- pop() 方法 要删除集合中的最后一个项目（请记住，set 是无序的，因此您不会知道被删除的是什么项目。）
- del 彻底删除集合：
del thisset - union() 返回包含两个集合中所有项目的新集合，也可以使用 update() 方法将一个集合中的所有项目插入另一个集合中：
注释：union() 和 update() 都将排除任何重复项。 还有其他方法将两个集合连接起来，并且仅保留重复项，或者永远不保留重复项，请查看此页面底部的集合方法完整列表。
thisset = {"apple", "banana", "cherry"}
thisset.add("orange")
thisset.update(["orange", "mango", "grapes"])
# 要确定集合中有多少项，请使用 len() 方法。
print(len(thisset))
thisset.remove("banana")
thisset.discard("banana") # 注释：如果要删除的项目不存在，则 discard() 不会引发错误。
# 合并两个集合
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set3 = set1.union(set2)
print(set3)
set1.update(set2)
print(set1)Set 方法
Python 拥有一套能够在集合（set）上使用的内建方法。
| 方法 | 描述 |
|---|---|
| add() | 向集合添加元素。 |
| clear() | 删除集合中的所有元素。 |
| copy() | 返回集合的副本。 |
| difference() | 返回包含两个或更多集合之间差异的集合。 |
| difference_update() | 删除此集合中也包含在另一个指定集合中的项目。 |
| discard() | 删除指定项目。 |
| intersection() | 返回为两个其他集合的交集的集合。 |
| intersection_update() | 删除此集合中不存在于其他指定集合中的项目。 |
| isdisjoint() | 返回两个集合是否有交集。 |
| issubset() | 返回另一个集合是否包含此集合。 |
| issuperset() | 返回此集合是否包含另一个集合。 |
| pop() | 从集合中删除一个元素。 |
| remove() | 删除指定元素。 |
| symmetric_difference() | 返回具有两组集合的对称差集的集合。 |
| symmetric_difference_update() | 插入此集合和另一个集合的对称差集。 |
| union() | 返回包含集合并集的集合。 |
| update() | 用此集合和其他集合的并集来更新集合。 |
Python 字典
字典（Dictionary） 字典是一个无序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。
thisdict = {
"brand": "Porsche",
"model": "911",
"year": 1963
}
print(thisdict)
x = thisdict["model"] # 方括号内引用其键名来访问字典的项目
x = thisdict.get("model") # 还有一个名为 get() 的方法会给你相同的结果：
thisdict["year"] = 2019 # 引用其键名来更改特定项的值
thisdict["color"] = "red" # 通过使用新的索引键并为其赋值，将项目添加到字典中
thisdict.pop("model") # pop() 方法删除具有指定键名的项：
thisdict.clear() # clear() 关键字清空字典
mydict = dict(thisdict) # dict() 方法创建字典的副本
mydict = thisdict.copy() # copy() 方法来复制字典
for x in thisdict.values(): # values() 函数返回字典的值
print(x)
for x in thisdict.keys():
print(x)
for x, y in thisdict.items(): # items() 函数遍历键和值
print(x, y)字典方法
Python 提供一组可以在字典上使用的内建方法。
| 方法 | 描述 |
|---|---|
| clear() | 删除字典中的所有元素 |
| copy() | 返回字典的副本 |
| fromkeys() | 返回拥有指定键和值的字典 |
| get() | 返回指定键的值 |
| items() | 返回包含每个键值对的元组的列表 |
| keys() | 返回包含字典键的列表 |
| pop() | 删除拥有指定键的元素 |
| popitem() | 删除最后插入的键值对 |
| setdefault() | 返回指定键的值。如果该键不存在，则插入具有指定值的键。 |
| update() | 使用指定的键值对字典进行更新 |
| values() | 返回字典中所有值的列表 |
Python If ... Else
Python 支持来自数学的常用逻辑条件：
- 等于：a == b
- 不等于：a != b
- 小于：a < b
- 小于等于：a <= b
- 大于：a > b
- 大于等于：a >= b
a = 200
b = 66
if b > a:
print("b is greater than a")
elif a == b:
print("a and b are equal")
else:
print("a is greater than b")
#### 简写 If
if a > b: print("a is greater than b") # 如果只有一条语句要执行，则可以将其与 if 语句放在同一行。
print("A") if a > b else print("B") # 如果只有两条语句要执行，一条用于 if，另一条用于 else，则可以将它们全部放在同一行：
print("A") if a > b else print("=") if a == b else print("B") # 还可以在同一行上使用多个 else 语句：Python While 循环
Python 有两个原始的循环命令：
- while 循环
- for 循环 while 循环 如果使用 while 循环，只要条件为真，我们就可以执行一组语句。
# 如果使用 break 语句，即使 while 条件为真，我们也可以停止循环：
# 如果使用 continue 语句，我们可以停止当前的迭代，并继续下一个：
# 通过使用 else 语句，当条件不再成立时，我们可以运行一次代码块：
i = 1
while i < 6:
print(i)
if i == 2:
continue
if i == 3:
break
i += 1
else:
print("i is no longer less than 6")Python For 循环
for 循环用于迭代序列（即列表，元组，字典，集合或字符串）。 这与其他编程语言中的 for 关键字不太相似，而是更像其他面向对象编程语言中的迭代器方法。 通过使用 for 循环，我们可以为列表、元组、集合中的每个项目等执行一组语句。
range() 函数
如需循环一组代码指定的次数，我们可以使用 range() 函数， range() 函数返回一个数字序列，默认情况下从 0 开始，并递增 1（默认地），并以指定的数字结束。
注意：range(10) 不是 0 到 10 的值，而是值 0 到 9。 range() 函数默认 0 为起始值，不过可以通过添加参数来指定起始值：range(3, 10)，这意味着值为 3 到 10（但不包括 10）： range() 函数默认将序列递增 1，但是可以通过添加第三个参数来指定增量值：range(2, 30, 3)：
这将返回从 2 开始（包括 2），并递增 3（默认是 1），直到小于 30（不包括 30）的所有数字： or 循环中的 else 关键字指定循环结束时要执行的代码块：
for i in range(10):
print(i)
else:
print("Finally finished!")Python 函数
函数是一种仅在调用时运行的代码块。 您可以将数据（称为参数）传递到函数中。 函数可以把数据作为结果返回。 在 Python 中，使用 def 关键字定义函数：
在 Python 文档中，“关键字参数”一词通常简称为 kwargs。
# 关键字参数
def my_function(child3, child2, child1):
print("The youngest child is " + child3)
my_function(child1 = "Phoebe", child2 = "Jennifer", child3 = "Rory") # 关键字参数
# 任意参数 # 如果参数数目未知，请在参数名称前添加 *：
def my_function(*kids): # 如果参数数目未知，请在参数名称前添加 *：
print("The youngest child is " + kids[2])
my_function("Phoebe", "Jennifer", "Rory")Python Lambda
如果在短时间内需要匿名函数，请使用 lambda 函数。 lambda 函数是一种小的匿名函数。 lambda 函数可接受任意数量的参数，但只能有一个表达式。
x = lambda a, b, c : a + b + c
print(x(5, 6, 2))Python 类和对象
- Python 是一种面向对象的编程语言。
- Python 中的几乎所有东西都是对象，拥有属性和方法。
- 类（Class）类似对象构造函数，或者是用于创建对象的“蓝图”。
创建类
如需创建类，请使用 class 关键字：
__init__() 函数
所有类都有一个名为 init() 的函数，它始终在启动类时执行。 使用 init() 函数将值赋给对象属性，或者在创建对象时需要执行的其他操作：
注释：每次使用类创建新对象时，都会自动调用 init() 函数。
对象方法
对象也可以包含方法。对象中的方法是属于该对象的函数。
提示：self 参数是对类的当前实例的引用，用于访问属于该类的变量。
self 参数
- self 参数是对类的当前实例的引用，用于访问属于该类的变量。
- 它不必被命名为 self，您可以随意调用它，但它必须是类中任意函数的首个参数：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def myfunc(self):
print("Hello my name is " + self.name)
def myfunc(abc):
print("Hello my name is " + abc.name)
p1 = Person("Bill", 63)
p1.myfunc()
print(p1.name)
print(p1.age)Python 继承
继承允许我们定义继承另一个类的所有方法和属性的类。 父类是继承的类，也称为基类。 子类是从另一个类继承的类，也称为派生类。
当您添加 init() 函数时，子类将不再继承父的 init() 函数。 注释：子的 init() 函数会覆盖对父的 init() 函数的继承。 如需保持父的 init() 函数的继承，请添加对父的 init() 函数的调用：
使用 super() 函数
Python 还有一个 super() 函数，它会使子类从其父继承所有方法和属性： 通过使用 super() 函数，您不必使用父元素的名称，它将自动从其父元素继承方法和属性。
class Student(Person):
def __init__(self, fname, lname):
Person.__init__(self, fname, lname)
super().__init__(fname, lname)提示：如果您在子类中添加一个与父类中的函数同名的方法，则将覆盖父方法的继承。
Python 迭代器
- 迭代器是一种对象，该对象包含值的可计数数字。
- 迭代器是可迭代的对象，这意味着您可以遍历所有值。
- 从技术上讲，在 Python 中，迭代器是实现迭代器协议的对象，它包含方法 iter() 和 next()。
迭代器 VS 可迭代对象（Iterable）
列表、元组、字典和集合都是可迭代的对象。它们是可迭代的容器，您可以从中获取迭代器（Iterator）。 所有这些对象都有用于获取迭代器的 iter() 方法：
# 从元组返回一个迭代器，并打印每个值：
mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)
print(next(myit))
print(next(myit))
print(next(myit))
# 提示：for 循环实际上创建了一个迭代器对象，并为每个循环执行 next() 方法。
mystr = "banana"
for x in mystr:
print(x)提示：for 循环实际上创建了一个迭代器对象，并为每个循环执行 next() 方法。
创建迭代器
要把对象/类创建为迭代器，必须为对象实现 iter() 和 next() 方法。
- 正如您在 Python 类/对象 一章中学到的，所有类都有名为 init() 的函数，它允许您在创建对象时进行一些初始化。
- iter() 方法的作用相似，您可以执行操作（初始化等），但必须始终返回 迭代器对象本身。
- next() 方法也允许您执行操作，并且必须返回序列中的下一个项目。
创建一个返回数字的迭代器，从 1 开始，每个序列将增加 1（返回 1、2、3、4、5 等）：
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
x = self.a
self.a += 1
return x
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))StopIteration 如果你有足够的 next() 语句，或者在 for 循环中使用，则上面的例子将永远进行下去。
- 为了防止迭代永远进行，我们可以使用 StopIteration 语句。
- 在 next() 方法中，如果迭代完成指定的次数，我们可以添加一个终止条件来引发错误：
在 20 个迭代之后停止：
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
print(x)Python 模块
模块是包含一组函数的文件，希望在应用程序中引用。
创建模块
如需创建模块，只需将所需代码保存在文件扩展名为 .py 的文件中：
import mymodule as mx # 您可以在导入模块时使用 as 关键字创建别名：
a = mx.person1["age"]
print(a)Python 作用域
变量仅在创建区域内可用。这称为作用域。
- 在函数内部创建的变量属于该函数的局部作用域，并且只能在该函数内部使用。
- global 关键字使变量成为全局变量。
Python 日期
Python 中的日期不是其自身的数据类型，但是我们可以导入名为 datetime 的模块，把日期视作日期对象进行处理。
- strftime() 方法 把日期对象格式化为可读字符串的方法
导入 datetime 模块：
import datetime
x = datetime.datetime.now()
print(x)
x = datetime.datetime(2019, 10, 1)
print(x.strftime("%B"))Python 数学
Python 拥有一组内置的数学函数，包括一个广泛的数学模块，允许你对数字执行数学任务。
- min() 和 max() 函数可用于查找可迭代对象中的最低或最高值：
- abs() 函数返回指定数字的绝对（正）值：
- pow(x, y) 函数返回 x 的 y 次幂（xy）的值。
- math.sqrt() 方法返回一个数字的平方根：
- math.ceil() 方法将一个数字向上舍入到最近的整数，而
- math.floor() 方法将一个数字向下舍入到最近的整数，并返回结果
- math.pi 常量返回 PI 的值
import math
x = min(5, 10, 25)
y = max(5, 10, 25)
x = math.sqrt(64)
print(x)
print(y)Python JSON
JSON 是用于存储和交换数据的语法。 JSON 是用 JavaScript 对象表示法（JavaScript object notation）编写的文本。
Python 有一个名为 json 的内置包，可用于处理 JSON 数据。
- 若有 JSON 字符串，则可以使用 json.loads() 方法对其进行解析。 结果将是 Python 字典。
- 若有 Python 对象，则可以使用 json.dumps() 方法将其转换为 JSON 字符串。 使用 separators 参数来更改默认分隔符：
import json
# 一些 JSON:
x = '{ "name":"Bill", "age":63, "city":"Seatle"}'
# 解析 x:
y = json.loads(x)
# 结果是 Python 字典：
print(y["age"])
# Python 对象（字典）：
x = {
"name": "Bill",
"age": 63,
"city": "Seatle"
}
# 转换为 JSON：
y = json.dumps(x)
# 结果是 JSON 字符串：
print(y)
# 使用 indent 参数来定义缩进的数量：
json.dumps(x, indent=4, separators=(". ", " = "))Python Try Except
- try 块允许您测试代码块以查找错误。
- except 块允许您处理错误。
- finally 块允许您执行代码，无论 try 和 except 块的结果如何。
Python 模块
- NumPy 模块 "Numerical Python"，是一个用于处理数组的 库。
- Matplotlib 模块 "Matplotlib"，是一个用于绘制图表的库。
- Pandas 模块 "Pandas"，是一个用于数据分析的库。
- SciPy,Scientific Python 是一个科学计算库，底层使用了 NumPy。
Scikit-learn 模块 "Scikit-learn"，是一个用于机器学习的库。TensorFlow 模块 "TensorFlow"，是一个用于机器学习的库。Keras 模块 "Keras"，是一个用于深度学习的库。