Python 基础入门大合集，新手小白必看！

Python 入门

一、第一个 Python 程序

>>> print("Hello world!")

二、变量和简单数据类型

>>> message = "Hello Python intepreter!"
>>> print(message)
>>> message = "Hello Python intepreter again!"
>>> print(message)

第一段代码就是将字符串Hello Python intepreter！存入一个名为message的变量中，即变量message的值为Hello Python intepreter!。变量的值时可以根据需求改变的，比如第三行代码的重新赋值。

Python变量命名规则：

• 变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为message_1，但不能将其命名为1_message。

• 变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greeting message会引发错误。

• 不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词（即保留字），如print 。

• 变量名应既简短又具有描述性。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。

• 慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0。

注意：

• Python是大小写敏感的，即Name和name是两个不同的变量名。

• 在使用变量时要注意变量名的拼写，拼写错误会引发程序的错误。

2.1 字符串

在Python中字符串有两种表示法，即用双引号或单引号包裹，如：

"This a string."
'This is a string, too.'

这两种表示法并无太大区别，似乎有些鸡肋；但是如果字符串本身就包含"或'符号时，这种表示法的优越性就体现出来了。如：

'He says:"Python is a great language.".'
"I'm iron man!"

如果一个字符串中既有单引号还有双引号的话那么就只能用\(反斜杠)来转义了。如：

'I\'m iron man'
"He says:\"Python is a great language.\"."

2.1.1 修改字符串大小写的一些操作

例如如下代码：

name = "Chinese Academy of Sciences"
print(name.title())
print(name.upper())
print(name.lower())

运行之后会有如下结果：

Chinese Academy Of Sciences #所有单词首字母都变为大写
CHINESE ACADEMY OF SCIENCES #所有单词的所有字母都变为大写
chinese academy of sciences #所有单词的所有字母都变为小写

上述代码中变量名后面的.是让Python解释器对变量进行后面的xx()的操作，这些操作都是临时的并不会真正改变变量的值。

2.1.2 字符串的拼接

有时我们需要将两个字符串拼接在一起，比如将一个人的姓和名组合成全名。如：

first_name = "Barry"
last_name = "Allen"
full_name = first_name + " " +last_name #" "表示由一个空格构成的字符串
print(full_name)

所以可以看出，Python是用+来拼接字符串的。（这真是太人性化了）

2.1.3 输出时的换行与缩进

如果有一个很长的字符串，在输出的时候为了输出结果看起来更美观，需要用到换行和缩进，这又该怎么实现呢？

print("Programing Languages:\n\tPython\n\tC\t\nJava")

输出结果：

Programing Languanges:
 Python
 C
 Java

这样我们就实现了换行和缩进，通过观察我们可以发现\n即表示换行，相当于按下回车换行；而\t实际上相当于键盘上的制表符Tab，按下相当于输入四个空格。

2.1.4 剔除字符串中冗余的空格

"python "、" python"和" python "这三个字符串对于我们人来说除了开头或结尾多了空格之外就没了任何区别，而且空格还是多于的，所以该怎么消除呢？例：

favorite_language = " Python "
print(favorite_language.rstrip()) #剔除字符串末尾空格
print(favorite_language.lstrip()) #剔除字符串开头空格
print(favorite_language.strip()) #剔除字符串两端空格

值得注意的是，这里剔除的是所有空格，并不仅仅是一个。

2.2 数字

2.2.1 整数

和字符串一样，数字也可以赋值给变量，如：

integer_number = 100

既然有了整数，就引出了四则运算。比如在交互式编程模式中有：

>>> 1 + 2 #加
3
>>> 2 - 3 #减
-1
>>> 3 * 8 #乘
24
>>> 3 / 2 #除
1.5
>>> 2 ** 3 #乘方
8
>>> 8 % 3 #取模（求余数）
2

2.2.2 浮点数

浮点数基本和整数类似，但须注意浮点数参与计算后小数点后的位数可能是不确定的。如：

