image.png

前言

python是一种效率极高的语言：相比于众多其他的语言，使用python编写时，程序包含的代码行更少。python语法也也有助于创建整洁的代码：相比其他语言，使用python编写的代码更容易阅读、调试和扩展。

第一部分 基础知识

第1章 起步

1.1 搭建编程环境

• 安装python3
• 安装文本编辑器-Geany
  
  在终端会话中，可使用终端命令cd（表示切换目录，change directory）在系统中导航。命令ls（list）显示当前目录中所有未隐藏的文件。要列出当前目录中的所有文件，可使用命令dir（表示目录，directory）。
  注：编程语言对语法的要求非常严格，只要你没有严格遵守语法，就会出错。

第2章 变量和简单数据类型

2.1 运行hello_world.py时发生的情况

语法突出功能.png

运行hello_world.py，拓展名.py告诉编辑器，文件包含的是python程序，编辑器使用python解释器来运行它，python解释器读取整个程序，确定其中每个单词的含义。

2.2 变量

2.2.1 变量的命名和使用

有关变量的规则

• 变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头，但不能以数字打头。message_1 √，1_message ×。
• 变量名不能包含空格，但可以使用下划线来分割其中的单词。greeting_message √，greeting message ×。
• 不要将python关键字和函数名用作变量名。
• 变量名应既简短又具有描述性。
• 慎用小写字母l和大写字母O，易被看成数字1和0.
  （最好使用小写的python变量名。）

2.2.2 使用变量时避免命名错误

2.3 字符串

在python中，用引号括起来的都是字符串，单引号或双引号。
“This is a string.”
'This is a string.'
（灵活地在字符串中包含引号和撇号。）

2.3.1 使用方法修改字符串的大小写

name.py

name = "ada lovelace"
print(name.title())

Ada Lovelace

方法是python可对数据执行的操作。
name.title()，name后面的句点（.）让python对变量name执行方法title()指定的操作。
每个方法后面都跟着一对括号，因为方法通常需要额外的信息来完成其工作。这种信息是括号内提供的。函数title()不需要额外的信息，因此它后面的括号是空的。

name = "Ada Lovelace"
print(name.upper())
print(name.lower())

ADA LOVELACE
ada lovelace

• 方法.title()：首字母大写
• 方法.upper()：全部大写
• 方法.lower()：全部小写

2.3.2 合并（拼接）字符串

python使用加号（+）来合并字符串，这种合并字符串的方法称为拼接。

first_name = "ada"
last_name = "lovelace"
full_name = first_name + " " + last_name
print(full_name)

ada lovelace

e.g 1

first_name = "ada"
last_name = "lovelace"
full_name = first_name + " " + last_name
print("Hello, " + full_name.title() + "!")

e.g 2

first_name = "ada"
last_name = "lovelace"
full_name = first_name + " " + last_name
message = "Hello, " + full_name.title() +"!"
print(message)

2.3.3 使用制表符或换行符来添加空白

空白，泛指任何非打印字符，如空格、制表符和换行符
字符组合\t：在字符串中添加制表符

image.png

字符组合\n：在字符串中添加换行符

image.png

字符串\n\t：让python换到下一行，并在下一行开头添加制表符

image.png

2.3.4 删除空白

剥除函数
python能够找出字符串开头和末尾多余的空白。
对变量调用方法rstrip()，可暂时删除字符串末尾的空白。要永久删除字符串中的空白，必须将删除操作的结果存回变量中。

image.png
image.png

• 方法.rstrip()：删除字符串末尾的空白

• 方法.lstrip()：删除字符串开头的空白

• 方法.strip()：删除字符串两端的空白

  favorite_language = "python "
  favorite_language = favorite_language.rstrip()
  print(favorite_language)
  

2.3.5 使用字符串时避免语法错误

2.3.6 python2中的print语句

- END - 2019/3/22 20:24-23:32

2.4 数字

2.4.1 整数

** 表乘方运算

2.4.2 浮点数

python将带小数点的数字都称为浮点数。
注：结果包含的小数位数可能是不确定的

2.4.3 使用函数str()避免类型错误

函数str()，python将非字符串值表示为字符串。
birthday.py

age = 23
message = "Happy " + age + "rd Birthday!"
print(message)

类型错误

age = 23
message = "Happy " + str(age) + "rd Birthday!"
print(message)

2.4.4 python2中的整数

在python2中，整数除法的结果只包含整数部分，小数部分被删除。
注意：计算整数结果时，采取的方式不是四舍五入，而是直接将小数部分直接删除。
务必确保至少有一个操作数为浮点数。3.0/2

