高效掌握Python——必備基礎(chǔ)

縮進 & 數(shù)據(jù)類型

任何一種編程語言都有自己的一套語法，編譯器或者解釋器就是負責(zé)把符合語法的程序代碼轉(zhuǎn)換成CPU能夠執(zhí)行的機器碼，然后執(zhí)行。

Python的語法比較簡單，采用縮進方式，堅持使用4個空格的縮進，且沒有結(jié)束引號，很優(yōu)雅，寫出來的代碼就像下面的樣子：

# print absolute value of an integer:
a = 100
if a >= 0:
	print(a)
else:
	print(-a)

記得Python程序是大小寫敏感的?。?！

計算機能處理的遠不止數(shù)值，還可以處理文本、圖形、音頻、視頻、網(wǎng)頁等各種各樣的數(shù)據(jù)，不同的數(shù)據(jù)，需要定義不同的數(shù)據(jù)類型。在Python中，能夠直接處理的數(shù)據(jù)類型有以下幾種：

1. 整數(shù) int
2. 浮點數(shù) float
3. 字符串 str（單引雙引都o(jì)k）（字符串內(nèi)部既包含’又包含"可以用轉(zhuǎn)義字符來標(biāo)識，轉(zhuǎn)義字符可以轉(zhuǎn)義很多字符，比如n表示換行，t表示制表符，字符本身也要轉(zhuǎn)義，所以表示的字符就是）
4. 布爾值 bool
5. 空值 None
6. 變量 對變量賦值x = y是把變量x指向真正的對象，該對象是變量y所指向的。隨后對變量y的賦值不影響變量x的指向。
7. 常量

字符編碼 & 格式化

因為計算機只能處理數(shù)字，如果要處理文本，就必須先把文本轉(zhuǎn)換為數(shù)字才能處理。最早的計算機在設(shè)計時采用8個比特（bit）作為一個字節(jié)（byte），所以，一個字節(jié)能表示的最大的整數(shù)就是255（二進制11111111=十進制255），如果要表示更大的整數(shù)，就必須用更多的字節(jié)。比如兩個字節(jié)可以表示的最大整數(shù)是65535，4個字節(jié)可以表示的最大整數(shù)是4294967295。

UTF-8編碼有一個額外的好處，就是ASCII編碼實際上可以被看成是UTF-8編碼的一部分，所以，大量只支持ASCII編碼的歷史遺留軟件可以在UTF-8編碼下繼續(xù)工作。

現(xiàn)在計算機系統(tǒng)通用的字符編碼工作方式：在計算機內(nèi)存中，統(tǒng)一使用Unicode編碼，當(dāng)需要保存到硬盤或者需要傳輸?shù)臅r候，就轉(zhuǎn)換為UTF-8編碼。用記事本編輯的時候，從文件讀取的UTF-8字符被轉(zhuǎn)換為Unicode字符到內(nèi)存里，編輯完成后，保存的時候再把Unicode轉(zhuǎn)換為UTF-8保存到文件：

瀏覽網(wǎng)頁的時候，服務(wù)器會把動態(tài)生成的Unicode內(nèi)容轉(zhuǎn)換為UTF-8再傳輸?shù)綖g覽器：

所以你看到很多網(wǎng)頁的源碼上會有類似的信息，表示該網(wǎng)頁正是用的UTF-8編碼。

在最新的Python 3版本中，字符串是以Unicode編碼的，也就是說，Python的字符串支持多語言。1個中文字符經(jīng)過UTF-8編碼后通常會占用3個字節(jié)，而1個英文字符只占用1個字節(jié)。

在Python中，采用的格式化方式和C語言是一致的，用%實現(xiàn)，舉例如下：

>>> 'Hello, %s' % 'world'
'Hello, world'
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'

list & tuple

list和tuple是Python內(nèi)置的有序集合，一個可變，一個不可變。根據(jù)需要來選擇使用它們。

list

list是一種有序的集合，可以隨時添加和刪除其中的元素。比如，列出班里所有同學(xué)的名字，就可以用一個list表示：

>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']

變量classmates就是一個list。用len()函數(shù)可以獲得list元素的個數(shù)：

>>> len(classmates)
3

用索引來訪問list中每一個位置的元素，記得索引是從0開始的。如果要取最后一個元素，除了計算索引位置外，還可以用-1做索引，直接獲取最后一個元素，倒數(shù)第二個就是[-2]。

list是一個可變的有序表，所以，可以往list中追加元素到末尾append()：

>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

也可以把元素插入到指定的位置，比如索引號為1的位置insert()：

>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

要刪除list末尾的元素，用pop()方法：

>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

要刪除指定位置的元素，用pop(i)方法，其中i是索引位置：

>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']

要把某個元素替換成別的元素，可以直接賦值給對應(yīng)的索引位置：

>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']

list里面的元素的數(shù)據(jù)類型也可以不同，比如：

>>> L = ['Apple', 123, True]

list元素也可以是另一個list，比如：

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

tuple

tuple與list灰常像，最大不同就是它一旦初始化，就不能修改！比如同樣是列出同學(xué)的名字：

>>> classmates = ('Michael', 'Bob', 'Tracy')

現(xiàn)在，classmates這個tuple不能變了，它也沒有append()，insert()這樣的方法。其他獲取元素的方法和list是一樣的，你可以正常地使用classmates[0]，classmates[-1]，但不能賦值成另外的元素。不可變的tuple有什么意義？因為tuple不可變，所以代碼更安全。如果可能，能用tuple代替list就盡量用tuple。

當(dāng)你定義一個tuple時，在定義的時候，tuple的元素就必須被確定下來，比如：