>>> 0.2 + 0.1
0.30000000000000004
>>> 3 * 0.1
0.30000000000000004

2.2.3 str()函数的使用

之前我们了解过字符串的拼接，但是下列代码在运行时会报错。

age = 18
print("Happy" + age + "th Birthday！")

其原因是，拼接只能是字符串与字符串的拼接，而这里的age是一个整数变量，二者的数据类型不同；不是字符串自然就会因为无法拼接而产生错误。那怎么解决这个问题呢？把整数类型转化成字符串类型就好了呀！如：

age = 18
print("Happy" + str(age) + "th Birthday！")

这里的str()是一个类型转换函数，可以将非字符串类型转化为字符串类型；括号里放的就是需要转化的对象。

2.3 注释

代码终究不是自然语言，将自己的想法转化成代码或许相对较为容易，但是如果是通过阅读代码理解其中的想法却是一件特别难的事情。所以，为了方便代码的阅读和理解，可以在代码的旁边写上注释对代码进行解释和说明。有时好的注释甚至比好的代码更重要，比如某人想出了一个绝妙的算法，区区几行代码就能解决一个复杂问题，但由于算法过于精妙思维跳跃过大，如果不提前了解算法就很难看懂代码；如果代码旁边又没有注释，那该是一件多么令人伤心的事情。

Python中注释有两种，一种是单行注释，另一种是多行注释。表示方法如下：

#这是单行注释，以井号#开头
"""这是多行注释
这是多行注释
这是多行注释
由前后三个引号包裹（单双均可，但要前后一致且不能混用）
"""

2.4 Python之禅

在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.1 列表是什么

列表是由一系列按特定顺序排列的元素组成的整体，组成列表的元素可以是字母、数字和字符串。列表中的元素是按需添加的，没有任何的条件限制，一个列表内的元素并不一定要完全相同。在Python中用方括号[]来表示列表，用逗号,分隔开其中的各个元素。如：

arbitray = [123, "string"]
fruits = ["Avocado", "Grapefruit", "Peach"]

创建好想要的列表后，可以试着输出列表，看看列表是怎么输出的。例：print(fruits)。

3.1.1 访问列表元素

如果我仅仅需要引用列表中的某一个元素，该怎么办呢？例：

fruits = ["Avocado", "Grapefruit", "Peach"]
print(fruits[0])
print(fruits[1])
print(fruits[2])

由此可见，想要引用列表中某一个元素只需在列表称后面加上方括号再填上对应的数字即可。但是需要注意的是，列表中元素的序号是从0开始的，即0号元素就是第一个元素。

除此之外，Python还可以倒序引用元素：

fruits = ["Avocado", "Grapefruit", "Peach"]
print(fruits[-1])
print(fruits[-2])
print(fruits[-3])

运行上述代码后不难发现，[-1]表示倒数第一个元素，[-2]表示倒数第二个，以此类推。

一个列表的小应用：

fruits = ["Avocado", "Grapefruit", "Peach"]
massage = "Do you like" + fruits[0].lower() + "?"

3.2 修改、添加和删除列表元素

3.2.1 修改列表元素

在上面已经说过了引用列表元素了，所以引用一次列表元素再将之重新赋值即可完成修改。如：

fruits = ["Avocado", "Grapefruit", "Peach"]
fruits[2] = "Lichi"
print(fruits[2])

3.2.2 添加列表元素

列表末尾追加元素

在列表末尾追加元素需要用到.append()操作。如：

fruits = ["Avocado", "Grapefruit", "Peach"]
fruits.append("Plum")
print(fruits)

灵活地使用.append()操作可以动态地创建列表。例如线初始化一个空列表，再通过一系列的.append()操作来添加列表元素。如：

fruits = []
fruits.append("Avocado")
fruits.append("grapefruit")
fruits.append("Peach")
print(fruits)

列表中间插入元素

在列表中间插入元素需要用到.insert()操作。.insert()操作需要两个参数，一是元素添加的位置，而是元素的内容。如：

