2023年
说明：如果代码有误的话，记得处理一下缩进，或者注释的问题，文章粘贴的代码在此处可能部分缩进有问题
学习资料：
3.25
一 变量和简单数据类型
输出
输入在第七章节
print()
### 字符串
```python
'hello'
"hello"
(1)大小写
字符串s
1.标题： s.title()
2.大写： s.upper()
3.小写： s.lower()
(2)字符串中使用变量
s1="hello"
s2="world"
s3=f"{s1}{s2}"//形式
或者
s3=s1+s2
print(f"hello,{s3.title()}!")
(3)删除空白
1.删除后面的空白
s.rstrip()//暂时删除
s=s.rstrip()//永久删除
2.前面的
s.lstrip()
3.前后
s.strip()
（4）加法
s="world"
print("hello "+s+"!")
故要将数字加入进去，需要用：str(3) 把3转换为字符串
二 数
整数.浮点数
(1)运算符
+ - * / %（仅两个整数才能使用%）
乘方 **
如：3**2 = 9
（2）同时给多个变量赋值
x,y,z = 1,2,3
注释
#这是注释
print("haha")
三 列表
列表的元素之间可以没有任何关系
定义和打印
a=[]
bicycle = ['a','b','c']
print(bicycle)
结果：['a','b','c']
访问列表元素
1.a=[1,2,3]
print(a[0])
s=['a','b','c']
print(s[0].title())
2.特殊之处
索引为-1，返回最后一个元素
......-2 ........第二个...
修改，添加，删除元素
修改
a=[1,2,3]
a[0]=0
添加
append()
insert()
（1）末尾添加
a=[1,2,3]
a.append(4)#a=[1,2,3,4]
(2)插入
a = [1,2,3]
a.insert(0,1)#a=[1,1,2,3]，0为索引，1为要添加的值
删除
del
pop ()
remove（）
（1）直接删除，不使用
a = [1,2,3]
del a[0]
(2)删除，并使用
a= [1,2,3]
b = a.pop()#弹出栈顶元素
(3)弹出任何位置的元素
a.pop(0)#0为索引
（4）根据值删除元素
a.remove(2)#2为列表中的一个值
组织列表
sort()
sorted()
s.sort()
sorted(s)
reserve()
len()
(1)永久排序
s = ['a','c','b']
s.sort()#['a','b','c']
s.sort(reverse=True)#['c','b','a']
(2)临时排序
print(sorted(s))#['a','b','c']
print(s)#['a','c','b']
(3)倒着打印
a.reserve()#倒着打印
(4)确定列表长度
len(a)
（5)方法 replace()将字符串中的特定单词都替换为另一个单词。
>>> message = "I really like dogs."
>>> message.replace('dog', 'cat')
2023.3.26 星期日
四 操作列表
循环
形式：
for 变量名 in 数组名:
for语句末尾的冒号告诉Python，下一行是循环的第一行。
a = [1,2,3]
for i in a:
print(i)
缩进
缩进代表for,if…里面的语句，
没有缩进则不代表
创建数值列表
range()
list()#将结果转换为列表
for i in range(1,5)
print(i)
将range 的列表存储到数字中
（1）
a = list(range(1,5))
print(a)
没有5
（2）
range(2,11,2)
#函数range()从2开始数，然后不断地加2，直到达到或超过终值（11），输出[2,4,6,8,10]
没有12
(3)
squares = []
for value in range(1,11):
square = value**2
squares.append(square)
print(squares)
没有11
对数字列表简单的计算
min(a)
max(a)
sum(a)#a为数组名
列表解析
前面介绍的生成列表squares的方式包含三四行代码，而列表解析让你只需编写一行代码就
能生成这样的列表。
squares = [value**2 for value in range(1,11)]
print(squares)
要使用这种语法，
(1)首先指定一个描述性的列表名，如squares；
(2)然后，指定一个左方括号，并定义一个表达式，用于生成你要存储到列表中的值。在这个示例中，表达式为value^2，它计算平方值。
(2)接下来，编写一个for循环，用于给表达式提供值，再加上右方括号。在这个示例中，or循环为for value in range(1,11)，它将值1~10提供给表达式value^2。请注意，这里的for语句末尾没有冒号。
使用列表的一部分（切片)
切片
要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range()一样，Python在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0、1和2的元素。
players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[0:3])
形式：
a[0:3]
如果你没有指定第一个索引，Python将自动从列表开头开始：
a[:4]
a[2:]
例如，如果你要输出名单上的最后三名队员，可使用切片
players[-3:]
创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引
[:]
遍历切片
players = ['charles', 'martina', 'michael', 'florence', 'eli']
print("Here are the first three players on my team:")
for player in players[:3]:
print(player.title())
复制列表
a = [1,2,3]
b = a[:]
例如，下例演示了在不使用切片的情况下复
制列表的情况
b = a
这里将a赋给b，而不是将a的副本存储到b。
这种语法实际上是让Python将新变量b关联到包含在a中的列表，因此这两个变量都指向同一个列表。鉴于此，当我们将4添加到a中时，它也将出现在
b中；同样，虽然’5好像只被加入到了b中，但它也将出现在这两个列表中。
3.27
元组
定义元组
有时候你需要创建一系列不可修改的元素，
元组可以满足这种需求。Python将不能修改的值称为不可变的，而不可变的列表被称为元组。
元组看起来犹如列表，但使用圆括号而不是方括号来标识。
a=(1,2)
print(a[0])
遍历元组中元素
for i int a:
print(i)
修改元组变量
虽然不能修改元组的元素，但可以给存储元组的变量赋值
a = (1,2)
a = (3,4)#合法
设置代码格式
缩进：四个空格
行长：<80
空行
五 if 语句
形式：
(1)
if 条件 ：
else :
(2)
if 条件 ：
elif 条件：
elif 条件：
else:（这个else可省略）
比较符号：
< == !=
= <=
与：and
或：or
cars = ['audi', 'bmw', 'subaru', 'toyota']
for car in cars:
if car == 'bmw':
print(car.upper())
else:
print(car.title())
a = 1
if a==1:
print("yes")
else:
print("no")
if (a == 1) and (b == 2):
print("yes")
else:
print("no")
检查特定值是否包含在列表中
要判断特定的值是否已包含在列表中，可使用关键字in。
c = [1,2,3]
if 4 in c:
print("that is so good")
else:
print("oh my god,it is terrible")
检查特定值是否不包含在列表中
not in
确定列表不是空的
在if语句中将列表名用在条件表达式中时，
Python将在列表
至少包含一个元素时返回True，
并在列表为空时返回False。
a = []
if a:
print("not empty")
else:
print("empty")
六 字典
使用字典
alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color'])
print(alien_0['points'])
在Python中，字典是一系列键—值对。
如上:'color’为键
’green’为对应的值
每个键都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。
在Python中，字典用放在花括号{}中的一系列键—值对表示，如前面的示例所示：
访问字典中的值
要获取与键相关联的值，可依次指定字典名和放在方括号内的键，如下所示：
alien_0 = {'color': 'green'}
print(alien_0['color'])
这将返回字典alien_0中与键’color’相关联的值：
green
alien_0 = {'color': 'green', 'points': 5}
new_points = alien_0['points']
print("You just earned " + str(new_points) + " points!")
上述代码首先定义了一个字典，然后从这个字典中获取与键’points’相关联的值，并将这个值存储在变量new_points中。接下来，将这个整数转换为字符串，并打印一条消息，指出玩家获得了多少个点
添加键—值对
要添加键—值对，可依次指定字典名、用
方括号括起的键和相关联的值。
alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)
注意，键—值对的排列顺序与添加顺序不同。Python不关心键—值对的添加顺序，
而只关心键和值之间的关联关系。
空字典：
a = {}
删除键—值对
fruit = {'apple' : 'red','banana' : 'yellow'}
print(fruit)
del fruit['apple']
print(fruit)
遍历字典
Python支持对字典遍历。字典可用于以各种方式存储信息，因此有多种遍历字典的方式：可遍历字典的所有键—值对、键或值
遍历所有的键—值对（items()）
要编写用于遍历字典的for循环，可声明两个变量，用于存储键—值对中的键和值。
对于这两个变量，可使用任何名称。
user_0 = {
'username': 'efermi',
'first': 'enrico',
'last': 'fermi',
}
for key, value in user_0.items():
print("\nKey: " + key)
print("Value: " + value)
for语句的第二部分包含字典名和方法items(），它返回一个键—值对列表。接下来，for循环依次将每个键—值对存储到指定的两个变量中。在前面的示例中，我们使用这两个变量来打印每个键及其相关联的值。第一条print语句中的"\n"确保在输出每个键—值对前都插入一个空行：
遍历字典中的所有键(keys())
(1)在不需要使用字典中的值时，方法**keys()**很有用。下面来遍历字典favorite_languages，并
将每个被调查者的名字都打印出来：
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python', #注意这里的逗号
}
for name in favorite_languages.keys():
print(name.title())
遍历字典时，会默认遍历所有的键，因此，如果将上述代码中的for name in favorite_
languages.keys():替换为for name in favorite_languages:，输出将不变。
fruit = {'apple':'red', 'banana' : 'yellow','watermelon' : 'green','grape' :'purple'}
a = ['apple','grape']
for name in fruit.keys():
print(name)
if name in a:
print(name + 'is in a')
3.28
(2) 按顺序遍历字典中的所有键
for a in sorted(fruit.keys()):
遍历字典中的所有值(values())
for s in fruit.values():
为剔除重复项，可使用集合（set）
for s in set(fruit.values()):
嵌套
字典列表
要将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套
alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}
aliens = [alien_0, alien_1, alien_2]
for alien in aliens:
print(alien)
# 创建一个用于存储外星人的空列表
aliens = []
# 创建30个绿色的外星人
for alien_number in range(30):
new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
aliens.append(new_alien)
# 显示前五个外星人
for alien in aliens[:5]:
print(alien)
# 显示创建了多少个外星人
print("Total number of aliens: " + str(len(aliens)))
for alien in aliens[0:3]:
if alien['color'] == 'green':
alien['color'] = 'yellow'
alien['speed'] = 'medium'
alien['points'] = 10
在字典中存储列表
favorite_languages = {
'jen': ['python', 'ruby'],
'sarah': ['c'],
'edward': ['ruby', 'go'],
'phil': ['python', 'haskell'], #注意这里的逗号
}
for name, languages in favorite_languages.items():
print("\n" + name.title() + "'s favorite languages are:")
for language in languages:
print("\t" + language.title())
place = {
'zhang' : ['yunnan' ,'beijing' ,'shanghai'],
'li':['fujian','chengdu'],
'wang' : ['jinlin','shandong'],
}
for s1,s2 in place.items():
print(s1 + " likes " + str(len(s2)) + " places,they are :")
for s in s2:
print(s)
在字典中存储字典
person = {
'zhang' : {
'food' : 'rice',
'fruit' : 'apple', #注意这里的逗号
},#注意这里的逗号
'li' : {
'food' : 'vegetable',
'fruit' : 'grape',#注意这里的逗号
},#注意这里的逗号
}
person = {
'zhang' : {
'food' : 'rice',
'fruit' : 'apple',
},
'li' : {
'food' : 'vegetable',
'fruit' : 'grape',
},
}
for s1,s2 in person.items():
if s1 == 'li':
print(s1)
print(s2)
s2['food'] = 'meat'
print(s2)
#结果：
li
{'food': 'vegetable', 'fruit': 'grape'}
{'food': 'meat', 'fruit': 'grape'}
*补充 集合
七 用户输入和while循环
输入
input()
函数 input() 让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python将其存储在
一个变量中
message = input("Tell me something, and I will repeat it back to you: ")
print(message)
#final
Tell me something, and I will repeat it back to you: Hello everyone!
Hello everyone!
prompt = "If you tell us who you are, we can personalize the messages you see."
prompt += "\nWhat is your first name? "
name = input(prompt)
print("\nHello, " + name + "!")
使用 int()来获取数值输入
使用函数input()时，Python将用户输入解读为字符串
函数int()将数字的字符串表示转换为数值表示
height = input()
height = int(height)
#输入为浮点数，用
height = float(height)
3.31
while 循环
current_number = 1
while current_number <= 5:
print(current_number)
current_number += 1
使用 break 退出循环
i = int(input())
flag = True
while flag:
if i<0:
flag = False
else:
print(i)
i = int(input())
在循环中使用 continue
current_number = 0
while current_number < 10:
current_number += 1
if current_number % 2 == 0:
continue
print(current_number)
我们首先将current_number设置成了0，由于它小于10，Python进入while循环。进入循环后，
我们以步长1的方式往上数，因此current_number为1。接下来，if语句检查current_number与2的求模运算结果。如果结果为0（意味current_number可被2整除），就执行continue语句，让Python忽略余下的代码，并返回到循环的开头。如果当前的数字不能被2整除，就执行循环中余下的代码，Python将这个数字打印出来：
结果：1 3 5 7 9
使用 while 循环来处理列表和字典
（1）移动元素
s = [1,2,3,4]
a = []
while(s):
i = s.pop()
a.append(i)
for i in a:
print(i)
（2）删除特定元素
pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
print(pets)
while 'cat' in pets:
pets.remove('cat')
print(pets)
（3)使用用户输入来填充字典
# 设置一个标志，指出调查是否继续
polling_active = True
while polling_active:
# 提示输入被调查者的名字和回答
name = input("\nWhat is your name? ")
response = input("Which mountain would you like to climb someday? ")
# 将答卷存储在字典中
responses[name] = response
# 看看是否还有人要参与调查
repeat = input("Would you like to let another person respond? (yes/ no) ")
if repeat == 'no':
polling_active = False
# 调查结束，显示结果
print("\n--- Poll Results ---")
print(responses)
for name, response in responses.items():
print(name + " would like to climb " + response + ".")
八 函数
定义函数
def greet_user():
"""显示简单的问候语"""
print("Hello!")
greet_user()#调用函数
这个示例演示了最简单的函数结构。第一行处的代码行使用关键字def来告诉Python你要定义一个
函数。这是函数定义，向Python指出了函数名，还可能在括号内指出函数为完成其任务需要什么
样的信息。在这里，函数名为greet_user()，它不需要任何信息就能完成其工作，因此括号是空
的（即便如此，括号也必不可少）。最后，定义以冒号结尾。
紧跟在def greet_user():后面的所有缩进行构成了函数体。第二行处的文本是被称为文档字符串
（docstring）的注释，描述了函数是做什么的。文档字符串用三引号括起，Python使用它们来生成有关程序中函数的文档。
代码行print(“Hello!”)是函数体内的唯一一行代码，greet_user()只做一项工作：
打印Hello!。
要使用这个函数，可调用它。函数调用让Python执行函数的代码。要调用函数，可依次指定
函数名以及用括号括起的必要信息。由于这个函数不需要任何信息，因此调用它时
只需输入greet_user()即可。和预期的一样，它打印Hello!
向函数传递信息
def greet_user(username): #传参
"""显示简单的问候语"""
print("Hello, " + username.title() + "!")
greet_user('jesse')
4.1
传递实参
向函数传递实参的方式很多，可使用位置实参，这要求实参的顺序与形参的顺序相同；也可使用关键字实参，其中每个实参都由变量名和值组成；还可使用列表和字典。
位置实参
def fruit_1(type_name,color):
print("I like " + color + type_name)
fruit_1('apple','red')
fruit_1('banana','yellow')
请确认函数调用中实参的顺序与函数定义中形参的顺序一致。
关键字实参
关键字实参是传递给函数的名称—值对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆（不会得到名为Hamster的harry这样的结果）。关键字实参让你无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。
def fruit_1(type_name,color):
print("I like " + color + type_name)
fruit_1(type_name='apple',color='red')
fruit_1(type_name='banana',color='yellow')
默认值
编写函数时，可给每个形参指定默认值。在调用函数中给形参提供了实参时，Python将使用
指定的实参值；否则，将使用形参的默认值。因此，给形参指定默认值后，可在函数调用中省略
相应的实参。使用默认值可简化函数调用，还可清楚地指出函数的典型用法。
def fruit_1(type_name,color = 'yellow'):#默认形参
print("I like " + color + type_name)
fruit_1(type_name='apple',color='red')
fruit_1(type_name='banana')
使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的实参(不可在有默认形参后面加入无默认形参的，会报错)。
def f(a ,b = 0 , c)#error
这让Python依然能够正确地解读位置实参。
返回值
函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。函数返回的值被称为返回值。在函数中，可使用return语句将值返回到调用函数的代码行。返回值让你能够将程序的大部分繁重工作移到函数中去完成，从而简化主程序。
返回简单值
def get_formatted_name(first_name, last_name):
"""返回整洁的姓名"""
full_name = first_name + ' ' + last_name
return full_name.title()
musician = get_formatted_name('jimi','hendrix')
print(musician)
返回字典
def build_person(first_name, last_name):
"""返回一个字典，其中包含有关一个人的信息"""
person = {'first': first_name,'last':last_name}
return person
musician = build_person('jimi', 'hendrix')
print(musician)
def build_person(first_name, last_name, age=''):
"""返回一个字典，其中包含有关一个人的信息"""
person = {'first': first_name, 'last': last_name}
if age:
person['age'] = age
return person
musician = build_person('jimi', 'hendrix', age=27)
print(musician)
在函数定义中，我们新增了一个可选形参age，并将其默认值设置为空字符串。如果函数调用中包含这个形参的值，这个值将存储到字典中。在任何情况下，这个函数都会存储人的姓名，但可对其进行修改，使其也存储有关人的其他信息。
def get_formatted_name(first_name, last_name,age = ''):
person = {'first' : first_name,'last' : last_name}
if age:
person['age'] = age
return person
musician = get_formatted_name('jimi', 'hendrix')
age = input("Please input your age:")
zhang = get_formatted_name('zhang','san',age)
print(musician)
print(zhang)
传递列表
def greet_users(names):
"""向列表中的每位用户都发出简单的问候"""
for name in names:
msg = "Hello, " + name.title() + "!"
print(msg)
usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)
禁止函数修改列表
有时候可在函数中修改列表，有时候不希望传进去的函数修改列表。
为解决这个问题，可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。
切片表示法 [:] 创建列表的副本。
def f(list_name):
person = []
for i in range(3):
list_name[i] = i
list = ['zhang','li','wang']
f(list[:])#传递切片原来列表值不变
print(list)
f(list)#传本身要改变
print(list)
结果：
['zhang','li','wang']
[0,1,2]
传递任意数量的实参
def make_pizza(*toppings):
"""打印顾客点的所有配料"""
print(toppings)
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')
形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封
装到这个元组中。函数体内的print语句通过生成输出来证明Python能够处理使用一个值调用函数的情形，也能处理使用三个值来调用函数的情形。它以类似的方式处理不同的调用，注意，Python将实参封装到一个元组中，即便函数只收到一个值也如此
结合使用位置实参和任意数量实参
如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。
def make_pizza(size, *toppings):
"""概述要制作的比萨"""
print("\nMaking a " + str(size) +
"-inch pizza with the following toppings:")
for topping in toppings:
print("- " + topping)
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
基于上述函数定义，Python将收到的第一个值存储在形参size中，并将其他的所有值都存储
在元组toppings中。在函数调用中，首先指定表示比萨尺寸的实参，然后根据需要指定任意数量的配料。
def tour(num,*p):
print(str(num) + " people will go to park, they are:")
for s in p:
print(s)
tour(3,'zhang','wang','li')
def food(*p):
print("client's ingredients")
for s in p:
print(s)
a = []
s = input("input your ingredient,if over,please input q:")
while(s!='q'):
a.append(s)
s = input()
food(a)
使用任意数量的关键字实参
有时候，需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息。在这种
情况下，可将函数编写成能够接受任意数量的键—值对——调用语句提供了多少就接受多少。一个这样的示例是创建用户简介：你知道你将收到有关用户的信息，但不确定会是什么样的信息。
在下面的示例中，函数build_profile()接受名和姓，同时还接受任意数量的关键字实参：
def build_profile(first, last, **user_info):
"""创建一个字典，其中包含我们知道的有关用户的一切"""
profile = {}
profile['first_name'] = first
profile['last_name'] = last
for key, value in user_info.items():
profile[key] = value
return profile
user_profile = build_profile('albert', 'einstein', location='princeton', field='physics')
print(user_profile)
函数build_profile()的定义要求提供名和姓，同时允许用户根据需要提供任意数量的名称—
值对。形参user_info中的两个星号让Python创建一个名为user_info的空字典，并将收到的所有名称—值对都封装到这个字典中。在这个函数中，可以像访问其他字典那样访问user_info中的名称—值对。
4.2
将函数存储在模块中
函数的优点之一是，使用它们可将代码块与主程序分离。通过给函数指定描述性名称，可让
主程序容易理解得多。你还可以更进一步，将函数存储在被称为模块的独立文件中，再将模块导入到主程序中。import语句允许在当前运行的程序文件中使用模块中的代码。
通过将函数存储在独立的文件中，可隐藏程序代码的细节，将重点放在程序的高层逻辑上。
这还能让你在众多不同的程序中重用函数。将函数存储在独立文件中后，可与其他程序员共享这些文件而不是整个程序。知道如何导入函数还能让你使用其他程序员编写的函数库。
导入整个模块
要让函数是可导入的，得先创建模块。模块是扩展名为.py的文件，包含要导入到程序中的
代码。下面来创建一个包含函数make_pizza()的模块。为此，我们将文件pizza.py中除函数
make_pizza()之外的其他代码都删除：
pizza.py
def make_pizza(size, *toppings):
"""概述要制作的比萨"""
print("\nMaking a " + str(size) +
"-inch pizza with the following toppings:")
for topping in toppings:
print("- " + topping)
making_pizza.py
import pizza
pizza.make_pizza(16, 'pepperoni')
pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
导入特定的函数
一个函数
from module_name import function_name
任意函数
from module_name import function_0, function_1, function_2
示例
from pizza import make_pizza
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
使用 as 给函数指定别名
如果要导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短
而独一无二的别名——函数的另一个名称，类似于外号。要给函数指定这种特殊外号，需要在导入它时这样做。
下面给函数make_pizza()指定了别名mp()。这是在import语句中使用make_pizza as mp实现的，关键字as将函数重命名为你提供的别名
from pizza import make_pizza as mp
mp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')
使用 as 给模块指定别名
import pizza as p
p.make_pizza(16, 'pepperoni')
p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
导入模块中的所有函数
使用星号（*）运算符可让Python导入模块中的所有函数：
from pizza import *
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
使用并非自己编写的
大型模块时，最好不要采用这种导入方法：如果模块中有函数的名称与你的项目中使用的名称相
同，可能导致意想不到的结果：Python可能遇到多个名称相同的函数或变量，进而覆盖函数，而不是分别导入所有函数
函数编写指南：
给形参指定默认值时，等号两边不要有空格
import出现问题
九 类
类初始操作
class Dog():
"""一次模拟小狗的简单尝试"""
def __init__(self, name, age): #注意这里左右两根线
"""初始化属性name和age"""
self.name = name
self.age = age
def sit(self): #注意括号里面不要少些self
"""模拟小狗被命令时蹲下"""
print(self.name.title() + " is now sitting.")
def roll_over(self):
"""模拟小狗被命令时打滚"""
print(self.name.title() + " rolled over!")
（1）方法init（）
类中的函数称为方法；你前面学到的有关函数的一切都适用于方法，就目前而言，唯一重要的差别是调用方法的方式。方法__init__()是一个特殊的方法，每当你根据Dog类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。
我们将方法__init__()定义成了包含三个形参：self、name和age。在这个方法的定义中，形参self必不可少，还必须位于其他形参的前面。为何必须在方法定义中包含形参self呢？因为Python调用这个__init__()方法来创建Dog实例时，将自动传入实参self。每个与类相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。
我们创建Dog实例时，Python将调用Dog类的方法__init__()。我们将通过实参向Dog()传递名字和年龄；self会自动传递，因此我们不需要传递它。每当我们根据Dog类创建实例时，都只需给最后两个形参（name和age）提供值。
class Person():
def __init__(self,first,second):#C++中为构造函数
self.first = first
self.second = second
def get(self):
print("Her/His name is " + self.first.title() + self.second.title())
def change(self):
s1,s2 = input("What is your name?").split(" ")
self.first = s1
self.second = s2
p = Person("zhang","wen jing")#C++中为Person p()
p.get()
p.change()
p.get()
定义的两个变量都有前缀self。以self为前缀的变量都可供类中的所有方法使用，我们
还可以通过类的任何实例来访问这些变量。self.name = name获取存储在形参name中的值，并将其存储到变量name中，然后该变量被关联到当前创建的实例。self.age = age的作用与此类似。
4.4
根据类创建实例
my_dog = Dog('willie', 6)
print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")
我们让Python创建一条名字为’willie’、
年龄为6的小狗。遇到这行代码时，Python使用实参’willie’和6调用Dog类中的方法__init__()。
方法__init__()创建一个表示特定小狗的示例，并使用我们提供的值来设置属性name和age。方法__init__()并未显式地包含return语句，但Python自动返回一个表示这条小狗的实例。我们将这
个实例存储在变量my_dog中。
给属性指定默认值
class Car():
def __init__(self, make, model, year):
"""初始化描述汽车的属性"""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
继承
编写类时，并非总是要从空白开始。如果你要编写的类是另一个现成类的特殊版本，可使用
继承。一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类，而新类称为子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。
创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方
法__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 = str(self.year) + ' ' + self.make + ' ' + self.model
return long_name.title()
def read_odometer(self):
print("This car has " + str(self.odometer_reading) + " miles on it.")
def update_odometer(self, mileage):
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("You can't roll back an odometer!")
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', 20 16)
print(my_tesla.get_descriptive_name())
创建子类时，父类必须包含在当前文件中，且位于子类前面。我们定义了子类ElectricCar。定义子类时，必须在括号内指定父类的名称。方法__init__()接受创建Car实例所需的信息
super()是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让Python调用
ElectricCar的父类的方法__init__()，让ElectricCar实例包含父类的所有属性。父类也称为超类（superclass），名称super因此而得名。
class Fruit():
def __init__(self,type_name,color):
self.type = type_name
self.color = color
def get(self):
print(self.type + " is " + self.color)
class Son(Fruit):
def __init__(self,name,color):
super().__init__(name,color)
apple = Fruit("apple","red")
apple.get()
给子类定义属性和方法
class Car():
--snip--
class ElectricCar(Car):
def __init__(self, make, model, year):
super().__init__(make, model, year)
self.battery_size = 70
def describe_battery(self):
print("This car has a " + str(self.battery_size) + "-kWh battery.")
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
重写父类的方法(函数)
def ElectricCar(Car):
--snip--
def fill_gas_tank():
"""电动汽车没有油箱"""
print("This car doesn't need a gas tank!")
现在，如果有人对电动汽车调用fill_gas_tank()，Python将忽略Car类中的方法fill_gas_tank()，转而运行上述代码。使用继承时，可让子类保留从父类那里继承而来的精华，并剔除不需要的糟粕
class Fruit():
def __init__(self,type_name,color):
self.type = type_name
self.color = color
def get(self):
print(self.type + " is " + self.color)
class Son(Fruit):
def __init__(self,name,color):
super().__init__(name,color)
self.i = 12
def get(self):
print(self.type + " " + str(self.i))
apple = Fruit("apple","red")
apple.get()
banana = Son("banana","yellow")
banana.get()
运行结果：
apple is red
banana 12
导入类
假设Car类储存在car.py
（1）导入单个类
from car import Car
( 2 )从一个模块中导入多个类
from car import Car,ElectricCar
( 3 )导入整个模块
import car
（4）导入模块中的所有类
from car import *
十 文件
从文件中读取数据
读取整个文件
with open('pi_digits.txt') as file_object:
contents = file_object.read()
print(contents)
在这个程序中，第1行代码做了大量的工作。
我们先来看看函数open()：
要以任何方式使用文件——哪怕仅仅是打印其内容，都得先打开文件，这样才能访问它。函数open()接受一个参数：要打开的文件的名称。Python在当前执行的文件所在的目录中查找指定的文件。在这个示例中，当前运行的是file_reader.py，因此Python在file_reader.py所在的目录中查找pi_digits.txt。函数open()返回一个表示文件的对象。在这里open(‘pi_digits.txt’)返回一个表示文件pi_digits.txt的对象；Python将这个对象存储在我们将在后面使用的变量中。
关键字with在不再需要访问文件后将其关闭。在这个程序中，注意到我们调用了open()，但没有调用close()；你也可以调用open()和close()来打开和关闭文件，但这样做时，如果程序存在bug，导致close()语句未执行，文件将不会关闭。这看似微不足道，但未妥善地关闭文件可能会导致数据丢失或受损。如果在程序中过早地调用close()，你会发现需要使用文件时它已关闭（无法访问），这会导致更多的错误。并非在任何情况下都能轻松确定关闭文件的恰当时机，但通过使用前面所示的结构，可让Python去确定：你只管打开文件，并在需要时使用它，Python自会在合适的时候自动将其关闭。
有了表示pi_digits.txt的文件对象后，我们使用方法read()（前述程序的第2行）读取这个文件的全部内容，并将其作为一个长长的字符串存储在变量contents中。这样，通过打印contents的值，就可将这个文本文件的全部内容显示出来
相比于原始文件，该输出唯一不同的地方是末尾多了一个空行。为何会多出这个空行呢？因为read()到达文件末尾时返回一个空字符串，而将这个空字符串显示出来时就是一个空行。要删除多出来的空行，可在print语句中使用rstrip()：
Python方法rstrip()删除（剥除）字符串末尾的空白。
文件路径
要让Python打开不与程序文件位于同一个目录中的文
件，需要提供文件路径，它让Python到系统的特定位置去查找。
由于文件夹text_files位于文件夹python_work中，因此可使用相对文件路径来打开该文件夹中的文件。相对文件路径让Python到指定的位置去查找，而该位置是相对于当前运行的程序所在目录的。
windows用（\）
with open('text_files\filename.txt') as file_object:
绝对路径：
file_path = 'C:\Users\ehmatthes\other_files\text_files\filename.txt'
with open(file_path) as file_object:
Linux和OS X 用（/）
with open('text_files/filename.txt') as file_object:
逐行读取
filename = 'pi_digits.txt'
with open(filename) as file_object:
for line in file_object:
print(line)
我们将要读取的文件的名称存储在变量filename中，这是使用文件时一种常见的做法。
由于变量filename表示的并非实际文件——它只是一个让Python知道到哪里去查找文件的字符串，因此可轻松地将’pi_digits.txt’替换为你要使用的另一个文件的名称。
调用open()后，将一个表示文件及其内容的对象存储到了变量file_object中。
这里也使用了关键字with，让Python负责妥善地打开和关闭文件。为查看文件的内容，我们通过对文件对象执行循环来遍历文件中的每一行
结果：
在这个文件中，每行的末尾都有一个看不见的换行符，而print语句也会加上一个换行符，因此每行末尾都有两个换行符：一个来自文件，另一个来自print语句。要消除这些多余的空白行，可在print语句中使用rstrip()
创建一个包含文件各行内容的列表
使用关键字with时，open()返回的文件对象只在with代码块内可用。如果要在with代码块外
访问文件的内容，可在with代码块内将文件的各行存储在一个列表中，并在with代码块外使用该列表：你可以立即处理文件的各个部分，也可推迟到程序后面再处理。
filename = 'pi_digits.txt'
with open(filename) as file_object:
lines = file_object.readlines()
for line in lines:
print(line.rstrip())
方法readlines()从文件中读取每一行，并将其存储在一个列表中；
接下来，该列表被存储到变量lines中；
在with代码块外，我们依然可以使用这个变量。
我们使用一个简单的for循环来打印lines中的各行。
由于列表lines的每个元素都对应于文件中的一行，因此输出与文件内容完全一致。
读取文本文件时，Python将其中的所有文本都解读为字符串。如果你读取的是数字，并要将其作为数值使用，就必须使用函数int()将其转换为整数，或使用函数float()将其转换为浮点数。
filename = 'pi_million_digits.txt'
with open(filename) as file_object:
lines = file_object.readlines()
pi_string = ''
for line in lines:
pi_string += line.rstrip()
birthday = input("Enter your birthday, in the form mmddyy: ")
if birthday in pi_string:#判断某一字符串是否在大的字符串内
print("Your birthday appears in the first million digits of pi!")
else:
print("Your birthday does not appear in the first million digits of pi.")
写入文件
写入空文件
filename = 'programming.txt'
with open(filename, 'w') as file_object:
file_object.write("I love programming.")
第一个实参也是要打开的文件的名称；
第二个实参（‘w’）告诉Python，我们要以写入模式打开这个文件。打开文件时，可指定读取模式（‘r’）、写入模式（‘w’）、附加模式（‘a’）或让你能够读取和写入文件的模式（‘r+’）。如果你省略了模式实参，Python将以默认的只读模式打开文件。
如果你要写入的文件不存在，函数open()将自动创建它。然而，以写入（‘w’）模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空该文件。
Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数str()将其转换为字符串格式。
写入多行
要让每个字符串都单独占一行，需要在write()语句中包含换行符：
filename = 'programming.txt'
with open(filename, 'w') as file_object:
file_object.write("I love programming.\n")
file_object.write("I love creating new games.\n")
1258
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
