條件判斷
計算機之所以能做很多自動化的任務，因為它可以自己做條件判斷，
比如，輸入用戶年齡，根據年齡列印不同的內容，在Python程式中，用if陳述句實作：
age = 20if age >= 18: print('your age is', age) print('adult')
根據Python的縮進規則，如果if陳述句判斷是True，就把縮進的兩行print陳述句執行了，否則，什么也不做，
也可以給if添加一個else陳述句，意思是，如果if判斷是False，不要執行if的內容，去把else執行了：
age = 3if age >= 18: print('your age is', age) print('adult')else: print('your age is', age) print('teenager')
（教程領到手，學習不用愁！vx:Y20200324324 備注JS即可免費領取哦！）
注意不要少寫了冒號:，
當然上面的判斷是很粗略的，完全可以用elif做更細致的判斷：
age = 3if age >= 18: print('adult')elif age >= 6: print('teenager')else: print('kid')
elif是else if的縮寫，完全可以有多個elif，所以if陳述句的完整形式就是：
if <條件判斷1>: <執行1>elif <條件判斷2>: <執行2>elif <條件判斷3>: <執行3>else: <執行4>
if陳述句執行有個特點，它是從上往下判斷，如果在某個判斷上是True，把該判斷對應的陳述句執行后，就忽略掉剩下的elif和else，所以，請測驗并解釋為什么下面的程式列印的是teenager：
age = 20if age >= 6: print('teenager')elif age >= 18: print('adult')else: print('kid')
if判斷條件還可以簡寫，比如寫：
if x: print('True')
只要x是非零數值、非空字串、非空list等，就判斷為True，否則為False，
input
最后看一個有問題的條件判斷，很多同學會用input()讀取用戶的輸入，這樣可以自己輸入，程式運行得更有意思：
birth = input('birth: ')if birth < 2000: print('00前')else: print('00后')
輸入1982，結果報錯：
Traceback (most recent call last): File "
這是因為input()回傳的資料型別是str，str不能直接和整數比較，必須先把str轉換成整數，Python提供了int()函式來完成這件事情：
s = input('birth: ')birth = int(s)if birth < 2000: print('00前')else: print('00后')
再次運行，就可以得到正確地結果，但是，如果輸入abc呢？又會得到一個錯誤資訊：
Traceback (most recent call last): File "
原來int()函式發現一個字串并不是合法的數字時就會報錯，程式就退出了，
回圈
要計算1+2+3，我們可以直接寫運算式：
1 + 2 + 36
要計算1+2+3+...+10，勉強也能寫出來，
但是，要計算1+2+3+...+10000，直接寫運算式就不可能了，
為了讓計算機能計算成千上萬次的重復運算，我們就需要回圈陳述句，
for...in回圈
Python的回圈有兩種，一種是for...in回圈，依次把list或tuple中的每個元素迭代出來，看例子：
names = ['Michael', 'Bob', 'Tracy']for name in names: print(name)
執行這段代碼，會依次列印names的每一個元素：
MichaelBobTracy
所以for x in ...回圈就是把每個元素代入變數x，然后每一次都執行縮進塊的陳述句進行輸出，
再比如我們想計算1-10的整數之和，可以用一個sum變數做累加：
sum = 0for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]: sum = sum + xprint(sum)
如果要計算1-100的整數之和，從1寫到100有點困難，
Python提供一個range()函式，可以生成一個整數序列，再通過list()函式可以轉換為list，
比如range(5)生成的序列是從0開始小于5的整數：
list(range(5))[0, 1, 2, 3, 4]
range(101)就可以生成0-100的整數序列，計算如下：
第一種：
輸入：
輸出：
第二種：
輸入：
輸出：
注意縮進，會輸出不一樣的結果：
輸入：
輸出：
while回圈
第二種回圈是while回圈，只要條件滿足，就不斷回圈，條件不滿足時退出回圈，輸出的是最后一個回圈的結果，
比如我們要計算100以內所有奇數之和，可以用while回圈實作：
sum = 0n = 99while n > 0: sum = sum + n n = n - 2print(sum)
在回圈內部變數n不斷自減，直到變為-1時，不再滿足while條件，回圈退出，
輸入：
輸出：
break
在回圈中，break陳述句可以提前退出回圈，程式結束，但必須配合if陳述句使用，例如，列印出1~10后，緊接著列印END，程式結束，
n = 1while n <= 100: if n > 10: # 當n = 11時，條件滿足，執行break陳述句 break # break陳述句會結束當前回圈 print(n) n = n + 1print('END')
continue
在回圈程序中，也可以通過continue陳述句，跳過當前的這次回圈，直接開始下一次回圈，但必須配合if陳述句使用，
如果我們想只列印 1-10之間的奇數，可以用continue陳述句跳過某些回圈：
n = 0while n < 10: n = n + 1 if n % 2 == 0: # 如果n是偶數，執行continue陳述句 continue # continue陳述句會直接繼續下一輪回圈，后續的print()陳述句不會執行 print(n)
執行上面的代碼可以看到，列印的不再是1～10，而是1，3，5，7，9，
要特別注意：不要濫用break和continue陳述句，
dict，{}
Python內置了字典：dict的支持，dict全稱dictionary，在其他語言中也稱為map，使用鍵-值（key-value）存盤，具有極快的查找速度，
舉個例子，假設要根據同學的名字查找對應的成績，如果用dict實作，只需要一個“名字”-“成績”的對照表，直接根據名字查找成績，無論這個表有多大，查找速度都不會變慢，用Python寫一個dict如下：
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}>>> d['Michael']95
這種key-value存盤方式，在放進去的時候，必須根據key算出value的存放位置，這樣，取的時候才能根據key直接拿到value，
把資料放入dict的方法，除了初始化時指定外，還可以通過key放入：
d['Adam'] = 67>>> d['Adam']67
由于一個key只能對應一個value，所以，多次對一個key放入value，后面的值會把前面的值沖掉：
d['Jack'] = 90>>> d['Jack']90>>> d['Jack'] = 88>>> d['Jack']88
d
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85,'Adam':67,'Jack':88}
如果key不存在，dict就會報錯：
d['Thomas']Traceback (most recent call last): File "
", line 1, in KeyError: 'Thomas'
要避免key不存在的錯誤，有兩種辦法，一是通過in判斷key是否存在：
'Thomas' in dFalse
二是通過dict提供的get()方法，如果key不存在，可以回傳None，或者自己指定的value：
d.get('Thomas')>>> d.get('Thomas', -1)-1
注意：回傳None的時候Python的互動環境不顯示結果，
要洗掉一個key，用pop(key)方法，對應的value也會從dict中洗掉：
d.pop('Bob')75>>> d{'Michael': 95, 'Tracy': 85}
請務必注意，dict內部存放的順序和key放入的順序是沒有關系的，
和list比較，dict有以下幾個特點：
查找和插入的速度極快，不會隨著key的增加而變慢；
需要占用大量的記憶體，記憶體浪費多，
而list相反：
查找和插入的時間隨著元素的增加而增加；
占用空間小，浪費記憶體很少，
所以，dict是用空間來換取時間的一種方法，
dict可以用在需要高速查找的很多地方，在Python代碼中幾乎無處不在，正確使用dict非常重要，需要牢記的第一條就是dict的key必須是不可變物件，
這是因為dict根據key來計算value的存盤位置，如果每次計算相同的key得出的結果不同，那dict內部就完全混亂了，這個通過key計算位置的演算法稱為哈希演算法（Hash），
要保證hash的正確性，作為key的物件就不能變，
在Python中，字串、整數等都是不可變的，因此，可以放心地作為key，而list是可變的，就不能作為key：
key = [1, 2, 3]>>> d[key] = 'a list'Traceback (most recent call last): File "
", line 1, in TypeError: unhashable type: 'list'
set
set和dict類似，也是一組key的集合，但不存盤value，由于key不能重復，所以，在set中，沒有重復的key，
要創建一個set，需要提供一個list作為輸入集合：
s = set([1, 2, 3])>>> s{1, 2, 3}
注意，傳入的引數[1, 2, 3]是一個list，而顯示的{1, 2, 3}只是告訴你這個set內部有1，2，3這3個元素，顯示的順序也不表示set是有序的，
重復元素在set中自動被過濾：
s = set([1, 1, 2, 2, 3, 3])>>> s{1, 2, 3}
通過add(key)方法可以添加元素到set中，可以重復添加，但不會有效果：
s.add(4)>>> s{1, 2, 3, 4}>>> s.add(4)>>> s{1, 2, 3, 4}
通過remove(key)方法可以洗掉元素：
s.remove(4)>>> s{1, 2, 3}
set可以看成數學意義上的無序和無重復元素的集合，因此，兩個set可以做數學意義上的交集、并集等操作：
s1 = set([1, 2, 3])>>> s2 = set([2, 3, 4])>>> s1 & s2{2, 3}>>> s1 | s2{1, 2, 3, 4}
set和dict的唯一區別僅在于沒有存盤對應的value，但是，set的原理和dict一樣，所以，同樣不可以放入可變物件，因為無法判斷兩個可變物件是否相等，也就無法保證set內部“不會有重復元素”，試試把list放入set，看看是否會報錯，
再議不可變物件
上面我們講了，str是不變物件，而list是可變物件，
對于可變物件，比如list，對list進行操作，list內部的內容是會變化的，比如：
a = ['c', 'b', 'a']>>> a.sort()>>> a['a', 'b', 'c']
而對于不可變物件，比如str，對str進行操作呢：
a = 'abc'>>> a.replace('a', 'A')'Abc'>>> a'abc'
雖然字串有個replace()方法，也確實變出了'Abc'，但變數a最后仍是'abc'，應該怎么理解呢？
我們先把代碼改成下面這樣：
a = 'abc'>>> b = a.replace('a', 'A')>>> b'Abc'>>> a'abc'
要始終牢記的是，a是變數，而'abc'才是字串物件！有些時候，我們經常說，物件a的內容是'abc'，但其實是指，a本身是一個變數，它指向的物件的內容才是'abc'：
┌───┐ ┌───────┐│ a │─────────────────>│ 'abc' │└───┘ └───────┘
當我們呼叫a.replace('a', 'A')時，實際上呼叫方法replace是作用在字串物件'abc'上的，而這個方法雖然名字叫replace，但卻沒有改變字串'abc'的內容，相反，replace方法創建了一個新字串'Abc'并回傳，如果我們用變數b指向該新字串，就容易理解了，變數a仍指向原有的字串'abc'，但變數b卻指向新字串'Abc'了：
┌───┐ ┌───────┐│ a │─────────────────>│ 'abc' │└───┘ └───────┘┌───┐ ┌───────┐│ b │─────────────────>│ 'Abc' │└───┘ └───────┘
所以，對于不變物件來說，呼叫物件自身的任意方法，也不會改變該物件自身的內容，相反，這些方法會創建新的物件并回傳，這樣，就保證了不可變物件本身永遠是不可變的，
小結
使用key-value存盤結構的dict在Python中非常有用，選擇不可變物件作為key很重要，最常用的key是字串，
tuple雖然是不變物件，但試試把(1, 2, 3)和(1, [2, 3])放入dict或set中，并解釋結果，
總結
我是白白，一個喜歡學習喜歡編程的年輕人
想學習python的可以關注私信我哦~
歡迎小白、萌新、大佬加入我們
小白學習交流基地【（九七四）（七二四）（八九四）】
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/246425.html
標籤：其他