fruits = ["Avocado", "Grapefruit", "Peach"]
fruits.insert(1,"Coconut")
print(fruits)

3.2.3 删除列表元素

1. 使用del语句删除元素

   del语句可以删除任意指定位置上的元素。如：

   fruits = ["Avocado", "Grapefruit", "Peach"]
   del fruits[1]
   print(fruits)
   

   需要注意的是，这种删除是不可逆，删除了就是删除了。

2. 使用.pop()操作弹出元素

   这种删除与del语句的删除不同，使用.pop()操作相当于从指定的列表中拿走（弹出）指定位置的元素并将之存入一个给定的变量内。如：

   fruits = ["Avocado", "Grapefruit", "Peach"]
   popped_fruit = fruits.pop(0)
   print(fruits)
   print(popped_fruit)
   

3. 根据值删除指定元素

   当我们很难甚至无法确定我想要删除的元素在列表中的位置时，但我们知道它的值，我们就可以用下述方法来删除元素。如：

   fruits = ["Avocado", "Grapefruit", "Peach"]
   fruits.remove("Peach")
   print(fruits)
   

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

3.3 组织列表

3.3.1 对列表进行永久排序

比如有一个字符串列表，我们想让这个列表中的元素按照字典序排列，就可以参照下面的方法。

fruits = ["avocado", "grapefruit", "peach", "lichi"]
fruits.sort()
print(fruits)

采用.sort()对列表的排序操作是永久的，是无法恢复的。同时，我如果想要列表倒序排序该怎么办呢？例：

fruits = ["avocado", "grapefruit", "peach", "lichi"]
fruits.sort(reverse = True)
print(fruits)

3.3.2 对列表进行临时排序

临时排序顾名思义就是临时地改变列表中元素的顺序，在使用一次之后列表中元素的顺序还是原来的顺序。临时排序需要用到函数sorted()，其功能和用法与.sort()类似。如：

fruits = ["avocado", "grapefruit", "peach", "lichi"]
print(sorted(fruits))
print(sorted(fruits,reverse = True))
print(fruits)

3.3.3 直接将列表倒序

如果我们并不需要列表中的元素按照逆字典序排列，而是希望直接将整个列表中的元素倒序排列，就可以采用如下方法：

fruits = ["avocado", "grapefruit", "peach", "lichi"]
print(fruits)
fruits.reverse()
print(fruits)

3.3.4 确定列表的长度

如果我们想知道一个列表里面又多少个元素，即这个列表的长度如何，我们可以使用len()函数来确定。如：

fruits = ["avocado", "grapefruit", "peach", "lichi"]
print(len(fruits))

除此之外，len()函数还可以返回字符串的长度，即有多少个字符。如：

print(len("DeoxyriboNucleic Acid"))

四、操作列表

4.1 遍历列表

如果我们需要打印一个列表中的所有元素，用print()语句挨个打印输出就会显得十分繁琐，元素较少还好说，一旦碰上很长的列表，简直就是折磨人，因此下面用for循环来遍历打印列表。

for subject in ["Theoretical Mechanics", "Electrodynamics", "Thermodynamics", "Quantum Mechanics"]:
    print(subject)

4.1.4 深入研究for循环

将for循环第一行代码抽象如下：

for item in list_of_items :

可见，for循环的骨架由for、in和:三部分组成，这三者缺一不可。for和in之间实一个变量名，一般为列表元素的概括性词汇；in和:之间的是列表名或一个列表。

接着便是需要循环执行的语句，需要循环执行的语句可以是一条语句，也可以是多条语句。需要注意的是，为了区分需要循环执行的语句和普通语句，我们需要将循环语句缩进之后陈列在for语句的下面。缩进的长度没有要求，但是对于同一个循环结构下的语句缩进必须统一。例：

for item in list_of_items :
    print(item)
    print(item.upper)
    print(item.title)
print(list_of_items) # 这条语句就不属于循环，因此不会被循环执行

缩进让代码之间的从属关系变得直观，缩进的统一也让代码显得更加美观。

4.2 创建数值列表