2.5 注释

添加说明，对你解决问题的方法进行大致的阐述。

2.5.1 如何编写注释

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

image.png
image.png
可正常执行.png

# -*- coding:utf-8 -*-

2.5.2该编写什么样的注释

编写注释的主要目的是阐述代码要做什么，以及是如何做到的。

2.6 python之禅

import this

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!

第3章 列表简介

3.1 列表是什么

列表由一系列按特定顺序排列的元素组成。（有序集合）元素之间可以没有任何关系。
鉴于列表通常包含多个元素，通常给列表指定一个表示复数的名称。
在python中，用方括号（[ ]）来表示列表，并用逗号来分隔其中的元素。

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

python将打印列表的内部表示，包括方括号：

image.png

- END - 2019/3/23 8:20-9:00

3.1.1 访问列表元素

要访问列表元素，可指出列表的名称，再指出元素的索引，并将其放在方括号内。

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

3.1.2 索引从0而不是1开始

在python中第一个列表元素的索引为0，而不是1。因此，要访问列表的任何元素，都可将其位置减1，并将结果作为索引。
最后一个列表元素，索引号为-1.
索引-2返回倒数第二个列表元素，索引-3返回倒数第三个列表元素。

31.3 使用列表中的各个值

3.2 修改、添加和删除元素

3.2.1 修改列表元素

修改列表元素的语法与访问列表元素的语法类似。要修改列表元素，可指定列表名和要修改的元素和索引，再指定该元素的新值。

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

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

3.2.2 在列表中添加元素

1.在列表末尾添加元素

使用方法append()将元素附加到列表末尾.

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

motorcycles.append('ducati')
print(motorcycles)

创建一个空列表，再使用一系列的append（）语句添加元素。

motorcycles = []

motorcycles.append('honda')
motorcycles.append('yamaha')
motorcycles.append('suzuki')

print(motorcycles)

2.在列表中插入元素

使用方法insert()可在列表的任何位置添加新元素。需要指定新元素的索引和值。这种操作将列表中既有的每个元素都右移一个位置。

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

motorcycles.insert(0,'ducati')
print(motorcycles)

3.2.3 在列表中删除元素

1.使用del语句删除元素

使用del可删除任何位置处的列表元素，条件是知道其索引。

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

del motorcycles[0]
print(motorcycles)

2.使用方法pop()删除元素

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

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

popped_motorcycle = motorcycles.pop()
print(motorcycles)
print(popped_motorcycle)

3.弹出列表中任何位置处的元素

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

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

first_owned = motorcycles.pop(0)
print("The first motorcycle I owned was a " + first_owned.title() + ".")

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

4.根据值删除元素

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

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

too_expensive = 'ducati'
motorcycles.remove(too_expensive)
print(motorcycles)
print("\nA " + too_expensive.title() + " is too expensive for me.")

注：方法remove()只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。

3.3 组织列表

3.3.1 使用方法sort()对列表进行永久性排序

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

image.png

方法sort()永久性的修改了元素的排列顺序，无法恢复到原来的排列顺序。
还可以按与字母顺序相反的顺序排列列表元素，只需向sort()方法传递参数reverse=True.

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

image.png

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

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

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

print("Here is the original list:")
print(cars)

print("Here is the sorted list:")
print(sorted(cars))

print("\nHere is the original list again:")
print(cars)

image.png

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

print(sorted(cars,reverse=True))

注意：在并非所有的值都是小写时，按字母顺序排列列表要复杂些。决定排列顺序时，有多种解读大写字母的方式，要指定准确的排列顺序，可能比我们这里所做的要复杂。

3.3.3 倒着打印列表

要反转列表元素的排列顺序，可使用方法reverse()。

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

cars.reverse()
print(cars)

image.png

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

3.3.4 确定列表的长度

使用函数len()可快速获悉列表的长度。
python计算列表元素数时从1开始。

练习.png

3.4 使用列表时避免索引错误

第4章 操作列表

4.1 遍历整个列表

需要对列表中的每个元素都执行相同的操作时，可使用python中的for循环。

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

4.1.1 深入地研究循环

编写for循环时，对于用于存储列表中每个值的临时变量，可指定任何名称。然而，选择描述单个列表元素的有意义的名称大有帮助。（命名约定）
使用单数和复数式名称，可帮助你判断代码段处理的是单个列表元素还是整个列表。

4.1.2 在for循环中执行更多的操作

