weixin_40725706

这个屌丝很懒，什么也没留下！

热门标签

蟒蛇书第二版Python入门_python蟒蛇书电子版

作者：weixin_40725706 | 2024-05-07 16:55:03

踩

python蟒蛇书电子版

第二章变量与简单的数据类型

2.2变量

设置一个变量并打印

代码：


message = "Hello python word"
print(message)

2.21变量的命名与使用

变量只能包含字母、数字、下划线。变量名能以字母或下划线打头，但不能以数字打头

变量名不能包含空格，但能使用下划线来分隔其中的词

不能使用Python中的关键字和函数名用作变量名

变量名应既简短又具有描述性。

慎用小写字母的l和大写的o

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

使用变量时避免命名错误，或变量使用错误。

2.23变量是标签

变量是可以赋给值的标签，也可以说变量指向特定的值。

2.3字符串

字符串是一系列字符。在Python中用引号括起来的都是字符串

2.3.1修改字符串的大小写

string.title()首字母大写的形式显示。


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

string.upper()将字符串中的所有字符都大写显示


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

string.lower()将字符串中的所有字符都小写显示


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

2.3.2在字符串中插入变量

将字符串插入变量中


first_name  = "ada"
last_name = "lovelace"
full_name = f"{first_name}{last_name}"
print(full_name)

这种f的用法叫f字符串，f是format的简写，因为Python通过把花括号内的变量替换为其值来设置字符串的格式。

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

\t：相当于tab键

\n：换行符

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

输出：

language:
Python
C
JavaScript

2.3.4删除空白

Python中能够找出字符串开头和末尾多余的空白

string.rstrip()：删除末尾的空白

string.lstrip()：删除开头的空白

string.strip()：删除两头的空白


favourite_language = 'python '
print(favourite_language.rstrip())
print(favourite_language.lstrip())
print(favourite_language.strip())

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

单引号之间再次使用单引号，将导致程序报错。

‘One of Python's strengths is its diverse community.’

2.4数

2.4.1整数

加：2+3

减：3-2

乘：2*3

除：3/2

乘方：3**2

Python支持运算次序，因此可在同一个表达式内使用多种运算，还可以使用圆括号来修改运算次序。

2+3*4 = 14

(2+3)*4 = 20

2.4.2浮点数

Python将所有带小数点的数称为浮点数。

0.1+0.2

0.30000000004

结果包含的小数位数是不确定的，可以暂时忽略多余的小数。

2.4.3整数和浮点数

将两个数相除结果总数浮点数

>>> 4/2
2.0

在任何运算中如果一个操作数是整数，另一个是浮点数，结果也是浮点数

>>> 1+0.2
1.2

Python认为只要有操作数是浮点数，Python默认得到的总是浮点数。

2.4.4数中的下划线

下划线可以让数字更易读

universe_age =14_000_000_000

>>> universe_age = 14_000_000_000
>>> print(universe_age)
14000000000
>>>

Python显示时不会打印下划线

在存储这种数时，Pyhton会忽略其中的下划线，将数字分组时，即便不是将每三个分为一组，也不会影响最终值，1000与1_000与1_00_0没有区别。

2.4.5同时给多个变量赋值

可在一行给多个变量赋值，增加程序可读性

>>> x,y,z = 0,0,0

2.4.6常量

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

MAX_CONNECTIONS = 5000

2.5注释

注释可以让程序可读性增加。

将不用的代码注释

为代码添加说明

2.5.1如何注释

使用#号注释，#号后面的内容会被Pyhton解释器或略

#向大家问好

print('Hello Pyhton people')

2.5.2该如何备注

利用备注将代码清晰的概述出来，节省阅读时间。

第三章列表简介

3.1什么是列表

列表有一组特定的顺序排列的元素组成。

3.1.1访问列表元素

1、利用该元素的索引访问列表中的该元素

>>> bicycle = ['trek','cannondale','redline','specialized']
>>> print(bicycle[0])
trek
2、结合其他的函数使用

>>> bicycle = ['trek','cannondale','redline','specialized']
>>> print(bicycle[0].title())
Trek

3.1.2索引从0开始不是从1开始

大多数编程语言的索引都是从0开始，而不是从1开始。

访问索引为1的元素，其实为列表中的第二个值

>>> bicycle = ['trek','cannondale','redline','specialized']
>>> print(bicycle[1])
cannondale

3.1.3使用列表中的个值

利用列表中元素的索引，你可以将列表中的元素当作变量使用。

>>> bicycle = ['trek','cannondale','redline','specialized']

>>> print(f'My first bicycle was a {bicycle[0].title()}')
My first bicycle was a Trek
>>>

3.2修改、添加和删除元素

列表是动态的，表示列表可以被程序进行各种操作。

3.2.1修改列表元素

修改列表元素相当于给元素赋予新的值，只要知道元素的索引就可以对特定的元素进行赋值。

>>> motorbicycle = ['honda','yamaha','suzuki']
>>> print(motorbicycle)
['honda', 'yamaha', 'suzuki']
>>> motorbicycle[0] = 'ducati'
>>> print(motorbicycle)
['ducati', 'yamaha', 'suzuki']

3.2.2列表中添加元素

1、append()在列表的末尾添加元素

使用appand元素附加将新的元素添加到列表末尾

>>> motorbicycle = ['honda','yamaha','suzuki']
>>> motorbicycle.append('ducati')
>>> print(motorbicycle)
['honda', 'yamaha', 'suzuki', 'ducati']
>>>

对空列表进行添加元素

>>> motorbicycle = []
>>> motorbicycle.append('honda')
>>> motorbicycle.append('yamaha')
>>> motorbicycle.append('suzuki')
>>> print(motorbicycle)
['honda', 'yamaha', 'suzuki']
>>>

2、insert()在列表中插入元素

使用insert()函数可在列表中的任何位置添加新元素。

>>> motorbicycle = ['honda','yamaha','suzuki']
>>> motorbicycle.insert(0,'ducati')
>>> print(motorbicycle)
['ducati', 'honda', 'yamaha', 'suzuki']
>>>

3.2.3从列表中删除元素

1、使用del语句删除元素

使用del删除元素

>>> motorbicycle = ['ducati', 'honda', 'yamaha', 'suzuki']

>>> del motorbicycle[0]
>>> print(motorbicycle)
['honda', 'yamaha', 'suzuki']
>>>
使用del 与元素索引删除对应索引的元素

>>> motorbicycle = ['honda', 'yamaha', 'suzuki']

>>> del motorbicycle[0]
>>> print(motorbicycle)
['yamaha', 'suzuki']
>>>

使用del删除对应的元素后，就无法再次访问这个元素了。

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

使用pop()可以删除列表末尾的元素，术语弹出源自于类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。

>>> motorbicycle = ['honda', 'yamaha', 'suzuki']

>>> popped_motorbicycle = motorbicycle.pop()
>>> print(popped_motorbicycle)
suzuki
>>> print(motorbicycle)
['honda', 'yamaha']
>>>

3、pop(0)弹出列表中任何位置处的元素

可以使用pop()函数删除任意位置的元素，只要在括号中添加要删除元素的索引即可。

>>> motorbicycle = ['honda', 'yamaha', 'suzuki']

>>> first_owned = motorbicycle.pop(0)
>>> print(f'My first motorbicycle I owned was a {first_owned.title()}')
My first motorbicycle I owned was a Honda
>>>

4、remove()根据元素删除元素

当你不知道元素的索引，但是知道元素的值时，可以使用remove()函数删除对应值的元素。

>>> motorbicycle = ['honda','yamaha','suzuki']
>>> motorbicycle.remove('yamaha')
>>> print(motorbicycle)
['honda', 'suzuki']
>>>

使用变量保存删除的值，这样我们可以在删除元素后利用变量再次访问该值。

>>> motorbicycle = ['honda','yamaha','suzuki']
>>> expensive = 'yamaha'
>>> motorbicycle.remove(expensive)
>>> print(f'\nA {expensive.title()} is too expensive for me')

A Yamaha is too expensive for me
>>>

3.3组织列表

列表创建时未按顺序排序，后面使用时需要根据一定的顺序进行排序。下面我们就讲一下如何对列表中的元素进行排序。