4.2.1 使用range()函数

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

>>>for value in range(0,5):
 print(value)
0
1
2
3
4

经观察可知，输出的结果只是0~4，并没有5。这说明若有a、b两个整数，且a<b；则range(a,b)会返回从 a 到 b-1 之间的所有整数。即包前不包后。

4.2.2 使用range()函数创建数值列表

实际上，使用range()函数并不能直接得到数值列表，需要使用list()函数进行转换。如：

numbers = list(range(0,5))
print(numbers)

除此之外呢，range()函数不仅能每次增加一个单位，还可以指定每次增加的步长，如生成前5个偶数的平方构成的一个数值列表：

even_numbers = list(range(2,11,2))
square = []
for number in even_numbers :
    square.append(number ** 2)
print(square)

4.2.3 对数字列表执行简单的统计操作

digits = [0, 1, 2, 3, 4, 5]
print(min(digits))
print(max(digits))
print(sum(digits))

4.2.4 列表解析

列表解析是将for循环和创建数字列表的代码合并成一行。如：

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

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

4.3 使用列表的一部分

4.3.1 切片

如果你想单独使用列表中相邻的几个元素而又并非全部，则可以使用下述方法：

beverage = ['Cola', 'Sprite', '7-up', 'Mirinda']
print(beverage[0:3])

运行上述代码后会发现，只有前三个元素被输出了出来，这是因为这里的0:3和range()函数的注意事项是一样的，都是包前不包后。

再看下面的其它例子：

beverage = ['Cola', 'Sprite', '7-up', 'Mirinda']
print(beverage[:2]) # 第一个数字是空的默认从第一个元素开始
print(beverage[1:]) # 最后一个数字是空的默认以最后一个元素结束
print(beverage[-2:])# -2即代表倒序第二个

4.3.2 遍历切片

beverage = ['Cola', 'Sprite', '7-up', 'Mirinda']
for drink in beverage[-2:]:
    print("I have " + drink + '.')

4.3.3 复制列表

说到要复制一个列表，你可能会想到下面的方法：

beverage = ['Cola', 'Sprite', '7-up', 'Mirinda']
drinks = []
for drink in beverage:
 drinks.append(drink)
print(beverage)
print(drinks)

确实，上述方法很容易想到也很容易理解；但是Python给我们提供了另一种更加便捷的方法：

beverage = ['Cola', 'Sprite', '7-up', 'Mirinda']
drinks = beverage[:]
print(drinks)

可能有人就是继续想，为什么不能像变量给变量赋值一样直接写成drinks = beverage呢？为什么还要加一个[:]？实际上Python的语法是允许这样的语句存在的，但是这种写法和前面两种写法在功能是有一点不同的。上述两种方法是复制出一个内容一样但由独立于原来列表的新列表，独立地意思就是修改其中一个列表的元素另一个列表的对应元素不会发生改变。

但drinks = beverage这种列表名直接复制的语句是将beverage的地址传给drinks；说人话就是这两个列表是完全同步的，修改其中任一列表，另一个列表也会发生同样的改变。如：

beverage = ['Cola', 'Sprite', '7-up', 'Mirinda']
drinks = beverage
print(drinks)
print(beverage)
drinks[1] = 'Ice tea'
print(beverage)
print(drinks)

4.4 元组

Python中还有一种和列表很相似的数据类型叫做：元组。它和列表的区别就在于它的元素确定了之后就无法修改。元组又圆括号()表示。如：

devices = ("Laptop", "Cellphone")
print(devices[0])
print(devices)
for device in devices :
    print(device.upper())

虽然元组中的单个元素是无法修改的，但是整个元组本身是可以被修改的。如：

devices = ("Laptop", "Cellphone")
print(devices)
devices = ("Fan", "Air Conditioner", "Rifrigerator")
print(devices)

五、if 语句

5.1 简单的示例

cars = ['audi', 'bmw', 'buick', 'chevrolet']
for car in cars:
    if car == 'bmw':
     print(car.upper())
    else:
     print(car.title)

