Python学习笔记——第二课堂

变量和数据类型

变量

• 变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为message_1，但不能将其命名为1_message。
• 变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greeting message会引发错误。
• 不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print （请参见附录A.4）。
• 变量名应既简短又具有描述性。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。
• 慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0。

练习

简单消息：将一条消息储存到变量中，再将其打印出来

massage = "Hello Python"
print(massage)

Hello Python

多条简单消息：将一条消息存储到变量中，将其打印出来；再将变量的值修改为一条新消息，并将其打印出来。

massage = "Hello"
print(massage)
massage = "World"
print(massage)

Hello
World

字符串

字符串字符串 就是一系列字符。在Python中，用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号

修改字符串的大小写

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

合并字符串

Python使用加号（+ ）来合并字符串。这种合并字符串的方法称为拼接拼接 。通过拼接，可使用存储在变量中的信息来创建完整的消息

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

在编程中，空白空白 泛指任何非打印字符，如空格、制表符和换行符。你可使用空白来组织输出，以使其更易读。

删除空白

Python能够找出字符串开头和末尾多余的空白。要确保字符串末尾没有空白，可使用方法rstrip()

你还可以剔除字符串开头的空白，或同时剔除字符串两端的空白。为此，可分别使用方法lstrip() 和strip()

练习

个性化消息：将用户的姓名存到一个变量中，并向该用户显示一条消息。显示的消息应非常简单，如“Hello Eric, would you like to learn some Python today?”。

name = "ada lovelace"
print("Hello " + name.title()  + " , would you like to learn some Python today?")  

Hello Ada Lovelace , would you like to learn some Python today?

调整名字的大小写：将一个人名存储到一个变量中，再以小写、大写和首字母大写的方式显示这个人名

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

ADA LOVELACE
ada lovelace
Ada Lovelace

剔除人名中的空白：剔除人名中的空白： 存储一个人名，并在其开头和末尾都包含一些空白字符。务必至少使用字符组合"\t" 和"\n" 各一次。
打印这个人名，以显示其开头和末尾的空白。然后，分别使用剔除函数lstrip() 、rstrip() 和strip() 对人名进行处理，并将结果打印出来。

name = " alsa  \tLili    Blue     \n"
print(name)
print(name.lstrip())
print(name.rstrip())
print(name.strip())

 alsa  	Lili    Blue     

alsa  	Lili    Blue     

 alsa  	Lili    Blue
alsa  	Lili    Blue

数字

在Python中，可对整数执行加（+ ）减（- ）乘（* ）除（/ ）运算

Python将带小数点的数字都称为浮点数浮点数 。大多数编程语言都使用了这个术语，它指出了这样一个事实：小数点可出现在数字的任何位置。

练习

最喜欢的数字： 将你最喜欢的数字存储在一个变量中，再使用这个变量创建一条消息，指出你最喜欢的数字，然后将这条消息打印出来。 、

num = 7
print("my best number is " +  str(num))

my best number is 7

列表

列表 由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0~9或所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有 任何关系。鉴于列表通常包含多个元素，给列表指定一个表示复数的名称（如letters 、digits 或names ）是个不错的主意

在Python中，用方括号（[] ）来表示列表，并用逗号来分隔其中的元素。

修改列表元素

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

在列表中添加元素

在列表中添加新元素时，最简单的方式是将元素附加到列表末尾。给列表附加元素时，它将添加到列表末尾。

方法append() 让动态地创建列表易如反掌，例如，你可以先创建一个空列表，再使用一系列的append() 语句添加元素。

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

在列表中删除元素

如果知道要删除的元素在列表中的位置，可使用del 语句。使用del 可删除任何位置处的列表元素，条件是知道其索引。

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

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

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

练习

姓名： 将一些朋友的姓名存储在一个列表中，并将其命名为names 。依次访问该列表中的每个元素，从而将每个朋友的姓名都打印出来。

names = ['bababab', 'lili', 'oppop', 'whilesh', 'hahaha']
for item in names:
    print(item)