3.3.1 sort()对列表进行永久排序

1、正排序

sort()将会永久的改变列表的排序，列表是无法恢复的。

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

2、反排序属性reverse

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

3.3.2 sorted()临时排序

将列表进行临时排序，排序后不影响列表原始顺序。

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

再使用sorted()之后，cars的原始顺序并没有被改变。

也可以使用reverse 属性将元素反向排序

>>> print(sorted(cars,reverse = True))
['toyota', 'subaru', 'bmw', 'audi']
>>>

3.3.3 reverse() 倒着打印列表

使用reverse()将列表元素顺序反转。

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

3.3.4 len()确定列表的长度

使用函数len()确定列表的长度。

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

>>> len(cars)
4
>>>

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

1、当所访问的索引超出列表元素个数时会报错。

2、记住索引从0开始

3、使用索引-1可以访问最后一个元素，当列表为空时会报错。

第四章操作列表

4.1遍历整个列表

我们可以使用循环来遍历整个列表，下面我们就了解一下循环。

4.1.1 for循环

利用for循环可以遍历列表中的每个元素，当遍历到最后一个元素时循环结束。

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

>>> for car in cars:
... print(car)
...
subaru
toyota
audi
bmw
>>>

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

可以利用循环对列表中的每个元素进行操作，但是注意缩进。

>>> magicians = ['alice','david','carolina']

>>> for magician in magicians:
... print(f'{magician},that was a great trick')
...
alice,that was a great trick
david,that was a great trick
carolina,that was a great trick
>>>

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

在for循环之后添加一些代码。

>>> magicians = ['alice','david','carolina']
>>> for magician in magicians:
... print(f'{magician},that was a great trick')
...
alice,that was a great trick
david,that was a great trick
carolina,that was a great trick
>>> print('think you ,everyone.that was a great magic show')
think you ,everyone.that was a great magic show
>>>

4.2避免缩进错误

Python解释器是利用缩进来进行判断程序之间的关系的，如for循环中的语句就是缩进后的代码。

4.2.1忘记缩进

忘记缩进代码时，Python没有找到for循环对应的代码块，代码会报错。

>>> for magician in magicians:
...
File "<stdin>", line 2

^
IndentationError: expected an indented block after 'for' statement on line 1
>>>

4.2.2忘记缩进额外的代码。

当代码忘记缩进时，就会当作for循环的代码块。

4.2.3不必要的缩进

>>> message = "Hello Python world"
>>> print(message)
File "<stdin>", line 1
print(message)
IndentationError: unexpected indent
>>>

4.2.4循环后不必要的缩进

4.2.5漏了冒号

4.3创建数值列表

需要存储一组数时，可以使用数值列表进行存储和访问。

4.3.1range()函数

range(开始值,结束值+1)

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

当指定从0开始时，可以不添加开始值

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

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

1、使用list()将range()的结果转化为列表并保存到变量中。

>>> number = list(range(1,6))
>>> print(number)
[1, 2, 3, 4, 5]
>>>

2、设定range()的步长

range(开始值,结束值+1,步长)

>>> number = list(range(2,11,2))
>>> print(number)
[2, 4, 6, 8, 10]
>>>

3、利用range()与for创建其他数字列表

>>> squares = []

>>> for value in range(1,11):
... square = value**2
... squares.append(square)
...
>>> print(squares)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>

4.3.3 min()max()sum()对数字列表执行简单的统计计算

1、min()求列表中的最小值

2、max()求列表中的最大值

3、sum()求列表中的所有元素的和

>>> num = [1,2,3,4,5,6,7,8,9,0]
>>> print(min(num))
0
>>> print(max(num))
9
>>> print(sum(num))
45
>>>

4.3.4列表解析

将for语句代码与其中的代码块进行简写叫做列表解析。

>>> square = [value**2 for value in range(1,11)]
>>> print(square)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>

4.4使用类表的一部分

当我们只需要列表中的部分元素时，我们可以将列表中的固定位置的元素进行提取，Python中叫做切片。

4.4.1切片

1、从0开始输出列表中三个元素

>>> player = ['charles','martian','michael','florence','eli']
>>> print(player[0:3])
['charles', 'martian', 'michael']

2、从1开始输出三个元素

>>> print(player[1:4])
['martian', 'michael', 'florence']

3、从0开始输出四个元素

>>> print(player[:4])
['charles', 'martian', 'michael', 'florence']

4、从末尾输出所有元素

>>> print(player[:-1])
['charles', 'martian', 'michael', 'florence']

5、从倒数第三个元素输出到末尾

>>> print(player[-3:])
['michael', 'florence', 'eli']
>>>

4.4.2遍历切片

利用for循环和切片，遍历切片中的元素

>>> for p in player[:3]:
... print(p.title())
...
Charles
Martian
Michael
>>>

4.4.3 复制列表(copy() deepcopy())

1、使用切片的形式复制列表

使用直接赋值的方式(friend_foods = my_foods)表示两个列表是相同的，都指向同一个列表地址。

>>> my_foods = ['pizza','falafel','carrot','cake']
>>> friend_foods = my_foods[:]
>>> print(friend_foods)
['pizza', 'falafel', 'carrot', 'cake']
>>> print(my_foods)
['pizza', 'falafel', 'carrot', 'cake']
>>>

2、copy() 导入copy模块用copy进行拷贝

>>> import copy

>>> firedd_foods = copy.copy(my_foods)
>>> my_foods[0] = 'c'
>>> print(firedd_foods)
['pizza', 'falafel', 'carrot', 'cake']
>>> print(my_foods)
['c', 'falafel', 'carrot', 'cake']
>>>

3、deepcopy()深拷贝

>>> import copy

>>> firedd_foods = copy.deepcopy(my_foods)
>>> my_foods[1] = 'd'
>>> print(firedd_foods)
['c', 'falafel', 'carrot', 'cake']
>>> print(my_foods)
['c', 'd', 'carrot', 'cake']
>>>

4.5元组

不可变的列表在Python中称为元组。

4.5.1定义元组

元组用括号来标识

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

改变元组的值时会报错

>>> dimensions[0] = 20
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>
注意：创建一个元素的元组需要在元素后加逗号

my_t = (3,)

4.5.2遍历元组中的所有值

>>> for dimension in dimensions:
... print(dimension)
...
200
50
>>>

4.5.3修改元组中的值

将元组中的值重新赋值时会报错，那如何修改元组中的值呢？可以将元组重新赋值。

>>> d = [200,50]
>>> d = [400,100]
>>> for v in d:
... print(v)
...
400
100
>>>

4.6设置代码格式

4.6.1格式设置指南

4.6.2缩进

每级缩进都使用四个空格。

4.6.3行长

行长不超过80字符

4.6.4空行

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

4.6.5其他格式设置指南

第五章if语句

5.1if示例

判断条件时候符合，符合执行对应代码。

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

>>> for car in cars:
... if car == 'bmw':
... print(car.upper())
... else:
... print(car.title())
...
Audi
BMW
Subaru
Toyota
>>>

5.2条件测试

if语句都是在判断一个为True或False的表达式，这种表达式叫做条件测试。条件值为True还是False来决定是否执行if语句中的代码。

5.2.1检查是否相等

使用 == 来判断变量中的值与特定值是否相等，这个符号叫做相等运算符，相等时返回True，不相等返回False。

>>> car = 'bmw'
>>> car == 'bmw'
True
>>>

5.2.2检查是否相等时区分大小写 ==

使用 == 判断值是否相等时区分大小写，大小写不同则值不同，返回False。

>>> car = 'Bmw'
>>> car == 'bmw'
False
>>>

如果只需要判断值，不分大小写时，可以在判断前将值都变为小写再判断。

>>> car = 'Bmw'
>>> car == 'bmw'
False
>>> car.lower() == 'bmw'
True
>>>

注意：lower()函数不会将改变后的值赋值给变量，因此不会影响变量原来的值。

5.2.3 检查是否不相等 !=

使用 != 判断两边的值是否不相等，不相等返回True，相等返回False。