magicians = ['alice','david','carolina']
for magician in magicians:
    print( magician.title() + ", that was a great trick!")
    print("I can't wait to see your next trick, " + magician.title() + ".\n")

4.1.3 在for循环结束后执行一些操作

在for循环后面，没有缩进的代码都只执行一次，而不会重复执行。

4.2 避免缩进错误

python根据缩进来判断代码行与前一个代码行的关系。

4.2.1 忘记缩进

4.2.2 忘记缩进额外的代码行

逻辑错误

4.2.3 不必要的缩进

4.2.4 循环后不必要的缩进

4.2.5 遗漏了冒号

for语句末尾的冒号告诉python，下一行是循环的第一行。

4.3 创建数字列表

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

4.3.1 使用函数range()

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

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

image.png

差一行为
要打印数字1~5，需要使用range(1,6)
要打印数字1~4，需要使用range(1,5)

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

要创建数字列表，可使用函数list()将range()的结果直接转换为列表。将range()作为list()的参数，输出将是一个数字列表。

numbers = list(range(1,6))
print(numbers)

[1,2,3,4,5]
使用函数range()时，还可指定步长。
e.g打印1~10内的偶数

even_numbers = list(range(2,11,2))
print(even_numbers)

[2,4,6,8,10]
e.g打印1~10的平方数

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

另一种方式

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

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

image.png

专门用于处理数字列表的python函数
min()
max()
sum()

4.3.4 列表解析

列表解析将for循环和创建新元素的代码合并成一行，并自动附加新元素。

squares = [value**2 for value in range(1,11)]
print(squares)

首先指定一个描述性的列表名，如squares,指定一个左方括号，并定义一个表达式，用于生成你要存储到列表中的值，本例表达式为value**2，然后编写一个for循环，用于给表达式提供值，再加上右方括号。本例for循环为for value in range(1,11),将值1~10提供给表达式.
注意：这里的for语句末尾没有冒号。

4.4 使用列表的一部分

列表的部分元素，python称为切片。

4.4.1 切片

要创建切片，可指定要使用的第一个元素的索引和最后一个元素的索引加1.
如，要输出列表中的前三个元素，需要指定索引0~3，将输出分别为0、1和2的元素。

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

image.png

如果没有指定第一个索引，python将自动从列表开头开始，末尾类似。

players = ['charles','martina','michael','florence','eli']
print(players[:4])
print(players[2:])
print(players[-3:])

负数索引返回里列表末尾相应距离的元素，因此可输出列表末尾的任何切片。

4.4.2 遍历切片

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

players = ['charles','martina','michael','florence','eli']
print("Here are the first three players on my team:")
for player in players[:3]:
     print(player.title())

4.4.3 复制列表

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

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

print("My favortie foods are:")
print(my_foods)

print("\nMy friend's foods are:")
print(friend_foods)

两个列表

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)

4.5 元组

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的。python将不能修改 的值称为不可变的，而不可变的列表被称为元组。

4.5.1 定义元组

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

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

4.5.2 遍历元组中的所有值

for循环

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

4.5.3 修改元组变量

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

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

dimensions = (400,100)
print("\nModified dimensions:")
for dimension in dimensions:
    print(dimension)

相比于列表，元组是更简单的数据结构。

4.6 设置代码格式

代码格式设置约定

4.6.1 格式设置约定

4.6.2 缩进

建议每级缩进都使用四个空格，使用制表符来缩进

4.6.3 行长

• 建议每行不超过80字符
• 注释的行长都不超过72字符

4.6.4 空行

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

4.6.5 其他格式设置指南

python改进提案 PEP8
- END- 2019/3/23 16:15-21:17

第5章 if语句

5.1 一个简单示例

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

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

5.2 条件测试

每条if语句的核心都是一个值为True或False的表达式，这种表达式被称为条件测试。python根据条件测试的值为True还是False来决定是否执行if语句中的代码。如果条件测试的值为True，python就执行紧跟在if语句后面的代码；如果为False，python就忽略这些代码。

5.2.1 检查是否相等

相等运算符==

5.2.2 检查是否相等时不考虑大小写

在python中检查是否相等时区分大小写。例如，两个大小写不同的值会被视为不相等：

image.png
image.png

5.2.3 检查是否不相等（!=）

requested_topping = 'mushrooms'
if requested_topping != 'anchovies':
    print("Hold the anchovies.")

5.2.4 比较数字

answer = 17
if anser != 42:
    print("That is not the correct answer.Please try again!")

5.2.5 检查多个条件

关键字and和or