bababab
lili
oppop
whilesh
hahaha

问候语： 继续使用练习3-1中的列表，但不打印每个朋友的姓名，而为每人打印一条消息。每条消息都包含相同的问候语，但抬头为相应朋友的姓名。

names = ['bababab', 'lili', 'opop', 'jkjk']
for item in names:
    print(item + " , How are you?")

bababab , How are you?
lili , How are you?
opop , How are you?
jkjk , How are you?

自己的列表： 想想你喜欢的通勤方式，如骑摩托车或开汽车，并创建一个包含多种通勤方式的列表。根据该列表打印一系列有关这些通勤方式的宣言，如“I would like to own a Honda motorcycle”。

vehicles = ["bike", "car", "motorcycle", "bus", "on foot"]
for item in vehicles:
    print("I would like to go to school by  " + item )

I would like to go to school by  bike
I would like to go to school by  car
I would like to go to school by  motorcycle
I would like to go to school by  bus
I would like to go to school by  on foot

嘉宾名单 ：如果你可以邀请任何人一起共进晚餐（无论是在世的还是故去的），你会邀请哪些人？请创建一个列表，其中包含至少3个你想邀请的人；然后，使用
这个列表打印消息，邀请这些人来与你共进晚餐。

people = ["mom", "teacher", "frind", "lili", "zip", "mmoy"]
for item in people:
    print(item + " , Would you like to take dinna with me?")

mom , Would you like to take dinna with me?
teacher , Would you like to take dinna with me?
frind , Would you like to take dinna with me?
lili , Would you like to take dinna with me?
zip , Would you like to take dinna with me?
mmoy , Would you like to take dinna with me?

修改嘉宾名单 ：你刚得知有位嘉宾无法赴约，因此需要另外邀请一位嘉宾。
以完成练习3-4时编写的程序为基础，在程序末尾添加一条print 语句，指出哪位嘉宾无法赴约。
修改嘉宾名单，将无法赴约的嘉宾的姓名替换为新邀请的嘉宾的姓名。
再次打印一系列消息，向名单中的每位嘉宾发出邀请。

people = ["mom", "teacher", "frind", "lili", "zip", "mmoy"]
for item in people:
    print(item + " , Would you like to take dinna with me?")
print("lili could not take dinna with me")
people.remove("lili")
people.append("lucy")
for item in people:
    print(item + " , Would you like to take dinna with me?")

mom , Would you like to take dinna with me?
teacher , Would you like to take dinna with me?
frind , Would you like to take dinna with me?
lili , Would you like to take dinna with me?
zip , Would you like to take dinna with me?
mmoy , Would you like to take dinna with me?
lili could not take dinna with me
mom , Would you like to take dinna with me?
teacher , Would you like to take dinna with me?
frind , Would you like to take dinna with me?
zip , Would you like to take dinna with me?
mmoy , Would you like to take dinna with me?
lucy , Would you like to take dinna with me?

添加嘉宾 ：你刚找到了一个更大的餐桌，可容纳更多的嘉宾。请想想你还想邀请哪三位嘉宾。
以完成练习3-4或练习3-5时编写的程序为基础，在程序末尾添加一条print 语句，指出你找到了一个更大的餐桌。
使用insert() 将一位新嘉宾添加到名单开头。
使用insert() 将另一位新嘉宾添加到名单中间。
使用append() 将最后一位新嘉宾添加到名单末尾。
打印一系列消息，向名单中的每位嘉宾发出邀请。

people = ["lili", "popo", "wow", "gree", "moon", "ana"]
print("We have a big table!")
people.insert(0, "lucy")
people.append("xixi")
for item in people:
    print(item + " , Would you like to take dinna with me?")

We have a big table!
lucy , Would you like to take dinna with me?
lili , Would you like to take dinna with me?
popo , Would you like to take dinna with me?
wow , Would you like to take dinna with me?
gree , Would you like to take dinna with me?
moon , Would you like to take dinna with me?
ana , Would you like to take dinna with me?
xixi , Would you like to take dinna with me?