>>> requested_topping = 'mushrooms'
>>> if requested_topping != 'anchovies':
... print('Hello the anchovies')
...
Hello the anchovies
>>>

5.2.4数值比较 == 、!= 、>、<、>=、<=

使用 == 、!= 、>、<、>=、<=来判断数值是否符合要求。

>>> age = 18
>>> age == 18
True
>>> age = 19
>>> age <21
True
>>> age <= 21
True
>>> age > 21
False
>>> age >= 21
False
>>>

5.2.5检测多个条件 and or

1、and检查多个条件

检查两个条件都是否成立时，使用and将两个条件合并。

>>> age_0 = 22
>>> age_1 = 18
>>> age_0 >= 21 and age_1 >= 21
False
>>> age_1 = 22
>>> age_0 >= 21 and age_1 >= 21
True
>>>

2、or检查多个条件

or检查多个条件，只要其中一个成立，则合并后的结果为True。只有都不成立结果为False。

>>> age_0 = 22
>>> age_1 = 18
>>> age_0 >= 21 or age_1 >=21
True
>>> age_0 = 18
>>> age_0 >= 21 or age_1 >= 21
False
>>>

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

使用in判断特定值是否在列表内，在返回True不在返回false

>>> requested_toppings = ['mushrooms','onions','pineapple']
>>> 'mushrooms' in requested_toppings
True
>>>

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

使用not in判断特定值是否在列表内，在返回True不在返回false

>>> 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')
...
Marie,you can post a response if you wish
>>>

5.2.8 布尔表达式

布尔表达式与条件表达式一样，布尔表达式结果只能为True或False

>>> game_active = True
>>> can_edit = False

5.3 if语句

上面我们讲了条件表达式，那我们条件表达式是与if语句配合使用的。

5.3.2 简单的if语句

第一行包含条件测试，后面缩进代码块中执行其他代码。

>>> age = 18
>>> if age >= 18 :
... print('You are old enough to vote')
...
You are old enough to vote
>>>

5.3.2 if - else语句

我们通常在条件测试通过时执行一个操作，在咩有通过时执行另一个操作，在这样的情况下可以使用if - else 语句。

>>> age = 18

>>> 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 !')
...
Sorry you are too young to vote
Please register to vote as soon as you turn 18 !
>>>

5.3.3 if - elif - else 语句

当我们需要判断两个条件时，可以使用if判断第一个条件，elif 判断第二个条件，当两个条件都不符合时执行else。

>>> age = 12
>>> if age <4 :
... print('You admission cost is $0.')
... elif age <18:
... print('You adnission cost is $25')
... else:
... print('You admission cost is $40')
...
You adnission cost is $25
>>>

为了让代码更简洁可以使用赋值方法，在代码的最后同一打印。

>>> age = 12
>>> price = 0
>>> if age < 4 :
... price = 0
... elif age < 18:
... price = 25
... else:
... price = 40
...
>>> print(f'Your admission cost is ${price}')
Your admission cost is $25
>>>

5.3.5 使用多个elif

我么可以使用elif 判断多个条件

>>> 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}')
Your admission cost is $25
>>>

5.3.6 省略else

一般情况下Python并不要求一定有else，当使用elif能使代码更清晰时，可以省略else

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

...
>>> print(f'Your admission cost is ${price}')
Your admission cost is $25

5.3.7 测试多个条件

if - elif - else 结构强大，但是当满足一个条件时，其他条件将不再执行，有时需要判断多个条件是否成立，且其中多个条件都符合要求时，可以使用多个if判断多个条件，多个条件成立时执行多行代码。

request_topping = ['mushroom','extra chess']
if 'mushroom' in request_topping:
   print('Adding mushroom')
if 'pepperoni' in request_topping :
   print('Adding pepperoni')
if 'extra chess' in request_topping:
   print('Adding extre chess')

Adding mushroom
Adding extre chess

5.4 使用if语句处理列表

将if与for语句配合使用，当循环读取列表中的元素符合条件时执行对应的代码。

5.4.1检查特殊元素

将if与for语句配合使用，当循环读取列表中的元素符合条件时执行对应的代码。

request_toppings = ['mushroom','green peppers','extre cheese']
for request in request_toppings:
   if request == 'green peppers':
       print(f'Sorry, we are out of green peppers right now.')
   else:
       print(f'Adding green pepppers')
print('\nFinished making your pizza')

Adding green pepppers
Sorry, we are out of green peppers right now.
Adding green pepppers

Finished making your pizza

5.4.2 确定列表是不是空

在循环之前我们可以使用if判断列表是否为空，为空可以跳过for循环。

在Python中 if后面的变量为条件测试，有元素返回Ture无元素返回False。

request_toppings = []
if request_toppings:
   for request in request_toppings:
       print(f'Adding {request}')
   print('\nFinished making your pizza')
else:
   print('Are you sure you want a plain pizza?')

Are you sure you want a plain pizza?

5.4.3 in 判断一个列表是否包含在另一个列表内

available_toppings = ['mushrooms','olives','green peppers','pepperoni','pineapple','extra cheese']
reuqest_toppings = ['mushrooms','french fires','extra cheese']
for reuqest_topping in reuqest_toppings:
   if reuqest_topping in available_toppings:
       print(f'Adding {reuqest_topping}')
   else:
       print(f"Sorry ,we don't have {reuqest_topping}")
print('\nFinished making your pizza')

Adding mushrooms
Sorry ,we don't have french fires
Adding extra cheese

Finished making your pizza

第六章字典

6.1一个简单的字典

在汉语词典中我们可以通过拼音找到我们想要的字，拼音就相当于门牌号，而字相当于住在里面的人。

6.2使用字典

在Python中，字典是一系列的键值对，每个键都与一个值相关联，你可以用键来访问对应的值。

字典用放在{}括号中的一系列键值对表示。

aline_0 = {'color':'green','point':5}

键值对是两个相关联的值，指定键时，Python将返回与之相关联的值。

6.2.1访问字典中的值

要获取键相关联的值，可将键放入方括号内

>>> alien_0 = {'color':'green','points':5}
>>> print(alien_0['color'])
green
>>>
当字典中有多个键值对时，依然可以利用键精确的找到对应的值

>>> alien_0 = {'color':'green','points':5}
>>> new_points = alien_0['points']
>>> print(f'You just earned {new_points} points!')
You just earned 5 points!
>>>

6.2.2 添加键值对

字典是一种动态结构，可随时在其中添加键值对。只需要将字典中没有的键放入中括号并对其赋值。就可将新的键值对添加到字典中。

>>> alien_0 = {'color':'green','points':5}
>>> alien_0['x_position'] = 0
>>> alien_0['y_position'] = 25
>>> print(alien_0)
{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}
>>>

6.2.3创建空字典

在使用字典前可以先创建一个空字典，然后根据需求向字典中添加键值对集合。

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

6.2.4 修改字典中的值

我们可以利用键修改其对应的值，将键写入中括号，并重新赋值。

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

>>> print(alien_0['color'])
green
>>> alien_0['color'] = 'yellow'
>>> print(alien_0['color'])
yellow
>>>

6.2.5 del 删除键值对

对与需要删除的键值对，可使用del将其删除。将要删除的键名写入中括号，进行删除。

>>> alien_0 = {'color':'yellow','points':5}

>>> del alien_0['points']
>>> print(alien_0)
{'color': 'yellow'}
>>>

使用del删除了‘‘point’’:5键值对，其他值不受影响。

6.2.6 长字典的书写

当字典键值对较多时，可以使用多行来写一个字典，增加程序的可读性。

favorite_language = {
   'jen':'Python',
   'sarah':'c',
   'edward':'ruby',
   'phil':'Python',
   }
print(favorite_language)

6.2.7 get()访问字典值

当获取的键值对在字典中不存在，程序就会报错。

>>> alien_0 = {'color':'yellow','points':5}

>>> print(alien_0['speed'])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'speed'
>>>

使用get()获取键值对时，当键值对在字典中不存在，可以返回信息。

利用get()获取键值对，不存在时反馈布尔值False

>>> alien_0 = {'color':'green','speed':'low'}
>>> point_value = alien_0.get('points',False)
>>> print(point_value)
False
>>>

