Python

大部分学编程语言是为了能用上，而不是因为觉得这门语言多么优美。只是在用多种语言都能实现目的的情况下，才会根据语言生态、求职优势、个人喜好等原因进行选择。

所以，这里我先说学习 Python 的好处，来激起你（以及我自己）对学习这门语言的兴趣。

学习 Python 的优点

• 工作岗位多：数据分析师、算法工程师、爬虫工程师、后端开发、自动化测试、运维开发、AI 训练师
• 开发速度快、无需关心内存管理
• 覆盖大量热门赛道：
  • 人工智能 / 大数据（绝对主流）
  • 网络爬虫（天花板）
  • Web 后端开发
  • 自动化运维 / 办公自动化（职场刚需）
  • 测试开发
• 生态繁荣，有海量第三方库，少造轮子
  • 数据处理：Pandas
  • 图像处理：OpenCV、Pillow
  • 接口开发：FastAPI
  • 爬虫：Requests

Python之禅

在控制台执行 import this，可以看到全文：

The Zen of 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!

对应中文译文：

Python之禅

Python之禅， by Tim Peters

优美优于丑陋。
明了优于隐晦。
简单优于复杂。
复杂优于凌乱。
扁平优于嵌套。
稀疏优于密集。
可读性很重要。
特例不足以打破规则。
尽管实用性胜过纯粹。
错误不应悄无声息地传递。
除非明确地沉默。
面对歧义，拒绝猜测的诱惑。
应该有一种——最好只有一种——明显的处理方式。
尽管这种方式一开始可能并不明显，除非你是荷兰人。
现在做胜过不做。
尽管不做常常胜过立马去做。
如果实现难以解释，那是个坏主意。
如果实现易于解释，那可能是个好主意。
命名空间是个绝妙的主意——让我们多做一些吧！

注释

在 Python中，单行注释用井号 # 标识。井号后面的内容都会被 Python 解释器忽略。

多行注释用三个单引号或者三个双引号来实现。

#!/usr/bin/python3