缩减名单 ：你刚得知新购买的餐桌无法及时送达，因此只能邀请两位嘉宾。
以完成练习3-6时编写的程序为基础，在程序末尾添加一行代码，打印一条你只能邀请两位嘉宾共进晚餐的消息。
使用pop() 不断地删除名单中的嘉宾，直到只有两位嘉宾为止。每次从名单中弹出一位嘉宾时，都打印一条消息，让该嘉宾知悉你很抱歉，无法邀请他来共进
晚餐。
对于余下的两位嘉宾中的每一位，都打印一条消息，指出他依然在受邀人之列。
使用del 将最后两位嘉宾从名单中删除，让名单变成空的。打印该名单，核实程序结束时名单确实是空的。

print("aoh,I can only invite two people")
people = ["lili", "poop", "greeen"]
people_non = people.pop()
print("sorry," + people_non  + ", I could not take dinna with you")
for i in people:
    print(i + " , You are still in list.")
del people[1]
del people[0]
print(people)

aoh,I can only invite two people
sorry,greeen, I could not take dinna with you
lili , You are still in list.
poop , You are still in list.
[]

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

方法sort() 永久性地修改了列表元素的排列顺序。按字母顺序排列的，再也无法恢复到原来的排列顺序

你还可以按与字母顺序相反的顺序排列列表元素，为此，只需向sort() 方法传递参数reverse=True 。

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

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

确定列表的长度

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

倒着打印列表

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

练习

放眼世界 ：想出至少5个你渴望去旅游的地方。
将这些地方存储在一个列表中，并确保其中的元素不是按字母顺序排列的。
按原始排列顺序打印该列表。不要考虑输出是否整洁的问题，只管打印原始Python列表。
使用sorted() 按字母顺序打印这个列表，同时不要修改它。
再次打印该列表，核实排列顺序未变。
使用sorted() 按与字母顺序相反的顺序打印这个列表，同时不要修改它。
再次打印该列表，核实排列顺序未变。
使用reverse() 修改列表元素的排列顺序。打印该列表，核实排列顺序确实变了。
使用reverse() 再次修改列表元素的排列顺序。打印该列表，核实已恢复到原来的排列顺序。
使用sort() 修改该列表，使其元素按字母顺序排列。打印该列表，核实排列顺序确实变了。
使用sort() 修改该列表，使其元素按与字母顺序相反的顺序排列。打印该列表，核实排列顺序确实变了

place = ["dalian", "datong", "beijin", "chengdu", "nanjin", "wulumuqi"]
print(place)
print(sorted(place))
print(place)
place.sort()
print(place)
place.sort(reverse=True)
print(place)

['dalian', 'datong', 'beijin', 'chengdu', 'nanjin', 'wulumuqi']
['beijin', 'chengdu', 'dalian', 'datong', 'nanjin', 'wulumuqi']
['dalian', 'datong', 'beijin', 'chengdu', 'nanjin', 'wulumuqi']
['beijin', 'chengdu', 'dalian', 'datong', 'nanjin', 'wulumuqi']
['wulumuqi', 'nanjin', 'datong', 'dalian', 'chengdu', 'beijin']

晚餐嘉宾 ：在完成练习3-4~练习3-7时编写的程序之一中，使用len() 打印一条消息，指出你邀请了多少位嘉宾来与你共进晚餐。

people=["lili", "opop", "ghgh", "anna"]
print("I have invited "+  str(len(people)) + "  people")

I have invited 4  people

使用range()创建数值列表

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

使用一个for 循环打印数字1~20（含）

for num in range(1, 21):
    print(num)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

创建一个列表，其中包含数字1~1 000 000，再使用min() 和max() 核实该列表确实是从1开始，到1 000 000结束的。另外，对这个列表
调用函数sum() ，看看Python将一百万个数字相加需要多长时间。

nums = list(range(1, 1000001))
print(min(nums))
print(max(nums))
print(sum(nums))

1
1000000
500000500000

