①title() 以首字母大写的方式显示每个单词
字符串改为全部大写upper()或全部小写lower()

②使用制表符\t或换行符\n来添加空白

③Python 能够找出字符串开头和末尾多余的空白。要确保字符串末尾没有空白，可使用方法 rstrip()。
要永久删除这个字符串中的空白，必须将删除操作的结果存回到变量中:favorite_language = favorite_language.rstrip()
你还可以剔除字符串开头的空白，或同时剔除字符串两端的空白。为此，可分别使用方法 lstrip() 和 strip()

④像上面这样在字符串中使用整数时，需要显式地指出你希望 Python 将这个整数用作字符串。为此，可调用函数 str() ，
它让 Python 将非字符串值表示为字符串

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

列表

1.在列表中添加新元素时，最简单的方式是将元素附加到列表末尾。方法 append() 将元素 'ducati' 添加到了列表末尾
motorcycles.append('ducati')

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

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

4.方法 pop() 可删除列表末尾的元素，并让你能够接着使用它。术语 弹出 （ pop ）源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。
实际上，你可以使用 pop() 来删除列表中任何位置的元素，只需在括号中指定要删除的元素的索引即可。

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

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

6.使用方法 sort() 对列表进行永久性排序,还可以按与字母顺序相反的顺序排列列表元素，为此，只需向 sort() 方法传递参数 reverse=True

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

8.要反转列表元素的排列顺序，可使用方法 reverse() 。注意， reverse() 不是指按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序

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

操作列表

1.遍历整个列表(for)

for magician in magicians:
**不能语句忘记后面的冒号**

2.避免缩进错误，python严格规定缩进

3.创建数值列表

3.1 使用函数 range().函数 range() 让你能够轻松地生成一系列的数字。

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

--如果将 range() 作为 list() 的参数，输出将为一个数字列表。即：numbers = list(range(1,6))
--使用函数 range() 时，还可指定步长。如：numbers = list(range(2,11,2))

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

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

3.4列表解析

列表解析 将 for 循环和创建新元素的代码合并成一行，并自动
附加新元素。如：squares = [value**2 for value in range(1,11)]

4.使用列表的一部分

4.1切片：要创建切片，可指定要使用的第一个元素和最后一个元素的索引。

与函数 range() 一样， Python 在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需要指定索引 0~3 ，这将输出分别为 0 、 1 和 2 的元素。
如：print(players[0:3])
--要让切片终止于列表末尾，只需省略终止索引!

4.2要遍历列表的部分元素，可在 for 循环中使用切片。

for player in players[:3]:

4.3复制列表

要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（ [:] ）。这让 Python 创建一个始于第一个元素，终止于最后一个元素的切片，即复制整个列表。

5.元组

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。 Python 将不能修改的值称为不可变的，而不可变的列表被称为 元组 。

5.1 定义元祖

元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

5.2 遍历元组中的所有值

像列表一样，也可以使用 for 循环来遍历元组中的所有值：

5.3 修改元组变量

虽然不能修改元组的元素，但可以给存储元组的变量赋值。即：重新定义整个元组：

6.设置代码格式

6.1 缩进：

①建议每级缩进都使用四个空格，这既可提高可读性，又留下了足够的多级缩进空间。
②在字处理文档中，大家常常使用制表符而不是空格来缩进。

6.2 行长：建议每行不超过 80 字符

6.3 空行：要将程序的不同部分分开，可使用空行。

if语句

1.条件测试

每条 if 语句的核心都是一个值为 True 或 False 的表达式，这种表达式被称为 条件测试 。

1.1检查是否相等(==)

1.2检查多个条件(and与or)

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

要判断特定的值是否已包含在列表中，可使用关键字 in 。同理：检查特定值是否不包含在列表中，可使用关键字 not in 。

1.4布尔表达式

car = 'subaru'
print("Is car == 'subaru'? I predict True.")
print(car == 'subaru')