除宝马外的汽车品牌均首字母大写输出，宝马则全部大写输出。

5.2 条件测试

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

5.2.1 简单条件测试

下面直接给出一些条件判断的例子，请在交互式编程窗口完成。如：

# 检查是否相等
>>> car = 'audi'  # 一个等号表示赋值
>>> car == 'audi' # 两个等号表示判断是否相等
True              # 交互式窗口返回的结果
>>> car == 'Audi'
False             # 说明大小写不同也不能算相等

# 检查是否不相等
>>> 'bmw' != 'audi' # !=表示不等于
True

# 比较数字
>>> GPA = 3.9
>>> GPA == 4
False
>>> GPA < 3    # 小于
False
>>> GPA <= 3.9 # 小于等于
True
>>> GPA >= 3.7 # 大于等于
True
>>> GPA > 3.8  # 大于
True
>>> GPA != 0
True

5.2.2 复合条件判断

与复合

>>> length = 90
>>> width = 50
>>> length > 80 and width > 40
True
>>> length > 100 and width >= 40
False
# 一般为了改善代码的可读性可以将代码写在圆括号里
>>> (length > 80) and (width <= 60)
True

或复合

# 或复合的形式和与复合基本一致
>>> length = 90
>>> width = 50
>>> (length > 80) or (width < 40)
True

5.2.3 检查给定值是否在列表里

检查给定值是否在列表里可用in和not in来判断。（由此可见Python的代码是多么具有可读性）。如：

>>> stationery = ['eraser', 'pen', 'ruler', 'compass']
>>> 'ink' in stationery
False
>>> 'ink' not in stationery
True

布尔类型

之前介绍的字符串、整数、浮点数、列表和元组都属于数据类型，现在介绍一种新的数据类型——布尔类型。根据刚刚介绍的条件测试可以知道，每做一次判断就会得到True或者False，实际上判断得到的True或者False可以存入一个变量，这种只存在True或者False两种取值的数据类型就叫做布尔类型。如：

bool = 1 > 2
print(bool)
bool = True
print(bool)

5.3 if 语句

简单 if 语句

list_of_age = [18, 19, 8, 14, 45]
for age in list_of_age :
 if age >= 18 :     # 和for循环一样有冒号
     print('adult') # 判断后才执行的语句需要缩进，缩进是相对于 if 语句缩进

if-else 语句

list_of_age = [18, 19, 8, 14, 45]
for age in list_of_age :
 if age >= 18 :
     print('adult')
    else: # 同样有冒号
        print('not an adult')

if-elif-else 语句

list_of_age = [18, 19, 8, 14, 45]
for age in list_of_age :
 if age >= 18 :
     print('adult')
    elif age >= 12 :
        print('teenager')
    else:
        print('child')

需要注意的是，上面只是一个简单的示例，实际上elif可以写好几个，其中包含的判断语句也可以是复合的。

5.4 if 语句简单应用

多列表应用

available_fruits = ['watermelon', 'durian', 'kiwifruit', 'thysme fruit']
wanted_fruits = ['watermelon', 'kiwifruit', 'orange']
for fruit in wanted_fruits :
    if fruit in available_fruits:
        print('Adding ' + fruit + '.')
    else:
        print("Sorry, we don't have " + fruit + " here.")
print("Finished making you salad.")

判断空列表

wanted_fruits = []
if wanted_fruits:
    for fruit in wanted_fruits:
        print("Adding " + fruit + " .")
    print("Finished making your salad.")
else:
    print("Are you sure you want to add nothing to your salad.")

六、字典

6.1 一个简单的字典

Zombie = {'Health Points':20,
          'Armor Points':2, 
          'Behavior':'hostile'}
print(Zombie['Health Points'])
print(Zombie['Armor Points'])
print(Zombie['Behavior'])

上面的例子就展示了一个简单的列表的格式和一个基本用途——储存信息。上面的列表储存的就是游戏 Minecraft 里面的一种攻击性生物的一点基本属性。熟练对掌握字典的使用就可以有效地构建出一件事物的模型。