1.使用and检查多个条件

age_0 = 22
age_1 = 18
(age_0 >= 21) and (age_1 >=21)

2.使用or检查多个条件

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

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

image.png

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

关键字not in

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

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

5.2.8 布尔表达式

布尔值通常用于记录条件。

5.3 if语句

if语句有很多种，选择使用哪种取决于要测试的条件数。

5.3.1 简单的if语句

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

if conditional_test:
    do something

示例

age = 19
if age >= 18:
    print("You are old enough to vote!")
    print("Have you registered to vote yet?')

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

5.3.3 if-elif-else结构

需要检查超过两个的情形。
python只执行if-elif-else结构中的一个代码块，它依次检查每个条件测试，直到遇到通过了的条件测试。测试通过后，python将执行紧跟在它后面的代码，并跳过余下的测试。

age = 12

if age < 4:
    print("Your admission cost is $0.")
elif age < 18:
    print("Your admission cost is $5.")
else:
    print("Your admission cost is $10.")

为让代码更简洁，可不在if-elif-else代码块中打印门票价格，而只在其中设置门票价格。

age = 12

if age < 4:
   price = 0
elif age < 18:
    price = 5
else:
    price = 10

print("Your admission cost is $" + str(price) + ".")

5.3.4 使用多个elif代码块

age = 12

if age < 4:
   price = 0
elif age < 18:
    price = 5
elif age < 65:
    price = 10
else:
    price = 5

print("Your admission cost is $" + str(price) + ".")

5.3.5 省略else代码块

python并不要求if-elif结构厚必须有else代码块。

age = 12

if age < 4:
   price = 0
elif age < 18:
    price = 5
elif age < 65:
    price = 10
elif age >= 65:
    price = 5

print("Your admission cost is $" + str(price) + ".")

5.3.6 测试多个条件

if-elif-else结构功能强大，但仅适合用于只有一个条件满足的情况：遇到通过了的测试后，python就跳过余下的测试。然而，有时候必须检查你关心的所有条件。在这种情况下，应使用一系列不包含elif和else代码块的简单if语句。

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

if 'mushrooms' in requested_toppings:
    print("Adding mushrooms.")
if 'pepperoni' in requested_toppings:
    print("Adding pepperoni")
if 'extra cheese' in requested_toppings:
    print("Adding extra cheese.")

print("\nFinished making your pizza.")

5.4 使用if语句来处理列表

5.4.1 检查特殊元素

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("Adding " + requested_topping + ".")

print("\nFinished making your pizza!")

5.4.2 确保列表不是空的

requested_toppings = []

if requested_toppings:
  for requested_topping in requested_toppings:
      print("Adding " + requested_topping + ".")
  print("\nFinished making your pizza.")
else:
  print("Are you sure you want a plain pizza?")

在if语句中将列表名用在条件表达式中时，python将在列表至少包含1个元素时返回True，并在列表为空时返回False。

5.4.3 使用多个列表

available_toppings = ['mushrooms','olives','green peppers',
                  'pepperoni','pineapple','extra cheese']
requested_toppings = ['mushrooms','french fries','extra cheese']

for requested_topping in requested_toppings:
    if requested_topping in available_toppings:
        print("Adding " + requested_topping + ".")
    else:
        print("Sorry, we don't have " + requested_topping + ".")

print("\nFinished making your pizza!")

5.5 设置if语句的格式

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

第6章 字典

字典可存储的信息量几乎不受限制.
学习存储字典的列表、存储列表的字典和存储字典的字典。
理解字典后，你就能更准确的为各种真实物体建模。

6.1 一个简单的字典

字典用放在花括号{ }中的一系列键-值对表示。键和值之间用冒号分隔，而键-值对之间用逗号分隔。

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

print(alien_0['color'])
print(alien_0['points'])

6.2 使用字典

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

6.2.1 访问字典中的值

要获取与键相关联的值，可依次指定字典名和放在方括号内的键。

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

new_points = alien_0['points']
print("You just earned " + str(new_points) + " points.")

6.2.2 添加键-值对

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

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

alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)

注意：键-值对的排列顺序和添加顺序不同。python不关心键值对的添加顺序，而只关心键和值之间的关联顺序。

6.2.3 先创建一个空字典

alien_0 = {}

alien_0['color'] = 'green'
alien_0['points'] = 5

print(alien_0)

6.2.4 修改字典中的值

要修改字典中的值，可依次指定字典名、用方括号括起来的键以及与该键相关联的新值。

alien_0 = {'color':'green'}
print("The alien is " + alien_0['color'] + ".")