1.5 if-else 语句

1.6 if-elif-else 结构

1.7 省略 else 代码块

Python 并不要求 if-elif 结构后面必须有 else 代码块。
else 是一条包罗万象的语句，只要不满足任何 if 或 elif 中的条件测试，其中的代码就会执行，这可能会引入无效甚至恶意的数据。如果知道最终要测试的条件，应考虑使用一个 elif 代码块来代替 else 代码块。这样，你就可以肯定，仅当满足相应的条件时，你的代码才会执行。

1.8测试多个条件：

如果你只想执行一个代码块，就使用 if-elif-else 结构；如果要运行多个代码块，就使用一系列独立的 if 语句。

2.使用 if 语句处理列表

2.1 检查特殊元素

2.2 确定列表不是空的

2.3 使用多个列表

3.设置 if 语句的格式

在诸如 == 、 >= 和 <= 等比较运算符两边各添加一个空格

字典

1.使用字典

在 Python 中， 字典 是一系列 键 — 值对 。每个 键 都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何 Python 对象用作字典中的值。
在 Python 中，字典用放在（大）花括号 {} 中的一系列键 — 值对表示：

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

键 — 值 对是两个相关联的值。指定键时， Python 将返回与之相关联的值。键和值之间用冒号分隔，而键 — 值对之间用逗号分隔。

1.1访问字典中的值

要获取与键相关联的值，可依次指定字典名和放在方括号内的键：
alien_0 = {'color': 'green'}
print(alien_0['color'])

1.2 添加键 — 值对

字典是一种动态结构，可随时在其中添加键 — 值对。要添加键 — 值对，可依次指定字典名、用方括号括起的键和相关联的值。

1.3 修改字典中的值

alien_0 = {'color': 'green'}
alien_0['color'] = 'yellow'

1.4 删除键 — 值对

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

1.5 由类似对象组成的字典

可以使用字典来存储众多对象的同一种信息。

2.遍历字典

有多种遍历字典的方式：可遍历字典的所有键 — 值对、键或值。

2.1 遍历所有的键 — 值对

要编写用于遍历字典的 for 循环，可声明两个变量，用于存储键 — 值对中的键和值。对于这两个变量，可使用任何名称。如：
for key, value in user_0.items():

for 语句的第二部分包含字典名和方法 items()，它返回一个键 — 值对列表。

2.2 遍历字典中的所有键

在不需要使用字典中的值时，方法 keys() 很有用。
遍历字典时，会默认遍历所有的键，因此，如果代码中的 for name in favorite_languages.keys(): 替换为 for name in favorite_languages: ，输出将不变。

2.3 按顺序遍历字典中的所有键

字典总是明确地记录键和值之间的关联关系，但获取字典的元素时，获取顺序是不可预测的。
要以特定的顺序返回元素，一种办法是在 for 循环中对返回的键进行排序。为此，可使用函数 sorted() 来获得按特定顺序排列的键列表的副本，如
for name in sorted(favorite_languages.keys()):

2.4 遍历字典中的所有值

①使用方法 values() ，它返回一个值列表，而不包含任何键。这种做法提取字典中所有的值，而没有考虑是否重复。
②通过对包含重复元素的列表调用 set() ，可让 Python 找出列表中独一无二的元素，并使用这些元素来创建一个集合。如：for language in set(favorite_languages.values()):

3.嵌套

将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为 嵌套 。你可以在列表中嵌套字典、在字典中嵌套列表甚至在字典中嵌套字典。

3.1 字典列表

创建一个列表，其中每个元素都是一个字典，包含有关该元素的各种信息。如：
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]

3.2 在字典中存储列表

有时候，需要将列表存储在字典中，而不是将字典存储在列表中。如下：
pizza = {
'crust': 'thick',
'toppings': ['mushrooms', 'extra cheese'],
}
-->每当需要在字典中将一个键关联到多个值时，都可以在字典中嵌套一个列表。

