Python基础学习
day_02
- 使用方法修改字符串的大小写
将字符串首字母变成大写
>>> name = "ada lovelace"
>>> print(name.title())
Ada Lovelace
将字符串全部变成大写
>>> print(name.upper())
ADA LOVELACE
将字符串全部变成小写
>>> print(name.lower())
ada lovelace
- 合并字符串
使用 + 来合并 first_name,last_name,空格
>>> first_name = "ada"
>>> last_name = "lovelace"
>>> full_name = first_name + " " +last_name
>>> print(full_name)
ada lovelace
乘热打铁，使用title()来组装一个字符串
>>> print("Hello,"+ " " + full_name.title() +"!")
Hello, Ada Lovelace!
也可以将整条信息储存在一个变量中
>>> message = "Hello,"+ " " + full_name.title() +"!"
>>> print(message)
Hello, Ada Lovelace!
- 使用制表符或换行符来添加空白
在字符中添加制表符，可以使用字符组合\t
>>> print("Python")
Python
>>> print("\tPython")
Python
在字符中添加换行符，可以使用字符组合\n
>>> print("I\nlove\nPython")
I
love
Python
使用换行符加上制表符
>>> print("I\n\tlove\n\tPython")
I
love
Python
- 删除空白
使用方法rstrip()，这种方法只是暂时的
>>> a_word = 'python '
>>> a_word
'python ' #输入的时候有一个空格符
>>> a_word.rstrip()
'python' #消除了空白
>>> a_word
'python '
要想永久删除空格，还需将删除的操作重新赋值到原来的变量里面
>>> a_word = a_word.rstrip()
>>> a_word
'python'
rstrip()剔除右边的空白
lstrip()剔除左边的空白
strip()剔除全部空白
>>> a_word = ' python ' #左边和右边都有空白
>>> a_word.rstrip()
' python'
>>> a_word.lstrip()
'python '
>>> a_word.strip()
'python'
- 使用字符串是避免语法错误
撇号位于两个双引号之间，故能识别出整个字符串
>>> message = "I'm a student."
>>> print(message)
I'm a student.
但是使用单引号时
>>> message = 'I'm a student.'
SyntaxError: invalid syntax
Python无法正确地确定字符串结束的位置
- 数字
整数
在Python中可以对整数进行+ - * / 运算
>>> 1+1
2
>>> 3-5
-2
>>> 3-2
1
>>> 3/2
1.5
>>> 8*9
72
Python使用两个乘号（**）进行乘方运算
>>> 8*9
72
>>> 3**3
27
>>> 2**3
8
>>> 5**5
3125
浮点数
使用浮点数是无需考虑其他行为。只需输入要使用的数字
>>> 1.2+5
6.2
>>> 1.2+36.3
37.5
>>> 1.7+9.6
11.299999999999999
>>> 1.6+1.6
3.2
>>> 0.2+0.1
0.30000000000000004
>>> 2*0.2
0.4
>>> 1*0.3
0.3
有时结果包含的小数点是不确定的
但是无需担心，接下来的学习中会解决此类问题
- 使用函数str()避免类型错误
有时候你希望
>>> age = 22
>>> message = "Happy" + " " + age +"rd Birthday!!"
你会希望输出"Happy 22rd Byrthday!!"
但是，很遗憾上述代码会引发错误
>>> age = 22
>>> message = "Happy" + " " + age +"rd Birthday!!"
Traceback (most recent call last):
File "<pyshell#54>", line 1, in <module>
message = "Happy" + " " + age +"rd Birthday!!"
TypeError: can only concatenate str (not "int") to str
这是一个类型错误，Python发现你使用了一个值为整数（int）的值，它不知道如何解读这个值，它认为这个变量表达的可能是22，也可能是字符2和字符2，为此，在调用变量是。你需要调用str()函数来将这个变量变成字符串。
>>>age = 22
>>> message = "Happy" + " " + str(age) + "rd Birthday!!"
>>> print(message)
Happy 22rd Birthday!!
- python之禅
在IDLE中运行import this就可以得到Python之禅
>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
以上就是Python第二天的学习内容，希望能对你有所帮助，祝你学有所成！！！
day_03
- 列表是什么
在Python中，用[]来表示列表，并用逗号来分隔其中的元素。下面是一个简单的列表示例：
>>> bicycles = ['treak','cannondale','redline','specialized']
>>> print(bicycles)
Python会将列表打印出来，包括方括号
['treak', 'cannondale', 'redline', 'specialized']
- 访问列表元素
利用[]来访问列表中的元素
>>> print(bicycles[0])
treak
上条语句利用了bicycles[0]来访问列表中的第一个元素
我可以使用昨天所讲的字符串方法，来使输出更加简洁——使用title()方法：
>>> print(bicycles[0].title())
Treak
- 索引是从0开始而不是从1开始
你可以看到
>>> bicycles = ['treak','cannondale','redline','specialized']
>>> print(bicycles[1])
cannondale
>>> print(bicycles[3])
specialized
下标为1的元素是cannondale、下标为3的元素是specialized
通过访问[-1]可以得到最后一个列表元素
>>> bicycles = ['treak','cannondale','redline','specialized']
>>> print(bicycles[-1])
specialized
同理访问[-2]得到倒数第二个元素，[-3]倒数第三个元素
- 使用列表中的各个值
下面来尝试提取一款自行车，并使用这个值来创建一条信息：
>>> message = "My first bicycles was a "+bicycles[1].title() + "."
>>> print(message)
My first bicycles was a Cannondale.
- 修改列表元素
例如，假设有一个动物列表，其中第一个元素是'tiger' ，如何修改它的值呢？
>>> animal = ['tiger','bird','fox']
>>> print(animal)
['tiger', 'bird', 'fox']
>>> animal[0] = 'monkey'
>>> print(animal)
['monkey', 'bird', 'fox']
- 在列表中添加元素
使用方法append()添加元素
>>> animal.append('fish')
>>> print(animal)
['monkey', 'bird', 'fox', 'fish']
这样就在列表中添加了一个函数
你还可以建立一个空列表，将元素一个一个地添加进去
>>> fruits = []
>>> fruits.append('apple')
>>> fruits.append('banana')
>>> fruits.append('cherry')
>>> print(fruits)
得到的结果是
['apple', 'banana', 'cherry']
但是使用这种方法添加的函数永远是在最后一个
为此你需要一个可以插入元素的方法
使用insert()方法可以在列表的任何位置添加新的元素。为此，你需要指定新元素的索引和值：
>>> fruits.insert(0,'lemon')
>>> print(fruits)
使用这个方法，'lemon' 被插入到列表开头，这种操作将列表中所有的元素都右移一个位置
['lemon', 'apple', 'banana', 'cherry']
- 在列表中删除元素
使用del语句删除元素
使用del语句的前提是，知道需要删除的元素的位置
>>> fruits = ['apple','banana','orange']
>>> print(fruits)
['apple', 'banana', 'orange']
>>> del fruits[0]
>>> print(fruits)
['banana', 'orange']
使用del语句删除了，列表中的第一个元素
['apple', 'banana', 'orange']
['banana', 'orange']
使用del可以删除任何位置的列表元素，条件是知道索引
使用方法pop()删除元素
方法pop()可删除列表末尾的元素，并让你能够接着使用他
>>> fruits = ['apple','banana','orange']
>>> print(fruits)
['apple', 'banana', 'orange']
>>> popend_fruits = fruits.pop()
>>> print(fruits)
['apple', 'banana']
>>> print(popend_fruits)
orange
如果水果是按时间购买的，我想知道最后购买的水果是哪一种？
>>> fruits = ['apple','banana','orange']
>>> print(fruits)
['apple', 'banana', 'orange']
>>> last_buy = fruits.pop()
>>> print("我最后买的水果是" + last_buy.title())
我最后买的水果是Orange
弹出列表中任何位置处的元素
实际上，可以使用pop()来弹出列表中的任何元素，只需在括号中指定要删除元素的索引即可
>>> fruits = ['apple','banana','orange']
>>> print(fruits)
['apple', 'banana', 'orange']
>>> second_fruits = fruits.pop(1)
>>> print(second_fruits)
apple
有时候，你不知带元素在列表中的位置。如果你只知道要删除的元素的值，可以使用方法remove()
假设，我们要从列表中删除值 ‘apple’
>>> fruits = ['apple','banana','orange']
>>> print(fruits)
['apple', 'banana', 'orange']
>>> fruits.remove('apple')
>>> print(fruits)
['orange', 'banana']
使用remove()让Python知道'apple'出现在什么位置，并将元素删除
动手试一试
嘉宾名单：如果你可以邀请任何人一起共进晚餐，你会邀请哪些人？请创建一个列表，其中包含至少3个你想邀请的人；然后。使用这个列表打印信息，邀请这些人来与你共进晚餐。
#嘉宾名单
guest = ['Harry','Ben','Babo','Jack']
for i in range(0,4):
print("我想邀请"+guest[i].title()+"来与我共进晚餐。")
我想邀请Harry来与我共进晚餐。
我想邀请Ben来与我共进晚餐。
我想邀请Babo来与我共进晚餐。
我想邀请Jack来与我共进晚餐。
guest = ['Harry','Ben','Babo','Jack']
print("我想邀请"+guest[0].title()+"," +guest[1].title() +","+guest[2].title() +","+guest[3].title()+"来与我共进晚餐。")
我想邀请Harry,Ben,Babo,Jack来与我共进晚餐。
修改嘉宾名单：你刚刚得知有位嘉宾无法赴约，因此需要邀请另外一名嘉宾
#嘉宾名单
guest = ['Harry','Ben','Babo','Jack']
guest.remove('Babo')
guest.insert(2,'Mical')
print("我想邀请"+guest[0].title()+"," +guest[1].title() +","+guest[2].title() +","+guest[3].title()+"来与我共进晚餐。")
我想邀请Harry,Ben,Mical,Jack来与我共进晚餐。
添加嘉宾：你找到了一个更大的餐桌，可以容纳更多的嘉宾。请再邀请多三个嘉宾
- 使用insert()在邀请名单的开头和中间添加一名嘉宾
- 使用append()将最后一名新嘉宾添加到名单末尾
- 打印一条信息，向名单中的每位嘉宾发出邀请
guest = ['Harry','Ben','Babo','Jack']
guest.remove('Babo')
guest.insert(2,'Mical')
guest.insert(0,'Batman')
guest.insert(2,'Ironman')
guest.append('Superman')
for i in range(0,8):
print("我想邀请"+guest[i].title()+"来与我共进晚餐。")
我想邀请Batman来与我共进晚餐。
我想邀请Harry来与我共进晚餐。
我想邀请Ironman来与我共进晚餐。
我想邀请Ben来与我共进晚餐。
我想邀请Mical来与我共进晚餐。
我想邀请Jack来与我共进晚餐。
我想邀请Superman来与我共进晚餐。
缩减名单：你刚得知新购买的餐桌无法按时到达，因此只能邀请两名嘉宾
- 在程序末尾打印你只能邀请两名嘉宾的信息
- 使用pop()不断地删除名单中的嘉宾，直到只剩下两名嘉宾，每次从名单中弹出一名嘉宾是，都打印一条信息，让该嘉宾知道的情况，无法与你共进晚餐
- 对于剩下的两位嘉宾，打印一份信息，告知他们仍然在邀请的嘉宾之列
guest = ['Harry','Ben','Babo','Jack']
guest.remove('Babo')
guest.insert(2,'Mical')
guest.insert(0,'Batman')
guest.insert(2,'Ironman')
guest.append('Superman')
print("非常抱歉，因为餐桌的原因，我只能邀请三个人来参加我的晚餐"+"\n\n")
one_guest = guest.pop()
print("非常抱歉"+ one_guest+"不能邀请你来我的晚餐")
two_guest = guest.pop()
print("非常抱歉"+ two_guest+"不能邀请你来我的晚餐")
three_guest = guest.pop()
print("非常抱歉"+ three_guest+"不能邀请你来我的晚餐")
four_guest = guest.pop()
print("非常抱歉"+ four_guest+"不能邀请你来我的晚餐" + "\n\n")
for i in range(0,4):
print("你好"+guest[i].title()+"你仍然在我的嘉宾之列。")
非常抱歉，因为餐桌的原因，我只能邀请三个人来参加我的晚餐
非常抱歉Superman不能邀请你来我的晚餐
非常抱歉Jack不能邀请你来我的晚餐
非常抱歉Mical不能邀请你来我的晚餐
非常抱歉Ben不能邀请你来我的晚餐
你好Batman你仍然在我的嘉宾之列。
你好Harry你仍然在我的嘉宾之列。
你好Ironman你仍然在我的嘉宾之列。
- 组织列表
在你创建的列表单中。元素的排列通常是无法预测的，因为你并非总能控制用户提供的数据。
使用方法sort()对列表进行永久性排序
Python中的sort()方法能较为轻松地对列表进行排序。假设你有一个汽车列表，并让其中的汽车按字母顺序排序。
cars = ['bmw','audi','fengtian','dazhong']
cars.sort()
print(cars)
['audi', 'bmw', 'dazhong', 'fengtian']
你还可以按照字母逆序排序，只需要向sort()方法传递参数reverse=True
cars = ['bmw','audi','fengtian','dazhong']
cars.sort(reverse=True)
print(cars)
['fengtian', 'dazhong', 'bmw', 'audi']
使用函数sorted()对列表进行临时排序
如果你想保留原来的列表，你可以使用函数sorted()对列表进行临时排序
cars = ['bmw','audi','fengtian','dazhong']
print("使用函数sorted()进行排列的列表")
print(sorted(cars))
print("原来的列表")
print(cars)
使用函数sorted()进行排列的列表
['audi', 'bmw', 'dazhong', 'fengtian']
原来的列表
['bmw', 'audi', 'fengtian', 'dazhong']
倒着打印列表
可使用方法reverse()。假设汽车是按照购买时间排列的，可以轻松地按照相反的顺序排列其中的汽车
cars = ['bmw','audi','fengtian','dazhong']
print("原来的列表")
print(cars)
print("按照购买时间的顺序逆序")
cars.reverse()
print(cars)
原来的列表
['bmw', 'audi', 'fengtian', 'dazhong']
按照购买时间的顺序逆序
['dazhong', 'fengtian', 'audi', 'bmw']
确定列表的长度——使用len()函数
print("该列表的长度")
print(len(cars))
该列表的长度
4
day_04
- 遍历整个列表
我们创建列表时，需要输出整个列表，但是通常列表会很长，包含很多元素，当列表长度发生变化是，都必须修改代码。通过for循环，我们可以很轻易地输出整个列表。
#遍历整个列表 创建一个水果列表
fruits = ['apple','orange','banana','cherry']
for i in fruits:
print(i)
apple
orange
banana
cherry
- 在for循环中执行更多的操作
对每个水果都打印一份信息，表示我太喜欢吃这个水果了
fruits = ['apple','orange','banana','cherry']
for i in fruits:
print("我真的太喜欢吃,"+i.title()+"这个水果了。")
print("我每天都要吃"+i.title()+".\n")
我真的太喜欢吃,Apple这个水果了。
我每天都要吃Apple.
我真的太喜欢吃,Orange这个水果了。
我每天都要吃Orange.
我真的太喜欢吃,Banana这个水果了。
我每天都要吃Banana.
我真的太喜欢吃,Cherry这个水果了。
我每天都要吃Cherry.
day_05
if语句
一个简单的示例
cars =['audo','bwm','benchi','toyota']
for i in cars:
if i=='bwm':
print(i.upper())
else:
print(i.title())
判断列表当中有没有'bmw' 如果有的话，就以全大写的方式打印出来，否则的话，以首字母大写的方式打印出来。
Audo
BWM
Benchi
Toyota
- 条件测试
每条if语句核心都是一个值为True和false的表达式，这种表达式杯称为条件测试。Python根据条件测试的值为True还是false来决定是否执行if语句中的代码。
检查特定的值是否包含在列表中
要判定特定的值是否已经在列表中，可以使用关键字in。
>>> aminal = ['lion','tiger','birl','monkey']
>>> 'lion' in aminal
True
>>> 'fish' in aminal
False
检查特定的值是否不包含在列表中
aminal = ['lion','tiger','birl','monkey']
aaa = 'fish'
if aaa not in aminal:
print(aaa.title()+"不在动物列表中")
Fish不在动物列表中
- 省略else语句块
else是一条包罗万象的语句，只要不满足任何if或者elif中的条件测试，其中的代码就会执行，这可能会引入无效甚至是恶意的数据。如果知道最终要测试的条件，应考虑使用一个elif代码来代替else代码块。这样，你就可以肯定，仅当满足相应条件时，你的代码才会运行。
- 测试多个条件
if-elif-else: 结构功能强大，但是仅适合一个条件满足的情况：遇到通过了的测试后，Python就跳过余下的测试。这种行为很好，效率很高。让你能够测试一个特定的条件。
然而，有些时候必须检查你关心的所有条件。在这种情况下，应使用一种不包含elif 和else的代码块的简单if语句。这种方法适合于 ，有多个条件都为true，且需要在每个true条件下执行相关的操作。
essage = ['mushroom','tea','buger','dumpling']
if 'dumpling' in essage:
print("有客人点餐dumpling")
if 'tea' in essage:
print("有客人点餐tea")
if 'apple' in essage:
print("有客人点餐apple")
print("\n点餐完毕")
有客人点餐dumpling
有客人点餐tea
点餐完毕
如果使用if-elif-else语句，代码将不能正确地运行，因为有一个测试通过后，就会跳过余下测试：
essage = ['mushroom','tea','buger','dumpling']
if 'dumpling' in essage:
print("有客人点餐dumpling")
elif 'tea' in essage:
print("有客人点餐tea")
elif 'apple' in essage:
print("有客人点餐apple")
print("\n点餐完毕")
有客人点餐dumpling
点餐完毕
- 使用if语句处理列表
检查特殊元素
继续使用前面的例子，这家餐厅在制作时，客人每次点一道菜都打印一条信息。通过创建一个列表，并使用一个循环来打印出客人点的菜：
essage = ['mushroom','tea','buger','dumpling']
for i in essage:
print("有客人点餐"+i.title())
print("\n点餐完毕")
有客人点餐Mushroom
有客人点餐Tea
有客人点餐Buger
有客人点餐Dumpling
点餐完毕
输出很简单，上述代码不过是一个简单的foe语句
然而，如果餐厅的茶用完了，该如何处理呢？
essage = ['mushroom','tea','buger','dumpling']
for i in essage:
if i == 'tea':
print("不好意思，店里没有tea")
else:
print("有客人点餐"+i.title())
print("\n点餐完毕")
有客人点餐Mushroom
不好意思，店里没有tea
有客人点餐Buger
有客人点餐Dumpling
点餐完毕
day_06(字典)
- 一个简单的字典
创建一个外星人字典
alien_0 = {'color':'green','points':5,'X_position':4,'Y_position':5,'speed':'unknow'}
print(alien_0['color'])
print(alien_0['points'])
new_color = alien_0['color']
new_points = alien_0['points']
print("恭喜，你击败了一个"+ new_color +"外星人，获得了"+str(new_points) +"个点数。")
- 添加键值对
alien_0['X_position'] = 4
alien_0['Y_position'] = 5
print(alien_0)
- 修改字典中的值
print("外星人现在的颜色是："+alien_0['color'])
alien_0 = {'color':'red'}
print("外星人现在的颜色是："+alien_0['color'])
- 改变外星人的移动位置
alien_0 = {'color':'green','points':5,'X_position':4,'Y_position':5,'speed':'unknow'}
#外星人的原始坐标
print("外星人的位置（"+ str(alien_0['X_position']) +","+ str(alien_0['Y_position']) +"）" )
add_number = 0
for i in range(10):
if alien_0['speed'] == 0:
add_number+=1
elif alien_0['speed'] == 'unknow':
add_number+=2
else:
add_number+=3
#新位置等于老位置加上增量
alien_0['X_position'] = alien_0['X_position'] + add_number
alien_0['Y_position'] = alien_0['Y_position'] + add_number
print("现在外星人的坐标是("+ str(alien_0['X_position']) +","+ str(alien_0['Y_position']) +"）")
外星人的位置（4,5）
现在外星人的坐标是(6,7）
现在外星人的坐标是(10,11）
现在外星人的坐标是(16,17）
现在外星人的坐标是(24,25）
现在外星人的坐标是(34,35）
现在外星人的坐标是(46,47）
现在外星人的坐标是(60,61）
现在外星人的坐标是(76,77）
现在外星人的坐标是(94,95）
现在外星人的坐标是(114,115）
- 删除键值对
对于字典中不再需要的值，可以使用del语句将相应的键值对彻底删除。使用del语句时，必须指定字典名和要删除的键。
下面的代码中，将alien_0中删除键'points' 及其值：
alien_0 = {'color':'green','points':5,'X_position':4,'Y_position':5,'speed':'unknow'}
print(alien_0)
del alien_0['points']
print(alien_0)
{'color': 'green', 'points': 5, 'X_position': 4, 'Y_position': 5, 'speed': 'unknow'}
{'color': 'green', 'X_position': 4, 'Y_position': 5, 'speed': 'unknow'}
删除的键值对，永远消失
- 由类似对象组成的字典
利用字典存储多个键值对时，可以使用以下的格式：
favorite_language = {
'herry':'java',
'mical':'python',
'jun':'ruby',
'lily':'C'
}
print("herry最喜欢的语言是："+ favorite_language['herry'].title())
herry最喜欢的语言是：Java
这个示例演示了如何将较长的print语句分成多行。
- 遍历字典
遍历所有的键值对
下面的字典中存储了一名用户的用户名、名和姓：
user_0= {
'user_name':'GHP',
'first':'G',
'last':'P'
}
for key,value in user_0.items(): #利用两个变量分别存储键和值
print('\n键: '+key)
print('值: '+value)
可以使用for来遍历字典
键: user_name
值: GHP
键: first
值: G
键: last
值: P
- 遍历字典中所有的键
user_0= {
'user_name':'GHP',
'first':'G',
'last':'P'
}
for name in user_0.keys():
print(name.title())
User_Name
First
Last
创建一个列表，使用列表中的值来遍历字典
favorite_language = {
'herry':'java',
'mical':'python',
'jun':'ruby',
'lily':'C'
}
friends = ['herry','mical']
for name in favorite_language.keys():
print(name.title())
if name in friends:
print("你好，" + name.title() + "我知道你最喜欢的语言是" + favorite_language[name].title())
Herry
你好，Herry我知道你最喜欢的语言是Java
Mical
你好，Mical我知道你最喜欢的语言是Python
Jun
Lily
按照顺序遍历字典中的所有键
字典总是明确的记录键之间的关联关系，但是获取字典元素时，获取顺序是不可预测的。
可以使用sorted() 来获取按特定顺序排列的键列表的副本：
favorite_language = {
'herry':'java',
'mical':'python',
'jun':'ruby',
'lily':'C'
}
for name in sorted(favorite_language.keys()):
print(name.title()+"谢谢你\n")
================= RESTART: H:\python练习\Python\Python38-32\字典.py ================
Herry谢谢你
Jun谢谢你
Lily谢谢你
Mical谢谢你
>>>
================= RESTART: H:\python练习\Python\Python38-32\字典.py ================
Herry谢谢你
Jun谢谢你
Lily谢谢你
Mical谢谢你
输出了两次，都是按字典中键的顺序输出
遍历字典中的所有值
如果你只想输出字典中所有的值，不输出键，你可以使用方法values()，它返回一个值列表，而不包含任何的值。
favorite_language = {
'herry':'java',
'mical':'python',
'jun':'ruby',
'lily':'C'
}
for language in sorted(favorite_language.values()):
print("他们喜欢的语言有："+language.title())
他们喜欢的语言有：C
他们喜欢的语言有：Java
他们喜欢的语言有：Python
他们喜欢的语言有：Ruby
- 嵌套
有时候需要将一系列字典存储在列表中，或将列表作为值存储在字典中，这称之为嵌套。你可以在列表中嵌套字典，在字典中嵌套列表甚至在字典中嵌套字典。
字典列表
如何管理成群结队的外星人？一种方法是创建一个外星人列表，其中每一个外星人都是一个字典，包含有外星人的各种信息。
alien_0 = {'color':'green','points':3}
alien_1 = {'color':'red','points':4}
alien_2 = {'color':'orange','points':6}
aliens = [alien_0,alien_1,alien_2]
for alien in aliens:
print(alien)
{'color': 'green', 'points': 3}
{'color': 'red', 'points': 4}
{'color': 'orange', 'points': 6}
下面我们使用range() 生成30个外星人：
#创建一个外星人的空列表
aliens = []
#创建30个外星人
for alien in range(30):
new_aliens = {'color':'green','points':3}
aliens.append(new_aliens)
#显示5个外星人
for alien in aliens[:5]:
print(alien)
print("...\n")
print("一共创建了"+ str(len(aliens))+"个机器人。")
{'color': 'green', 'points': 3}
{'color': 'green', 'points': 3}
{'color': 'green', 'points': 3}
{'color': 'green', 'points': 3}
{'color': 'green', 'points': 3}
...
一共创建了30个机器人。
修改每个机器人的相关数值
#创建一个外星人的空列表
aliens = []
#创建30个外星人
for alien in range(30):
new_aliens = {'color':'green','points':3}
aliens.append(new_aliens)
#显示5个外星人
for alien in aliens[0:3]:
if alien['color'] == 'green':
alien['color'] = 'red'
alien['points'] = 6
for alien in aliens[0:7]:
print(alien)
print("...\n")
print("一共创建了"+ str(len(aliens))+"个机器人。")
{'color': 'red', 'points': 6}
{'color': 'red', 'points': 6}
{'color': 'red', 'points': 6}
{'color': 'green', 'points': 3}
{'color': 'green', 'points': 3}
{'color': 'green', 'points': 3}
{'color': 'green', 'points': 3}
...
一共创建了30个机器人。
还可以添加一些条件
#显示5个外星人
for alien in aliens[0:3]:
if alien['color'] == 'green':
alien['color'] = 'red'
alien['points'] = 6
elif alien['color'] == 'red':
alien['color'] = 'green'
alien['points'] = 3
在字典中存储列表
存储披萨的信息
pizza = {
"面皮":"榴莲面皮",
"佐料":["榴莲","虾仁","牛肉","芝士"]
}
#错误，列表不能直接输出，需要用循环遍历，不能再错
'''print("你点的是1号披萨，是"+pizza["面皮"]+","+"里面有"+pizza["佐料"]+"的pizza.")'''
print("你点的是1号"+pizza["面皮"]+"披萨")
for i in pizza["佐料"]:
print("其中1号披萨中的佐料有\t"+i)
你点的是1号榴莲面皮披萨
其中1号披萨中的佐料有 榴莲
其中1号披萨中的佐料有 虾仁
其中1号披萨中的佐料有 牛肉
其中1号披萨中的佐料有 芝士
输出每个人喜欢的语言：
favorite_language = {
'harry':['python','php'],
'merry':['java'],
'micle':['c'],
'ben':['嵌入式','c++']
}
for k,v in favorite_language.items():
print("\n"+k+"喜欢的是")
for language in v:
print("\t"+language.title())
harry喜欢的是
Python
Php
merry喜欢的是
Java
micle喜欢的是
C
ben喜欢的是
嵌入式
C++
在字典中存储字典
创建一个城市字典
cities = {
'Beijing':{
'population':3000000,
'country':'中国',
'foods':['北京烤鸭','豆汁']
},
'GuangZhou':{
'population':20000000,
'country':'中国',
'foods':['云吞','烧麦']
},
'NewYork':{
'population':4000000,
'country':'美国',
'foods':['汉堡','牛排']
}
}
for k,v in cities.items(): #v就是一个小字典
print("\n城市的名字"+k)
new_population = v['population']
countries = v['country']
print("它的人口有"+str(new_population))
print("这个城市属于"+countries)
for food in v['foods']:
print("他们喜欢的食物是:"+food)
城市的名字Beijing
它的人口有3000000
这个城市属于中国
他们喜欢的食物是:北京烤鸭
他们喜欢的食物是:豆汁
城市的名字GuangZhou
它的人口有20000000
这个城市属于中国
他们喜欢的食物是:云吞
他们喜欢的食物是:烧麦
城市的名字NewYork
它的人口有4000000
这个城市属于美国
他们喜欢的食物是:汉堡
他们喜欢的食物是:牛排
day_07 (用户输入和while循环)
- 使用while循环
while循环与for循环的区别，for循环用于针对集合中的每个元素的一个代码块，而while循环不断地运行，直到指定的条件不满足为止：
使用while循环来数数：
#while循环
i = 0
while (i<5):
i+=1
print(i)
1
2
3
4
5
让用户选择何时退出
message_0 = "你有两个选择，要么输入一条信息，要么输入'quit'退出程序"
message_1 = " "
while message_1 != 'quit':
message_1 = input(message_0)
print(message_1)
你有两个选择，要么输入一条信息，要么输入'quit'退出程序你好啊
你好啊
你有两个选择，要么输入一条信息，要么输入'quit'退出程序hello
hello
你有两个选择，要么输入一条信息，要么输入'quit'退出程序quit
quit
不输出最后的quit，需要再加一个判断语句；
message_0 = "你有两个选择，要么输入一条信息，要么输入'quit'退出程序"
message_1 = " "
while message_1 != 'quit':
message_1 = input(message_0)
if message_1 !='quit':
print(message_1)
你有两个选择，要么输入一条信息，要么输入'quit'退出程序不要在意别人拥有的
不要在意别人拥有的
你有两个选择，要么输入一条信息，要么输入'quit'退出程序quit
- 使用标志
在要求很多条件满足才能继续运行的程序中，可定义一个变量，用于判断整个程序是否处于活动状态。这个变量被称为标志，充当了程序的交通信号灯。你可以让程序在标志为True时继续运行，并在任何事件导致标志的值为Flase时让程序停止运行。这样，在while语句中就只需检出一个条件——标志的当前值是否为True，并将所有的测试都放在其他地方，从而让程序更加简洁。
message_0 = "你有两个选择，要么输入一条信息，要么输入'quit'退出程序"
message_1 = " "
active = True
while active:
message_1 = input(message_0)
if message_1 =='quit':
active = False
else:
print(message_1)
你有两个选择，要么输入一条信息，要么输入'quit'退出程序nihao
nihao
你有两个选择，要么输入一条信息，要么输入'quit'退出程序quit
- 使用while循环来处理列表和字典
#在列表之间移动元素
#首先创建两个列表
first_list = ['apple','orange','cherry','banana']
second_list = []
#验证每个元素，直到没有元素为止
#将每个已验证的元素，移到空列表当中
while first_list:
fruits = first_list.pop()
print("已经验证的元素:"+fruits.title())
second_list.append(fruits)
#显示所有已验证的元素
print("\n已经验证的元素")
for i in second_list:
print(i)
已经验证的元素:Banana
已经验证的元素:Cherry
已经验证的元素:Orange
已经验证的元素:Apple
已经验证的元素
banana
cherry
orange
apple
删除包含特定值的所有列表元素
列表中有多个相同的元素，我们该如何只是将相同的元素删除：
#创建一个宠物列表
pets = ['dog','cat','dog','cat','fish','rabbit','cat']
print(pets)
while 'cat' in pets:
pets.remove('cat')
print(pets)
['dog', 'cat', 'dog', 'cat', 'fish', 'rabbit', 'cat']
['dog', 'dog', 'fish', 'rabbit']
使用用户输入来填充字典
#使用用户输入来充填字典
responses = {} #创建一个空字典
#设置一个标签，用于指出调查是否继续
active = True
while active:
#提示输入被调查者的名字和回答
name = input("请输入你的名字：")
response = input("你喜欢吃什么?")
responses[name] = response
#看看是否还有人参与调查
message = input("是否还有人参与调查[yes/no]")
if message == "no":
active = False
print("\n调查结果")
for name,response in responses.items():
print(name.title()+"喜欢吃"+response.title()+"。\n")
请输入你的名字：ghp
你喜欢吃什么?西瓜
是否还有人参与调查[yes/no]yes
请输入你的名字：lily
你喜欢吃什么?哈密瓜
是否还有人参与调查[yes/no]no
调查结果
Ghp喜欢吃西瓜。
Lily喜欢吃哈密瓜。
day_08(函数)
- 定义函数
#定义一个函数
def greet_user():
print("Hello!!!")
greet_user()
Hello!!!
向函数传递信息
在greet_user()括号内添加一个参数
#定义一个函数
def greet_user(username):
print("Hello\t"+username.title()+"\t!!!")
greet_user('GHP')
Hello Ghp !!!
形参和实参
在函数greet_user()的定义中，变量username是一个形参————函数完成其工作所需要的一项信息。在代码greet_user('GHP') 中，值'GHP' 是一个实参。实参是调用函数时传递给函数的信息。我们调用函数时，将要让函数使用的信息放在括号内。在greet_user('GHP')中，将实参'GHP' 传递给了函数greet_user()，这个值被存储在形参username中。
- 传递实参
位置实参
一个显示宠物信息的函数：
def pets(animal_type,animal_name):
'''显示宠物的信息'''
print("我有一条"+animal_type)
print("\n它的名字叫做"+animal_name)
pets('短尾猫','harry')
我有一条短尾猫
它的名字叫做harry
多次调用函数
def pets(animal_type,animal_name):
'''显示宠物的信息'''
print("我有一条"+animal_type)
print("它的名字叫做"+animal_name+"\n")
pets('短尾猫','harry')
pets('哈皮狗','ben')
我有一条短尾猫
它的名字叫做harry
我有一条哈皮狗
它的名字叫做ben
位置实参的顺序很重要
关键字实参
使用关键字实参无需考虑函数中的顺序调用，
def pets(animal_type,animal_name):
'''显示宠物的信息'''
print("我有一条"+animal_type)
print("它的名字叫做"+animal_name+"\n")
pets('短尾猫','harry')
pets(animal_name='micle',animal_type='沙皮猫')
我有一条短尾猫
它的名字叫做harry
我有一条沙皮猫
它的名字叫做micle
默认值
def pets(animal_name,animal_type ='狗'):
'''显示宠物的信息'''
print("我有一条"+animal_type)
print("它的名字叫做"+animal_name+"\n")
pets('happy')
我有一条狗
它的名字叫做happy
等效的函数调用
- 返回值
函数返回的值称为返回值
返回简单值
def get_name(first_name,second_name):
full_name = first_name+ ' ' + second_name
return full_name
name_01 = get_name('周','杰伦')
print(name_01)
周 杰伦
让实参变成可选的
def get_name(first_name,last_name,middle_name = ''):
if middle_name:
full_name = first_name +' ' + middle_name +' ' + last_name +"\n"
else:
full_name = first_name +' ' + last_name +"\n"
return full_name
name_01 = get_name('周','杰','伦')
print(name_01)
name_02 = get_name('周','杰')
print(name_02)
Python将非空字符串解读为True，因此如果函数调用中提供了中间名，if middle_name将为True
周 伦 杰
周 杰
返回字典
def build_person(first_name,last_name):
person = {'first':first_name,'last':last_name}
return person
message = build_person("周杰伦","张学友")
print(message)
{'first': '周杰伦', 'last': '张学友'}
存储年龄
def build_person(first_name,last_name,age = ''):
person = {'first':first_name,'last':last_name}
if age:
person['age'] = age
return person
message = build_person("周杰伦","张学友",28)
print(message)
{'first': '周杰伦', 'last': '张学友', 'age': 28}
结合使用函数和while循环
def get_name(first_name,second_name):
full_name = first_name+ " " +second_name
return full_name
while True:
print("请输入你的名字")
print("输入'q' 后可退出程序")
f_name = input("请输入你的姓氏")
if f_name == 'q':
break
l_name = input("请输入你的名")
if l_name == 'q':
break
your_name = get_name(f_name,l_name)
print("你好，"+your_name+"\n")
请输入你的名字
输入'q' 后可退出程序
请输入你的姓氏周
请输入你的名杰伦
你好，周 杰伦
请输入你的名字
输入'q' 后可退出程序
请输入你的姓氏q
>>>
- 传递列表
假设有一个用户列表，我想要问候其中的每位用户。下面的示例将一个名字列表传递给一个名为greet_users()的函数
#向函数传送列表
def greet_user(names):
for name in names:
message = "你好,"+ name+"。\n"
print(message)
user_name = ['harry','ben','jack']
greet_user(user_name)
你好,harry。
你好,ben。
你好,jack。
在函数中修改列表
一家为用户提交的设计制作3D打印模型公司。需要打印的设计存储在一个列表中，打印后移到另一个列表中。下面是在不使用函数的情况下模拟这个过程的代码：
#首先创建一个列表，其中包含一些要打印的软件
first_list = ['iphone case','robot pendant','dodecahedron']
completed_models = []
#模拟打印每个设计，直到没有打印的设计为止
#打印每个设计后，都将其移到列表completed_models中
while first_list:
current_design = first_list.pop()
#模拟根据设计制作3D打印模型的过程
print("打印模型："+ current_design)
completed_models.append(current_design)
#显示打印好的所有模型
print("\n所有已经打印好的模型")
for completed_model in completed_models:
print(completed_model )
打印模型：dodecahedron
打印模型：robot pendant
打印模型：iphone case
所有已经打印好的模型
dodecahedron
robot pendant
iphone case
- 传递任意数量的实参
有时候你不知道需要接受多少个参数
例如，一个制作披萨的函数，他需要接受很多的配料，但是你无法预测顾客需要多少种配料。下面的函数只有一个形参，但是不管提供多少的实参，这个形参都将他们统统收入囊中：
def make_pizza(*toppings): #星号*让Python创建了一个名为toppings的新元组
''' 打印顾客点的配料'''
print(toppings)
make_pizza('榴莲')
make_pizza('火腿','猪肉','牛肉','芝士','虾仁')
('榴莲',)
('火腿', '猪肉', '牛肉', '芝士', '虾仁')
对客户的要求进行遍历
def make_pizza(*toppings):
''' 打印顾客点的配料'''
print("\n顾客点的披萨中的配料有")
for i in toppings:
print(i,end=" ")
make_pizza('榴莲')
make_pizza('火腿','猪肉','牛肉','芝士','虾仁')
顾客点的披萨中的配料有
榴莲
顾客点的披萨中的配料有
火腿 猪肉 牛肉 芝士 虾仁
结合使用位置实参和任意数实参
如果前面的函数还需要一个表示披萨尺寸的实参，必须将该形参放在形参*toppings的前面：
def make_pizza(size,*toppings):
''' 打印顾客点的配料'''
print("\n顾客点的披萨尺寸为"+str(size)+",其中的中的配料有")
for i in toppings:
print(i,end=" ")
make_pizza(14,'榴莲')
make_pizza(12,'火腿','猪肉','牛肉','芝士','虾仁')
顾客点的披萨尺寸为14,其中的中的配料有
榴莲
顾客点的披萨尺寸为12,其中的中的配料有
火腿 猪肉 牛肉 芝士 虾仁
使用任意数量的关键字实参
在函数中创建一个 字典，以存放输入的键值对
def user_name(xing,ming,**other):
name = {}
print("你的姓氏是：")
name['姓氏'] = xing
print(name['姓氏'])
print("你的名字是：")
name['名字'] = ming
print(name['名字'] )
for k,v in other.items():
name[k] = v
return name
message = user_name('周','杰伦',hobby='打篮球',goodfor='唱歌')
print(message)
你的姓氏是：
周
你的名字是：
杰伦
{'姓氏': '周', '名字': '杰伦', 'hobby': '打篮球', 'goodfor': '唱歌'}
- 将函数存储在模块中
导入特定的函数
from 模块名 import 函数名
from 模块名 import 函数名1,函数名2,函数名3, ......
使用as给函数指定别名
from 模块名 import 函数名 as 自己定的其他名字
使用as给模块指定别名
import 模块名 as 自己定的其他名字
导入模块的所有函数
使用*可以导入模块中的所有函数
from 模块名 import *
day_09(类)
根据要求来创建对象被称为实例化，基于类创建对象时，每个对象都自动具备这种通用行为，然后可以根据需要赋予每个对象独特的个性。使用面向对象编程，可以模拟现实情景，其逼真程度达到令我惊讶的地步。
- 创建和使用类
创建一个Dog类，使其每个实例都存储名字和年龄。我们将赋予小狗蹲下和打滚的能力。
#encoding:utf-8
class Dog():
'''一次模拟小狗的简单尝试'''
def __init__(self,name,age):
'''初始化属性name和age'''
self.name = name
self.age = age
def sit(self):
'''模拟小狗被命令蹲下'''
print(self.name.title()+"现在已经蹲下了")
def roll_over(self):
'''模拟小狗被命令时打滚'''
print(self.name.title()+"现在正在打滚")
-
方法__init__（）
方法 init()是一个特殊的方法，当你根据Dog类创建实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。
我们将方法__init__()定义成了包含三个参数：self、name、age。在这个方法中。形参self必不可少，还须位于其他形参的前面。为何必须包含self？因为Python调用这个方法来创建Dog实例时，将自动传入实参self。每个与类相关的联的方法都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。
以self为前缀的变量都可以供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量。可以通过实例访问的变量称为属性。
根据类创建实例
下面来创建一个表示特定小狗的实例（基于上面创建的Dog类）：
my_dog = Dog('harry',12)
print("我的狗的名字是"+my_dog.name.title()+"。")
print("\n我的狗现在已经"+str(my_dog.age)+"岁了。")
我的狗的名字是Harry。
我的狗现在已经12岁了。
调用方法
my_dog = Dog('harry',12)
my_dog.sit()
my_dog.roll_over()
Harry现在已经蹲下了
Harry现在正在打滚
创建多个实例
#访问属性
my_dog = Dog('harry',12)
print("我的狗的名字是"+my_dog.name.title()+"。")
print("我的狗现在已经"+str(my_dog.age)+"岁了。")
#调用方法
my_dog.sit()
my_dog.roll_over()
#创建多个实例
your_dog = Dog('jack',11)
print("\n你的狗的名字是"+your_dog.name.title()+"。")
print("你的狗现在已经"+str(your_dog.age)+"岁了。")
your_dog.sit()
your_dog.roll_over()
我的狗的名字是Harry。
我的狗现在已经12岁了。
Harry现在已经蹲下了
Harry现在正在打滚
你的狗的名字是Jack。
你的狗现在已经11岁了。
Jack现在已经蹲下了
Jack现在正在打滚
- 动手试一试
餐馆：创建一个名为resturant 的类，其方法__init__()设置两个属性：restaurant_name和cuisine_type 。创建一个名为describe_restaurant()的方法和一个名为open_restaurant()的方法，其中前者打印前述两项信息，而后者打印一条信息，指出餐馆正在营业。
根据这个类创建一个名为restaurant的实例，分别打印其两个属性，再调用前述两个方法。
#encoding:utf-8
class Restaurant():
def __init__(self,restaurant_name,cuisine_type):
'''创建餐馆的两个属性'''
self.restaurant_name = restaurant_name
self.cuisine_type = cuisine_type
def describe_restaurant(self):
print("这家餐馆的名字叫做"+self.restaurant_name.title())
print("这家餐馆的烹饪类型是"+self.cuisine_type)
def open_restaurant(self):
print("这家餐馆正在营业")
#创建一个名为message 的实例
message_01 = Restaurant('mqilin','西餐厅')
message_02 = Restaurant('广州酒家','粤菜')
message_01.open_restaurant()
message_01.describe_restaurant()
print("\n")
message_02.open_restaurant()
message_02.describe_restaurant()
这家餐馆正在营业
这家餐馆的名字叫做Mqilin
这家餐馆的烹饪类型是西餐厅
这家餐馆正在营业
这家餐馆的名字叫做广州酒家
这家餐馆的烹饪类型是粤菜
- 使用类和实例
car类
下面来编写一个表示汽车的类，它存储了有关汽车的信息，还有一个汇总这些信息的方法：
#encoding:utf-8
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
my_new_car = Car('BMW','a1',2020)
print(my_new_car.get_descriptive_name())
2020 BMW a1
下面给它添加一个随时间变化的属性，它存储汽车的总里程。
给属性指定默认值
下面添加一个名为odometer_reading，其初始值为0.我们还添加了一个名为read_odometer的方法，用于读取汽车的里程表：
#encoding:utf-8
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
def read_odometer(self):
'''打印一条指出汽车里程的信息'''
print("你的汽车已经行驶了"+str(self.odometer_reading)+"km!")
my_new_car = Car('BMW','a1',2020)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()
2020 BMW a1
你的汽车已经行驶了0km!
修改属性的值
#encoding:utf-8
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
def read_odometer(self):
'''打印一条指出汽车里程的信息'''
print("你的汽车已经行驶了"+str(self.odometer_reading)+"km!")
my_new_car = Car('BMW','a1',2020)
print(my_new_car.get_descriptive_name())
# my_new_car.read_odometer()
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
直接修改属性的值
~~~
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
2020 BMW a1
你的汽车已经行驶了23km!
通过方法修改属性的值
~~~
my_new_car.update_odmoeter(25)
my_new_car.read_odometer()
2020 BMW a1
你的汽车已经行驶了25km!
可以对update_odometer（）进行扩展，使其在修改里程表读数时做额外的工作。下面来添加一些逻辑，禁止任何人将里程表读数往回调：
~~~
def update_odmoeter(self,message):
'''
将里程表读书设置为指定的值
禁止里程表读数往回调
'''
if message >= self.odometer_reading:
self.odometer_reading = message
else:
print("你不可以将数值回调")
~~~
通过方法对属性的值进行递增
#encoding:utf-8
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
def read_odometer(self):
'''打印一条指出汽车里程的信息'''
print("你的汽车已经行驶了"+str(self.odometer_reading)+"km!")
def update_odmoeter(self,message):
'''
将里程表读书设置为指定的值
禁止里程表读数往回调
'''
if message >= self.odometer_reading:
self.odometer_reading = message
else:
print("你不可以将数值回调")
def increment_odometer(self,mil_message):
'''增加里程表的读数'''
self.odometer_reading += mil_message
my_use_car = Car('本田','雅阁',2015)
print(my_use_car.get_descriptive_name())
my_use_car.update_odmoeter(23500)
my_use_car.read_odometer()
my_use_car.increment_odometer(100)
my_use_car.read_odometer()
2015 本田 雅阁
你的汽车已经行驶了23500km!
你的汽车已经行驶了23600km!
-
继承
编写类时，并非总是要从空白开始。如果你编写的类是另一个现成类的特殊版本，可以使用继承。一个类继承另一个类时，他将自动获取另一个类的所有属性和方法；原有的类称之为父类，而新类称之为子类。子类继承了父类的所有属性和方法，同时还可以定义自己的属性和方法。
子类的方法__init__()
下面来模拟电动车。电动车是一种特殊的汽车，因此我们可以在前面创建的Car类的基础上创建类ElectricCar，这样我们就只需为电动车特殊的属性和行为编写代码
#来创建一个电动车的类
class ElectricCar(Car):
'''电动车独特的属性'''
def __init__(self,make,model,year):
'''初始化父类的属性'''
super().__init__(make,model,year)
my_tesla = ElectricCar('tesla','model s',2016)
print(my_tesla.get_descriptive_name())
2016 tesla model s
创建子类时，父类必须包含在当前文件中，且位于子类的前面
给予类定义属性和方法
下面来添加一个电动车特有的属性（电瓶），以及一个描述该属性的方法。我们将存储电瓶容量，并编写一个打印电瓶描述的方法：
#来创建一个电动车的类
class ElectricCar(Car):
'''电动车独特的属性'''
def __init__(self,make,model,year):
'''
初始化父类的属性
初始化电动车特有的属性
'''
super().__init__(make,model,year)
self.battery_size = 70
def describe_battery(self):
'''打印一条信息来描述电瓶'''
print("这辆电瓶车有着"+ str(self.battery_size) + "容量的电池")
my_tesla = ElectricCar('tesla','model s',2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
2016 tesla model s
这辆电瓶车有着70容量的电池
重写父类的方法
对于父类的方法，只要它不符合子类模拟实物的行为，都可以对其进行重写。为此，可以在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，Python将不会考虑这个父类方法，而只关心你在子类中定义的相应方法：
假设Car类中有一个名为fill_gas_tank()的方法，它对电瓶车来说毫无意义，因此你想要重写它。下面演示了一种重写的方法。
class Car():
def fill_gas_tank(self):
'''为汽车增加尾气排放数值'''
print("该汽车的尾气排放量为"+ str(self.gas_tank) +"每公里")
~~~Python
class ElectricCar(Car):
def fill_gas_tank(self):
'''电动车没有油箱'''
print("电动车不会排除尾气")
my_tesla = ElectricCar('tesla','model s',2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
my_tesla.fill_gas_tank()
print("\n")
my_car = Car('本田','思域',2018)
my_car.fill_gas_tank()
~~~
2016 tesla model s
这辆电瓶车有着70容量的电池
电动车不会排除尾气
该汽车的尾气排放量为13每公里
将实例用作属性
使用代码模拟实物时，你可能会发现自己给类添加的细节越来越多：属性和方法清单以及文件都越来越长。在这种情况下，可能需要将类的一部分作为一个独立的类提取出来。你可以将大型类拆分成多个协同工作的小类。
例如，不断给ElectricCar类添加细节时，我们可能会发现其中包含很多专门针对汽车电瓶的属性和方法。在这种情况下，我们可将这些属性和方法提取出来，放到另一个专门名为Battery的类中，并将一个Battery实例用作ElectricCar类的一个属性:
class Car():
```Python
#来创建一个电瓶类
class Battery():
'''一次模拟电动汽车电瓶的简单尝试'''
def __init__(self,battery_size=70):
'''初始化电瓶的属性'''
self.battery_size = battery_size
def describe_battery(self):
'''打印一条描述电瓶的信息'''
print("这辆电动车的电瓶的容量是"+ str(self.battery_size))
#来创建一个电动车的类
class ElectricCar(Car):
'''电动车独特的属性'''
def __init__(self,make,model,year):
'''
初始化父类的属性
初始化电动车特有的属性
'''
super().__init__(make,model,year)
self.battery = Battery()
my_test = ElectricCar('tesla','model s',2016)
print(my_test.get_descriptive_name())
my_test.attery.describe_battery()
```
~~~Python
2016 tesla model s
这辆电动车的电瓶的容量是70
下面再给Battery添加一个方法，它根据电瓶容量报告汽车的续航里程：
class Battery():
'''一次模拟电动汽车电瓶的简单尝试'''
def __init__(self,battery_size=70):
'''初始化电瓶的属性'''
self.battery_size = battery_size
def describe_battery(self):
'''打印一条描述电瓶的信息'''
print("这辆电动车的电瓶的容量是"+ str(self.battery_size))
def get_range(self):
'''打印出一条信息，指出电瓶的续航里程'''
if self.battery_size == 70:
range = 240
elif self.battery_size == 85:
range = 270
message = "现在的电池容量能走"+str(range)+"KM 路程"
print(message)
#来创建一个电动车的类
class ElectricCar(Car):
'''电动车独特的属性'''
def __init__(self,make,model,year):
'''
初始化父类的属性
初始化电动车特有的属性
'''
super().__init__(make,model,year)
self.battery = Battery()
my_test = ElectricCar('tesla','model s',2016)
print(my_test.get_descriptive_name())
my_test.battery.describe_battery()
my_test.battery.get_range()
2016 tesla model s
这辆电动车的电瓶的容量是70
现在的电池容量能走240KM 路程
- 导入类
随着你不断地给类添加功能，文件可能变得很长，即便你妥善地使用了继承亦如此。为遵循python的总体理念，应让文件尽可能整洁。为在这方面提供帮助，python允许你将类存储在模块中，然后在主程序中导入所需的模块。
导入单个类
#encoding:utf-8
from Car import Car
my_new_car = Car('东风','日产',2022)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
2022 东风 日产
你的汽车已经行驶了23km!
在一个模块中存储多个类
现在可以新建一个名为my_electric_car.py的文件，导入ElectricCar类，并创建一辆电动汽车了：
#encoding:utf-8
from Car import ElectricCar
my_tesla = ElectricCar('tesla','model s',2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()
2016 tesla model s
这辆电动车的电瓶的容量是70
现在的电池容量能走240KM 路程
来源：oschina
链接：https://my.oschina.net/u/4318340/blog/4282968