利用get()获取键值对，不存在时反馈字符串语句

>>> alien_0 = {'color':'green','speed':'low'}

>>> point_value = alien_0.get('points','No point value assigend .')
>>> print(point_value)
No point value assigend .
>>>

与if综合用法

>>> alien_0 = {'color':'green','speed':'low'}

>>> point_value = alien_0.get('points',False)
>>> if point_value:
... print(point_value)
... else:
... print('No point value assigned .')
...
No point value assigned .
>>>

6.3遍历字典

6.3.1遍历所有键值对 items()

使用for循环遍历所有键值对，使用 items()方法。

>>> user_0 = {
... 'username':'efermi',
... 'first':'enrico',
... 'last':'fermi',
... }
>>> for key,value in user_0.items():
... print(f'\nKey:{key}')
... print(f'Value:{value}')
...

Key:username
Value:efermi

Key:first
Value:enrico

Key:last
Value:fermi
>>>

我们使用字典的方法items()来获取字典中的每一对键值对，再将键赋值给key，值赋值给value。

6.3.2遍历字典中的所有键 keys()

1、在不需要值只需要键的时候我们可以只获取字典中的键。使用for循环与keys()方法获取字典中的键。

>>> favorite_language = {
... 'jen':'Python',
... 'sarah':'c',
... 'edward':'ruby',
... 'phil':'Python',
... }
>>> for name in favorite_language.keys():
... print(name.title())
...
Jen
Sarah
Edward
Phil
>>>

2、显式的使用keys()可让代码更容易理解，也可以省略。

>>> favorite_language = {
... 'jen':'Python',
... 'sarah':'c',
... 'edward':'ruby',
... 'phil':'Python',
... }
>>> firends = {'phil','sarah'}
>>> for name in favorite_language:
... print(f'Hi {name.title()}')
... if name in firends:
... language = favorite_language[name].title()
... print(f'{name.title()},I see you love {language}')
...
Hi Jen
Hi Sarah
Sarah,I see you love C
Hi Edward
Hi Phil
Phil,I see you love Python
>>>

3、keys()方法返回的是字典中的所有键所组成的列表

>>> favorite_language = {'jen':'Python','sarah':'c','edward':'ruby','phil':'python'}

>>> if 'erin' not in favorite_language:
... print('Erin.Please take our poll!')
...
Erin.Please take our poll!
>>>

6.3.3 sorted() 按照特定的顺序遍历字典中的所有键

先使用keys()方法获取字典中所有键，再使用sorted()方法将键列表分类。

>>> favorite_language = {'jen':'Python','sarah':'c','edward':'ruby','phil':'python'}
>>> for name in sorted(favorite_language):
... print(f'{name.title()},think you for taking the poll!')
...
Edward,think you for taking the poll!
Jen,think you for taking the poll!
Phil,think you for taking the poll!
Sarah,think you for taking the poll!
>>>

6.3.4 values()遍历字典中的所有值

1、使用values()方法可以获取字典中所有的值，返回列表。

>>> favorite_language = {'jen':'Python','sarah':'c','edward':'ruby','phil':'python'}
>>> print('The following languages have been mentioned')
The following languages have been mentioned
>>> for language in favorite_language.values():
... print(language.title())
...
Python
C
Ruby
Python
>>>

2、字典中存在许多重复值时，可以使用set()方法将重复的值删除

>>> favorite_language = {'jen':'Python','sarah':'c','edward':'ruby','phil':'Python'}
>>> for language in set(favorite_language.values()):
... print(language.title())
...
Ruby
Python
C
>>>

set()函数的作用创建不包含重复元素的列表，删除重复元素。

6.4 嵌套

在有些情况会出现字典中包含列表，或者字典中包含另一个字典，这种情况叫嵌套。

6.4.1字典列表

将多个字典放入到列表中

>>> alien_0 = {'color':'green','points':5}
>>> alien_1 = {'color':'yellow','points':10}
>>> alien_2 = {'color':'red','point':15}
>>> aliens = [alien_0,alien_1,alien_2]
>>> for alien in aliens:
... print(alien)
...
{'color': 'green', 'points': 5}
{'color': 'yellow', 'points': 10}
{'color': 'red', 'point': 15}
>>>

快捷创建多个字典列表

>>> aliens = []

>>> for alien in range(30):
... new_alien = {'color':'green','points':5,'speed':'low'}
... aliens.append(new_alien)
...
>>> print(f'Total number if aliens:{len(aliens)}')
Total number if aliens:30
>>>

将列表中前三个外星人改为黄色

>>> for alien in aliens[:3]:
... alien['color'] = 'yellow'
...
>>> for alien in aliens[:5]:
... print(alien)
...
{'color': 'yellow', 'points': 5, 'speed': 'low'}
{'color': 'yellow', 'points': 5, 'speed': 'low'}
{'color': 'yellow', 'points': 5, 'speed': 'low'}
{'color': 'green', 'points': 5, 'speed': 'low'}
{'color': 'green', 'points': 5, 'speed': 'low'}
>>>

6.4.2 在字典中存储列表

1、将多个列表存储在字典中

>>> pizza = {'crust':'thick','topping':['mushrooms','extra cheese']}

>>> print(f"You ordered a {pizza['crust']} - crusr pizza""with the following toppings:")
You ordered a thick - crusr pizzawith the following toppings:
>>> for topping in pizza['topping']:
... print(f"\t {topping} + topping")
...
mushrooms + topping
extra cheese + topping
>>>

2、我们使用字典中的键来获取字典中的值列表

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

>>> for name,language in favorite_language.items():
... print(f"\n{name.title()}'s favorite languages are:")
... for lang in language:
... print(f'\t{lang.title()}')
...

Jen's favorite languages are:
Python
Ruby

Sarah's favorite languages are:
C

Edward's favorite languages are:
Ruby
Go

Phil's favorite languages are:
Python
Haskell
>>>

6.4.3 在字典中存储字典

我们有很多用户，每个用户都有自己的信息，那我们需要用用户名作为字典的键，用户信息作为字典的值，用户信息又会分为多种不同信息，同样需要用字典来保存。

>>> user = {
... "aeinstenin":{
... "first":"albert",
... "last":"einstenin",
... "location":"princeton",
... },
... "mcurie":{
... "first":"marie",
... "last":"curie",
... "location":"paris",
... },
... }
>>> for username,user_info in user.items():
... print(f"\n Username:{username}")
... full_name = f"{user_info['first']} {user_info['last']}"
... location = user_info['location']
...
... print(f"\tFull name :{full_name.title()}")
... print(f"\tLocation:{location.title()}")
...

Username:aeinstenin
Full name :Albert Einstenin
Location:Princeton

Username:mcurie
Full name :Marie Curie
Location:Paris
>>>

字典嵌套字典时，字典中的数据结构都相同，这样有利于循环读取，便于处理里面的代码。如果数据不同，代码将很复杂。

第七章用户输入和While循环

7.1函数input()工作原理

input()函数可以让程序暂停运行，等待用户输入一些文本，获取用户输入的文本后程序向下执行。

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

在使用input()函数时，需要向用户提供提示说明，告诉用户要如何去做。

7.1.1编写清晰的程序

每当使用input()函数时，都必须指定清晰易懂的提示，准确的指出希望用户提供的信息。

>>> name = input("Please enter you name : ")
Please enter you name : YGL
>>> print(f"{name.title()}")
Ygl
>>>

当提示很长，有多行的时候，可以用变量保存提示，在程序中调用提示，保证代码的可读性。

>>> prompt = "If you tell us who you are ,we can personalize the message you see ."
>>> prompt += "\n What is you name?"
>>> name = input(prompt)
If you tell us who you are ,we can personalize the message you see .
What is you name?ygl
>>> print(f"Hello {name.title()}")
Hello Ygl
>>>

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

使用input()函数时，用户输入的信息类型为字符串，不管是不是数字，都按照字符串接收。

>>> age = input("How old you ?")
How old you ?21
>>> age
'21'
>>>

我们可以使用int()函数来将用户输入的数值字符串转化为整数。

>>> age = input("How old you ?")
How old you ?21
>>> age = int(age)
>>> age >= 18
True
>>>

