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.
- 在for回圈結束后執行一些操作
在for回圈結束后列印一條陳述句，應在for回圈的外面列印‘’
fruits = ['apple','orange','banana','cherry']
for i in fruits:
print("我真的太喜歡吃,"+i.title()+"這個水果了，")
print("我每天都要吃"+i.title()+".\n")
print("我明天就去買!!!!")
我真的太喜歡吃,Apple這個水果了，
我每天都要吃Apple.
我真的太喜歡吃,Orange這個水果了，
我每天都要吃Orange.
我真的太喜歡吃,Banana這個水果了，
我每天都要吃Banana.
我真的太喜歡吃,Cherry這個水果了，
我每天都要吃Cherry.
我明天就去買!!!!
- 避免縮進錯誤
-
忘記縮進，在for陳述句中記得在for陳述句代碼最后有一個冒號: 將其遺漏可以會造成縮進錯誤
-
忘記縮進額外的代碼
-
不必要的縮進
message = "python" print(message)#print不屬于前一行代碼，他們是平等的關系，所以不需要縮進 -
回圈后的不必要縮進 例如：回圈內的代碼需要縮進，代碼結束后代碼不需要縮進
- 創建數字串列
使用函式range()
Python函式range()能幫你輕松地生成一系列的數字
for i in range(0,5):
print(i)
0
1
2
3
4
range()生成從第一個數開始到第二個數的前一個值結束
使用range()創建數字串列
number_list = list(range(0,7))
print(number_list)
[0, 1, 2, 3, 4, 5, 6]
使用range()時，還可以指定步長
number_list = list(range(0,20,2))
print(number_list)
步長為2時，輸出所有偶數
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
創建臨時變數square()，將每個計算得到的值附加到串列快的末尾：
square = []
for i in range(1,11):
ad = i**2
square.append(ad)
print(square)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
對數字串列進行簡單的統計
找出串列中的最小值min()、最大值max()、總和sum()
square = []
for i in range(1,11):
ad = i**2
square.append(ad)
print(square)
print(min(square),max(square),sum(square))
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
1 100 385 #輸出了串列中的最小值、最大值、總和
串列決議
使用一行代碼就完成對串列的平方
square = [i**2 for i in range(1,11)]
print(square)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
- 使用串列的一部分
切片
控制需要輸出串列的元素
fruits = ['lemon','apple','banana','orange']
print(fruits[0:3])
['lemon', 'apple', 'banana']
輸出了前三種水果
是可以生成任何子集，例如“你需要提取第2~3個元素；可以將起始索引指定為1，末尾索引指定為4
fruits = ['lemon','apple','banana','orange']
print(fruits[1:3])
['apple', 'banana']
沒有指定第一個索引的情況
fruits = ['lemon','apple','banana','orange']
print(fruits[:3])
['lemon', 'apple', 'banana']
沒有指定最后一個索引的情況
fruits = ['lemon','apple','banana','orange']
print(fruits[1:])
['apple', 'banana', 'orange']
遍歷切片
如果需要遍歷一部分串列元素，可以使用for回圈中使用切片，在下面串列中我們遍歷前三種水果
fruits = ['lemon','apple','banana','orange']
print("遍歷前三種水果")
for i in fruits[:3]:
print(i.title())
遍歷前三種水果
Lemon
Apple
Banana
復制串列
你喜歡的水果，你的朋友也喜歡，需要將你喜歡的水果串列復制，然后賦值給你朋友的水果串列
fruits = ['lemon','apple','banana','orange']
friend_fruits = fruits[:]
print("我喜歡的水果")
print(fruits)
print("\n我朋友喜歡的水果")
print(friend_fruits)
我喜歡的水果
['lemon', 'apple', 'banana', 'orange']
我朋友喜歡的水果
['lemon', 'apple', 'banana', 'orange']
- 元組
創建一個不可修改的的串列——元組
定義元組
元組與串列類似，串列使用[]來進行定義，元組使用()進行定義
例如：有一個大小不應改變的矩形，可以將其長度寬度存盤在一個元組中，從而確保他們是不能修改的
message =(100,90)
print(message[0])
print(message[1])
100
90
像串列一樣，元組也能遍歷其中的所有值
message =(100,90)
for i in message:
print(i)
100
90
雖然不能修改元組的值，但是可以向元組中的元素賦值
message =(100,90)
print("原來的值")
for i in message:
print(i)
message =(400,500)
print("\n賦值后的值")
for i in message:
print(i)
原來的值
100
90
賦值后的值
400
500
以上就是Python基礎學習第四天的內容，
- 在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 路程
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/145722.html
標籤：Python
上一篇：樸素貝葉斯-垃圾郵件分類