>>> t = (1, 2)
>>> t
(1, 2)

一個“可變的”tuple：

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

tuple所謂的“不變”是說，tuple的每個元素，指向永遠不變。即指向’a’，就不能改成指向’b’，指向一個list，就不能改成指向其他對象，但指向的這個list本身是可變的！

條件判斷

就是if，elif，else, 看幾行代碼就懂了。

age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')

elif是else if的縮寫，完全可以有多個elif，所以if語句的完整形式就是：

if <條件判斷1>:
    <執(zhí)行1>
elif <條件判斷2>:
    <執(zhí)行2>
elif <條件判斷3>:
    <執(zhí)行3>
else:
    <執(zhí)行4>

if語句執(zhí)行有個特點，它是從上往下判斷，如果在某個判斷上是True，把該判斷對應(yīng)的語句執(zhí)行后，就忽略掉剩下的elif和else。

只要判斷的條件是非零數(shù)值、非空字符串、非空list等，就判斷為True，否則為False。

最后看一個簡單的判斷00后的代碼：

s = input('birth: ')
birth = int(s)
if birth < 2000:
	print('00前')
else:
	print('00后')

循環(huán)

for…in

幾個典型的代碼：
打印list中的所有元素：

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

累加list中的所有元素：

sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)

利用range()也能達到循環(huán)的效果

list(range(5))
[0, 1, 2, 3, 4]

while

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

break

在循環(huán)中，break語句可以提前退出循環(huán)。

n = 1
while n <= 100:
	if n > 10:      # 當(dāng)n = 11時，條件滿足，執(zhí)行break語句break# break語句會結(jié)束當(dāng)前循環(huán)print(n)
    	n = n + 1
print('END')

執(zhí)行上面的代碼可以看到，打印出1~10后，緊接著打印END，程序結(jié)束。

continue

在循環(huán)過程中，也可以通過continue語句，跳過當(dāng)前的這次循環(huán)，直接開始下一次循環(huán)。

n = 0
while n < 10:
    n = n + 1
	if n % 2 == 0:  # 如果n是偶數(shù)，執(zhí)行continue語句
		continue    # continue語句會直接繼續(xù)下一輪循環(huán)，后續(xù)的print()語句不會執(zhí)行
	print(n)

執(zhí)行上面的代碼可以看到，打印的不再是1～10，而是1，3，5，7，9。
break語句可以在循環(huán)過程中直接退出循環(huán)，而continue語句可以提前結(jié)束本輪循環(huán)，并直接開始下一輪循環(huán)。這兩個語句通常都必須配合if語句使用。

字典 dict & set

dict

就是字典，有著key和value。先在字典的索引表里（比如部首表）查這個字對應(yīng)的頁碼，然后直接翻到該頁，找到這個字。無論找哪個字，這種查找速度都非?？?，不會隨著字典大小的增加而變慢。

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

把數(shù)據(jù)放入dict的方法，除了初始化時指定外，還可以通過key放入：

>>> d['Adam'] = 67
>>> d['Adam']
67

由于一個key只能對應(yīng)一個value，所以，多次對一個key放入value，后面的值會把前面的值沖掉，如果key不存在，dict就會報錯：

>>> d['Jack'] = 90
>>> d['Jack']
90
>>> d['Jack'] = 88
>>> d['Jack']
88

要刪除一個key，用pop(key)方法，對應(yīng)的value也會從dict中刪除：

>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}

dict內(nèi)部存放的順序和key放入的順序是沒有關(guān)系的。

和list比較，dict有以下幾個特點：

1. 查找和插入的速度極快，不會隨著key的增加而變慢；
2. 需要占用大量的內(nèi)存，內(nèi)存浪費多。

而list相反：

1. 查找和插入的時間隨著元素的增加而增加；
2. 占用空間小，浪費內(nèi)存很少。

所以，dict是用空間來換取時間的一種方法。

dict的key必須是不可變對象！??！通過key計算位置的算法稱為哈希算法（Hash），要保證hash的正確性，作為key的對象就不能變。 在Python中，字符串、整數(shù)等都是不可變的，因此，可以放心地作為key。而list是可變的，就不能作為key

set

set和dict類似，也是一組key的集合，但不存儲value。由于key不能重復(fù)，所以，在set中，沒有重復(fù)的key。

要創(chuàng)建一個set，需要提供一個list作為輸入集合：

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

重復(fù)元素在set中自動被過濾：

>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}

set可以看成數(shù)學(xué)意義上的無序和無重復(fù)元素的集合，因此，兩個set可以做數(shù)學(xué)意義上的交集、并集等操作：

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

set和dict的唯一區(qū)別僅在于沒有存儲對應(yīng)的value，set的原理和dict一樣，所以，同樣不可以放入可變對象。

可變不可變大家可能有點懵了，對于不變對象來說，調(diào)用對象自身的任意方法，也不會改變該對象自身的內(nèi)容。相反，這些方法會創(chuàng)建新的對象并返回，這樣，就保證了不可變對象本身永遠是不可變的?？聪旅娴拇a就懂了：

>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'

附上其他文章的鏈接：

《Python簡介，無代碼》

《高效掌握Python——函數(shù)》

《高效掌握Python——高級特性》

《高效掌握Python——函數(shù)式編程》

《高效掌握Python——模塊，包》

《一文極速回顧面向?qū)ο缶幊蘋OP》

本文內(nèi)容屬于筆記，大部分內(nèi)容源自 廖雪峰老師的博客， 非常推薦大家去他的網(wǎng)站學(xué)習(xí)！