7.1.3求模运算符

%求模运算符就是求一个数除以一个数所得的余数，我们可以使用它来判断一个数是不是偶数

>>> number = input("Enter a number ,and I'll tell you if it's even or odd: ")
Enter a number ,and I'll tell you if it's even or odd: 42
>>> number = int(number)
>>> if number%2 == 0:
... print(f"\n The number {number} is even.")
... else:
... print(f"\n The number {number} is odd")
...

The number 42 is even.
>>>

7.2 while循环简介

for 循环时有次数的循环，针对集合中的所有元素都执行一个代码块，而while循环则不断运行，直到指定条件不满足为止。

7.2.1使用while循环

使用while循环来数数

>>> current_num = 1
>>> while current_num <=5:
... print(current_num)
... current_num +=1
...
1
2
3
4
5
>>>

7.2.2 让用户选择退出

可以使用while循环让程序在用户愿意时不断运行，当用户输入的值为停止值时，停止运行。

>>> prompt = "\n Tell me something ,and I will repeat it back to you :"
>>> prompt += "Enter 'quit' to end the program"
>>> message = ""
>>> while message != 'quit':
... message = input(prompt)
... print(message)
...

Tell me something ,and I will repeat it back to you :Enter 'quit' to end the program

Tell me something ,and I will repeat it back to you :Enter 'quit' to end the programquit
quit
>>>

7.2.3 使用标志

我们在使用while时通常会使用一个标志，这个标志是一个布尔值，通过对布尔值的赋值来控制while程序的运行。

>>> prompt = "\nTell me something ,and I will repect it back you :"
>>> prompt += "\nEnter 'quit' to end the program."
>>> active = True
>>> while active:
... message = input(prompt)
... if message =='quit':
... active = False
... else:
... print(message)
...

Tell me something ,and I will repect it back you :
Enter 'quit' to end the program.Hello
Hello

Tell me something ,and I will repect it back you :
Enter 'quit' to end the program.Hi HI
Hi HI

Tell me something ,and I will repect it back you :
Enter 'quit' to end the program.quit
>>>

7.2.4使用break退出循环

要立即退出循环并不再执行循环中的其他代码，我们需要使用break退出循环

>>> prompt = "\nTell me something ,and I will repect it back you :"
>>> prompt += "\nEnter 'quit' to end the program."
>>> active = True

>>> while active:
... message = input(prompt)
... if message == 'quit':
... break
... else:
... print(message)
...

Tell me something ,and I will repect it back you :
Enter 'quit' to end the program.No
No

Tell me something ,and I will repect it back you :
Enter 'quit' to end the program.Hellow
Hellow

Tell me something ,and I will repect it back you :
Enter 'quit' to end the program.quit
>>>

7.2.5在循环中使用continue

当条件符合我们要求时，我们想从循环开头重新开始，省略下面的代码执行，这个时候我们可以使用continue。

比如：从1~10 我们只打印其中的奇数

>>> current_num = 0
>>> while current_num <10:
... current_num += 1
... if current_num%2 == 0 :
... continue
... print(current_num)
...
1
3
5
7
9
>>>

7.2.6 避免无限循环

每个while循环都必须有停止的途径，不能一直执行下去。

>>> x = 1
>>> while x <= 5:
... print(x)
... x +=1
...
1
2
3
4
5
>>>

当程序缺少了 x+= 1这行代码，那while循环将永远执行下去，我们必须避免这种情况的发生。

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

使用for循环遍历列表是一种很有效的方式，但是不能在遍历的时候修改列表中的值，值的改变会是for循环失去指针。可以通过while循环来遍历列表与字典。

7.3.1在列表之间移动元素

当我们有一个列表中有一些未验证的用户，我们需要验证这些用户后把他们放入另一个验证后的列表中。

>>> unconfirmed_user = ['alice','brian','candace']
>>> confirmed_user = []
>>> while unconfirmed_user:
... current_user = unconfirmed_user.pop()
... print(f"Verifying user:{current_user.title()}")
... confirmed_user.append(current_user)
...
Verifying user:Candace
Verifying user:Brian
Verifying user:Alice
>>> print("\nThe following users have been confirmed:")

The following users have been confirmed:
>>> for user in confirmed_user:
... print(user)
...
candace
brian
alice
>>>

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

我们之前使用remove()函数删除列表中的特定元素，如果这个元素在列表中有很多个，那我们使用remove()只能删除最开始的那一个。我们可以使用while循环来删除其中的出现多次的元素。

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

7.3.3使用用户输入填充字典

可以使用while循环提示用户输入多次任意信息，并将信息保存到一个字典中。

respones = {}
>>> active = True

>>> while active:
... name = input("\nWhat you name?")
... response = input("While mountain would you like to climb someday?")
... responses[name] = response
... repeat = input("Whold you like to let another person respond?(yes/no)")
... if repeat == 'no':
... active = False
...

What you name?Eric
While mountain would you like to climb someday?Denali
Whold you like to let another person respond?(yes/no)yes

What you name?Lynn
While mountain would you like to climb someday?Devil's THumb
Whold you like to let another person respond?(yes/no)no
>>> print("\n -- Pool Result ---")

-- Pool Result ---
>>> for name, response in responses.items():
... print(f"{name.title()} would like to climb {response}")
...
Eric would like to climb Denali
Lynn would like to climb Devil's THumb
>>>

第八章函数

8.1定义函数

当我们遇到重复的代码时，每次将这些代码重新编写，既影响了代码的可读性，有浪费了时间，我们可以使用函数将这些代码放到一起。在需要这些代码时再调用。

>>> def greet_user():
... print("Hello!")
...
>>> greet_user()
Hello!
>>>

def：关键字用来定义函数。

greet_user：定义的函数名

print("Hello!")：函数代码块

我们要是用函数就需要使用函数名来调用它，这就是调用函数。

8.1.1向函数传递信息

如果一个函数内的代码变量都是固定的，那我们也只能在特定的时候使用它，那当需要函数中不同的变量或代码时我们只能重新写一个函数并修改函数名和其中的变量与代码。这样就违背了我们简化代码，提升代码阅读性的初衷，这时我们就需要像击鼓传花一样，把我们需要的变量传到函数中去。这时我们就需要用的函数的传参。

我们可以给函数添加一个参数，我们调用函数同时对参数赋值，函数中参数也会有相应的变化。

>>> def greet_user(name):
... '''显示简单的问候'''
... print(f"{name.title()} Hello !")
...
>>> greet_user('jesse')
Jesse Hello !
>>>

name ：传参

8.1.2实参和行参

在之前的代码中，我们定义的传参name为形参，我们在调用函数时传入的参数"Jesse"为实参。

8.2传递实参

函数定义中可能有多个形参，因此函数调用也可能有多个实参

传递实参与形参的位置顺序相同叫做位置实参。

我们直接将形参进行赋值的形式叫做关键字实参。

8.2.1位置实参

实参与形参的位置相对应，这种基于实参顺序的传参方式叫位置实参。

>>> def describe_pet(animal,pet_name):
... '''显示宠物信息'''
... print(f"\nI have a {animal}.")
... print(f"My {animal}'s name is {pet_name.title()}")
...
>>> describe_pet("hamster","harry")

I have a hamster.
My hamster's name is Harry
>>>

hamster实参被赋给了animal形参

harry实参被赋给了pet_name形参

这种赋值是顺序决定的

1、多次调用函数

当我们需要做很多次相同的事情时，多次调用函数给我们带来了便利。

>>> def describe_pet(animal,pet_name):
... '''显示宠物信息'''
... print(f"\nI have a {animal}.")
... print(f"My {animal}'s name is {pet_name.title()}")
...
>>> describe_pet("hamster","harry")

I have a hamster.
My hamster's name is Harry
>>> describe_pet("dog","willie")

I have a dog.
My dog's name is Willie
>>>

2、位置参数顺序很重要

传参时如果实参顺序错误，函数运行也会是错误的结果。

>>> describe_pet("harry","hamster")

I have a harry.
My harry's name is Hamster
>>>

8.2.2关键字实参