alien_0['color'] = 'yellow'
print("The alien is now " + alien_0['color'] + ".")

另一例子

# -*- coding:utf-8 -*-
alien_0 = {'x_position':0,'y_positon':25,'speed':'medium'}
print("Original x_position: " + str(alien_0['x_position']))

# 向右移动外星人
# 据外星人当前速度决定将其移动多远
if alien_0['speed'] == 'slow':
    x_increment = 1
elif alien_0['speed'] == 'medium':
    x_increment = 2
else:
    # 这个外星人的速度一定很快
    x_increment = 3

# 新位置等于老位置加上增量
alien_0['x_position'] = alien_0['x_position'] + x_increment
print("New x_position: " + str(alien_0['x_position']))

6.2.5 删除键-值对

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

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

del alien_0['points']
print(alien_0)

6.2.6 由类似对象组成的字典

前面的示例中，字典存储的是一个对象（游戏中的一个外星人）的多种信息，但你也可以使用字典来存储众多对象的同一种信息。

favorite_languages = {
    'jen':'python',
    'sarah':'C',
    'edward':'ruby',
    'phil':'python',
    #在最后一个键值对后面加上逗号，为以后在下一行添加键值对做好准备
    }

print("sarah's favorite language is " + 
    favorite_languages['sarah'].title() +
    ".")

6.3 遍历字典

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

6.3.1 遍历所有的键-值对

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

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

要编写用于遍历字典的for循环，可声明两个变量，用于存储键-值对中的键和值。对于这两个变量，可使用任何名称。
方法items()

for k,v in user_0.items()

注意：即使遍历字典时，键-值对的返回顺序也与存储顺序不同。python不关心键-值对的存储顺序，而只跟踪键和值之间的关联关系。

6.3.2 遍历字典中的所有键

在不需要使用字典中的值时，方法keys()很有用。

for name in favorite_languages.keys():
    print(name.title())

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

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

for name in sorted(favorite_languages.keys()):

6.3.4 遍历字典中的所有值

使用方法values()，返回一个值列表，而不包含任何键。

for language in favorite_languages.values():

为剔除重复项，可使用集合（set）。集合类似于列表，但每个元素都必须是独一无二的。

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

6.4 嵌套

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

6.4.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]

for alien in aliens:
    print(alien)

使用rang()生成30个外星人。

# -*- coding:utf-8 -*-
# 创建一个用于储存外星人的空列表
aliens = []

# 创建30个绿色的外星人
for alien_number in range(30):
    new_alien = {'color':'green','points':5,'speed':'slow'}
    aliens.append(new_alien)

# 显示前5个外星人
for alien in aliens[:5]:
    print(alien)
print("...")

# 显示创建了多少个外星人
print("Total number of aliens: " + str(len(aliens)))

range()返回一系列数字，其唯一的用途是告诉python我们要重复这个循环多少次。

# 创建一个用于存储外星人的空列表
aliens = []

# 创建30个绿色的外星人
for alien_number in range(0,30):
new_alien = {'color':'green','points':5,'speed':'slow'}
aliens.append(new_alien)

for alien in aliens[0:3]:
    if alien['color'] == 'green':
        alien['color'] = 'yellow'
        alien['points'] = 10
        alien['speed'] = 'medium'

# 显示前五个外星人
for alien in aliens[0:5]:
    print(alien)

print("...")

6.4.2 在字典中存储列表

每当需要在字典中将一个键关联到多个值时，都可以在字典中嵌套一个列表。

# 存储所点比萨的信息
pizza = {
    'crust':'thick',
    'toppings':['mushrooms','extra cheese'],
    }
# 概述所点的比萨
print("You ordered a " + pizza['crust'] + "-crust pizza " +
    "with the following toppings:")

for topping in pizza['toppings']:
    print("\t" + topping)

示例

favorite_languages = {
    'jen':['python','ruby'],
    'sarah':['c'],
    'edward':['ruby','go'],
    'phil':['python','haskell'],
    }

for name,languages in favortie_languages.items():
    print("\n" + name.title() + "'s favorite languages are:")
    for language in languages:
        print("\t" + language.title())

6.4.3 在字典中存储字典

users = {
    'aeinstein':{
        'first':'albert',
        'last':'einstein',
        'location':'princeton',
        },
    'mcurie':{
        'first':'marie',
        'last':'curie',
        'location':'paris',
        },
    }

for username,user_info in users.items():
    print("\nUsername: " + username)
    full_name = user_info['first'] + " " + user_info['last']
    location = user_info['location']