6.2 使用列表

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

键—值对是两个相关联的值。指定键时，Python将返回与之相关联的值。键和值之间用冒号分隔，而键—值对之间用逗号分隔。在字典中，你想存储多少个键—值对都可以。

6.2.1 访问字典中的值

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

Sheep = {'Health Points':10}
print(Sheep['Health Points'])

6.2.2 添加键值对

比如我要给上述字典添加生物行为的键值对：

Sheep = {'Health Points':10}
Sheep['Behavior'] = 'Neutral'
print(Sheep)

有了上述特性，就可以根据需求动态地添加字典中的键值对或构造字典了。

6.2.3 修改字典中的值

Zombie = {'Health Points':20,
          'Armor Points':2, 
          'Behavior':'hostile'}
print('The zombie\'s health points is ' + str(Zombie['Health Points']) + '.')
Zombie['Health Points'] = 10
print('The zombie\'s health points is now ' + str(Zombie['Health Points']) + '.')

6.2.4 删除键值对

Zombie = {'Health Points':20,
          'Armor Points':2, 
          'Behavior':'hostile'}
print(Zombie)
del Zombie['Armor Points']
print(Zombie)

6.3 遍历字典

6.3.1 遍历字典所有键值对

Physicist = {'Nickname':'The Fantastic','First name':'Richard', 'Last name':'Feynman'}
for key, value in Physicist.items():
    print('\nKey: ' + key)
    print('Value: ' + value)

6.3.2 遍历字典中所有的键

可以使用.keys()来遍历所有的键。如：

Physicist = {'Nickname':'The Fantastic','First name':'Richard', 'Last name':'Feynman'}
for key in Physicist.keys():
    print('\nKey: ' + key)

按固定的顺序遍历字典中的键则需要使用sorted()函数。如：

Physicist = {'Nickname':'The Fantastic','First name':'Richard', 'Last name':'Feynman'}
for key in sorted(Physicist.keys()):
    print('\nKey: ' + key)

6.3.3 遍历字典中所有的值

和遍历字典中的键一样，这里可以使用.values()来实现。如：

Physicist = {'Nickname':'The Fantastic','First name':'Richard', 'Last name':'Feynman'}
for key in Physicist.values():
    print('\nKey: ' + key)

在有些情况下，一个字典中有很多值可能是重复的，在打印输出时为了消除重复输出的部分可以使用set()函数，如：

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

6.4 嵌套

Python 有个很强大的功能就是支持列表和列表、字典和列表、字典与字典的嵌套；也就是说列表的元素可以是列表、也可以是字典，同时字典的 value 也可以是列表或者字典。具体例子不再给出，读者可以自行尝试。

七、用户输入和 while 循环

7.1 input() 函数的工作原理

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

massage = input('Type in something, and I will repeat it to you:')
print(massage)

input()函数括号里的字符串是用于提示用户输入的，input()函数的返回值是一串字符串。如：

age = input('How old are you?')
print(age)

运行上述代码之后会发现age是以字符串的格式输出的，所以我们就需要用一种方法把字符串转换为整数。如：

x = input('Please type in the x that you want to calculate:')
x = int(x)
y = x**2 + 2*x + 1
print('y is ' + str(y) + '.')

7.2 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. "
active = True #提前定义一个布尔变量设置为True，再将之作为循环的判据
while active:
 message = input(prompt)
 if message == 'quit':
  active = False # 再满足要求时就将标志更改以跳出循环
 else:
  print(message)

7.2.3 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 #break语句可以直接无条件跳出当前的循环
 else:
  print("I'd love to go to " + city.title() + "!")

7.2.4 在循环中使用 continue 语句