3.3 在字典中存储字典

如果有多个网站用户，每个都有独特的用户名，可在字典中将用户名作为键，然后将每位用户的信息存储在一个字典中，并将该字典作为与用户名相关联的值。如下：
users = {
'aeinstein': {
'first': 'albert',
'last': 'einstein',
'location': 'princeton',
},
'mcurie': {
'first': 'marie',
'last': 'curie',
'location': 'paris',
},
}

七.用户输入与while循环

1.1 函数 input() 的工作原理.

函数 input() 让程序暂停运行，等待用户输入一些文本。获取用户输入后， Python 将其存储在一个变量中，以方便你使用。
如：name = input("Please enter your name: ")

-->注意：如果你使用的是 Python 2.7 ，应使用函数 raw_input() 来提示用户输入。这个函数与 Python 3 中的 input() 一样，也将输入解读为字符串。

1.2 使用 int() 来获取数值输入.

使用函数 input() 时， Python 将用户输入解读为字符串。函数 int() 将数字的字符串表示转换为数值表示,将输入用于数值比较.
比如：
age = input("How old are you? ")
How old are you? 21
age = int(age)

1.3 求模运算符

求模运算符 （ % ）是一个很有用的工具，它将两个数相除并返回余数

2.使用 while 循环

比如：
current_number = 1
while current_number <= 5:
print(current_number)
current_number += 1

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

2.2 使用标志

在要求很多条件都满足才继续运行的程序中，可定义一个变量，用于判断整个程序是否处于活动状态。这个变量被称为 标志 ，充当了程序的交通信号灯。比如：
prompt = "\nTell me something, and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program. "
active = True
while active:
message = input(prompt)
if message == 'quit':
active = False
else:
print(message)

2.3 使用 break 退出循环.

立即退出 while 循环，不再运行循环中余下的代码，也不管条件测试的结果如何，可使用 break 语句。
break 语句用于控制程序流程，可使用它来控制哪些代码行将执行，哪些代码行不执行，从而让程序按你的要求执行你要执行的代码。

2.4 在循环中使用 continue.

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

3.使用 while 循环来处理列表和字典

3.1 在列表之间移动元素

首先，创建一个待验证用户列表
和一个用于存储已验证用户的空列表
unconfirmed_users = ['alice', 'brian', 'candace']
confirmed_users = []