奇数 ：通过给函数range() 指定第三个参数来创建一个列表，其中包含1~20的奇数；再使用一个for 循环将这些数字都打印出来。

nums = list(range(1, 21, 2))
for num in nums:
    print(num)

1
3
5
7
9
11
13
15
17
19

3的倍数：创建一个列表，其中包含3~30内能被3整除的数字；再使用一个for 循环将这个列表中的数字都打印出来。

nums = list(range(3, 31, 3))
for num in nums:
    print(num)

3
6
9
12
15
18
21
24
27
30

立方 ：将同一个数字乘三次称为立方。例如，在Python中，2的立方用2**3 表示。请创建一个列表，其中包含前10个整数（即1~10）的立方，使用列表解析生成一个列表，其中包含前10个整数的立方

nums = [num**3 for num in range(1, 11)]
print(nums)

[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

切片的使用

要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range() 一样，Python在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0 、1 和2 的元素。

复制列表

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

练习

切片 ：选择你在本章编写的一个程序，在末尾添加几行代码，以完成如下任务。
打印消息“The first three items in the list are:”，再使用切片来打印列表的前三个元素。
打印消息“Three items from the middle of the list are:”，再使用切片来打印列表中间的三个元素。
打印消息“The last three items in the list are:”，再使用切片来打印列表末尾的三个元素。

list = ["lili", "coco", "song", "vivi", "fgfg", "emm"]
print("The first three items in list are:  ")
print(list[:3])
print("Three items from the middle of the are:  ")
print(list[1:4])
print("The last three items in the list are:   ")
print(list[-3:])

The first three items in list are:  
['lili', 'coco', 'song']
Three items from the middle of the are:  
['coco', 'song', 'vivi']
The last three items in the list are:   
['vivi', 'fgfg', 'emm']

你的比萨和我的比萨 ：在你为完成练习4-1而编写的程序中，创建比萨列表的副本，并将其存储到变量friend_pizzas 中，再完成如下任务。
在原来的比萨列表中添加一种比萨。
在列表friend_pizzas 中添加另一种比萨。
核实你有两个不同的列表。为此，打印消息“My favorite pizzas are:”，再使用一个for 循环来打印第一个列表；打印消息“My friend’s favorite pizzas are:”，再使用一
个for 循环来打印第二个列表。核实新增的比萨被添加到了正确的列表中。

friend_pizzas = ["apple", "food", "fish", "joke", "orange"]
my_pizzas = friend_pizzas[:]
friend_pizzas.append("beef")
print("My favorite pizzas are: ")
for food in my_pizzas:
    print(food)
print("My friends favorite pizzas are；")
for food in friend_pizzas:
    print(food)

My favorite pizzas are: 
apple
food
fish
joke
orange
My friends favorite pizzas are；
apple
food
fish
joke
orange
beef

元组

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。

然而，有时候你需要创建一系列不可修 改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的不可变的 ，而不可变的列表被称为元组 。

定义元组

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

练习

自助餐 ：有一家自助式餐馆，只提供五种简单的食品。请想出五种简单的食品，并将其存储在一个元组中。
使用一个for 循环将该餐馆提供的五种食品都打印出来。
尝试修改其中的一个元素，核实Python确实会拒绝你这样做。
餐馆调整了菜单，替换了它提供的其中两种食品。请编写一个这样的代码块：给元组变量赋值，并使用一个for 循环将新元组的每个元素都打印出来。

menu = ("pizza", "fish", "ice-cream", "hamburger", "apple")
# menu[0] = orange
menu = ("pizza", "fish", "ice-cream", "beef", "corn")
print("I have changed the menu")
for food in menu:
    print(food)

I have changed the menu
pizza
fish
ice-cream
beef
corn

if 语句

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

Python根据条件测试的值为True 还是False 来决定是否执行if 语句中的代码。如果 条件测试的值为True ，Python就执行紧跟在if 语句后面的代码；如果为False ，Python就忽略这些代码

if-elif-else结构

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

使用多个elif代码块

忽略else代码块

Python并不要求if-elif 结构后面必须有else 代码块。在有些情况下，else 代码块很有用；而在其他一些情况下，使用一条elif 语句来处理特定的情形更清晰

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

练习

编写一系列条件测试；将每个测试以及你对其结果的预测和实际结果都打印出来。
详细研究实际结果，直到你明白了它为何为True 或False 。
创建至少10个测试，且其中结果分别为True 和False 的测试都至少有5个。

car = "subaru"
print("Is car == 'subaru'? I predict True.")
print(car == 'subaru')
print("\nIs car == 'audi'? I predict False.")
print(car == 'audi')

Is car == 'subaru'? I predict True.
True

Is car == 'audi'? I predict False.
False

外星人颜色外星人颜色#1 ：假设在游戏中刚射杀了一个外星人，请创建一个名为alien_color 的变量，并将其设置为’green’ 、‘yellow’ 或’red’ 。
编写一条if 语句，检查外星人是否是绿色的；如果是，就打印一条消息，指出玩家获得了5个点。
编写这个程序的两个版本，在一个版本中上述测试通过了，而在另一个版本中未通过（未通过测试时没有输出）。

alien_color = "green"
if alien_color == "green":
    print("You have 5 poins")

You have 5 poins

alien_color = "red"
if alien_color =="green":
    print("You have 5 poins")

外星人颜色外星人颜色#2 ：像练习5-3那样设置外星人的颜色，并编写一个if-else 结构。
如果外星人是绿色的，就打印一条消息，指出玩家因射杀该外星人获得了5个点。
如果外星人不是绿色的，就打印一条消息，指出玩家获得了10个点。
编写这个程序的两个版本，在一个版本中执行if 代码块，而在另一个版本中执行else 代码块。

alien_color  = "green"
if alien_color == "green":
    print("You have killed the alien_color,attained 5 points ")
else:
    print("You attain 10 points ")
    

You have killed the alien_color,attained 5 points 

alien_color = "red"
if alien_color == "green":
    print("abaaba")
else:
    print("You attain 10 points ")

You attain 10 points 

外星人颜色外星人颜色#3 ：将练习5-4中的if-else 结构改为if-elif-else 结构。
如果外星人是绿色的，就打印一条消息，指出玩家获得了5个点。
如果外星人是黄色的，就打印一条消息，指出玩家获得了10个点。
如果外星人是红色的，就打印一条消息，指出玩家获得了15个点。
编写这个程序的三个版本，它们分别在外星人为绿色、黄色和红色时打印一条消息。

if alien_color == "green":
    print("You have attained 5 points")
elif alien_color  == "yellow":
    print("You have attained 10 points")
elif alien_color == "red":
    print("You have attained 15 points")

使用if语句处理列表（确定列表不是空的）

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

练习

以特殊方式跟管理员打招呼 ：创建一个至少包含5个用户名的列表，且其中一个用户名为’admin’ 。想象你要编写代码，在每位用户登录网站后都打印一条问
候消息。遍历用户名列表，并向每位用户打印一条问候消息。
如果用户名为’admin’ ，就打印一条特殊的问候消息，如“Helo admin, would you like to see a status report?”。
否则，打印一条普通的问候消息，如“Helo Eric, thank you for logging in again”

users = ["admin", "admax", "ada", "aba", "bbc", "mmm"]
for user in users:
    if user == "admin":
        print("Hello admin, would you like to see a atatus report?")
    else:
        print("hello, " + user + "thank you for logging in again")

Hello admin, would you like to see a atatus report?
hello, admaxthank you for logging in again
hello, adathank you for logging in again
hello, abathank you for logging in again
hello, bbcthank you for logging in again
hello, mmmthank you for logging in again

处理没有用户的情形 ：在为完成练习5-8编写的程序中，添加一条if 语句，检查用户名列表是否为空。
如果为空，就打印消息“We need to find some users!”。
删除列表中的所有用户名，确定将打印正确的消息。

users = []
if users:
    for user in users:
        if user == "admin":
            print("Hello admin, would you like to see a atatus report?")
        else:
            print("hello, " + user + "thank you for logging in again")
else:
    print("We need to find some users!")

We need to find some users!

字典

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

与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将 任何Python对象用作字典中的值。

在Python中，字典用放在花括号{} 中的一系列键—值对表示

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

添加键–值对

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

修改字典中的值

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

删除键–值对

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

练习

使用一个字典来存储一个熟人的信息，包括名、姓、年龄和居住的城市。该字典应包含键first_name 、last_name 、age 和city 。将存储在该字典中
的每项信息都打印出来。

man = {'first_name':'Green', 'last_name':'lili', 'age':18, 'city':'chongqing'}
print(man['first_name'])
print(man['last_name'])
print(man['age'])
print(man['city'])

Green
lili
18
chongqing

词汇表 ：Python字典可用于模拟现实生活中的字典，但为避免混淆，我们将后者称为词汇表。
想出你在前面学过的5个编程词汇，将它们用作词汇表中的键，并将它们的含义作为值存储在词汇表中。
以整洁的方式打印每个词汇及其含义。为此，你可以先打印词汇，在它后面加上一个冒号，再打印词汇的含义；也可在一行打印词汇，再使用换行符（\n ）插入一个空行，然后在下一行以缩进的方式打印词汇的含义

langevage = {"python":"len", "java":"str", "C":"printf", "go":"for"}
print("python :  " + langevage["python"])
print("java:  " + langevage["java"])
print("C:  " + langevage["C"])
print("go:  " + langevage["go"])

python :  len
java:  str
C:  printf
go:  for

遍历字典中所有的键或值

在不需要使用字典中的值时，方法keys() 很有用。实际上，它返回一个列表，其中包含字典中的所有键

如果你感兴趣的主要是字典包含的值，可使用方法values() ，它返回一个值列表，而不包含任何键。

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

在字典中储存列表

在字典中储存字典

练习

词汇表2 ：既然你知道了如何遍历字典，现在请整理你为完成练习6-3而编写的代码，将其中的一系列print 语句替换为一个遍历字典中的键和值的循环。确定该循环正确无误后，再在词汇表中添加术语。当你再次运行这个程序时，这些新术语及其含义将自动包含在输出中。

langevage = {"python":"len", "java":"str", "C":"printf", "go":"for"}
langevage.update({"temo":"help"})
for key, value in langevage.items():
    print(key)
    print(value)

python
len
java
str
C
printf
go
for
temo
help

用户输入与while循环

函数input()的工作原理

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

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

练习

汽车租赁 ：编写一个程序，询问用户要租赁什么样的汽车，并打印一条消息，如“Let me see if I can find you a Subaru”。

使用标志

在要求很多条件都满足才继续运行的程序中，可定义一个变量，用于判断整个程序是否处于活动状态。这个变量被称为标志标志 ，充当了程序的交通信号灯。你可让程序在标志 为True 时继续运行，并在任何事件导致标志的值为False 时让程序停止运行。这样，在while 语句中就只需检查一个条件——标志的当前值是否为True ，并将所有测试（是 否发生了应将标志设置为False 的事件）都放在其他地方，从而让程序变得更为整洁。

使用break退出循环

在任何Python循环中都可使用break 语句。

在循环中使用continue

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

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

我们使用函数remove() 来删除列表中的特定值，这之所以可行，是因为要删除的值在列表中只出现了一次。

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

['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
 ['dog', 'dog', 'goldfish', 'rabbit']

使用用户输入来填充字典

函数

使用关键字def 来告诉Python你要定义一个函数。这是函数定义。最后，定义以冒号结尾

实参和形参

实参是 调用函数时传递给函数的信息。我们调用函数时，将要让函数使用的信息放在括号内。

位置实参

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

关键字实参

关键字实参关键字实参 是传递给函数的名称—值对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆

返回值

函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。函数返回的值被称为返回值

在函数中修改列表

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

将函数存储在模块中

将函数存储在被称为模块模块 的独立文件中， 再将模块导入导入 到主程序中。import 语句允许在当前运行的程序文件中使用模块中的代码。

导入整个模块

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

导入特定的函数

from module_name import function_name
from module_name import function_0, function_1, function_2

使用as给函数指定别名

import module_name as mn

导入模块中的所有函数

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

类

定义类

使用关键字 class 定义类，类名通常采用首字母大写的命名规范。

class MyClass:
    # 类的属性和方法定义

实例化对象

通过类创建对象的过程称为实例化。

obj = MyClass()  # 创建 MyClass 类的一个对象

类的属性

类的属性是对象的数据或状态，可以通过对象的实例访问。

obj.attribute = value

构造函数 __init__

__init__ 是一个特殊的方法，用于初始化对象的属性。

class MyClass:
    def __init__(self, attribute):
        self.attribute = attribute

类的方法

类的方法是与类相关联的函数，可以操作对象的属性。

class MyClass:
    def my_method(self):
        # 方法实现

继承

通过继承可以创建一个新类，新类继承了现有类的属性和方法，可以重写或扩展基类的功能。

class ChildClass(ParentClass):
    # 子类的属性和方法定义

多态

多态指的是不同类的对象可以使用相同的方法名，但具体执行的操作可以不同。

类的特殊方法： Python 中有一些特殊方法，以双下划线 __ 开头和结尾，如 __init__、__str__、__repr__ 等，用于实现特定功能，如对象的初始化、字符串表示等。

类的属性和方法访问控制： 可以使用访问控制符号（public、protected、private）来控制类的属性和方法的访问权限，但 Python 中没有明确的关键字或符号定义这些权限，一般通过命名约定来实现。

类的封装、继承和多态是面向对象编程三大特性的体现，能够帮助我们更好地组织代码和实现代码的复用。

文件

读取整个文件

with open('pi_digits.txt') as file_object:
    contents = file_object.read()
    print(contents)

函数open() 返回一个表示文件的对象。在这里，open(‘pi_digits.txt’) 返回一个表示文件pi_digits.txt 的对象；Python将这个对象存储在我们将 在后面使用的变量中。

关键字with 在不再需要访问文件后将其关闭。你只管打开文件，并在需要时使用它，Python自会在合适的时候自动将其关闭。

要让Python打开不与程序文件位于同一个目录中的文件，需要提供文件路径文件路径 ，它让Python到系统的特定位置 去查找。

逐行读取

要以每次一行的方式检查文件，可对文件对象使用for 循环

创建一个包含文件隔行内容的列表

使用关键字with 时，open() 返回的文件对象只在with 代码块内可用。如果要在with 代码块外访问文件的内容，可在with 代码块内将文件的各行存储在一个列表中，并在with 代码块外使用该列表

方法readlines() 从文件中读取每一行，并将其存储在一个列表中；

使用文件的内容

读取文本文件时，Python将其中的所有文本都解读为字符串。如果你读取的是数字，并要将其作为数值使用，就必须使用函数int() 将其转换为整数，或使用 函数float() 将其转换为浮点数。

写入文件

要将文本写入文件，你在调用open() 时需要提供另一个实参，告诉Python你要写入打开的文件。

打开文件 时，可指定读取模式读取模式 （‘r’ ）、写入模式写入模式 （‘w’ ）、附加模式附加模式 （‘a’ ）或让你能够读取和写入文件的模式（‘r+’ ）。如果你省略了模式实参，Python将以默认的只读模式打 开文件。

如果你要写入的文件不存在，函数open() 将自动创建它。然而，以写入（‘w’ ）模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空 该文件。

写入多行

函数write() 不会在你写入的文本末尾添加换行符，因此如果你写入多行时需要指定换行符

附加到文件

如果你要给文件添加内容，而不是覆盖原有的内容，可以附加模式附加模式 打开文件。你以附加模式打开文件时，Python不会在返回文件对象前清空文件，而你写入到文件的行都将添加 到文件末尾。如果指定的文件不存在，Python将为你创建一个空文件。