关键字实参是传递给函数的名称值对，将实参与形参关联起来，在传递参数时即使顺序错误也能正确传参。

>>> def describe_pet(animal,pet_name):
... '''显示宠物信息'''
... print(f"\nI have a {animal}.")
... print(f"My {animal}'s name is {pet_name.title()}")
...

>>> describe_pet(pet_name = "harry",animal = "hamster")

I have a hamster.
My hamster's name is Harry
>>>

从上面的代码我们可以看出，关键字传参，即使是不按照顺序，只要将实参与形参关联，运行结果就是正确的。

8.2.3默认值

编写函数时，可给每个形参指定默认值，在调用函数时，如果未传递实参，形参会被赋值为默认值，保证程序不会因为没有实参而报错。

>>> def describe_pet(pet_name,animal = "dog"):
... '''显示宠物讯息'''
... print(f"\nI have a {animal}.")
... print(f"My {animal}'s name is {pet_name.title()}")
...
>>> describe_pet(pet_name = "Willie")

I have a dog.
My dog's name is Willie
>>>
animal = "dog" 在定义形参的时候直接将形参赋值，所赋予的值就是形参的默认值。

当形参有默认值时，调用函数时可以不给有默认值的形参传递实参。

8.2.4等效的函数调用

对于已有形参并且形参设定了默认值：animal = "dog"

下面这些函数调用都是可行的

只传递名字实参

describe_pet("willie")

describe_pet(pet_name = "willie")

传递所有实参

describe_pet("harry","hamster")

describe_pet(pet_name = "harry",animal = "hamster")

describe_pet(animal = "hamster",pet_name = "harry")

8.2.5避免实参错误

要注意的是没有定义默认值的形参必须要传入实参，如果忘记传入实参会报错。

>>> describe_pet()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: describe_pet() missing 1 required positional argument: 'pet_name'
>>>

8.3返回值

函数并非是只能显示有些东西，还可以经过函数内的代码处理一些复杂的操作并返回一个值，这个值叫做返回值。

8.3.1返回简单值

使用return将函数处理后的数据返回，并又函数外的变量接收。


def get_formatted_name(first_name, last_name):
    '''返回整洁的姓名'''
    full_name = f"{first_name} {last_name}"
    return full_name.title()
musician = get_formatted_name("jimi","hendrix")
print(musician)

8.3.2让实参变成可选

我们提供一个中间名，将名、中间名、和姓结合起来


def get_formatted_name(first_name,middle_name, last_name):
    '''返回整洁的姓名'''
    full_name = f"{first_name} {middle_name} {last_name}"
    return full_name.title()
musician = get_formatted_name("john","lee","last_name")
print(musician)
 
John Last_Name Lee

但不是所有人都有中间名，我们可以将中间名设定为可选参数。给中间名一个空默认值。当调用函数时，可以不传参中间名，程序不会报错。


def get_formatted_name(first_name,last_name,middle_name = ""):
    '''返回整洁的姓名'''
    full_name = f"{first_name} {middle_name} {last_name}"
    return full_name.title()
musician = get_formatted_name("jimi","hendrix")
print(musician)
musician = get_formatted_name("john","lee","last_name")
print(musician)
 
Jimi  Hendrix
John Last_Name Lee

在函数的形参中，我们把middle_name赋值为空，这样middle_name就成为了可选参数。可以传参也可以省略。

8.3.3返回字典

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


def build_person(first_name,last_name,age = None):
    '''返回一个字典，其中包含有关一个人的信息'''
    person = {'first':first_name,'last':last_name}
    if age:
        person['age'] = age
    return person
musician = build_person('jimi','hendrix')
print(musician)
musician = build_person('jimi','hendrix',age = 27)
print(musician)
 
{'first': 'jimi', 'last': 'hendrix'}
{'first': 'jimi', 'last': 'hendrix', 'age': 27}

我们将age设定为一个可选参数，并将其默认值设定None，可将None设定为占值符，None相当于False。

8.3.4结合使用函数和while

可以使用Python中的其他结构与函数结合起来，使程序可读性更高。


def get_formatted_name(first_name = None,last_name = None):
    '''返回整洁的姓名'''
    full_name = f"{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(f"\nHello,{formatted_name}!")
 
 
 
Please tell me your name:
(enter 'q' at any time to quit)
First_name:eric
Last_name:matthes
 
Hello,Eric Matthes!
 
Please tell me your name:
(enter 'q' at any time to quit)
First_name:q

我们使用了可选参数来保证用户只输入姓或名的情况不会报错，同时也使用了break在用户输入q时停止循环。

8.4传递列表

我们可以传递变量给函数，当然我们也可以传递列表给函数。这样可以传递更多信息给函数进行处理。


 
def greet_users(names):
    '''向列表中的每个用户发出简单的问候'''
    for name in names:
        msg = f"Hello,{name.title()}"
        print(msg)
user_names = ["hannah","ty","margot"]
greet_users(user_names)
 
 
Hello,Hannah
Hello,Ty
Hello,Margot

8.4.1在函数中修改列表

在函数中修改列表都是永久性的，对于列表的传参传递的是列表的地址，所有当函数内修改列表时函数外同样生效。