验证每个用户，直到没有未验证用户为止
将每个经过验证的列表都移到已验证用户列表中
while unconfirmed_users:
current_user = unconfirmed_users.pop()
print("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())

3.2 删除包含特定值的所有列表元素

我们使用函数 remove() 来删除列表中的特定值，这之所以可行，是因为要删除的值在列表中只出现了一次。如果要删除列表中所有包含特定值的元素，
-->要删除所有这些元素，可不断运行一个 while 循环，直到列表中不再包含特定值，如下：（注意缩进！！！）
pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
while 'cat' in pets:
pets.remove('cat')
print(pets)

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

可使用 while 循环提示用户输入任意数量的信息。将收集的数据存储在一个字典中. 如：

定义了一个空字典（ responses ）
responses = {}
设置一个标志，指出调查是否继续
polling_active = True
while polling_active:
提示输入被调查者的名字和回答
name = input("\nWhat is your name? ")
response = input("Which mountain would you like to climb someday? ")
将答卷存储在字典中
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(name + " would like to climb " + response + ".")

八. 函数

1.1 定义函数（def）

使用关键字 def 来告诉 Python 你要定义一个函数。这是函数定义，向 Python 指出了函数名，还可能在括号内指出函数为完成其任务需要什么样的信息。形如def greet_user(): 后面冒号不能忘！

1.2 向函数传递信息

函数定义 def greet_user() 的括号内添加 username 。通过在这里添加 username ，就可让函数接受你给 username 指定的任何值。如：

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

1.3 实参和形参

在函数 greet_user() 的定义中，变量 username 是一个 形参 —— 函数完成其工作所需的一项信息。在代码 greet_user('jesse') 中，值 'jesse' 是一个 实参 。实参是调用函数时传递给函数的信息。

2. 传递实参

鉴于函数定义中可能包含多个形参，因此函数调用中也可能包含多个实参。向函数传递实参的方式很多，可使用 位置实参 ，这要求实参的顺序与形参的顺序相同；也可使用 关键字实参 ，其中每个实参都由变量名和值组成；还可使用列表和字典。

2.1 位置实参

调用函数时， Python 必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参。如：
def describe_pet(animal_type, pet_name):
""" 显示宠物的信息 """
print("\nI have a " + animal_type + ".")
print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet('hamster', 'harry')

上述中：实参 'hamster' 存储在形参 animal_type 中，而实参 'harry' 存储在形参 pet_name 中。

2.2 关键字实参

关键字实参 是传递给函数的名称 — 值对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆。关键字实参让你无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。如：
def describe_pet(animal_type, pet_name):
""" 显示宠物的信息 """
print("\nI have a " + animal_type + ".")
print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet(animal_type='hamster', pet_name='harry')

上述中: 明确地指出了各个实参对应的形参。

2.3 默认值

编写函数时，可给每个形参指定 默认值 。在调用函数中给形参提供了实参时， Python 将使用指定的实参值；否则，将使用形参的默认值。如：
def describe_pet(pet_name, animal_type='dog'):
其中这里修改了函数 describe_pet() 的定义，在其中给形参 animal_type 指定了默认值 'dog' 。这样，调用这个函数时，如果没有给 animal_type 指定值， Python 将把这个形参设置为 'dog'

2.4 等效的函数调用

鉴于可混合使用位置实参、关键字实参和默认值，通常有多种等效的函数调用方式。比如 def describe_pet(pet_name, animal_type='dog'):
上述中，在任何情况下都必须给 pet_name 提供实参；指定该实参时可以使用位置方式，也可以使用关键字方式。如果要描述的动物不是小狗，还必须在函数调用中给 animal_type 提供实参；同样，指定该实参时可以使用位置方式，也可以使用关键字方式。

3. 返回值

函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。函数返回的值被称为 返回值。
在函数中，可使用 return 语句将值返回到调用函数的代码行。返回值让你能够将程序的大部分繁重工作移到函数中去完成，从而简化主程序。

3.1 返回简单值

以下函数，它接受名和姓并返回整洁的姓名：
def get_formatted_name(first_name, last_name):
""" 返回整洁的姓名 """
full_name = first_name + ' ' + last_name
return full_name.title()
musician = get_formatted_name('jimi', 'hendrix')
print(musician)

3.2 让实参变成可选的

有时候，需要让实参变成可选的，这样使用函数的人就只需在必要时才提供额外的信息。可使用默认值来让实参变成可选的。

举例：扩展函数 get_formatted_name() ，使其还处理中间名。为此，可将其修改成类似于下面这样：
def get_formatted_name(first_name, middle_name, last_name):
""" 返回整洁的姓名 """
full_name = first_name + ' ' + middle_name + ' ' + last_name
return full_name.title()
musician = get_formatted_name('john', 'lee', 'hooker')
print(musician)

上述中，只要同时提供名、中间名和姓，这个函数就能正确地运行。然而，并非所有的人都有中间名，但如果你调用这个函数时只提供了名和姓，它将不能正确地运行。为让中间名变成可选的，可给实参 middle_name 指定一个默认值 —— 空字符串，并在用户没有提供中间名时不使用这个实参。

为让 get_formatted_name() 在没有提供中间名时依然可行，可给实参 middle_name 指定一个默认值 —— 空字符串，并将其移到形参列表的末尾：

def get_formatted_name(first_name, last_name, middle_name=''):
""" 返回整洁的姓名 """
if middle_name:
full_name = first_name + ' ' + middle_name + ' ' + last_name
else:
full_name = first_name + ' ' + last_name
return full_name.title()
musician = get_formatted_name('jimi', 'hendrix')
print(musician)

3.3 返回字典

函数可返回任何类型的值，包括列表和字典等较复杂的数据结构。如下：
def build_person(first_name, last_name):
""" 返回一个字典，其中包含有关一个人的信息 """
person = {'first': first_name, 'last': last_name}
return person
musician = build_person('jimi', 'hendrix')
print(musician)

3.4 结合使用函数和 while 循环

例如，下面将结合使用函数 get_formatted_name() 和 while 循环，以更正规的方式问候用户。
def get_formatted_name(first_name, last_name):
""" 返回整洁的姓名 """
full_name = first_name + ' ' + last_name
return full_name.title()
# 这是一个无限循环 !
while True:
print("\nPlease tell me your name:")
f_name = input("First name: ")
l_name = input("Last name: ")

formatted_name = get_formatted_name(f_name, l_name)
print("\nHello, " + formatted_name + "!")

上述这个 while 循环存在一个问题：没有定义退出条件。修改如下;

  def get_formatted_name(first_name, last_name):
  """ 返回整洁的姓名 """
    full_name = first_name + ' ' + last_name
    return full_name.title()
  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("\nHello, " + formatted_name + "!")

上述添加了一条消息来告诉用户如何退出，然后在每次提示用户输入时，都检查他输入的是否是退出值，如果是，就退出循环。

4.传递列表

向函数传递列表很有用，这种列表包含的可能是名字、数字或更复杂的对象（如字典）。将列表传递给函数后，函数就能直接访问其内容。
假设有一个用户列表，我们要问候其中的每位用户。即：

def greet_users(names):
""" 向列表中的每位用户都发出简单的问候 """
for name in names:
msg = "Hello, " + name.title() + "!"
print(msg)
usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)