有时在执行循环程序时，为了提高程序执行的效率，并不需要每个执行循环的元素都走完整个循环而需要提前结束，只需要满足特定条件的元素才需要执行完整个循环程序。就像在不考虑无症状感染者和潜伏期患者的情况下， 一个人如果各方面体征都表现正常就可以直接排除，不在进行接下来的患病检测，这样就达到了提高检测效率的目的。当然这只是简要的说明，实际情况可能更为复杂。在此 continue 语句就给了我们一个提前结束循环的功能。例：我要输出 1~10 之间的所有偶数，在判断一个数不是偶数之后就用 continue 语句提前结束，而不执行接下来的打印：

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

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

循环列表

needed_fruits = ['strawberry', 'apple', 'banana', 'blueberry']
used_fruits = []
while needed_fruits:
    current_fruit = needed_fruits.pop()
    print('Adding ' + current_fruit  + ' to your cake.')
    used_fruits.append(current_fruit)
print("Your cake is finished!")
print('The following fruits are added to your cake:')
for fruit in used_fruits:
    print(fruit.title())

7.3.1 删除列表中的多个相同的值

pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
print(pets)
while 'cat' in pets:
    pets.remove('cat')
print(pets)

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

polling_result = {} #初始化空字典
polling_active = True #设置标签来控制循环结束与否

while polling_active:
    name = input('\nWhat is your name?')
    favorite_fruit = input('What is your favorite fruit?')
    polling_result[name] = favorite_fruit
    repeat = input('Are you the last one to take the poll?(yes or no)')
    if repeat == 'yes':
        polling_active = False

print("\n--- Poll Results ---")
for name, fruit in polling_result.items():
    print(name + " would like to eat " + fruit + ".")

八、 函数

8.1 定义函数

def greet_user():
 print('Hello, nice to meet you!')

greet_user()

8.1.1 向函数传递信息

def greet_user(name):
 print('Hello ' + name +', nice to meet you!')

greet_user('Hershey')

8.2 传递实参

8.2.1 位置参数

在调用函数时，传入参数的相对位置要和参数设置时的位置保持一致，例如：

def test(parameter1, parameter2):
    print('第一个值为：' + parameter1)
    print('第二个值为：' + parameter2)

argument1 = 'Hershey'
argument2 = 'Soulson'
test(argument1, argument2)
test(argument2, argument1)

8.2.2 关键字参数

如果在函数参数过多，参数设置的相对位置记不清楚就可以采用关键字参数来保证传参的正确性，如：

def mydoll(owner, doll):
    print("\nI'm " + owner +', and my favorite doll is ' + doll + '.')

person = ['Hershey', 'Soulson']
toy = ['teddy', 'doraemon']
for i in range(0,2):
    mydoll(doll = toy[i], owner = person[i])

8.2.3 默认值

在有时函数的某一个参数会经常出现同一个值，这是就可以设置函数的默认值，这样在函数调用时就可以减少输入：

def mydoll(owner, doll = 'teddy'): # we set default values to parameters in this way
    print("I'm " + owner +', my favorite doll is ' + doll + '.')

mydoll('Hershey') # This value goes to the first parameter

8.3 函数的返回值

有时我们给函数传递一些数据之后，希望函数能将处理后的数据传递回来，这个传递回来的值就叫做返回值：

def factorial(integer):
    for i in range(1, integer): # i会遍历1到integer-1的所有整数，缺少了integer本身
        integer *= i            # 但是此处直接拿integer参与运算，就可成功计算阶乘
    return integer
num = 5
fac = factorial(num) 
print('%d 的阶乘是：%d 。' %(num, fac) )

8.3.1 让实参变成可选的

假如一个函数为了功能的全面会设置多个参数，但是在实际操作过程中并不是每一次都回用到所有的参数，因此就需要特殊的处理将参数变成可选择的。例：

def get_formatted_name(first_name, last_name, middle_name=''): # Not everyone has a 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)

函数的英文是 function，本意为功能，所以函数就是实现某一个特殊功能的语句块。所以在编写和使用函数的过程中要灵活使用不要受到限制，要很好地利用python函数的特性来实现自己想要的功能。比如函数的返回值可以多样化，还可以结合各种循环语句等等。

8.4 给函数传递列表

传给函数的参数也可以是一个列表，例如：