'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号
这是多行注释，用三个单引号
'''
print("Hello, World!")

注意

虽然多行字符串在这里被当作多行注释使用，但它实际上是一个字符串，我们只要不使用它，它不会影响程序的运行。

这些字符串在代码中可以被放置在一些位置，而不引起实际的执行，从而达到注释的效果。

变量

在程序中可随时修改变量的值，而Python将始终记录变量的最新值。

message = "Hello Python world!"
print(message)

message = "Hello Python Crash Course world!""
print(message)

以上代码将输出：

Hello Python world!
Hello Python Crash Course world!

变量的命令

1. 变量名只能包含字母、数字和下划线。变量名能以字母或下划线打头，但不能以数字打头。
2. 变量名不能包含空格，但能使用下划线来分隔其中的单词。
3. 不要将 Python 中的保留关键字（如 print）用于函数名和变量名上。
4. 变量名应既简短又具有描述性。

字符串

字符串就是一系列字符。在Python中，用引号括起的都是字符串（单引号、双引号都行），如下所示：

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

常见方法

title()

将每个单词的首字母转为大写。

name = "hello world"

# 输出：`Hello World`
print(name.title())

upper()

将字符串全部转大写：

name = "Hello world"

# 输出 `HELLO WORLD`
print(name.upper())

lower()

将字符串全部转小写：

name = "Hello world"

# 输出 `hello world`
print(name.lower())

f-string（3.6+）

在字符串中使用变量。

first_name = "hello"
last_name = "world"
full_name = f"{first_name} {last_name}"

# 输出 `hello world`
print(full_name)

format()（3.0 通用方案）

name = "hello"
age = 18
res = "姓名：{}，年龄：{}".format(name, age)

# 输出 `姓名：hello，年龄：18`
print(res)

符号处理

添加制表符

要在字符串中添加制表符，可使用字符组合 \t。

# 输出 `Python`
print("Python")

输出 `  Python`
print("\tPython")

添加换行符

要在字符串中添加换行符，可使用字符组合 \n：

print("Languages:\nPython\nC\nJavaScript")

输出如下：

Languages:
Python
C
JavaScript

删除左右空白

• 删除字符串右边的空白可以用 rstrip
• 删除左边的空白可以用 lstrip()
• 同时删除两边的空白可以用 strip()

favorite_language = 'python '

# 输出 `python`
favorite_language.rstrip()

数字

Python3 支持整数（int）、浮点数（float）、复数（complex）三种类型的数字。

整数

整数支持加（+）、减（-）、乘（*）、除（/）等运算。

不同进制示例：

• 十六进制：0xA0F
• 八进制：0o37

使用两个乘号表示乘方运算

平方：

# 3^2 => 9
3 ** 2

六次方：

# 10^6 = 1000000
10 ** 6

浮点数

所有带小数点的数都视为浮点数。

精度丢失问题

浮点数的计算会有精度问题

# 得到 `0.30000000000000004`
0.2 + 0.1

不存在完全没有浮点数精度丢失的通用编程语言，根源分两类：

• 硬件层面：计算机底层默认二进制存储小数，十进制有限小数（0.1、0.2）二进制是无限循环小数，截断存储必然丢失精度；
• 数学层面：任何有限位数存储方案，都无法完整表达全体实数，一定会存在近似。

精度丢失问题的解决方案有：

方案一：十进制高精度类型（财务、金融专用，无精度丢失）

核心原理：直接用十进制存储数字，不转二进制，完美适配小数（0.1、0.01、金额），不存在二进制循环小数问题。

使用 Python 内置的 decimal 标准库可以实现。

from decimal import Decimal
# 用字符串传入，避免float先污染精度
a = Decimal("0.1")
b = Decimal("0.2")
print(a + b)  # 输出 0.3，无精度丢失

方案二：分数精确运算（有理数完全无损）

原理：用分子 + 分母存储有理数，所有加减乘除分数运算 100% 精确，无任何近似。

使用 Python 标准库 fractions 可以实现。

from fractions import Fraction
a = Fraction("0.1")
b = Fraction("0.2")
print(a + b) # 3/1，完全精确

缺点：只能处理有理数，无法精确表示无理数（π、√2）；复杂运算分母极易爆炸，性能极差。

整数和浮点数

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

# 得到 `2.0`
4 / 2

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

数中的下划线

书写很大的数时，可使用下划线将其中的数字分组，使其更清晰易读（Python 3.6开始支持）：

# 其实这个下划线并不需要从右往左每 3 个数字加一个，你写 `14_00_0_0_00_000` 也是 ok 的，只是不太符合大众习惯
universe_age = 14_000_000_000

# 得到 `14000000000`（Python不会打印其中的下划线）
print(universe_age)

同时给多个变量赋值

可在一行代码中给多个变量赋值，这有助于缩短程序并提高其可读性。这种做法最常用于将一系列数赋给一组变量。

# 一次性给 a b c 三个变量赋值
a, b, c = 10, 20, 30
print(a)  # 10
print(b)  # 20
print(c)  # 30

等价写法：

# 不使用多变量赋值，要写三行
a = 10
b = 20
c = 30

常量

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

列表

在Python中，用方括号 [] 表示列表，并用逗号分隔其中的元素。如果让 Python 将列表打印出来，Python 将打印列表的内部表示，包括方括号：

bicycles = ['trek','cannondale','redline','specialized']

# 输出：`['trek','cannondale','redline','specialized']`
print(bicycles)

通过将索引指定为 -1，可让 Python 返回最后一个列表元素：

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

这种约定也适用于其他负数索引。例如，索引 -2 返回倒数第二个列表元素，索引 -3 返回倒数第三个列表元素，依此类推。

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

# 输出内容为：My first bicycle was a Trek.
print(message)

要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值。

motorcycles = ['honda','yamaha','suzuki']

motorcycles[0] = 'ducati'
print(motorcycles)

在列表中添加新元素时，最简单的方式是将元素附加 append 到列表。给列表附加元素时，它将添加到列表末尾。

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

motorcycles.append('ducati')

使用方法 insert() 可在列表的任何位置添加新元素。为此，你需要指定新元素的索引和值。

motorcycles = ['honda','yamaha','suzuki']

motorcycles.insert(0,'ducati')

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

如果知道要删除的元素在列表中的位置，可使用del语句。

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

del motorcycles[0]
print(motorcycles)

方法 pop() 删除列表末尾的元素，并让你能够接着使用它。术语弹出(pop)源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。

motorcycles = ['honda','yamaha','suzuki']

popped_motorcycle = motorcycles.pop()

# ['honda','yamaha']
print(motorcycles)

# suzuki
print(popped_motorcycle)

实际上，可以使用pop()来删除列表中任意位置的元素，只需在圆括号中指定要删除元素的索引即可。

motorcycles = ['honda','yamaha','suzuki']

first_owned = motorcycles.pop(0)

# The first motorcycle I owned was a Honda.
print(f"The first motorcycle I owned was a {first_owned.title()}.")

如果你不确定该使用 del 语句还是 pop() 方法，下面是一个简单的判断标准：

• 如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；
• 如果你要在删除元素后还能继续使用它，就使用方法pop()。

有时候，你不知道要从列表中删除的值所处的位置。如果只知道要删除的元素的值，可使用方法 remove()。

motorcycles = ['honda','yamaha','suzuki','ducati']

motorcycles.remove('ducati')

方法 sort() 让你能够较为轻松地对列表进行排序（按字母顺序升序排列）。方法 sort() 永久性地修改列表元素的排列顺序。

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

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

还可以按与字母顺序相反的顺序排列列表元素，只需向 sort() 方法传递参数 reverse=True 即可。

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

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

要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数 sorted()。函数 sorted() 让你能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序。

注意，调用函数 sorted() 后，原始列表元素的排列顺序并没有变。如果要按与字母顺序相反的顺序显示列表，也可向函数 sorted() 传递参数 reverse=True。

要反转列表元素的排列顺序，可使用方法 reverse()。注意，reverse() 不是按与字母顺序相反的顺序排列列表元素，而只是反转列表元素当前的排列顺序。方法 reverse() 永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，只需对列表再次调用 reverse() 即可。

使用函数 len() 可快速获悉列表的长度。

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

# 4
len(cars)

索引错误的话会导致报错，比如下面这段代码：

motorcycles = ['honda','yamaha','suzuki']
print(motorcycles[3])

会导致报错：

Traceback (most recent call last):
  File "motorcycles.py",line 2,in <module>
    print(motorcycles[3])
IndexError:list index out of range

遍历列表，可以使用 for 语句。for 语句末尾的冒号告诉 Python，下一行是循环的第一行。如果不小心遗漏了冒号，将导致语法错误。

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

Python函数 range() 让你能够轻松地生成一系列数。例如，可以像下面这样使用函数 range() 来打印一系列数：

for value in range(1,5):
    print(value)

上述代码会输出 1~4，不会输出 5：

1
2
3
4

调用函数 range() 时，也可只指定一个参数，这样它将从 0 开始。例如，range(6)返回数 0～5。

要创建数字列表，可使用函数 list() 将 range() 的结果直接转换为列表。

numbers = list(range(1,6))

# [1,2,3,4,5]
print(numbers)

使用函数range()时，还可指定步长。为此，可给这个函数指定第三个参数，Python将根据这个步长来生成数。

# `range()` 函数的第三个入参表示步长
even_numbers = list(range(2,11,2))

# [2,4,6,8,10]
print(even_numbers)

使用函数 range() 几乎能够创建任何需要的数集。

如何创建一个列表，其中包含前 10 个整数（1～10）的平方呢？

在Python中，用两个星号 ** 表示乘方运算。下面的代码演示了如何将前10个整数的平方加入一个列表中：

squares = []
for value in range(1,11):
    squares.append(value ** 2)

# [1,4,9,16,25,36,49,64,81,100]
print(squares)

有几个专门用于处理数字列表的Python函数。例如，你可以轻松地找出数字列表的最大值、最小值和总和：

digits = [1,2,3,4,5,6,7,8,9,0]

# 0
min(digits)

# 9
max(digits)

# 45
sum(digits)

前面介绍的生成列表squares的方式包含三四行代码，而列表解析让你只需编写一行代码就能生成这样的列表。列表解析将for循环和创建新元素的代码合并成一行，并自动附加新元素。

# 请注意，这里的for语句末尾没有冒号。
squares = [value**2 for value in range(1,11)]

# [1,4,9,16,25,36,49,64,81,100]
print(squares)

除了处理整个列表，你还可以处理列表的部分元素，Python称之为切片。

要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range()一样，Python在到达第二个索引之前的元素后停止。

players = ['charles','martina','michael','florence','eli']

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

如果没有指定第一个索引，Python将自动从列表开头开始：

players = ['charles','martina','michael','florence','eli']

# ['charles','martina','michael','florence']
print(players[:4])

要让切片终止于列表末尾，也可使用类似的语法。例如，如果要提取从第三个元素到列表末尾的所有元素，可将起始索引指定为2，并省略终止索引：

players = ['charles','martina','michael','florence','eli']

# ['michael','florence','eli']
print(players[2:])

前面说过，负数索引返回离列表末尾相应距离的元素，因此你可以输出列表末尾的任意切片。例如，如果要输出名单上的最后三名队员，可使用切片 players[-3:]：

players = ['charles','martina','michael','florence','eli']

# 输出 `['michael', 'florence', 'eli']`
print(players[-3:])

注意

注意：可在表示切片的方括号内指定第三个值。这个值告诉Python在指定范围内每隔多少元素提取一个。

遍历切片：

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

要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引 [:]。

元组

Python 将不能修改的值称为不可变的，而不可变的列表被称为元组。元组看起来很像列表，但使用圆括号而非中括号来标识。定义元组后，就可使用索引来访问其元素，就像访问列表元素一样。

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

my_t = (3,)

遍历元组中的所有值：

dimensions = (200,50)
for dimension in dimensions:
    print(dimension)

输出结果为：

200
50

相比于列表，元组是更简单的数据结构。如果需要存储的一组值在程序的整个生命周期内都不变，就可以使用元组。

if 语句

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

for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title())

要检查是否两个条件都为 True，可使用关键字 and 将两个条件测试合而为一。

关键字 or也能够让你检查多个条件，但只要至少一个条件满足，就能通过整个测试。仅当两个测试都没有通过时，使用 or 的表达式才为 False。

要判断特定的值是否已包含在列表中，可使用关键字 in。

requested_toppings = ['mushrooms','onions','pineapple']

# True
'mushrooms'in requested_toppings

# False
'pepperoni'in requested_toppings

还有些时候，确定特定的值未包含在列表中很重要。在这种情况下，可使用关键字 not in。

banned_users = ['andrew','carolina','david']
user = 'marie'

if user not in banned_users:
    print(f"{user.title()},you can post a response if you wish.")

布尔表达式：

game_active = True
can_edit = False

最简单的 if 语句只有一个测试和一个操作：

if conditional_test:
    do something

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!")

requested_toppings = ['mushrooms','green peppers','extra cheese']

for requested_topping in requested_toppings:
    if requested_topping == 'green peppers':
        print("Sorry,we are out of green peppers right now.")
    else:
        print(f"Adding {requested_topping}.")

print("\nFinished making your pizza!")

if-elif-else 结构：

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.")

age = 12

if age < 4:
    price = 0
elif age < 18:
    price = 25
elif age < 65:
    price = 40
else:
    price = 20

print(f"Your admission cost is ${price}.")

else 代码块是可以省略的：

age = 12

if age < 4:
    price = 0
elif age <18:
    price = 25
elif age <65:
    price = 40
elif age >= 65:
    price = 20

print(f"Your admission cost is ${price}.")

在 if 语句中将列表名用作条件表达式时，Python 将在列表至少包含一个元素时返回 True，并在列表为空时返回 False（这点和 JavaScript 中的空数组的布尔值判断逻辑不一样）。

字典

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

在 Python 3.7 中，字典中元素的排列顺序与定义时相同。如果将字典打印出来或遍历其元素，将发现元素的排列顺序与添加顺序相同。

alien_0 = {'color':'green','points':5}

对于字典中不再需要的信息，可使用 del 语句将相应的键值对彻底删除。使用 del 语句时，必须指定字典名和要删除的键。

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

del alien_0['points']
print(alien_0)

使用 dict[key] 这种方式从字典中获取感兴趣的值时，可能会引发问题：如果指定的键不存在就会出错。就字典而言，可使用方法 get() 在指定的键不存在时返回一个默认值，从而避免这样的错误。方法 get() 的第一个参数用于指定键，是必不可少的；第二个参数为指定的键不存在时要返回的值，是可选的。

alien_0 = {'color':'green','speed':'slow'}

point_value = alien_0.get('points','No point value assigned.')

# 输出 `No point value assigned.`
print(point_value)

遍历所有键值对：

user_0 = {
    'username':'efermi',
    'first':'enrico',
    'last':'fermi',
}

for key,value in user_0.items():
    print(f"\nKey:{key}")
    print(f"Value:{value}")

遍历字典中的所有键：

favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python',
}

# .keys() 是可以省略的，默认就是遍历所有键
for name in favorite_languages.keys():
    print(name.title())

遍历字典时，会默认遍历所有的键。即 for name in favorite_languages: 等价于 for name in favorite_languages.keys():。显式地使用方法 keys() 可让代码更容易理解，你可以选择这样做，但是也可以省略它。

要以特定顺序返回元素，一种办法是在 for 循环中对返回的键进行排序。为此，可使用函数 sorted() 来获得按特定顺序排列的键列表的副本：

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.")

遍历字典中的所有值：

favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python',
}

print("The following languages have been mentioned:")
for language in favorite_languages.values():
    print(language.title())

通过对包含重复元素的列表调用 set()，可让 Python 找出列表中独一无二的元素，并使用这些元素来创建一个集合。

favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python',
}

print("The following languages have been mentioned:")
for language in set(favorite_languages.values()):
    print(language.title())

可使用一对花括号直接创建集合，并在其中用逗号分隔元素：

languages = {'python','ruby','python','c'}

# {'ruby','python','c'}
languages

用户输入和while循环

函数 input() 让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python 将其赋给一个变量，以方便你使用。

message = input("Tell me something,and I will repeat it back to you:")
print(message)

函数 input() 接受一个参数——要向用户显示的提示或说明，让用户知道该如何做。在本例中，Python 运行第一行代码时，用户将看到提示 Tell me something,and I will repeat it back to you:。程序等待用户输入，并在用户按回车键后继续运行。输入被赋给变量 message，接下来的 print(message) 将输入呈现给用户。

函数int()将数的字符串表示转换为数值表示，如下所示：

age = input("How old are you?")
# How old are you?21

age = int(age)

# True
age >= 18

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)
    print(message)

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

pets = ['dog','cat','dog','goldfish','cat','rabbit','cat']
print(pets)

while 'cat'in pets:
    pets.remove('cat')

print(pets)

函数

有时候，预先不知道函数需要接受多少个实参，好在 Python 允许函数从调用语句中收集任意数量的实参。例如，来看一个制作披萨的函数，它需要接受很多配料，但无法预先确定顾客要多少种配料。下面的函数只有一个形参 *toppings（配料的意思），但不管调用语句提供了多少实参，这个形参会将它们统统收入囊中：

def make_pizza(*toppings):
    """打印顾客点的所有配料。"""
    print(toppings)

make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')

形参名 *toppings 中的星号让 Python 创建一个名为 toppings 的空元组，并将收到的所有值都封装到这个元组中。函数体内的函数调用 print() 通过生成输出，证明 Python 能够处理使用一个值来调用函数的情形，也能处理使用三个值来调用函数的情形。它以类似的方式处理不同的调用。注意，Python 将实参封装到一个元组中，即便函数只收到一个值。上面的函数输入内容如下，注意第一个输出结果中有一个逗号：

('pepperoni',)
('mushrooms','green peppers','extra cheese')

如果要遍历其中的具体元素：

def make_pizza(*toppings):
    """概述要制作的披萨。"""
    print("\nMaking a pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')

结合使用位置实参和任意数量实参：

def make_pizza(size,*toppings):
    """概述要制作的披萨。"""
    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')

*args

你经常会看到通用形参名 *args，它也收集任意数量的位置实参。

使用任意数量的关键字实参：

def build_profile(first,last,**user_info):
    """创建一个字典，其中包含我们知道的有关用户的一切。"""
    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'}

**kwargs

注意　你经常会看到形参名 **kwargs，它用于收集任意数量的关键字实参。

顺序规则：普通位置参数 → *args → 关键字参数 → kwargs

def func(a, b, *args, x=10, **kwargs):
    print(a, b)
    print(args)
    print(x)
    print(kwargs)

func(1, 2, 3, 4, x=100, name="李四", score=90)

写法	接收参数类型	打包成
*args	多余位置参数	元组 tuple
**kwargs	多余关键字参数	字典 dict

import 语句允许在当前运行的程序文件中使用模块中的代码。

假定现在有文件 pizza.py 内容如下：

def make_pizza(size,*toppings):
    """概述要制作的披萨。"""
    print(f"\nMaking a {size}-inch pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

导入整个模块（只需编写一条import语句并在其中指定模块名，就可在程序中使用该模块中的所有函数）：

import pizza

pizza.make_pizza(16,'pepperoni')
pizza.make_pizza(12,'mushrooms','green peppers','extra cheese')

还可以导入模块中的特定函数，这种导入方法的语法如下：

from module_name import function_name

通过用逗号分隔函数名，可根据需要从模块中导入任意数量的函数：

from module_name import function_0,function_1,function_2

使用 as 给函数指定别名：

from pizza import make_pizza as mp

mp(16,'pepperoni')
mp(12,'mushrooms','green peppers','extra cheese')

使用 as 给模块指定别名：

import pizza as p

p.make_pizza(16,'pepperoni')
p.make_pizza(12,'mushrooms','green peppers','extra cheese')

使用星号 * 运算符可让 Python 导入模块中的所有函数：

from pizza import *

make_pizza(16,'pepperoni')
make_pizza(12,'mushrooms','green peppers','extra cheese')

给形参指定默认值时，等号两边不要有空格：

def function_name(parameter_0,parameter_1='default value')

对于函数调用中的关键字实参，也应遵循这种约定：

function_name(value_0,parameter_1='value')