4.1 在函数中修改列表

将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的，这让你能够高效地处理大量的数据。
例子：需要打印的设计存储在一个列表中，打印后移到另一个列表中。下面是在不使用函数的情况下模拟这个过程的代码：
# 首先创建一个列表，其中包含一些要打印的设计
unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']
completed_models = []
# 模拟打印每个设计，直到没有未打印的设计为止
# 打印每个设计后，都将其移到列表 completed_models 中
while unprinted_designs:
current_design = unprinted_designs.pop()
# 模拟根据设计制作 3D 打印模型的过程
print("Printing model: " + current_design)
completed_models.append(current_design)
# 显示打印好的所有模型
print("\nThe following models have been printed:")
for completed_model in completed_models:
print(completed_model)

为重新组织这些代码，我们可编写两个函数，每个都做一件具体的工作。大部分代码都与原来相同，只是效率更高。第一个函数将负责处理打印设计的工作，而第二个将概述打印了哪些设计：

  def print_models(unprinted_designs, completed_models):
  """
  模拟打印每个设计，直到没有未打印的设计为止
  打印每个设计后，都将其移到列表 completed_models 中
  """
  while unprinted_designs:
    current_design = unprinted_designs.pop()
    #  模拟根据设计制作 3D 打印模型的过程
    print("Printing model: " + current_design)
    completed_models.append(current_design)

  def show_completed_models(completed_models):
  """ 显示打印好的所有模型 """
  print("\nThe following models have been printed:")
  for completed_model in completed_models:
    print(completed_model)
  unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']
  completed_models = []

  print_models(unprinted_designs, completed_models)
  show_completed_models(completed_models)

4.2 禁止函数修改列表

有时候，需要禁止函数修改列表，为解决这个问题，可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。
要将列表的副本传递给函数，可以像下面这样做：
function_name(list_name[:]) 其中，切片表示法 [:] 创建列表的副本。