def average(score_list):
    return sum(score_list)/len(score_list)

score = [100, 95, 93, 95, 92]
print(average(score))

为什么要把列表单独拿出来说呢，是因为列表具有一定的特殊性，特殊在哪儿呢，我们往下看：

def greet(last_name):
    last_name = "Mr." + last_name  # 在函数里面修改传入的变量
    print("Good morning " + last_name + ".")

surname = "Simith"
print(surname)        # 还没传入函数
greet(surname)        # 函数里面会进行修改
print(surname)        # 在此打印这个变量

如果你运行了上述程序，你会发现surname这个变量，虽然在函数里面被修改，但是在函数之外并没有发生实质性的改变。但如果我们 换成一个列表呢：

def average(score_list):
    sum = 0
    n = len(score_list)
    for i in range(n):
        sum += score_list.pop()  # 每次循环都会删除列表中最后一个元素
    return sum / n

score = [100, 95, 93, 95, 92]
print(score)
print(average(score))
print(score)

运行上述代码你就会发现，在函数内是可以对传入的列表进行修改的，而对函数外的变量则不能。那怎么禁止让函数修改函数之外的列表呢？这里我们需要用到切片操作：

def average(score_list):
    sum = 0
    n = len(score_list)
    for i in range(n):
        sum += score_list.pop()  # 每次循环都会删除列表中最后一个元素
    return sum / n

score = [100, 95, 93, 95, 92]
print(score)
print(average(score[:]))        # 此处采用切片传参，即可保证列表值不被修改
print(score)

同时我还想告诉你们，python还有个特性，就是函数外的变量是可以直接调用的，并不一定要传参进去才能用。例如：

def greet():
    # global surname           # 使用global关键字将该变量声明为全局变量
    surname = "Mr." + surname  # 在函数里面修改传入的变量
    print("Good morning " + surname + ".")

surname = "Simith"
print(surname)        # 还没传入函数
greet(surname)        # 函数里面会进行修改
print(surname)   

在运行上述代码时，可以把第二行的注释去掉再运行一下，看最后的输出有什么区别。

8.5 传递任意数量的实参

我也不知道这个会用在什么地方，但是 Python 有这个这个特性那么还是值得说一说，但我就智慧简单地举一个例子：

def showItems(*items):  # 在变量名前面加上一个星号，在传入多个参数的时候会得到一个元组对象
 for item in items:
  print(item)

showItems("Book", "Pen", "Ink", "Eraser")

8.6 函数模块及其导入

加入你写了一些特别好用的函数，并且经常会用到，同时考虑到如果每次都再写一遍过于麻烦，或者复制粘贴一遍也比较麻烦，就可以将你写的所有函数打包成一个模块，在需要用到的时候导入即可。

怎么打包呢？很简单，只需要新建一个 .py 文件， 自己取一个合适的名字，比如 myfunctions.py。然后每当你在同一个文件夹下的其它文件里写代码时，就只需要导入这个文件（模块）就可以了。具体怎么操作？看下边：

### myfunctions.py      # 先创建模块，名叫 myfunctions
def showItems(*items):  # 在变量名前面加上一个星号，在传入多个参数的时候会得到一个元组对象
 for item in items:
  print(item)
        
def greet(last_name):
    last_name = "Mr." + last_name  # 在函数里面修改传入的变量
    print("Good morning " + last_name + ".")

下面是调用模块的基本方法：

## 在同一个文件夹下其它的python文件里面
## 比如名叫：demo.py
import myfunctions

myfunctions.greet("Einstein")

import myfunctions as my # 如果模块名太长，可以这样给它取个别名

my.showItems("Book", "Pen", "Ink", "Eraser")

from myfunctions import greet  # 只导出模块中的部分函数，

greet("Feynman")   ## 此时不用再在函数前面加上模块名了

from myfunctions import *  ## 偷懒导入全部的函数

showItems("Book", "Pen", "Ink", "Eraser")
greet("Feynman")                   # 同时也不用写模块名