print("\tFull name: " + full_name.title())
print("\tLocation: " + location.title())

第7章 用户输入和while循环

7.1 函数input() 的工作原理

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

函数input()接受一个参数：即要向用户显示的提示或说明，让用户知道该如何做。

7.1.1 编写清晰的程序

使用函数input()时，应指定清晰而易于明白的提示。
创建多行字符串的方式
有时候提示可能超过一行，在这种情况下，可将提示存储在一个变量中，再将该变量传递给函数input()。

prompt = "If you tell us who you are, we can personalize the   message you see."
prompt += "\nWhat is your first name?"

name = input(prompt)
print("\nHello, " + name + "!") 

7.1.2 使用int()来获取数值的输入

使用函数input()时，python将用户输入解读为字符串。
使用函数int()，python将输入视为数值。函数int()将数字的字符串表示转换为数值表示。

image.png

将数值输入用于计算和比较前，务必将其转换为数值表示。

height = input("How tall are you, in inches?")
height = int(height)

if height >= 36:
    print("\nYou're tall enough to ride!")
else:
    print("\nYou'll be able to ride when you're little older.")

7.1.3 求模运算符

求模运算符（%），将两个数相除并返回余数。
如果一个数可被另一个数整除，余数就为0，因此求模运算符将返回0.可利用这一点来判断一个数是奇数还是偶数。

number = input("Enter a number, and I'll tell you if it's ever or odd:")
number = int(number)

if number % 2 ==0:
    print("\nThe number " + str(number) + " is even.")
else:
    print("\nThe number " + str(number) + " is odd.")

7.1.4 在python2.7中获取输入

用函数raw_input()来提示用户输入

7.2 while循环简介

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

7.2.1 使用while循环

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

7.2.2 让用户选择何时推出

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)

创建一个变量message用于存储用户输入的值。将变量message的初始值设置为空字符串“”，让python首次执行while循环代码行时有可供检查的东西。

7.2.3 使用标志

在要求很多条件都满足才继续运行的程序中，可定义一个变量，用于判断整个程序是否处于活动状态。这个变量被称为标志。
可让程序在标志为True时继续运行，并在任何事件导致标志的值为False时让程序停止运行。
（while语句中只需检查一个条件——标志的当前值是否为True）
在程序中添加一个标志，标志命名可指定任何名称。

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)

标志很有用：在其中的任何一个事件导致活动标志变成False时，主游戏循环将退出。

7.2.4 使用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("I'd love to go to " + city.title() + "!")

注意：在任何python循环中都可使用break语句。

7.2.5 在循环中使用continue

要返回到循环开头，并根据条件测试结果决定是否继续执行循环，可使用continue语句。

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

如果结果为0，就执行continue语句，让python忽略余下的代码，并返回到循环开头。

image.png

7.2.6 避免无限循环

如果程序陷入无限循环，可按ctrl+C，也可关闭显示程序输出的终端窗口。

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

for循环是一种遍历列表的有效方式，但在for循环中不应修改列表，否则将导致python难以跟踪其中的元素。要在遍历列表的同时对其进行修改，可使用while循环。

7.3.1 在列表之间移动元素

# -*- coding:utf-8 -*-
# 首先，创建一个待验证用户列表
# 和一个用于存储已验证用户的列表
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())

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

方法remove（）

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

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

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

# -*- coding:utf-8 -*-
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 you like to climb " + response + ".")

- END - 2019/3/24

第8章 函数

函数是带名字的代码块，用于完成具体的工作。要执行函数定义的特定任务，可调用该函数。

8.1 定义函数

# -*- coding:utf-8 -*-
def greet_user():
    """显示简单的问候语"""
    print("Hello!")

greet_user()

File "greeter4.py", line 3
SyntaxError: (unicode error) 'utf-8' codec can't decode byte 0xcf in position 0: invalid continuation byte

# -*- coding:GBK -*-
def greet_user():
    """显示简单的问候语"""
    print("Hello!")

greet_user()

竟然可以用了。

使用关键字def来告诉python你要定义一个函数。函数定义，向python指出了函数名，还可能在括号内指出函数为完成其任务需要什么样的信息。定义以冒号结尾。
紧跟在def greet_user():后面的所有缩进构成了函数体。"""显示简单的问候语"""是文档字符串的注释。文档字符串用三引号括起，python使用它们来生成有关程序中函数的文档。
函数调用让python执行函数的代码，要调用函数，可依次指定函数名以及用括号括起的必要信息。