unprinted_designs = ['phone_case','robot pendant','dodecahedron']
completed_models = []
while unprinted_designs:
    current_design = unprinted_designs.pop()
    print(f"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)
 
 
Printing model:dodecahedron
Printing model:robot pendant
Printing model:phone_case
 
The following models have been printed:
dodecahedron
robot pendant
phone_case

我们可以根据我们之前学习的知识，将上面的代码变成两个函数，是代码更加简洁。


def print_models(unprinted_designs,completed_models):
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        print(f"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 = ['phone_case','robot pendant','dodecahedron']
completed_models = []
#调用函数
print_models(unprinted_designs,completed_models)
show_completed_models(completed_models)

8.4.2禁止修改列表

当我们需要传递列表，并希望列表的值不被修改时，我们可以将列表的值传递给函数，而不是将列表的地址传递给函数。

使用切片的方式将列表中的元素传递给函数：
function_name(list_name[:])


def print_models(unprinted_designs,completed_models):
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        print(f"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 = ['phone_case','robot pendant','dodecahedron']
completed_models = []
#调用函数
print_models(unprinted_designs[:],completed_models)
print(unprinted_designs)
show_completed_models(completed_models)
 
Printing model:dodecahedron
Printing model:robot pendant
Printing model:phone_case
['phone_case', 'robot pendant', 'dodecahedron']
 
The following models have been printed:
dodecahedron
robot pendant
phone_case

8.5传递任意数量的实参

有时间我们不知道需要传递多少参数给函数，Python允许函数从调用语句中收集任意数量的实参。


def make_pizza(*toppings):
    '''打印顾客点的所有配料'''
    print(toppings)
make_pizza(['pepperoni'])
make_pizza(['mushrooms','green peppers','extra cheese'])
 
 
(['pepperoni'],)
(['mushrooms', 'green peppers', 'extra cheese'],)

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

注意：python将实参封装到一个元组中，所有无论参数为多少，都可以正常运行。

使用循环读取元组中的值


def make_pizza(*toppings):
    '''打印顾客点的所有配料'''
    for topping in toppings:
        print(f'--{topping}')
make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')
 
 
--pepperoni
--mushrooms
--green peppers
--extra cheese

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

如果要让函数接收其他类型的实参与任意数量的实参，那必须将任意数量的形参的最后面，并在传参时先使用位置实参或关键字实参传递，然后再传递任意数量的实参。


def make_pizza(size,*toppings):
    '''打印顾客点的所有配料'''
    print(f"\nMaking a {size}-inch pizza with the following topping:")
    for topping in toppings:
        print(f'--{topping}')
make_pizza(6,'pepperoni')
make_pizza(12,'mushrooms','green peppers','extra cheese')
 
 
 
Making a 6-inch pizza with the following topping:
--pepperoni
 
Making a 12-inch pizza with the following topping:
--mushrooms
--green peppers
--extra cheese

注意：在代码中经常看到的*args就是接收任意数量实参的意思。

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

函数使用元组可以接收任意数量的实参，函数还可以使用字典接收任意数量的关键字实参。


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就是接收任意数量关键字实参的意思。

8.6将函数存储在模块中

函数可以写在模块中与主程序分开，需要使用模块中的函数时可以将模块导入到主程序，利用模块名调用对应的函数。import语句就是导入模块使用的。

将函数保存在独立的文件中，可隐藏代码细节，将重点放在主程序的高逻辑中。也可以让多个程序中重用函数。导入函数的方式也能让你白嫖其他程序员的函数。

8.6.1导入整个模块 import

模块时拓展名为.py的文件，其中包含要导入的函数代码。

模块文件：


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

主程序代码：


import pizza
 
pizza.make_pizza(16,'pepperoni')
pizza.make_pizza(12,'mushrooms','green_peppers','extra cheese')
 
 
 Making a 16-inch pizza with the following toppings:
- pepperoni
 
 Making a 12-inch pizza with the following toppings:
- mushrooms
- green_peppers
- extra cheese

我们可以使用下面语法调用任何模块文件中的任何函数

model_name.function_name()

8.6.2导入特定的函数 from..import...

我们还可以导入模块中特定的函数

from model_name import function_name


from pizza import make_pizza
 
make_pizza(16,'pepperoni')
make_pizza(12,'mushrooms','green_peppers','extra cheese')

通过逗号导入任意数量的函数

from model_name import function_0,function_1,function_2

8.6.3 使用as给函数指定别名 from...import... as...

我们可以给导入的模块中的函数指定别名，可以给函数指定简短的别名来轻松调用模块中的函数。

from model_name import function_name as mn


from pizza import make_pizza as mp
 
mp(16,'pepperoni')
mp(12,'mushrooms','green_peppers','extra cheese')

8.6.4使用as给模块指定别名 import... as...

我们可以给导入的模块指定别名，可以给模块指定简短的别名来轻松调用模块中的函数。

import model_name as mn


import pizza as p
 
p.make_pizza(16,'pepperoni')
p.make_pizza(12,'mushrooms','green_peppers','extra cheese')

8.6.5导入模块中的所有函数 *

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

from model_name import *


from pizza import *
 
make_pizza(16,'pepperoni')
make_pizza(12,'mushrooms','green_peppers','extra cheese')

8.7函数编写指南

编写函数时要牢记几个细节：
1、函数名要使用描述性名称，且只能使用小写字母与下划线。

2、函数内要有描述性功能注释，阐述其功能，注释要紧跟在函数名后面，并采用文档字符串的形式。

3、给形参指定默认值时，等号两边不能有空格。

4、对于调用函数时，传入的关键字实参的等号两边不能有空格。

5、函数定义的形参较长时，可以在左括号后换行

def function_name(

parameter_0,parameter_1,parameter_2,

parameter_3,parameter_4,parameter_5):

function body...

第九章类

9.1创建和使用类

类，顾名思义，表示一种类型，如：人类，是对我们人的一种归类；车，是对所有车的统称和归类。

创建类就是能表达同一类的相同特征。

9.1.1创建Dog类

狗都会蹲下和打滚，我们创建一个Dog类，并在类中创建蹲下和打滚的函数。当我们创建一个小狗对象时，小狗对象就有了蹲下和打滚的功能。


class Dog:
    '''一次模拟小狗的简单尝试'''
 
    def __int__(self,name,age):
        '''初始化属性 name 和 age'''
        self.name = name
        self.age = age
 
    def sit(self):
        '''模拟小狗收到命令时蹲下'''
        print(f'{self.name} is now sitting.')
 
    def roll_over(self):
        '''模拟小狗收到指令时打滚'''
        print(f"{self.name} roller over.")

1、方法 init()

类中的函数成为方法，所以之前所有关于函数的一切都适用于方法，唯独调用的方法。

__init__()是一个特殊的方法，当使用Dog类创建新实例时会默认运行。

__init__()中有三个形参其中self是必须要存在的形参，且必须位于所有形参前面。为什么一定要有形参self？因为Python调用方法创建Dog实例时，将自动传入实参self。它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。

2、self.变量

定义的变量前都有self，已self为前缀的变量可供类中的所有方法使用。可以通过类中的任何实例来访问，相当于类中的全局变量。

self.name = name 获取形参相关联的值，将其赋值给变量name。然后该变量被关联到当前创建的实例。这样可以通过实例访问的变量称为属性。

9.1.2根据类创建实例

可将类看做创建相关实例的说明，如Dog类中的相关属性和方法告诉我们如何创建小狗。


class Dog:
    '''一次模拟小狗的简单尝试'''
    def __init__(self,name,age):
        '''初始化属性 name 和 age'''
        self.name = name
        self.age = age
 
    def sit(self):
        '''模拟小狗收到命令时蹲下'''
        print(f'{self.name.title()} is now sitting.')
 
    def roll_over(self):
        '''模拟小狗收到指令时打滚'''
        print(f"{self.name.title()} rolled over!")
 
my_dog = Dog("Willie",6)
print(f"My dog's name is {my_dog.name}.")
print(f"My dog is {my_dog.age} years old.")
 
my_dog.sit()
my_dog.roll_over()
 
 
 
 
My dog's name is Willie.
My dog is 6 years old.
Willie is now sitting.
Willie rolled over!

1、访问属性

my_dog.name

使用实例点属性，可以访问与该实例关联的属性。

2、调用方法

my_dog.sit()

使用实例点方法，可以调用Dog中定义的任何方法。

3、创建多个实例


my_dog = Dog("Willie",6)
your_dog = Dog("Lucy",3)
 
print(f"My dog's name is {my_dog.name}.")
print(f"My dog is {my_dog.age} years old.")
my_dog.sit()
 
print(f"My dog's name is {your_dog.name}.")
print(f"My dog is {your_dog.age} years old.")
your_dog.sit()
 
 
My dog's name is Willie.
My dog is 6 years old.
Willie is now sitting.
My dog's name is Lucy.
My dog is 3 years old.
Lucy is now sitting.

9.2使用类和实例

使用类来虚拟现实世界，类编好后，你的大部分时间将花在创建实例上，你需要执行一个重要的任务是修改实例的属性。可以直接修改实例的属性，也可以编写方法已特定的方式进行修改。

9.2.1Car类

编写一个汽车类，存储汽车的相关信息。


class Car:
    '''一次模拟汽车的简单尝试'''
    def __init__(self,make,model,year):
        '''初始化描述汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
 
    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
 
my_new_car = Car('audi','a4',2019)
 
 
 
2019 Audi A4

9.2.2给属性指定默认值

我们在__init__()初始化方法中为属性赋值，那这个值就是属性的默认值。


class Car:
    '''一次模拟汽车的简单尝试'''
    def __init__(self,make,model,year):
        '''初始化描述汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
 
    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def read_odometer(self):
        '''打印一条指出汽车里程的消息'''
        print(f"This car has {self.odometer_reading} miles on it.")
 
my_new_car = Car('audi','a4',2019)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()

9.2.3修改属性的值

1、直接修改属性的值

我们可以使用实例给属性重新赋值来修改属性的值。


class Car:
    '''一次模拟汽车的简单尝试'''
    def __init__(self,make,model,year):
        '''初始化描述汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
 
    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def read_odometer(self):
        '''打印一条指出汽车里程的消息'''
        print(f"This car has {self.odometer_reading} miles on it.")
 
my_new_car = Car('audi','a4',2019)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
 
 
2019 Audi A4
This car has 23 miles on it.

2、使用方法修改属性的值


class Car:
    '''一次模拟汽车的简单尝试'''
    def __init__(self,make,model,year):
        '''初始化描述汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
 
    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def read_odometer(self):
        '''打印一条指出汽车里程的消息'''
        print(f"This car has {self.odometer_reading} miles on it.")
    def update_odometer(self,mileage):
        '''
        将里程表读数设置为指定的值
        '''
        self.odometer_reading = mileage
 
my_new_car = Car('audi','a4',2019)
print(my_new_car.get_descriptive_name())
 
my_new_car.update_odometer(23)
my_new_car.read_odometer()
 
 
2019 Audi A4
This car has 23 miles on it.

3、通过方法对属性的值进行递增


class Car:
    '''一次模拟汽车的简单尝试'''
    def __init__(self,make,model,year):
        '''初始化描述汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
 
    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def read_odometer(self):
        '''打印一条指出汽车里程的消息'''
        print(f"This car has {self.odometer_reading} miles on it.")
    def update_odometer(self,mileage):
        '''
        将里程表读数设置为指定的值
        '''
        self.odometer_reading = mileage
    def increment_odometer(self,miles):
        '''将里程表读数增加指定的量'''
        self.odometer_reading += miles
 
my_new_car = Car('audi','a4',2019)
print(my_new_car.get_descriptive_name())
 
my_new_car.update_odometer(23_500)
my_new_car.read_odometer()
 
my_new_car.increment_odometer(100)
my_new_car.read_odometer()
 
 
2019 Audi A4
This car has 23500 miles on it.
This car has 23600 miles on it.

9.3继承

要编写一个类，既包含现有的旧类的功能，有包含新的功能，那我们可以使用继承，一个类继承另一个类时，将自动获取另一个类的所有属性和方法。原类叫做父类，而新类叫做字类。

9.3.1子类的方法__init__()

我们既然要继承父类那就要关联父类。

class 父类名：

class 子类名(父类名)：

__init__(self):

'''重写父类的属性'''

super().__init__(父类的属性)


class Car:
    '''一次模拟汽车的简单尝试'''
    def __init__(self,make,model,year):
        '''初始化描述汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
 
    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def read_odometer(self):
        '''打印一条指出汽车里程的消息'''
        print(f"This car has {self.odometer_reading} miles on it.")
    def update_odometer(self,mileage):
        '''
        将里程表读数设置为指定的值
        '''
        self.odometer_reading = mileage
    def increment_odometer(self,miles):
        '''将里程表读数增加指定的量'''
        self.odometer_reading += miles
 
class ElectricCar(Car):
    '''电动汽车的独特之处'''
    def __init__(self,make,model,year):
        '''初始化父类的属性'''
        super().__init__(make,model,year)
 
 
my_tesla = ElectricCar('tesla','model s',2019)
print(my_tesla.get_descriptive_name())
 
2019 Tesla Model S

注意：

1、创建子类时，父类必须包含在当前文件中。

2、在定义子类时，必须在括号内指定父类名称。

3、super()是一个特殊函数，让你能够调用父类的方法，super().__init__()，相当于初始化一个父类供你使用，父类又叫做超类也是有此而来。

9.3.2给子类定义属性和方法

我们创建子类的原因是子类比父类有更多的特殊方法和属性，那我们来为电动车添加特殊的方法和属性吧。


class Car:
    '''一次模拟汽车的简单尝试'''
    def __init__(self,make,model,year):
        '''初始化描述汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
 
    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def read_odometer(self):
        '''打印一条指出汽车里程的消息'''
        print(f"This car has {self.odometer_reading} miles on it.")
    def update_odometer(self,mileage):
        '''
        将里程表读数设置为指定的值
        '''
        self.odometer_reading = mileage
    def increment_odometer(self,miles):
        '''将里程表读数增加指定的量'''
        self.odometer_reading += miles
 
class ElectricCar(Car):
    '''电动汽车的独特之处'''
    def __init__(self,make,model,year):
        '''初始化父类的属性'''
        super().__init__(make,model,year)
        self.battery_size = 75
    def describe_battery(self):
        '''打印一条描述电瓶容量的消息'''
        print(f"This car has a {self.battery_size}-kWh battery.")
    def fill_gas_tank(self):
        '''电动汽车没有油箱'''
        print("This car doesn't need a gas tank!")
 
my_tesla = ElectricCar('tesla','model s',2019)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
 
 
2019 Tesla Model S
This car has a 75-kWh battery.

对于子类的特殊性没有限制，可以添加任意的属性和方法，但是当一个子类的属性和方法是整个类都具有的，那应当将此属性和方法添加到父类中，如电动车有轮子，都有的车都有轮子，那我们就需要将有轮子这个属性添加到车这个父类中。

9.3.3重写父类的方法

对于同一种方法，子类表现出来的与父类不同，那我们可以在子类中重写父类的方法。

这样在使用子类调用这个方法时，只能调用子类的方法，表现出子类特有的方法。


class Car:
    '''一次模拟汽车的简单尝试'''
    def __init__(self,make,model,year):
        '''初始化描述汽车的属性'''
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
 
    def get_descriptive_name(self):
        '''返回整洁的描述性信息'''
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def read_odometer(self):
        '''打印一条指出汽车里程的消息'''
        print(f"This car has {self.odometer_reading} miles on it.")
    def update_odometer(self,mileage):
        '''
        将里程表读数设置为指定的值
        '''
        self.odometer_reading = mileage
    def increment_odometer(self,miles):
        '''将里程表读数增加指定的量'''
        self.odometer_reading += miles
    def fill_gas_tank(self):
        '''汽车有油箱'''
        print("This car has a gas tank!")
 
class ElectricCar(Car):
    '''电动汽车的独特之处'''
    def __init__(self,make,model,year):
        '''初始化父类的属性'''
        super().__init__(make,model,year)
        self.battery_size = 75
    def describe_battery(self):
        '''打印一条描述电瓶容量的消息'''
        print(f"This car has a {self.battery_size}-kWh battery.")
    def fill_gas_tank(self):
        '''电动汽车没有油箱'''
        print("This car doesn't need a gas tank!")
 
my_tesla = ElectricCar('tesla','model s',2019)
print(my_tesla.get_descriptive_name())
my_tesla.fill_gas_tank()
 
 
2019 Tesla Model S
This car doesn't need a gas tank!

9.3.4 将实例用作属性

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/550267

蟒蛇书第二版Python入门_python蟒蛇书电子版

第二章变量与简单的数据类型

2.2变量

2.21变量的命名与使用

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

2.23变量是标签

2.3字符串

2.3.1修改字符串的大小写

2.3.2在字符串中插入变量

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

2.3.4删除空白

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

2.4数

2.4.1整数

2.4.2浮点数

2.4.3整数和浮点数

2.4.4数中的下划线

2.4.5同时给多个变量赋值

2.4.6常量

2.5注释

2.5.1如何注释

2.5.2该如何备注

第三章列表简介

3.1什么是列表

3.1.1访问列表元素

3.1.2索引从0开始不是从1开始

3.1.3使用列表中的个值

3.2修改、添加和删除元素

3.2.1修改列表元素

3.2.2列表中添加元素

1、append()在列表的末尾添加元素

2、insert()在列表中插入元素

3.2.3从列表中删除元素

1、使用del语句删除元素

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

3、pop(0)弹出列表中任何位置处的元素

4、remove()根据元素删除元素

3.3组织列表

3.3.1 sort()对列表进行永久排序

1、正排序

2、反排序 属性reverse

3.3.2 sorted()临时排序

3.3.3 reverse() 倒着打印列表

3.3.4 len()确定列表的长度

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

1、当所访问的索引超出列表元素个数时会报错。

2、记住索引从0开始

3、使用索引-1可以访问最后一个元素，当列表为空时会报错。

第四章操作列表

4.1遍历整个列表

4.1.1 for循环

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

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

4.2避免缩进错误

4.2.1忘记缩进

4.2.2忘记缩进额外的代码。

4.2.3不必要的缩进

4.2.4循环后不必要的缩进

4.2.5漏了冒号

4.3创建数值列表

4.3.1range()函数

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

1、使用list()将range()的结果转化为列表并保存到变量中。

2、设定range()的步长

3、利用range()与for创建其他数字列表

4.3.3 min()max()sum()对数字列表执行简单的统计计算

1、min()求列表中的最小值

2、max()求列表中的最大值

3、sum()求列表中的所有元素的和

4.3.4列表解析

4.4使用类表的一部分

4.4.1切片

1、从0开始输出列表中三个元素

2、从1开始输出三个元素

3、从0开始输出四个元素

4、从末尾输出所有元素

5、从倒数第三个元素输出到末尾

4.4.2遍历切片

4.4.3 复制列表(copy() deepcopy())

1、使用切片的形式复制列表

2、反排序属性reverse