5. 传递任意数量的实参

Python 允许函数从调用语句中收集任意数量的实参。
下面的函数只有一个形参 toppings ，但不管调用语句提供了多少实参，这个
形参都将它们统统收入囊中：
def make_pizza(toppings):
""" 打印顾客点的所有配料 """
print(toppings)
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

形参名 *toppings 中的星号让 Python 创建一个名为 toppings 的空元组，并将收到的所有值都封装到这个元组中。

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

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。 Python 先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。
前面的函数还需要一个表示比萨尺寸的实参，必须将该形参放在形参 *toppings 的前面：

  def make_pizza(size, *toppings):
  """ 概述要制作的比萨 """
  print("\nMaking a " + str(size) +
        "-inch pizza with the following toppings:")
  for topping in toppings:
        print("- " + topping)
  make_pizza(16, 'pepperoni')
  make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

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

有时候，需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息。在这种情况下，可将函数编写成能够接受任意数量的键 — 值对 —— 调用语句提供了多少就接受多少。
在下面的示例中，函数 build_profile() 接受名和姓，同时还接受任意数量的关键字实参：
def build_profile(first, last, **user_info):
""" 创建一个字典，其中包含我们知道的有关用户的一切 """
profile = {}
profile['first_name'] = first
profile['last_name'] = last
for key, value in user_info.items():
profile[key] = value
return profile

6. 将函数存储在模块中

函数的优点之一是，使用它们可将代码块与主程序分离。通过给函数指定描述性名称，可让主程序容易理解得多。
可以更进一步，将函数存储在被称为 模块 的独立文件中，再将模块 导入 到主程序中。 import 语句允许在当前运行的程序文件中使用模块中的代码。
导入模块的方法有多种：

6.1 导入整个模块

要让函数是可导入的，得先创建模块。 模块 是扩展名为 .py 的文件，包含要导入到程序中的代码。
下面来创建一个包含函数 make_pizza() 的模块 pizza.py：

  def make_pizza(size, *toppings):
  """ 概述要制作的比萨 """
    print("\nMaking a " + str(size) +
        "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)
接下来，在某一文件导入刚创建的模块，再调用 make_pizza() 两次：
  import pizza
  pizza.make_pizza(16, 'pepperoni')
  pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

6.2 导入特定的函数

导入模块中的特定函数，这种导入方法的语法如下：from module_name import function_name
过用逗号分隔函数名，可根据需要从模块中导入任意数量的函数：
from module_name import function_0, function_1, function_2

对于前面的实例，如果只想导入要使用的函数，代码将类似于下面这样：
from pizza import make_pizza

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
若使用这种语法，调用函数时就无需使用句点。

6.3 使用 as 给函数指定别名

如果要导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的 别名 —— 函数的另一个名称。
下面给函数 make_pizza() 指定了别名 mp() 。这是在 import 语句中使用 make_pizza as mp 实现的，关键字 as 将函数重命名为你提供的别名：
from pizza import make_pizza as mp

mp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')
指定别名的通用语法如下：
from module_name import function_name as fn

6.4 使用 as 给模块指定别名

还可以给模块指定别名。通过给模块指定简短的别名（如给模块 pizza 指定别名 p ），让你能够更轻松地调用模块中的函数。相比于 pizza.make_pizza()
， p.make_pizza() 更为简洁：
import pizza as p

p.make_pizza(16, 'pepperoni')
p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
上述 import 语句给模块 pizza 指定了别名 p ，但该模块中所有函数的名称都没变。调用函数 make_pizza() 时，可编写代码 p.make_pizza() 而不是 pizza.make_pizza()

给模块指定别名的通用语法如下：
import module_name as mn

6.5 导入模块中的所有函数

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

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

7. 函数编写指南

编写函数时，需要牢记几个细节。应给函数指定描述性名称，且只在其中使用小写字母和下划线。给模块命名时也应遵循上述约定。