8.1.1 向函数传递信息

# -*- coding:gbk -*-
def greet_user(username):
    """显示简单的问候语"""
    print("Hello, " + username.title() + "!")

greet_user('jesse')

在函数定义def greet_user()的括号内添加username，就可让函数接受你给username指定的任何值。
代码greet_uer('jesse')调用函数greet_user()，并向它提供执行print语句所需的信息。

实参和形参

在函数greet_user()的定义中，变量username是一个形参——函数完成其工作所需的一项信息。在代码greet_user('jesse')中，值'jesse'是一个实参。实参是调用函数时传递给函数的信息。我们调用函数时，将要让函数使用的信息放在括号内。在greet_user('jesse')中，将实参'jesse'传递给了函数greet_user()，这个值被存储在形参username中。

8.2 传递实参

函数定义中可能包含多个形参，因此函数调用中也可能包含多个实参。向函数传递实参的方式很多：位置实参，要求实参的顺序与形参的顺序相同；关键字实参，其中每个实参都由变量名和值组成，还可使用列表和字典。
- END - 2019/3/25 21:40-22:32

8.2.1 位置实参

调用函数时，python必须将函数调用中的每个实参都关联到函数定义中的一个形参。最简单的关联方式是基于实参的顺序，这种关联方式被称为位置实参。

# -*- coding:GBK -*-
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')

1.调用函数多次

在函数中，可根据需要使用任意数量的位置实参，python将按顺序将函数调用中的实参关联到函数定义中相应的形参。

2.位置实参的顺序很重要

8.2.2 关键字实参

关键字实参是传递给函数的名称-值对。直接在实参中将名称和值关联起来，关键字实参让你无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。

describe_pet(pet_name='harry',animal_type='hamster')

关键字实参的顺序无关紧要，python知道各个值该存储到哪个形参中。
注意：使用关键字实参时，务必准确地指定函数定义中的形参名。

8.2.3 默认值

编写函数时，可给每个形参指定默认值。在调用函数中，给形参提供了实参时，python将使用指定的实参值；否则，将使用形参的默认值。使用默认值可简化函数调用。

# -*- coding:GBK -*-
def describe_pet(pet_name,animal_type='dog'):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")

describe_pet('wille')
describe_pet(pet_name='wille')
describe_pet(pet_name='harry',animal_type='hamster')

注意：使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的形参。这让python依然能够正确地解读位置实参。

8.2.4 等效的函数调用

def describe_pet(pet_name,animal_type='dog'):

示例

# 一条名为willie的小狗
describe_pet('willie')
describe_pet(pet_name='willie')

#一只名为harry的仓鼠
describe_pet('harry','hamster')
describe_pet(pet_name='harry',animal_type='hamster')
describe_pet(animal_type='hamster',pet_name='harry')

8.2.5 避免实参错误

8.3 返回值

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

8.3.1 返回简单值

# -*- coding:GBK -*-
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)

调用返回值的函数时，需要提供一个变量（musician），用于存储返回的值。

8.3.2 让实参变成可选的

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

# -*- coding:GBK -*-
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)

musician = get_formatted_name('john','hooker','lee')
print(musician)

在函数体中，检查是否提供了中间名，python将非空字符串解读为True。

8.3.3 返回字典

函数可返回任何类型的值，包括列表和字典等较复杂的数据结构。

# -*- coding:GBK -*-
def build_person(first_name,last_name):
    """返回一个字典，其中包含有关一个人的信息"""
    person = {'first':first_name,'last':last_name}
    return person

musician = build_person('jimi','hendrix')
print(musician)

例二

# -*- coding:GBK -*-
def build_person(first_name,last_name,age=''):
    """返回一个字典，其中包含有关一个人的信息"""
    person = {'first':first_name,'last':last_name}
    if age:
        person['age'] = age
    return person

musician = build_person('jimi','hendrix',age=27)
print(musician)

新增可选形参，并将其默认值设置为空字符串

8.3.4 结合使用函数和while循环

- END - 2019/3/26 18:55-21:08

# -*- coding:GBK -*-
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 + "!")

定义退出条件

 # -*- coding:GBK -*-
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 + "!")

8.4 传递列表

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

8.4.1 在函数中修改列表

将列表传递给函数后，函数就可以对其进行修改。在函数中对这个列表所做的任何修改都是永久性的，这让你能够高效地处理大量的数据。

# -*- coding:gbk -*-
# 首先创建一个列表，其中包含一些要打印的设计
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)

编写函数

# -*- coding:gbk -*-
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)

