python基础

①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. 函数编写指南

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

你可能感兴趣的:(python基础)