一、变量
1、变量的命名和使用
2、使用方法修改字符串的大小写
①以首字母大写的方式显示每个单词，使用 title() 方法
message="this is I study Python first day" print(message.title())
②将字符串全部修改为大写或者小写，使用方法 upper() 和 lower()
message="this is I study Python first day" print(message.upper()) print(message.lower())
3、拼接字符串
python使用加号(+)来拼接字符串。
name="zhangsan" address="beijing" message=name+"-"+address print(message) message=name+" "+address print(message)
简单问候语
first_name="ada" last_name="lovelace" full_name=first_name+" "+last_name print(full_name) print("Hello,"+full_name.title()+"!")
可以使用拼接来创建信息，再把整条消息都存储在一个变量中
first_name="ada" last_name="lovelace" full_name=first_name+" "+last_name message="Hello,"+full_name.title()+",happy!" print(message)
4、使用制表符或换行符来添加空白
在编程中，空白泛指任何非打印字符，如空格、制表符和换行符。可使用空白来组织输出，使其更易读。
要在字符串中添加制表符，可使用字符组合
print("Python") print(" python")
要在字符串中添加换行符，使用字符组合
print("Linux Python MySQL")
5、删除空白
删除字符串末尾的空白，使用方法 rstrip()
message="Python " message
message.rstrip()
要永久删除这个字符串中的空白，必须将删除操作的结果返回到变量中
message=message.rstrip()
message
删除字符串开头的空白，使用方法 lstrip()
message=" Python " message.lstrip()
删除字符串两端的空白，使用方法 strip()
message=" Python " message.strip()
6、使用字符串避免语法错误
①一对双引号中存在单引号可以正常输出，一对单引号中存在双引号可以正常输出。
②一对单引号中存在单引号会报错，一对双引号中存在双引号会报错，因为python会将第一对单引号或双引号视为字符串，其余的文本视为python代码，从而引发错误。
7、函数str()
将python中的非字符串表示为字符串，如果不进行转换会报错。
age=25 message="happy "+str(age)+"rd birthday" print(message)
Python之禅：在Python终端会话中执行命令import this。
二、列表简介
列表是由一系列按特定顺序排列的元素组成，可以创建包含字母表中的所有字母，数字0~9或所有家庭成员姓名的列表，也可以将任何东西加入列表中，其中的元素之间可以没有任何关系。
在Python中，用方括号（[ ]）表示列表，并用逗号来分割其中的元素。
#列表包含几类自行车
bicycles = ['trek','cannondale','redline','specialized'] print(bicycles)
如果让python将列表打印出来，python将打印列表的内部所有，包括方括号。
1、列表是有序集合，因此要访问列表的任何元素，只需将该元素的位置或索引告诉python即可，要访问列表元素，可指出列表的名称，再指出元素的索引，并将其放在方括号内。
#提取第一款自行车 bicycles = ['trek','cannondale','redline','specialized'] print(bicycles[0])
当请求获取列表元素时，Python只返回该元素，而不包括方括号和引号。
#输出第一款自行车，首字母大写，使用title()方法 bicycles = ['trek','cannondale','redline','specialized'] print(bicycles[0].title())
2、索引从0而不是1开始
在python中，第一个列表元素的索引是0而不是1，第二个列表元素的索引是1，按照这种计算方式，要访问列表的任何元素，都可将其位置减1
#访问索引1和3处的自行车,返回列表中的第二个和第四个元素 bicycles = ['trek','cannondale','redline','specialized'] print(bicycles[1]) print(bicycles[3])
3、Python访问最后一个列表元素提供了一种特殊语法，通过索引指定为 -1 ，可让Python返回最后一个列表元素。
bicycles = ['trek','cannondale','redline','specialized'] print(bicycles[-1])
索引 -2 返回倒数第二个列表元素，索引 -3 返回倒数第三个列表元素，以此类推。
4、使用列表中的各个值
可像使用其他变量一样使用列表中的各个值，可以使用拼接根据列表中的值创建信息。
bicycles = ['trek','cannondale','redline','specialized'] message="my first bicycle was "+bicycles[0].title()+"." print(message)
5、修改、添加和删除元素
创建的大多数列表都将是动态的，列表将随着程序的运行增删元素。
①修改列表元素的语法与访问列表元素的语法类似，要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值。
#修改第一个人物的名字为"赵信" student=['锐雯','盖伦','亚索','璐璐'] print(student) student[0]="赵信" print(student)
可以修改任何列表元素的值。
②在列表中添加元素
在列表末尾添加元素，使用 append() 方法
#在列表末尾添加一个人物”剑圣“ student=['锐雯','盖伦','亚索','璐璐'] print(student) student.append('剑圣') print(student)
可以先创建一个空列表，再使用 append() 方法去添加
figure=[] figure.append('诺手') figure.append('木木') figure.append('狼人') print(figure)
在列表的任何位置插入元素 -- insert()
#在索引2处添加一个人物”拉克丝“ student=['锐雯','盖伦','亚索','璐璐'] print(student) student.insert(2,'拉克丝') print(student)
③从列表中删除元素 -- del
#删除索引位置0的人物 student=['锐雯','盖伦','亚索','璐璐'] print(student) del student[0] print(student)
④使用方法 pop() 删除元素
有时候需要将元素从列表中删除， 并接着使用它的值，方法 pop() 可删除列表末尾的元素，并让你能够接着使用它。
术语弹出（pop）源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。
#删除列表最后一个元素，并继续使用其值 student=['锐雯','盖伦','亚索','璐璐'] print(student) figure=student.pop() print(student) print(figure)
⑤使用 pop() 方法弹出任何位置处的元素。
可以使用pop() 来删除列表中任何位置的元素，只需在括号中指定要删除的元素的索引即可。
#删除索引位置2的人物 student=['锐雯','盖伦','亚索','璐璐'] figure=student.pop(2) print(figure) print("I like use a figure is"+figure)
※如果要从列表中删除一个元素，且不再以任何方式使用它就用 del 语句；如果要在删除元素后还继续使用，就使用方法 pop()
⑥根据值删除元素
不知道列表中删除值的所处位置，知道想删除元素的值，可以使用 remove() 方法。
#从列表中删除“亚索‘ student=['锐雯','盖伦','亚索','璐璐'] print(student) student.remove("亚索") print(student)
※方法 remove() 只删除列表中第一个指定的值，如果要删除的值在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。
6、组织列表
元素的排列顺序常常是无法预测的，需要特定的顺序呈现信息。
①使用方法 sort() 对列表进行永久性排序
#对自行车按照字母顺序排序 bicycles = ['trek','cannondale','redline','specialized'] bicycles.sort() print(bicycles)
方法 sort() 永久性的修改了列表元素的排列顺序，无法恢复到原来的排列顺序。
②反向排序，向 sort() 方法传递参数 reverse=True
#将自行车按照反向按照字母排序 bicycles = ['trek','cannondale','redline','specialized'] bicycles.sort(reverse=True) print(bicycles)
③使用函数 sorted() 对列表进行临时排序
要保留列表元素原来的排列顺序，同时以特定的顺序呈现他们，可使用函数 sorted() ，函数 sorted() 能够按照特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序。
#对自行车按照字母临时排序 bicycles = ['trek','cannondale','redline','specialized'] print(bicycles) print(sorted(bicycles)) print(bicycles)
按与字母顺序相反的顺序显示列表，可向函数 sorted() 传递参数 reverse=True
bicycles = ['trek','cannondale','redline','specialized'] print(bicycles) print(sorted(bicycles,reverse=True))
④倒着打印列表
要反转列表元素的排列顺序，使用方法 reverse()
#倒着打印列表 student=['锐雯','盖伦','亚索','璐璐'] student.reverse() print(student)
reverse() 不是指按与字母顺序相反的顺序排列列表元素，只是反转列表元素的排列顺序。
reverse() 方法可以永久性的修改元素的排列顺序，但可随时恢复到原来的排列顺序，为此只需对列表再次调用reverse() 即可
7、确定列表的长度
使用 len() 可快速获悉列表的长度
student=['锐雯','盖伦','亚索','璐璐'] len(student)
三、操作列表
1、for 循环
figure=['锐雯','盖伦','亚索','璐璐'] for item in figure: print("I Like use "+item+"!")
for 循环后面，没有缩进的代码都执行一次，而不会重复执行。
figure=['锐雯','盖伦','亚索','璐璐'] for item in figure: print("I Like use "+item+"!") print("Do you like play LOL?")
2、创建数值列表
①使用函数 range()
for item in range(1,5): print(item)
range() 前闭后开。
②range()创建数字列表
要创建数字列表，可使用函数 list() 将 range() 的结果直接转换为列表，如果将 range() 作为 list() 的参数，输出将作为一个数字列表
number = list(range(1,6)) print(number)
使用函数 range() 时，可指定步长。
number = list(range(1,10,2)) print(number)
使用函数range() 几乎能够创建任何需要的数字集
#将前10个整数的平方加入到一个列表中 number = [] for item in range(1,11): total=item ** 2 number.append(total) print(number)
#为了使代码简洁，可不使用临时变量total number = [] for item in range(1,11): number.append(item**2) print(number)
③专门对数字列表执行统计计算的函数
min -- 显示列表中的最小值
max -- 显示列表中的最大值
sum -- 统计列表中数值的总和
number = list(range(0,21)) print(number) print(min(number)) print(max(number)) print(sum(number))
3、列表解析
列表解析只需编写一行代码就能生成这样的列表，列表解析将 for 循环和创建新元素的代码合并成一行，并自动附加新元素。
number = [item ** 2 for item in range(1,11)] print(number)
4、切片
切片可以处理列表的部分元素，创建切片要指定使用的第一个元素和最后一个元素的索引。与函数range() 一样，Python在到达指定的第二个索引前面的元素停止，要输出列表中的前三个元素，需要指定索引0~3，这将分别输出0、1、2的元素。
figure=['锐雯','盖伦','亚索','璐璐','剑姬','安妮','盲僧'] print(figure[0:4])
#如果没有指定第一个索引，Python将自动从列表开头开始 figure=['锐雯','盖伦','亚索','璐璐','剑姬','安妮','盲僧'] print(figure[:6])
#让切片从列表的某个索引到列表末尾 figure=['锐雯','盖伦','亚索','璐璐','剑姬','安妮','盲僧'] print(figure[2:])
负数索引可以返回离列表末尾相应距离的元素。
#输出最后三个人物的名字 figure=['锐雯','盖伦','亚索','璐璐','剑姬','安妮','盲僧'] print(figure[-3:])
5、遍历切片
遍历列表中的部分元素，可在for循环中使用切片。
figure=['锐雯','盖伦','亚索','璐璐','剑姬','安妮','盲僧'] for item in figure[:5]: print(item)
6、复制列表
复制列表可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（:）,这让python创建一个始于第一个元素，终止于最后一个元素的切片，即复制整个列表。
figure = ['锐雯','盖伦','亚索','璐璐','剑姬','安妮','盲僧'] student = figure[:] print(figure) print(student)
7、元组
列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，有时候需要创建一系列不可修改的元素，元组可以满足这种修改，Python将不可修改的值称为不可变的，而不可变的列表称为元组。
元组看起来犹如列表，但是使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。
figure = ('亚索','锐雯','卡特') print(figure)
元组不允许修改元素的值
①遍历元组中的所有值
像列表一样，也可以使用for循环来遍历元组的所有值
figure = ('亚索','锐雯','卡特') for item in figure: print(item)
②修改元组变量
虽然不能修改元组的元素，但可以给存储元组的变量赋值。
figure = ('亚索','锐雯','卡特') print(figure) figure = ('赵信','盖伦','剑圣','诺手') print(figure)
相比于列表，元组是更简单的数据结构，如果需要存储的一组值在程序的整个生命周期内都不变，可使用元组。
四、if 语句
在Python中，if语句能够检查程序的当前状态，并据此采取相应的措施。
#遍历列表，如果是”trek“，字母全部大写，其他的都是首字母大写 bicycles = ['trek','cannondale','redline','specialized'] for item in bicycles: if item == 'trek': print(item.upper()) else: print(item.title())
每条 if 语句的核心都是一个值为 True 或 False 的表达式，这种表达式称为条件测试。Python 根据条件测试的值为 True 还是 False 来决定是否执行 if 语句中的代码，如果条件测试的值为 True，Python 就执行紧跟在 if 语句后面的代码；如果为 False,Python就忽略这些代码。
①大多数条件测试都将一个变量的当前值和特定值进行比较，最简单的条件测试检查变量的值是否与特定值相等。
bicycle = 'trek' bicycle == 'trek'
bicycle = 'trek' bicycle == 'redline'
两个大小写不相同的值会被视为不相等。
如果大小写无关紧要，只是想检查变量的值，可将变量的值转换为小写再进行比较。
bicycle = 'TREK' bicycle.lower() == 'trek'
②检查是否不相等
要判断两个值是否不等，可结合使用叹号和等号（!=）,叹号表示不
bicycles = ['trek','cannondale','redline','specialized'] for item in bicycles: if item != 'apple': print('这不是自行车')
③比较数字
1、检查多个条件
需要两个条件都为 true 时才执行的操作或只要求一个条件为 true 时就执行相应的擦欧总，需要用到 and 和 or
①使用 and 检查多个条件，两边都为 true 才返回 true，有一个为 false 则返回 false
age = 20 age_1 = 25 age == 20 and age_1 == 25
②使用 or 检查多个条件，两边有一个是 true 则返回 true，两边都为 false 才返回 false
age = 20 age_1 = 25 age == 20 or age_1 == 100
2、检查特定值是否包含在列表中，使用 in
执行操作前检查列表中是否包含特定的值，要判断特定值是否已经在列表中，可使用关键字 in
bicycles = ['trek','cannondale','redline','specialized'] 'trek' in bicycles
3、检查特定值是否不包含在列表中，使用 not in
bicycles = ['trek','cannondale','redline','specialized'] figure = 'monkey' if figure not in bicycles: print(figure+"is an animal")
4、布尔表达式
布尔表达式是条件测试的别名，与条件表达式一样，布尔表达式的结果要么为 True，要么为 False
布尔表达式通常用于记录条件，如游戏正在运行，或用户是否可以编辑网站的特定内容。
game_active = True
can_edit = False
※else是一条包罗万象的语句，只要不满足任何 if 或 elif 中的条件测试，其中的代码就会执行，这可能会引入无效甚至恶意的数据，如果知道最终要测试的条件，应考虑使用一个elif代码块来代替else代码块，这样就可以肯定，仅当满足相应的条件时，代码才会执行。
※if-elif-else结构功能强大，且仅适合用于一个条件满足的情况，遇到通过了的测试，Python就跳过余下的测试。
※单独使用代码块时，如果关心每个条件，就需要用一系列的 if
figure = ('亚索','锐雯','盲僧') if "亚索" in figure: print("亚索是中单") if "锐雯" in figure: print("锐雯是上单") if "盲僧" in figure: print("盲僧是打野")
单独的代码块如果使用 if-elif 结构，那么满足第一个条件就跳出
figure = ('亚索','锐雯','盲僧') if "亚索" in figure: print("亚索是中单") elif "锐雯" in figure: print("锐雯是上单") elif "盲僧" in figure: print("盲僧是打野")
如果是在 for 循环中使用 if-elif-else 可以，都使用 if 也可以
figure = ('亚索','锐雯','盲僧') for item in figure: if item == '亚索': print(item+"是中单") elif item == '锐雯': print(item+"是上单") else: print(item+"是打野")
5、检查特殊元素
figure = ('亚索','锐雯','盲僧') for item in figure: if item == '亚索': print(item+" this hero was select") else: print("you select hero is "+item)
6、确定列表不是空的
在运行 for 循环前确定列表是否为空。
figure = [] if figure: for figure in figure: print("use "+figure) print("begin game") else: print("don't select a hero")
在 if 语句中将列表名用在条件表达式中时，Python 将在列表至少包含一个元素时返回 True，并在列表为空时返回 False，如果列表不为空，就运行与前一个示例相同的 for 循环。
figure = ['亚索','锐雯'] if figure: for figure in figure: print("use "+figure) print("begin game") else: print("don't select a hero")
使用多个列表
figure = ['盖伦','锐雯','亚索','泰隆','剑姬'] user_figure = ['盖伦','拉克丝','锐雯'] for user_figure in user_figure: #user_figure 列表自己遍历自己的元素 if user_figure in figure: #每遍历一个元素判断是否在 figure 列表中 print('The user select hero is '+user_figure) else: print("Sorry,The user can't select "+user_figure)
五、字典
字典可存储的信息量几乎不受限制。
1、一个简单的字典
alien = {'color':'green','points':5}
print(alien['color'])
print(alien['points'])
2、使用字典
在Python中，字典是一系列的键值对，每个键都与一个值相关联，可以使用键来访问与之关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何 Python 对象用作字典中的值。
在Python中，字典用放在花括号 { } 中的一系列键值对表示。
键值对是两个相关联的值，指定键时，Python将返回与之相关联的值。键和值之间用冒号分割，而键值对之间用逗号分割，在字典中，想存储多少个键值对都可以。
alien = {'color':'green','points':5}
要获取与键相关联的值，可依次指定字典名和放在方括号内的键
alien = {'color':'green'}
print(alien['color'])
alien = {'color':'green','points':5}
new_alien = alien['points']
print("You just earned "+str(new_alien)+" points")
3、添加键值对
字典是一种动态结构，可随时在其中添加键值对。要添加键值对，可依次指定字典名、用方括号括起来的键和相关联的值。
①添加键值对
fruit = {'apple':'red','banana':'yellow'}
fruit['peach'] = 'pink'
print(fruit)
②创建空字典在添加键值对
fruit = {} fruit['apple'] = 'red' print(fruit)
③修改字典中的值
修改字典中的值，依次指定字典名、用方括号括起来的键以及与该键相关联的新值。
fruit = {'apple':'red'}
print("The apple color is "+fruit['apple'])
fruit['apple'] = 'green'
print("now,The apple color is "+fruit['apple'])
number = {'a':1,'b':2,'c':3}
if number['a'] == 1:
x = 1
elif number['a'] == 2:
x = 2
else:
x = 3
number['a'] = x + number['a']
print("the number a is "+str(number['a']))
4、删除键值对
对于字典中不需要的信息，可使用 del 语句将相应的键值对彻底删除。使用 del 语句时，必须指定字典名和要删除的键
fruit = {'apple': 'red', 'banana': 'yellow', 'peach': 'pink'}
print(fruit)
del fruit['peach']
print(fruit)
5、由类似对象组成的字典
可以使用字典来存储众多对象的同一信息。对于较长的字典，可采用如下方法
fruit = {'apple': 'red',
'banana': 'yellow',
'peach': 'pink',
'orange':'orange',
'kiwi':'green'
}
print("the apple color is "+fruit['apple'].title())
6、遍历字典：
#使用 items() 方法将返回一个键值对列表。
fruit = {'apple':'red','banana':'yellow','peach':'pink'} for key,value in fruit.items(): print("key: "+key) print("value: "+value+" ")
①遍历字典中的所有键 -- keys()
fruit = {'apple':'red','banana':'yellow','peach':'pink'}
for key in fruit.keys():
print("The key is "+key)
②按顺序遍历字典中的所有键
fruit = {'apple':'red','banana':'yellow','peach':'pink','pear':'yellow'}
for item in sorted(fruit.keys()):
print(item)
字典总是明确的记录键和值之间的关联关系，但获取字典元素时，获取顺序是不可预测的，如果按顺序输出，使用函数 sorted() 来获得按特定顺序排列列表的副本。
③遍历字典中的所有值 -- values()，返回一个值列表，不包含任何键
fruit = { 'apple':'red', 'banana':'yellow', 'peach':'pink', 'pear':'yellow' } for item in fruit.values(): print(item)
④去除重复项 -- set()
fruit = { 'apple':'red', 'banana':'yellow', 'peach':'pink', 'pear':'yellow' } for item in set(fruit.values()): print(item)
7、嵌套
将一系列字典存储在列表中，或将列表作为值存储在字典中，称为嵌套。可以在列表中嵌套字典、在字典中嵌套列表或在字典中嵌套字典。
①在列表中嵌套字典
fruit_1 = {'apple':'red'}
fruit_2 = {'banana':'yellow'}
fruit_3 = {'peach':'pink'}
fruit_4 = {'pear':'yellow'}
fruit = [fruit_1,fruit_2,fruit_3,fruit_4]
print(fruit)
for item in fruit:
print(item)
②在字典中嵌套列表
fruit = { 'orange':'orange', 'apple':['red','green'] } print("The fruit orange's color is "+fruit['orange']+" ") for item in fruit['apple']: print("The fruit apple's color is "+item)
③在字典中存储字典
#将每位用户的信息存储在一个字典中，对于每位用户，存储其三项信息：名、姓和居住地，遍历所有用户名，并访问每个用户相关联的信息字典。 users = { 'W':{ 'first':'wang', 'last':'_A' }, 'L':{ 'first':'li', 'last':'_B' } } for username,user_info in users.items(): print(" Username: "+username) full_name = user_info['first']+user_info['last'] print("Full_name："+full_name.title())
#字典存储列表
favorite_places = {'zhangsan':['beijing','shanghai'],'lisi':['hunan','guangzhou','xizang'],'wangwu':['guizhou','neimeng']} for name,place in favorite_places.items(): print(" "+name+"喜欢去的地方是：") for item in place: print(item.title())
# 创建一个名为cities 的字典，其中将三个城市名用作键；对于每座城市，都创建一个字典，并在其中包含该城市所属的国家、人口约数以及一个有关该 城市的事实。在表示每座城市的字典中，
应包含country 、population 和fact 等键。将每座城市的名字以及有关它们的信息都打印出来。 cities = { 'China':{ 'country':'beijing', 'population':'2153.6 million', 'fact':'capital' }, 'USA':{ 'country':'New York', 'population':'870 million', 'fact':'sports' }, 'Japan':{ 'country':'Tokyo', 'population':'1394 million', 'fact':'hot' } } for country,info in cities.items(): print("Select city is "+country) print("The city's country is "+info['country']) print("The city's population is "+info['population']) print("The city's fact is "+info['fact']+" ")
六、用户输入和while循环
函数 input() 可以接收用户输入的内容。
①函数 Input() 的工作原理
函数 Input() 让程序暂停运行，等待用户输入一些文本，获取用户输入后，Python将其存储在一个变量中，方便之后使用。
message = input("please input a tel number：") print(message)
每当使用 input() 函数时，都应该指定清晰而易于明白的提示，有时候提示超过一行，可将提示存储在一个变量中，再将变量传递给函数 input() 。
message = "This is a long message." message += " please input your number" tel = input(message) print(tel)
使用函数 input() 时，Python 将用户输入解读为字符串
age = input("please input your age：") age
当进行数字比较时，此时会报错，因为无法将字符串和数字进行比较。
函数 int() 将Python的输入视为数值，
age = input("please input your age：") age = int(age) if age < 30: print("your are so young")
或
age = int(input("please input your age："))
if age < 30:
print("your are so young")
1、求模运算符
求模运算符将两个数相除并返回余数，不会指出一个数是另一个数的多少倍，而指出余数是多少。
number = int(input("please input a number: ")) if number % 2 == 0 : print("The number "+str(number)+" is even") else: print("The number "+str(number)+" is odd")
#判断一个数是不是100的整数 number = input("please input a number: ") number = int(number) if number % 100 == 0: print("This "+str(number)+" is an integer multiple of 100") else: print("This "+str(number)+" is not an integer multiple of 100")
2、while循环简介
for 循环用于针对集合中的每个元素的一个代码块，而 while 循环不断的运行，直到指定的条件不满足为止。
#使用循环来数数 number = 1 while number <= 5: print(number) number += 1
message_a = input("please input a str: ") while message_a != 'quit': message_a = input("please input a str: ") if message_a == 'quit': print("over") else: print("continue")
#添加一个标志，将这个标志命名为 active，可以将标志命名为任何名称。用于判断程序是否应该继续执行。
active = True while active: message_a = input("please input a str: ") if message_a == 'quit': active = False else: print("continue")
将程序变量 active 设置为 True，让程序处于活动状态，这样简化了while语句，不需要做任何比较，将变量 active 变为 True，循环将继续执行。将变量 active 设置为 False，这将导致 while 循环不再执行。
1、使用 break 退出循环
要立即退出 while 循环，不再运行循环中余下的代码，也不管条件测试的结果如何，可使用 break 语句，break 语句用于控制程序流程，可使用它来控制哪些代码行执行，哪些代码行不执行。
city = "Please enter according to the prompt," city += " Please input a city name：" while True: message = input(city) if message == 'quit': break else: print("I love city is "+message+" ")
在任何Python循环中都可使用break语句，可使用break语句来退出遍历列表或字典的for循环。
2、在循环中使用continue
要返回到循环开头，并根据条件测试结果决定是否继续执行循环，可使用continue语句，它不像break语句那样不再执行余下的代码并退出整个循环。
number = 0 while number < 10: number += 1 if number % 2 == 0: continue print(number)
message = "please input a fruit: " while True: fruit = input(message) if fruit == 'quit': break else: print("I Like eat fruit is "+fruit+" ")
3、使用 while 循环来处理列表和字典
for 循环是一种遍历列表的有效方式，但在 for 循环中不应修改列表，否则将导致 Python 难以跟踪其中的元素。要在遍历列表的同时对其进行修改，可使用 while 循环，通过将 while 循环同列表和字典结合使用，可收集、存储并组织大量输入，供以后查看和显示。
在列表之间移动元素
fruit = ['apple','banana','peach'] fruit_new = [] while fruit: fruit_A = fruit.pop() print("I like this fruit: "+fruit_A) fruit_new.append(fruit_A) for item in fruit_new: print(item.title())
①删除包含特定值的所有列表元素
pets = ['cat','dog','rabbit','cat','pig','cat'] print(pets) while 'cat' in pets: pets.remove("cat") print(pets)
②使用用户输入来填充字典
question = {} active = True while active: name = input("What's your name: ") ques = input("How do you like fruit: ") question[name] = ques resp = input("Have another person?(yes/no): ") if resp == 'yes': continue elif resp == 'no': active = False print(" Over") else: print("please input right option") continue for name,ques in question.items(): print(name.title()+" like fruit is "+ques.title())
七、函数
函数是带名字的代码块，用于完成具体的工作。
要执行函数定义的特定任务，可调用该函数，需要在程序中多次执行同一项任务时，无需反复编写该任务的代码，只需要调用执行该任务的函数。
定义函数，使用 def 定义函数
def number(): '''定义一个简单的函数''' print("Hello World") number()
函数i调用让Python执行函数的代码，要调用函数，可依次指定函数名以及用括号括起的必要信息。
1、向函数传递信息
def greet_user(username): print("Hello, "+username.title() + "!") greet_user('Jerry')
在函数定义 greet_user() 的括号内添加 username ，通过在这里添加 username ，就可让函数接受你给 username 的任何值，函数调用时给 username 指定一个值，调用 greet_user() 时，可将一个名字传递给它。
2、实参和形参
在函数 greet_user() 的定义中，变量 username 是一个形参，形参是函数完成其工作所需的一项信息，在代码 greet_user('Jerry') 中，值 'Jerry' 是一个实参，实参是调用函数时传递给函数的信息。
我们调用函数时，将要让函数使用的信息放在括号内，在greet_user('Jerry')中，将实参‘Jerry’ 传递给了函数 greet_user()，这个值被存储在形参 username 中。
3、传递实参
函数定义中可能包含多个形参，因此函数调用中也可能包含多个实参。向函数传递实参的方式很多，可使用位置实参，这要求实参的顺序与形参的顺序相同，也可使用关键字实参，其中每个实参都由变量名和值组成，还可使用列表和字典。
①位置实参
Python必须将函数调用中的每个实参都关联到函数定义中的一个形参，最简单的关联方式是基于实参的顺序，这种关联方式被称为位置实参。
def fruit(fruit_name,fruit_color): print("I like fruit name is "+fruit_name+",and It's color is "+fruit_color) fruit('apple','green')
②可以调用函数多次
def fruit(fruit_name,fruit_color): print("I like fruit name is "+fruit_name+",and It's color is "+fruit_color) fruit('apple','green') fruit('peach','pink')
在函数中，根据需要使用任意数量的位置实参，Python将按顺序将函数调用中的实参关联到函数定义中相应的形参。
4、关键字实参
关键字实参是传递给函数的名称---值对，直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆，关键字实参无需考虑函数调用中的实参顺序，清楚的指出了函数调用中各个值的用途。
def fruit(fruit_name,fruit_color): print("I like fruit name is "+fruit_name+",and It's color is "+fruit_color) fruit(fruit_name='apple',fruit_color='green') fruit(fruit_color='pink',fruit_name='peach')
5、默认值
编写函数时，可给每个形参指定默认值，在调用函数中给形参提供了实参时，Python将使用指定的实参值，否则，将使用形参的默认值，给形参指定默认值后，可在函数调用中省略相应的实参。
def fruit(fruit_name,fruit_color='red'): print("I Like fruit is "+fruit_name+",It's color is "+fruit_color) fruit(fruit_name='apple') fruit(fruit_name='banana',fruit_color='yellow') fruit('orange')
6、返回值
函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。函数返回的值被称为返回值。
在函数中，可使用 return 语句将值返回到调用函数的代码行，返回值能够将程序的大部分繁重工作移到函数中去完成，从而简化主程序。
def fruit(fruit_name,fruit_color): full_name = fruit_name+' '+fruit_color return full_name.title() message = fruit('apple','color') print(message)
调用返回值的函数时，需要提供一个变量，用于存储返回的值，才能整洁输出，不提供变量返回的将是带引号的
①让实参变成可选的
有时候需要让实参变成可选的，这样使用函数的人只需在必要时才能提供额外的信息，可使用默认值让实参变成可选的。
def get_formatted_name(first_name,last_name,middle_name=''): if middle_name: #判断middle_name 是否有值，有的人没有中间名 full_name = first_name+'-'+middle_name+'-'+last_name return full_name.title() else: full_name = first_name+'-'+last_name return full_name.title() message = get_formatted_name('Stephen','Curry','Waddell') print(message) message = get_formatted_name('LeBron','James') print(message)
②返回字典
函数可返回任何类型的值，包括列表和字典等较复杂的数据结构。
def fruit(fruit_name,fruit_color): fruit_full = {'name':fruit_name,'color':fruit_color} return fruit_full message = fruit('apple','red') print(message)
def name(first_name,last_name,age=''): person = {'first':first_name,'last':'last_name'} if age: person['age'] = age return person message = name('Wang','_A') print(message) message = name('L','_B',age=24) print(message)
7、结合使用函数和while循环
def fruit(fruit_name,fruit_color): fruit_full_name = fruit_name+'-'+fruit_color return fruit_full_name.title() while True: print(" 请输入你喜欢的水果的名称和颜色") f1 = input("Fruit's name: ") l1 = input("Fruit's color: ") message = fruit(f1,l1) print("I Like fruit is "+message)
def fruit(fruit_name,fruit_color): fruit_full_name = fruit_name+'-'+fruit_color return fruit_full_name.title() while True: print(" 请输入你喜欢的水果的名称和颜色") f1 = input("Fruit's name: ") l1 = input("Fruit's color: ") if f1 == 'q' and l1 == 'q': break message = fruit(f1,l1) print("I Like fruit is "+message)
def fruit(fruit_name,fruit_color): full_fruit = {fruit_name:fruit_color} return full_fruit while True: fruit_n = input("please input fruit's name: ") fruit_c = input("please input fruit's color: ") if fruit_n == 'quit' and fruit_c == 'quit': break message = fruit(fruit_n,fruit_c) for name,color in message.items(): print(name+"'s color is"+color)
#可选形参 def fruit(fruit_name,fruit_color,fruit_count=''): fruit_full = {'fruit_name':fruit_name,'fruit_color':fruit_color} if fruit_count: fruit_full['fruit_count'] = fruit_count return fruit_full while True: fruit_n = input("input fruit's name: ") if fruit_n == 'quit': break fruit_c = input("input fruit's color: ") if fruit_c == 'quit': break fruit_co = input("input fruit's count: ") if fruit_co == 'quit': break message = fruit(fruit_n,fruit_c,fruit_co) print(message)
8、传递列表
向函数传递列表，列表包含的可能是名字、数字或更复杂的对象(如字典)，将列表传递给函数后，函数就能直接访问其内容。
def greet_users(names): for name in names: print("Hello,"+name.title()+"!") username = ['Tom','Jerry','Hardon'] greet_users(username)
①在函数中修改列表
列表传递给函数后，函数可对其进行修改，在函数中对这个列表所作的任何修改都是永久性的，能够高效的处理大量数据。
def fruit(fruit_name,fruit_full): while fruit_name: fruit_a = fruit_name.pop() print("弹出的元素是："+fruit_a) fruit_full.append(fruit_a) def fruit_new(fruit_full): for item in fruit_full: print("元素："+item) fruit_name = ['apple','banana','pear','orange'] fruit_full = [] fruit(fruit_name,fruit_full) fruit_new(fruit_full)
②禁止函数修改列表
切片表示法[:] 可以创建副本的形式操作，而原列表不发生变化
#name是列表
修改列表：fruit(name,color)
使用副本，不修改列表：fruit(name[:],color)
9、传递任意数量的实参 -- *
预先不知道函数需要接受多少个实参，Python允许函数从调用语句中收集任意数量的实参。
def fruit(*fruit_name): print(fruit_name) fruit('apple') fruit('apple','banana','orange')
使用 * 号让形参可以接受多个参数。
def fruit(*fruit_name): for item in fruit_name: print(item) fruit('apple','banana','orange')
10、结合使用位置实参和任意数量实参
如果让函数接收不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后，Python先匹配位置关键字和关键字实参，再将余下的实参都收集到最后一个形参中。
def fruit(fruit_name,*fruit_color): print("The Fruit is "+fruit_name) for item in fruit_color: print("- " +item) fruit('orange','orange') fruit('apple','red','green','yellow')
Python将收到的第一个值存储在形参 fruit_name 中，并将其他的所有值都存储在元组 fruit_color 中。
11、使用任意数量的关键字实参
需要接受任意数量的实参，但是预先不知道传递给函数的会是什么样的信息，这种情况下，可将函数编写能够接受任意数量的键值对，调用语句提供了多少就接受多少。
def fruit(fruit_name,fruit_color,**fruit_info): profile = {} profile['fruit_name'] = fruit_name profile['fruit_color'] = fruit_color for key,value in fruit_info.items(): #遍历字典fruit_info的键值对，并将每一个键存储到字典profile中。 profile[key] = value return profile fruit_full = fruit('apple','red',location='Beijing',count=20) print(fruit_full)
12、将函数存储在模块中
函数的优点之一是，使用他们可将代码块与主程序分离，通过给函数指定描述性名称，可让主程序容易理解的多。
可以将函数存储在称为模块的独立文件中，再将模块导入到主程序中，import 语句允许再当前运行的程序文件中使用模块中的代码。
①导入整个模块
要让函数导入，需要先创建模块，模块是扩展名为 .py 的文件，包含要导入到程序中的代码，例，创建一个包含 make_pizza() 的模块，保存在 pizza.py中。
def make_pizza(size,*toppings): '''概述要制作的披萨''' print(" Making a "+str(size)+ "-inch pizza with the following toppings:") for topping in toppings: print("- "+ topping)
在 pizza.py 所在的目录中创建另一个名为 making_pizzas.py 的文件，这个文件导入刚刚创建的模块并进行调用。
import pizza pizza.make_pizza('12','pepperoni') pizza.make_pizza('16','mushrooms','green peppers','extra cheese')
调用 pizza.py 模块后得出的结果，在making_pizzas.py 中可以使用 pizza.py 定义的所有函数。
#使用 import 就可以导入函数，导入后的使用方法
module_name.function_name()
②导入特定的函数
from module_name import function_name
通过用逗号分割函数名，可根据需要从模块中导入任意数量的函数
from module_name import function_0,function_1.function_2
对于前面的making_pizza.py 示例，如果只想导入想要的函数，可以使用类似下面
from pizza import make_pizza
③使用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')
八、类
首字母大写的名称指的是类。
在面向对象编程中，表示显示世界中的事物和情景的类，并基于这些类来创建对象，编写类时，定义一大类对象都有的通用行为。
基于类创建对象时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。
根据类来创建对象被称为实例化，能够用类的实例。
1、创建和使用类
例：编写一个表示小狗的简单类Dog，不是特定的小狗，而是任何小狗，大多数小狗都有名字和年龄，还会蹲下和打滚。由于大多数小狗都具备上述两项信息和两种行为，这个类让Python知道如何创建小狗的对象，编写这个类后再使用它来创建表示特定小狗的实例。
#创建Dog类 #根据Dog类的每个实例都将存储名字和年龄，赋予每条小狗蹲下(sit()) 和 打滚 (roll_over()) 的能力 class Dog(): '''一次模拟小狗的简单尝试''' def __init__(self,name,age): '''初始化属性name和age''' self.name = name self.age = age def sit(self): '''模拟小狗被命令时蹲下''' print(self.name.title()+" is now sitting.") def roll_over(self): '''模拟小狗被命令时打滚''' print(self.name.title()+" rolled over!")
①方法 __init__()
前面学到的有关函数的一切都适用于方法。__init__() 是一个特殊的方法，每当根据Dog()类创建实例时，Python都会自动运行它，在这个方法的名称中，开头和末尾各有两个下划线，避免Python默认方法与前面普通方法发生名称冲突。
上面Dog()例子中，将方法__init__() 定义成了包含三个形参：self、name、age，在这个方法的定义中，形参 self 必不可少，还必须位于其他形参的前面，Python 调用这个 __init__() 方法来创建 Dog 实例时将自动传入实参 self。每个类相关联的方法调用都自动传递实参 self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。
Python 调用Dog类的方法 __init__()，通过实参向 Dog() 传递名字和年龄；self 会自动传递，因此不需要传递它，每当根据Dog类创建实例时，都只需给最后两个形参(name 和 age)提供值。
以self为前缀的变量都可供类中的所有方法使用，还可以通过类的任何实例来访问这些变量。self.name = name 获取存储在形参 name 中的值，并将其存储到变量中，然后该变量被关联到当前创建的实例。
Dog 类定义的另外两个方法，sit() 和 roll_over() ，这些方法不需要额外的信息，如名字或年龄，因此它们只有一个形参self。
class Dog(): '''一次模拟小狗的简单尝试''' def __init__(self,name,age): '''初始化属性name和age''' self.name = name self.age = age def sit(self): '''模拟小狗被命令时蹲下''' print(self.name.title()+" is now sitting.") def roll_over(self): '''模拟小狗被命令时打滚''' print(self.name.title()+" rolled over!") my_dog = Dog('naonao',6) print("My Dog's name is "+my_dog.name+" ,and it's age is "+str(my_dog.age)) #my_dog.name 访问小狗名字
②访问属性
要访问实例的属性，可使用句点表示法：如 my_dog.name、my_dog.age
③调用方法
根据 Dog 类创建实例后，就可以使用句点表示法调用 Dog 类中定义的任何方法
class Dog(): '''一次模拟小狗的简单尝试''' def __init__(self,name,age): '''初始化属性name和age''' self.name = name self.age = age def sit(self): '''模拟小狗被命令时蹲下''' print(self.name.title()+" is now sitting.") def roll_over(self): '''模拟小狗被命令时打滚''' print(self.name.title()+" rolled over!") my_dog = Dog('naonao',6) my_dog.sit() my_dog.roll_over()
④创建多个实例
class Dog(): '''一次模拟小狗的简单尝试''' def __init__(self,name,age): '''初始化属性name和age''' self.name = name self.age = age def sit(self): '''模拟小狗被命令时蹲下''' print(self.name.title()+" is now sitting.") def roll_over(self): '''模拟小狗被命令时打滚''' print(self.name.title()+" rolled over!") my_dog = Dog('naonao',6) my_dog.sit() your_dog = Dog('niuniu','8') your_dog.roll_over() print("My Dog's name is "+my_dog.name+",and it's age is "+str(my_dog.age)) print("My Dog's name is "+your_dog.name+",and it's age is "+str(your_dog.age))
#创建一个名为Restaurant 的类，其方法__init__() 设置两个属性：restaurant_name 和cuisine_type 。创建一个名 为describe_restaurant() 的方法和一个名为open_restaurant() 的方法，其中前者打印前述两项信息，而后者打印一条消息，指出餐馆正在营业。 根据这个类创建一个名为restaurant 的实例，分别打印其两个属性，再调用前述两个方法 class Restaurant(): def __init__(self,restaurant_name,cuisine_type): self.restaurant_name = restaurant_name self.cuisine_type = cuisine_type def describe_restaurant(self): print("restaurant name is "+self.restaurant_name+",cusine type is "+self.cuisine_type) def open_restaurant(self): print("餐馆正常营业") restaurant = Restaurant('python','⭐⭐⭐⭐⭐') print("Look! "+restaurant.restaurant_name+",and it;s type is "+restaurant.cuisine_type) restaurant.describe_restaurant() restaurant.open_restaurant()
class User(): def __init__(self,first_name,last_name,*info): #info 传入多个信息 self.fn = first_name self.ln = last_name self.info = info def describe_user(self): print("first name is "+self.fn+",last name is "+self.ln) print("Like sports:") for item in self.info: #遍历info print(item) def greet_user(self): print("Hello,"+self.fn+"-"+self.ln) user = User('Lebron','James','basketball','swimming') user.describe_user() user.greet_user()
2、使用类和实例
可以使用类来模拟世界中的很多情景，类编写好后，大部分时间都将花在使用根据类创建的实例上，需要执行的一个重要任务是修改实例的属性，可以直接修改实例的属性，也可以编写方法以特定的方式进行修改
class Car(): def __init__(self,make,model,year): '''初始化描述汽车的属性''' self.make = make self.model = model self.year = year def get_descriptive_name(self): '''返回整洁的信息''' long_name = str(self.year)+' '+self.make+' '+self.model return long_name.title() my_new_car = Car('audi','a4',2021) print(my_new_car.get_descriptive_name())
①给属性指定默认值
类中的每个属性都必须有初始值，哪怕这个值是0或空字符串。
添加一个名为 odometer_reading 的属性，其初始值总是为0 ，再添加一个名为 read_odometer() 的方法，用于读取汽车的里程表。
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.") my_new_car = Car('audi','a4',2021) print(my_new_car.get_descriptive_name()) my_new_car.read_odometer()
可以以三种方法修改属性的值：直接通过实例进行修改、通过方法进行修改、通过方法进行递增（增加特定的值）
①直接修改属性的值
class Car(): def __init__(self,make,model,year): '''初始化描述汽车的属性''' self.make = make self.model = model self.year = year self.odometer_reading = 0 #添加的属性 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.") my_new_car = Car('audi','a4',2021) print(my_new_car.get_descriptive_name()) my_new_car.read_odometer() my_new_car.odometer_reading = 23 #直接修改属性 odometer_reading 的值为23 my_new_car.read_odometer()
②通过方法修改属性的值
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_data(self,data): #定义一个用来修改属性值得方法 self.odometer_reading = data #将传入的参数的值存储到 odometer_reading 中 my_new_car = Car('audi','a4',2021) print(my_new_car.get_descriptive_name()) my_new_car.read_odometer() my_new_car.update_data(23) #向方法update_data传递参数 my_new_car.read_odometer()
可以添加逻辑禁止将里程表读数回调
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_data(self,data): if data >= self.odometer_reading: #判断修改的里程是否大于定义的里程值 self.odometer_reading = data else: print("You can't roll back an odometer!") my_new_car = Car('audi','a4',2021) print(my_new_car.get_descriptive_name()) my_new_car.read_odometer() my_new_car.update_data(-1) #将里程的值变为 -1 my_new_car.read_odometer()
③通过方法对属性的值进行递增
有时候需要将属性值递增特定特定的量，而不是将其设置为全新的值。假设购买了一辆二手车，且从购买到登记期间增加了100英里的里程。
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): self.odometer_reading = mileage def increment_odometer(self,miles): self.odometer_reading += miles my_used_car = Car('subaru','outback',2013) print(my_used_car.get_descriptive_name()) my_used_car.update_odometer(23500) my_used_car.read_odometer() my_used_car.increment_odometer(23600) my_used_car.read_odometer()
#User 类中，添加一个名为login_attempts 的属性。编写一个名为increment_login_attempts() 的方法， 它将属性login_attempts 的值加1。再编写一个名为reset_login_attempts() 的方法，它将属性login_attempts 的值重置为0。 根据User 类创建一个实例，再调用方法increment_login_attempts() 多次。打印属性login_attempts 的值，确认它被正确地递增；然后，调用方 法reset_login_attempts() ，并再次打印属性login_attempts 的值，确认它被重置为0。 class User(): def __init__(self,first_name,last_name,*info): self.fn = first_name self.ln = last_name self.info = info self.login_attempts = 20 def describe_user(self): print("first name is "+self.fn+",last name is "+self.ln) print("Like sports:") for item in self.info: print(item) def greet_user(self): print("Hello,"+self.fn+"-"+self.ln) print("Now Login users are: "+str(user.login_attempts)) def increment_login_attempts(self,login_number): self.login_attempts += login_number #递增将属性login_attempts的值加1 def reset_login_attempts(self): self.login_attempts = 0 #重置login_attempts的值为0 user = User('Lebron','James','basketball','swimming') user.describe_user() user.greet_user() user.increment_login_attempts(10) #验证login_attempts的值是递增的 user.greet_user() user.increment_login_attempts(20) #验证login_attempts的值是递增的 user.greet_user() user.reset_login_attempts() #重置login_attempts的值为0 user.greet_user()
3、继承
编写类时，并非总是要从空白开始，如果编写的类是另一个现成类的特殊版本，可使用继承，一个类继承另一个类时，将自动获得另一个类的所有属性和方法
原有的类称为父类，而新类称为子类，子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。
①子类的方法 __init__()
创建子类的实例时，Python首先需要完成的任务是父类的所有属性赋值，为此，子类的 __init__()需要父类施以援手。
例：模拟电动汽车，电动汽车是一种特殊的汽车，可以在前面的Car类的基础上创建新类ElectricCar，这样我们就只需为电动汽车特有的属性和行为编写代码。
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_data(self,mileage): if mileage >= self.odometer_reading: self.odometer_reading = mileage else: print("You can't roll back an odometer!") class ElectricCar(Car): #定义子类 ElectricCar，定义子类时，必须在括号内指定父类的名称 """电动汽车的独特之处""" def __init__(self,make,model,year): #方法 __init__()接受创建 Car 实例所需的信息 """初始化父类的属性""" super().__init__(make,model,year) #super()是一个特殊函数，帮助Python将父类和子类关联起来，让Python调用ElectricCar的父类方法__init__()，让ElectricCar实例包含父类的所有属性 #父类也称为超类，名称 super 因此而得名
my_tesla = ElectricCar('tesla','model s',2016) print(my_tesla.get_descriptive_name())
②重写父类的方法
对于父类的方法，只要不符合子类模拟的实物的行为，都可对其进行重写，可在子类中定义一个与要重写的父类方法同名，这样 Python 将不会考虑这个父类方法，只关注在子类中定义的相应方法。
#Car 类有一个名为fill_gas_tank() 的方法，它对全电动汽车来说毫无意义，因此想重写它。 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 fill_gas_tank(self): #父类中fill_gas_tank() 方法输出"汽车使用汽油" print("汽车使用汽油") class ElectricCar(Car): """电动汽车的独特之处""" def __init__(self,make,model,year): """初始化父类的属性""" super().__init__(make,model,year) def fill_gas_tank(self): #子类中重写 fill_gas_tank()方法，与父类方法同名，之后只调用子类的方法 print("电动车用电") my_tesla = ElectricCar('tesla','model s',2016) print(my_tesla.get_descriptive_name()) my_tesla.fill_gas_tank()
③将实例用作属性
使用代码模拟实物时，可能会发现自己给类添加的细节越累越多，属性和方法清单以及文件都越来越长，这种情况下需要将类的一部分作为一个独立的类提取出来，可以将大型类拆分成多个协同工作的小类。
class Car(): def __init__(self,make,model,year): self.make = make self.model = model self.year = year def get_descriptive_name(self): '''返回整洁的信息''' long_time = str(self.year)+' '+self.make+' '+self.model return long_time class Battery(): #新定义的Battery新类，没有继承任何类 def __init__(self,battery_size=70): #方法 __init__() 除self外，还有另一个形参battery_size，这个形参时可选的，如果没有给它提供值，电瓶容量被设置为70. self.battery_size = battery_size def describe_battery(self): '''打印一条描述电瓶的信息''' print("This car has a "+str(self.battery_size)+"-kwh battery.") class ElectricCar(Car): def __init__(self,make,model,year): """初始化父类的属性，再初始化电动汽车特有的属性""" super().__init__(make,model,year) self.battery = Battery() #添加一个名为 self.battery的属性，让Python创建一个新的Battery实例（默认值70）,并将该实例存储再属性self.battery中 #每当方法__init__()被调用时，都将执行该操作，因此现在每个ElectricCar实例都包含一个自动创建的Battery实例 my_tesla = ElectricCar('tesla','models',2016) print(my_tesla.get_descriptive_name()) my_tesla.battery.describe_battery() #需要使用电动汽车的属性 battery描述电瓶,这行代码让Python在实例my_tesla中查找属性battery，并对存储在该属性中的Battery实例调用方法describe_battery()
4、导入类
随着不断给类添加功能，文件可能变得很长，为遵循Python的总体概念，应让文件尽可能简洁，Python允许将类存储再模块中，然后在主程序中导入所需的模块。
import module_name from class_name
例：从Car模块中导入my_Car
from Car import my_Car
my_new_car = my_Car('audi','a4',2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
①在一个模块中存储多个类
#Battery.py，定义函数 class Car(): def __init__(self,make,model,year): self.make = make self.model = model self.year = year def get_descriptive_name(self): '''返回整洁的信息''' long_time = str(self.year)+' '+self.make+' '+self.model return long_time class Battery(): def __init__(self,battery_size=70): self.battery_size = battery_size def describe_battery(self): '''打印一条描述电瓶的信息''' print("This car has a "+str(self.battery_size)+"-kwh battery.") def get_range(self): if self.battery_size == 70: range = 240 elif self.battery_size == 85: range = 270 print("Hello,This car has a " + str(self.battery_size) + "-kwh battery"+",and "+str(range)+" km !") class ElectricCar(Car): def __init__(self,make,model,year): """初始化父类的属性，再初始化电动汽车特有的属性""" super().__init__(make,model,year) self.battery = Battery()
②导入一个类进行调用
from Battery import ElectricCar my_tesla = ElectricCar('tesla','models',2016) print(my_tesla.get_descriptive_name()) my_tesla.battery.describe_battery() my_tesla.battery.get_range()
③从一个模块中导入多个类
from module_name import class_name1,class_name2
例：
form Car import Car,ElectricCar
④导入整个模块
import module_name
例
import Car
⑤导入模块中的所有类
from module_name imprt *
5、在一个模块中导入另一个模块
有时候需要将类分散到多个模块中，以免模块太大，或在同一个模块中存储不相关的类，将类存储在多个模块中时，可能会发现一个模块中的类依赖于另一个模块中的类，在这种情况下可在前一个模块中导入必要的类。
例：Car、ElectricCar类和Battery类分别存储在一个模块，ElectricCar类和Battery类依赖Car类,将后两者的文件复制到 Car类存在的文件 from car import Car class Battery(): --snip-- class ElectricCar(Car): --snip--