每个函数都应只负责一项具体的工作

8.4.2 禁止函数修改列表

有时候，需要禁止函数修改列表。可向函数传递列表的副本而不是原件，这样函数所做的任何修改都只影响副本，而丝毫不影响原件。

print_models(unprinted_designs[:],completed_models)

虽然向函数传递列表的副本可保留原始列表的内容，但除非有充分的理由需要传递副本，否则还是应该将原始列表传递给函数，因为让函数使用现成列表可避免花时间和内存创建副本，从而提高效率，在处理大型列表时尤其如此。

8.5 传递任意数量的实参

# -*- coding:gbk -*-
def make_pizza(*toppings):
    """打印顾客点的所有配料"""
    print(toppings)

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

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

# -*- coding:gbk -*-
def make_pizza(*toppings):
    """概述要制作的比萨"""
    print("\nMaking a pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)

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

- END - 2019/3/27 23:27

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

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。

# -*- coding:gbk -*-
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')

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

# -*- coding:gbk -*-
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

user_profile = build_profile('albert','einstein',
                        location='princeton',
                        field='physics')
print(user_profile)

形参**user_info中的两个星号让python创建一个名为user_info的空字典，并将收到的所有名称-值对都封装到这个字典中。

8.6 将函数存储在模块中

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

通过将函数存储在独立的文件中，可隐藏程序代码的细节，将重点放在程序的高层逻辑上。这还能让你在众多不同的程序中重用函数。将函数存储在独立文件中后，可与其他程序员共用这些文件而不是整个程序。知道如何导入函数还能让你使用其他程序员编写的函数库。

8.6.1 导入整个模块

要让函数是可导入的，得先创建模块。模块是扩展名为.py的文件，包含要导入到程序中的代码。
pizza4.py

# -*- coding:gbk -*-
def make_pizza(size,*toppings):
    """概述要制作的比萨"""
    print("\nMaking a " + str(size) +
    "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)

pizza4.py

# -*- coding:gbk -*-
import pizza4

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

python读取这个文件时，代码行import pizza4让python打开文件pizza4.py，并将其中的所有函数都复制到这个程序中。
语法：

module_name.function_name()

8.6.2 导入特定的函数

导入模块中的特定函数

 from module_name import function_name

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

from module_name import function_0,function_1,function_2

前一示例

from pizza4 import make_pizza

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

若使用这种方法，调用函数时就无需使用句点。由于我们在import语句中显式地导入了函数make_pizza(),因此调用它时只需指定其名称。

8.6.3 使用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

8.6.4 使用as给模块指定别名

import pizza as p

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

给模块指定别名的通用语法：

import module_name as mn

8.6.5 导入模块中的所有函数

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

from pizza import *

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

由于导入了每个函数，可通过名称来调用每个函数，而无需使用句点表示法。然而，使用并非自己编写的大型模块时，最好不要采用这种导入方法：如果模块中有函数的名称与你的项目中使用的名称相同，可能导致意想不到的结果：python可能遇到多个名称相同的函数或变量，进而覆盖函数，而不是分别导入所有的函数。
最佳的做法是，要么只导入你需要使用的函数，要么导入整个模块并使用句点表示法。这让代码更清晰，更容易阅读和理解。

8.7 函数编写指南

编写函数时，需要牢记几个细节。

• 应给函数指定描述性名称，且只在其中使用小写字母和下划线。（给模块命名时同理）

• 每个函数都应包含简要地阐述其功能的注释，该注释应紧跟在函数定义后面，并采用文档字符串格式。

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

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

• PEP8建议代码行的长度不要超过79字符，这样只要编辑器窗口适中，就能看到整行代码。如果形参很多，导致函数定义的长度超过了79字符，可在函数定义中输入左括号后按回车键，并在下一行按两次Tab键，从而将形参列表和只缩进一层的函数体区分开来。大多数编辑器都会自动对齐后续参数列表行，使其缩进程度与你给第一个参数列表行指定的缩进程度相同。

  def function_name(
        parameter_0,parameter_1,parameter_2,
        parameter_3,parameter_4,parameter_5):
     function body...
  

• 如果程序或模块包含多个函数，可使用两个空行将相邻的函数分开，这样将更容易知道前一个函数在什么地方结束，下一个函数从什么地方开始。

• 所有的import语句都应放在文件开头，唯一例外的情形是，在文件开头使用了注释来描述整个程序。
  - END - 2019/3/28 22:14
  - END - 2019/3/29-3/30 14:57 复习巩固前8章内容