十分鐘快速入門 Python，看完即會，不用收藏！

阿新 • • 發佈：2019-05-14

win 等待變量命名 json stdin 要求收藏初始化 mage

本文以 Eric Matthes 的《Python編程：從入門到實踐》為基礎，以有一定其他語言經驗的程序員視角，對書中內容提煉總結，化繁為簡，將這本書的精髓融合成一篇10分鐘能讀完的文章。

讀完本篇文章後，可對 Python 語言特性、編碼風格有一定了解，並可寫出簡單的 Python 程序。

100?多位經驗豐富的開發者參與，在 Github 上獲得了近?1000?個?star?的開源項目想了解下嗎？
項目地址：github.com/cachecats/c…

一、安裝與運行

各個系統的 Python 安裝教程請自行查閱資料，這裏不再贅述。

檢查 Python 版本，在命令行輸入?python?即可，同時會進入命令行交互模式，可以在這裏執行 python 命令。

如果電腦中安裝了 python2.x 和 python3.x 兩個版本，輸入?python?運行的是 2.x 版本。想運行 3.x，則需輸入?python3。

在命令行輸入?python?：

Solo-mac:~ solo$ python
Python 2.7.10 (default, Aug 17 2018, 19:45:58)
[GCC 4.2.1 Compatible Apple LLVM 10.0.0 (clang-1000.0.42)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

在命令行輸入?python3?：

Solo-mac:~ solo$ python3
Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 26 2018, 23:26:24)
[Clang 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

輸入?exit()?即可退出命令行模式。

命令行運行 python 文件

如果是寫好了一個 python 文件，想通過命令行運行它，進入這個目錄，在命令行輸入?python 文件名.py

?即可。

比如桌面上有個文件?hello.py，內容是打印一句話：

print("Hello, Python")

想運行它，先進入 Desktop 目錄，再在命令行輸入?python hello.py?就能運行：

Solo-mac:Desktop solo$ python hello.py
Hello, Python

大家在學python的時候肯定會遇到很多難題，以及對於新技術的追求，這裏推薦一下我們的Python學習扣qun：784758214，這裏是python學習者聚集地！！同時，自己是一名高級python開發工程師，從基礎的python腳本到web開發、爬蟲、django、數據挖掘等，零基礎到項目實戰的資料都有整理。送給每一位python的小夥伴！每日分享一些學習的方法和需要註意的小細節

技術分享圖片

二、變量和簡單數據類型

2.1 變量命名規則

變量名只能包含字母、數字和下劃線。變量名可以字母或下劃線打頭，但不能以數字打頭，例如，可將變量命名為message_1，但不能將其命名為1_message。
變量名不能包含空格，但可使用下劃線來分隔其中的單詞。例如，變量名greeting_message 可行，但變量名greeting message會引發錯誤。
不要將Python關鍵字和函數名用作變量名，即不要使用Python保留用於特殊用途的單詞，如print。
變量名應既簡短又具有描述性。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。
慎用小寫字母l和大寫字母O，因為它們可能被人錯看成數字1和0。

變量名應該是小寫的，雖然沒有強制規定，但是約定俗稱的規則。

2.2 字符串

字符串就是一系列字符。在Python中，用引號括起的都是字符串，其中的引號可以是單引號，也可以是雙引號，還可以同時使用。如：

"This is a string." 
‘This is also a string.‘
"I love ‘python‘"

2.2.1 字符串的簡單運算

下面介紹字符串的簡單運算。

title()

title()以首字母大寫的方式顯示每個單詞，即將每個單詞的首字母都改為大寫。

>>> name = ‘solo coder‘
>>> name.title()
‘Solo Coder‘

upper()、lower()

將字符串改為全部大寫或全部小寫。

>>> name
‘solo coder‘
>>> name.upper()
‘SOLO CODER‘
>>> name.lower()
‘solo coder‘
>>> name
‘solo coder‘

註意：title()、upper()、lower() 均不改變原字符串，只是輸出了一個新的字符串。

2.2.2 合並（拼接）字符串

Python使用加號(+)來合並字符串。

>>> first = ‘solo‘
>>> last = ‘coder‘
>>> full = first + ‘ ‘ + last
>>> full
‘solo coder‘

2.2.3 使用制表符或換行符來添加空白

在編程中，空白泛指任何非打印字符，如空格、制表符和換行符。

要在字符串中添加制表符，可使用字符組合?\t，要在字符串中添加換行符，可使用字符組合?\n?。

>>> print(‘\tPython‘)
    Python
>>> print(‘Hello,\nPython‘)
Hello,
Python

2.2.4 刪除空白

rstrip()?刪除右側空白，lstrip()?刪除左側空白，strip()?刪除兩端空白。

>>> msg = ‘ Python ‘
>>> msg
‘ Python ‘
>>> msg.rstrip()
‘ Python‘
>>> msg.lstrip()
‘Python ‘
>>> msg.strip()
‘Python‘
>>> msg
‘ Python ‘

註意執行完去空格命令後，再打印出 msg，還是原來的字符串，這說明?strip()?也不改變原來的字符串。

2.2.5 Python 2 中的 print 語句

在Python 2中，print語句的語法稍有不同:

>>> python2.7
>>> print "Hello Python 2.7 world!" 
Hello Python 2.7 world!

在Python 2中，無需將要打印的內容放在括號內。從技術上說，Python 3中的print是一個函數，因此括號必不可少。有些Python 2 print語句也包含括號，但其行為與Python 3中稍有不同。簡單地說，在Python 2代碼中，有些print語句包含括號，有些不包含。

2.3 數字

2.3.1 整數

在Python中，可對整數執行加(+)減(-)乘(*)除(/)運算。

>>> 2 + 3 
5
>>> 3 - 2 
1
>>> 2 * 3 
6
>>> 3 / 2 
1.5

Python還支持運算次序，因此你可在同一個表達式中使用多種運算。你還可以使用括號來修改運算次序，讓Python按你指定的次序執行運算，如下所示:

>>> 2 + 3*4
14
>>> (2 + 3) * 4 20

2.3.2 浮點數

Python將帶小數點的數字都稱為浮點數。大多數編程語言都使用了這個術語，它指出了這樣一個事實:小數點可出現在數字的任何位置。

從很大程度上說，使用浮點數時都無需考慮其行為。你只需輸入要使用的數字，Python通常都會按你期望的方式處理它們:

>>> 0.1 + 0.1
0.2
>>> 0.2 + 0.2 9 0.4
>>>2 * 0.1
0.2
>>>2 * 0.2
0.4

但需要註意的是，結果包含的小數位數可能是不確定的:

>>> 0.2 + 0.1 
0.30000000000000004 
>>> 3 * 0.1 
0.30000000000000004

所有語言都存在這種問題，沒有什麽可擔心的。Python會盡力找到一種方式，以盡可能精確地表示結果，但鑒於計算機內部表示數字的方式，這在有些情況下很難。後面將會學習更多的處理方式。

2.3.3 使用函數str()避免類型錯誤

如果用數字跟字符串拼接，就會出現類型錯誤。為避免這個問題，可以使用?str()?將數字轉換為字符串再進行操作。

>>> age = 18
>>> print(‘my age is ‘ + age)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str
>>> print(‘my age is ‘ + str(age))
my age is 18

2.3.4 Python 2 中的整數

在Python 2中，將兩個整數相除得到的結果稍有不同:

>>> python2.7 
>>> 3 / 2
1

Python返回的結果為1，而不是1.5。在Python 2中，整數除法的結果只包含整數部分，小數部分被刪除。請註意，計算整數結果時，采取的方式不是四舍五入，而是將小數部分直接刪除。

在Python 2中，若要避免這種情況，務必確保至少有一個操作數為浮點數，這樣結果也將為浮點數:

>>> 3 / 2
1
>>> 3.0 / 2
1.5
>>> 3 / 2.0 
1.5
>>> 3.0 / 2.0 
1.5

從Python 3轉而用Python 2或從Python 2轉而用Python 3時，這種除法行為常常會令人迷惑。使用或編寫同時使用浮點數和整數的代碼時，一定要註意這種異常行為。

2.3.5 註釋

在Python中，註釋用井號(#)標識。井號後面的內容都會被Python解釋器忽略。如

# 向大家問好
print("Hello Python people!")

三、列表

列表由一系列按特定順序排列的元素組成。

在Python中，用方括號([])來表示列表，並用逗號來分隔其中的元素。

>>> list = []
>>> list.append(‘haha‘)
>>> list.append(‘heihei‘)
>>> list.append(‘hehe‘)
>>> list
[‘haha‘, ‘heihei‘, ‘hehe‘]
>>> list[0]
‘haha‘

獲取最後一個元素可以用 -1，如 list[-1] 是獲取最後一個元素，list[-2] 是獲取倒數第二個元素。

3.1 列表的增刪改查

3.1.1 修改元素

修改元素直接用索引修改

>>> list[0] = ‘nihao‘
>>> list
[‘nihao‘, ‘heihei‘, ‘hehe‘]

3.1.2 添加元素

可以在末尾添加，也可以在任意位置插入。

在末尾添加：append

>>> list.append(‘wa‘)
>>> list
[‘nihao‘, ‘heihei‘, ‘hehe‘, ‘wa‘]

插入：insert

>>> list.insert(1, ‘hello‘)
>>> list
[‘nihao‘, ‘hello‘, ‘heihei‘, ‘hehe‘, ‘wa‘]

3.1.3 刪除元素

刪除有三種方式：

del：按索引刪除
pop()：刪除列表最後一個元素並返回最後一個元素的值。也可以傳索引刪除任意位置的值。
remove()：按值刪除

>>> list
[‘nihao‘, ‘hello‘, ‘heihei‘, ‘hehe‘, ‘wa‘]
>>> del list[1]
>>> list
[‘nihao‘, ‘heihei‘, ‘hehe‘, ‘wa‘]
>>> list.pop()
‘wa‘
>>> list.remove(‘hehe‘)
>>> list
[‘nihao‘, ‘heihei‘]

給?pop()?傳索引刪除其他位置的值

>>> list
[‘nihao‘, ‘heihei‘]
>>> list.pop(0)
‘nihao‘
>>> list
[‘heihei‘]

註意：

方法remove()只刪除第一個指定的值。如果要刪除的值可能在列表中出現多次，就需要使用循環來判斷是否刪除了所有這樣的值。

如果你不確定該使用del語句還是pop()方法，下面是一個簡單的判斷標準:如果你要從列表中刪除一個元素，且不再以任何方式使用它，就使用del語句;如果你要在刪除元素後還能繼續使用它，就使用方法pop()。

3.2 組織列表

本節將介紹列表的排序、反轉、計算長度等操作。

列表的排序主要有兩種方式：

使用方法sort()對列表進行永久性排序
使用函數sorted()對列表進行臨時排序

3.2.1 使用方法sort()對列表進行永久性排序

使用?sort()?方法將改變原列表。如果要反轉排序，只需向sort()方法傳遞參數 reverse=True。

>>> list
[‘zhangsan‘, ‘lisi‘, ‘bob‘, ‘alex‘]
>>> list.sort()
>>> list
[‘alex‘, ‘bob‘, ‘lisi‘, ‘zhangsan‘]
>>> list.sort(reverse=True)
>>> list
[‘zhangsan‘, ‘lisi‘, ‘bob‘, ‘alex‘]

3.2.2 使用函數sorted()對列表進行臨時排序

函數?sorted()?讓你能夠按特定順序顯示列表元素，同時不影響它們在列表中的原始排列順序。

如果要反轉排序，只需向?sorted()?傳遞參數 reverse=True。

>>> list = [‘douglas‘,‘alex‘,‘solo‘,‘super‘]
>>> sorted(list)
[‘alex‘, ‘douglas‘, ‘solo‘, ‘super‘]
>>> list
[‘douglas‘, ‘alex‘, ‘solo‘, ‘super‘]
>>> sorted(list, reverse=True)
[‘super‘, ‘solo‘, ‘douglas‘, ‘alex‘]
>>> list
[‘douglas‘, ‘alex‘, ‘solo‘, ‘super‘]

3.2.3 反轉列表

要反轉列表元素的排列順序，可使用方法?reverse()。?reverse()?也會改變原始列表。

reverse()?只會按原來的順序反轉，不會進行額外的按字母排序。

>>> list
[‘douglas‘, ‘alex‘, ‘solo‘, ‘super‘]
>>> list.reverse()
>>> list
[‘super‘, ‘solo‘, ‘alex‘, ‘douglas‘]

3.2.4 確定列表的長度

使用函數len()可快速獲悉列表的長度。

>>> list
[‘super‘, ‘solo‘, ‘alex‘, ‘douglas‘]
>>> len(list)
4

3.3 操作列表

3.3.1 循環

使用?for…in?循環。

python 以縮進來區分代碼塊，所以需要正確的縮進

>>> cats
[‘super‘, ‘solo‘, ‘alex‘, ‘douglas‘]
>>> for cat in cats:
...     print(cat)
...
super
solo
alex
douglas

3.3.2 range()

Python函數range()讓你能夠輕松地生成一系列的數字。

>>> for value in range(1,5):
...     print(value)
...
1
2
3
4

註意：range() 會產生包含第一個參數但不包含第二個參數的一系列數值。

使用?range()?創建列表

>>> numbers = list(range(1,6))
>>> numbers
[1, 2, 3, 4, 5]

range()?還可以指定步長。下面的例子生成了從0開始，到11的偶數：

>>> nums = list(range(0,11,2))
>>> nums
[0, 2, 4, 6, 8, 10]

3.3.3 對列表簡單的計算

有幾個專門用於處理數字列表的Python函數。

min()：計算最小值
max()：計算最大值
sum()：計算總和

>>> numbers
[1, 2, 3, 4, 5]
>>> min(numbers)
1
>>> max(numbers)
5
>>> sum(numbers)
15

3.3.4 列表解析

列表解析將for循環和創建新元素的代碼合並成一行，並自動附加新元素。

>>> squares = [value**2 for value in range(1,11)]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

要使用這種語法，首先指定一個描述性的列表名，如squares;然後，指定一個左方括號，並定義一個表達式，用於生成你要存儲到列表中的值。在這個示例中，表達式為 value 2，它計算平方值。接下來，編寫一個for循環，用於給表達式提供值，再加上右方括號。在這個示例中， for循環為for value in range(1,11)，它將值1~10提供給表達式 value 2。請註意，這裏的for 語句末尾沒有冒號。

3.4 切片

要創建切片，可指定要使用的第一個元素和最後一個元素的索引。與函數range()一樣，Python在到達你指定的第二個索引前面的元素後停止。要輸出列表中的前三個元素，需要指定索引0~3，這將輸出分別為0、1和2的元素。

>>> names = [‘aa‘,‘bb‘,‘cc‘,‘dd‘]
>>> print(names[1:4])
[‘bb‘, ‘cc‘, ‘dd‘]

如果你沒有指定第一個索引，Python將自動從列表開頭開始:

>>> print(names[:4])
[‘aa‘, ‘bb‘, ‘cc‘, ‘dd‘]

如果沒有指定終止索引，將自動取到列表末尾

>>> print(names[2:])
[‘cc‘, ‘dd‘]

也可以使用負數索引，比如返回最後三個元素

>>> print(names[-3:])
[‘bb‘, ‘cc‘, ‘dd‘]

遍歷切片

>>> for name in names[1:3]:
...     print(name)
...
bb
cc

3.5 復制列表

可以使用切片來快速復制列表，不指定開始索引和結束索引。

>>> names
[‘aa‘, ‘bb‘, ‘cc‘, ‘dd‘]
>>> names2 = names[:]
>>> names2
[‘aa‘, ‘bb‘, ‘cc‘, ‘dd‘]

用切片復制出來的新列表，跟原來的列表是完全不同的列表，改變其實一個不會影響另一個列表。

>>> names.append(‘ee‘)
>>> names
[‘aa‘, ‘bb‘, ‘cc‘, ‘dd‘, ‘ee‘]
>>> names2
[‘aa‘, ‘bb‘, ‘cc‘, ‘dd‘]

而如果簡單的通過賦值將 names 賦值給 names2，就不能得到兩個列表，實際上它們都指向了同一個列表。如果改變其中一個，另一個也將被改變。

>>> names
[‘aa‘, ‘bb‘, ‘cc‘, ‘dd‘]
>>> names2 = names
>>> names2
[‘aa‘, ‘bb‘, ‘cc‘, ‘dd‘]
>>> names.append(‘ee‘)
>>> names
[‘aa‘, ‘bb‘, ‘cc‘, ‘dd‘, ‘ee‘]
>>> names2
[‘aa‘, ‘bb‘, ‘cc‘, ‘dd‘, ‘ee‘]

3.6 元組

Python將不能修改的值稱為不可變的，而不可變的列表被稱為元組。

元組看起來猶如列表，但使用圓括號而不是方括號來標識。定義元組後，就可以使用索引來訪問其元素，就像訪問列表元素一樣。

>>> food = (‘apple‘, ‘orange‘)
>>> food[0]
‘apple‘
>>> food[1]
‘orange‘
>>> food[1] = ‘banana‘
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: ‘tuple‘ object does not support item assignment

遍歷用法跟列表一致。

四、條件判斷

每條if語句的核心都是一個值為True或False的表達式，這種表達式被稱為條件測試。

檢查是否相等，用?==
檢查是否不相等，用?!=
數字比較?>、?<、?>=、?<=
多個條件與?and
多個條件或?or

判斷列表是否包含某元素?in

>>> names
[‘aa‘, ‘bb‘, ‘cc‘, ‘dd‘, ‘ee‘]
>>> ‘bb‘ in names
True

判斷列表是否不包含某元素

>>> names
[‘aa‘, ‘bb‘, ‘cc‘, ‘dd‘, ‘ee‘]
>>> ‘ff‘ not in names
True

if 語句

簡單的 if-else

>>> a = 10
>>> if a > 10:
...     print(‘hello‘)
... else:
...     print(‘bye‘)
...
bye

if-elif-else

>>> if a<5:
...     print(a<5)
... elif 5<a<10:
...     print(‘5<a<10‘)
... else:
...     print(‘a>10‘)
...
a>10

五、字典

在Python中，字典是一系列鍵-值對。每個鍵都與一個值相關聯，你可以使用鍵來訪問與之相關聯的值。與鍵相關聯的值可以是數字、字符串、列表乃至字典。事實上，可將任何Python對象用作字典中的值。

5.1 字典的增刪改查

使用字典

在Python中，字典用放在花括號{}中的一系列鍵-值對表示。

>>> user = {‘name‘:‘bob‘, ‘sex‘:‘male‘, ‘age‘:20}
>>> user
{‘name‘: ‘bob‘, ‘sex‘: ‘male‘, ‘age‘: 20}

訪問字典中的值

要獲取與鍵相關聯的值，可依次指定字典名和放在方括號內的鍵。

>>> user
{‘name‘: ‘bob‘, ‘sex‘: ‘male‘, ‘age‘: 20}
>>> user[‘name‘]
‘bob‘
>>> user[‘age‘]
20

添加鍵值對

字典是一種動態結構，可隨時在其中添加鍵—值對。

>>> user[‘city‘]=‘beijing‘
>>> user
{‘name‘: ‘bob‘, ‘sex‘: ‘male‘, ‘age‘: 20, ‘city‘: ‘beijing‘}

修改字典中的值

要修改字典中的值，可依次指定字典名、用方括號括起的鍵以及與該鍵相關聯的新值。

>>> cat = {}
>>> cat[‘color‘] = ‘white‘
>>> cat[‘age‘] = 4
>>> cat
{‘color‘: ‘white‘, ‘age‘: 4}
>>> cat[‘age‘] = 6
>>> cat
{‘color‘: ‘white‘, ‘age‘: 6}

刪除鍵值對

對於字典中不再需要的信息，可使用del語句將相應的鍵—值對徹底刪除。使用del語句時，必須指定字典名和要刪除的鍵。

>>> del cat[‘color‘]
>>> cat
{‘age‘: 6}

5.2 遍歷字典

字典可用於以各種方式存儲信息，因此有多種遍歷字典的方式:可遍歷字典的所有鍵—值對、鍵或值。

遍歷所有鍵值對?`items()`

>>> cat
{‘age‘: 6, ‘color‘: ‘white‘, ‘city‘: ‘beijing‘}
>>> for k,v in cat.items():
...     print(k + ‘-‘ + str(v))
...
age-6
color-white
city-beijing

通過?for k,v in cat.items()?的方式遍歷所有的鍵值對，k?代表鍵，v?代表值。

註意：即便遍歷字典時，鍵—值對的返回順序也與存儲順序不同。Python不關心鍵—值對的存儲順序，而只跟蹤鍵和值之間的關聯關系。

遍歷所有鍵?`keys()`

如果不需要用值，可以用?keys()?遍歷出所有的鍵。

>>> cat
{‘age‘: 6, ‘color‘: ‘white‘, ‘city‘: ‘beijing‘}
>>> for k in cat.keys():
...     print(k.title())
...
Age
Color
City

上面的例子打印出了?cat?的所有鍵，用字符串的?title()?方法使每個單詞的首字母大寫。

遍歷字典時會默認遍歷所有的鍵，for k in cat.keys()?和?for k in cat?的效果一樣。

按順序遍歷所有鍵，可用?sorted()?排序，這讓Python列出字典中的所有鍵，並在遍歷前對這個列表進行排序。

>>> for k in sorted(cat.keys()):
...     print(k.title())
...
Age
City
Color

遍歷所有值?`values()`

>>> for value in cat.values():
...     print(str(value))
...
6
white
beijing

如果需要剔除重復項，可以使用?set()

>>> cat
{‘age‘: 6, ‘color‘: ‘white‘, ‘city‘: ‘beijing‘, ‘city2‘: ‘beijing‘}
>>> for value in cat.values():
...     print(str(value))
...
6
white
beijing
beijing
>>> for value in set(cat.values()):
...     print(str(value))
...
beijing
white
6

5.3 嵌套

可以在列表中嵌套字典、在字典中嵌套列表以及在字典中嵌套字典。這裏就不演示了。

六、用戶輸入和while循環

6.1 用戶輸入

函數input()讓程序暫停運行，等待用戶輸入一些文本。獲取用戶輸入後，Python將其存儲在一個變量中，以方便你使用。

>>> msg = input(‘Please input your name: ‘)
Please input your name: solo
>>> msg
‘solo‘

如果你使用的是Python 2.7，應使用函數raw_input()來提示用戶輸入。這個函數與Python 3中的input()一樣，也將輸入解讀為字符串。

Python 2.7也包含函數input()，但它將用戶輸入解讀為Python代碼，並嘗試運行它們。如果你使用的是Python 2.7，請使用raw_input()而不是input()來獲取輸入。

如果想將輸入的內容轉換為數字，可以用?int()?來轉換。

6.2 while 循環

for循環用於針對集合中的每個元素都一個代碼塊，而while循環不斷地運行，直到指定的條件不滿足為止。

>>> num = 1
>>> while num <= 5:
...     print(str(num))
...     num += 1
...
1
2
3
4
5

break

要立即退出while循環，不再運行循環中余下的代碼，也不管條件測試的結果如何，可使用break語句。break語句用於控制程序流程，可使用它來控制哪些代碼行將執行，哪些代碼行不執行，從而讓程序按你的要求執行你要執行的代碼。

continue

要返回到循環開頭，並根據條件測試結果決定是否繼續執行循環，可使用continue語句，它不像 break 語句那樣不再執行余下的代碼並退出整個循環。

七、函數

Python 用關鍵字?def?來定義函數，函數名以冒號?:?結尾，冒號之後的縮進裏的內容都是函數體。

>>> def greet():
...     print(‘Hello World!‘)
...
>>> greet()
Hello World!

7.1 函數參數

可以向函數傳遞參數。下面的例子向函數?greet()?傳遞了個參數?name。其中?name?是形參，solo?是實參。

>>> def greet(name):
...     print(‘Hello,‘ + name)
...
>>> greet(‘solo‘)
Hello,solo

向函數傳遞實參的方式很多，可使用位置實參，這要求實參的順序與形參的順序相同;也可使用關鍵字實參，其中每個實參都由變量名和值組成;還可使用列表和字典。

位置實參

你調用函數時，Python必須將函數調用中的每個實參都關聯到函數定義中的一個形參。為此，最簡單的關聯方式是基於實參的順序。這種關聯方式被稱為位置實參。

>>> def student(name, age):
...     print(‘Hello, My name is ‘ + name + ‘, I am ‘ + str(age) + ‘ years old‘)
...
>>> student(‘solo‘, 18)
Hello, My name is solo, I am 18 years old

按照形參定義的順序傳遞的實參就稱為位置實參。

關鍵字實參

關鍵字實參是傳遞給函數的名稱—值對。關鍵字實參讓你無需考慮函數調用中的實參順序，還清楚地指出了函數調用中各個值的用途。

>>> student(age=18, name=‘solo‘)
Hello, My name is solo, I am 18 years old

接著位置實參中的例子，student(name, age)?方法第一個參數是?name，第二個參數是?age?。我們用關鍵字實參指明傳遞的是哪一個，即使順序寫亂了得到的結果也不會亂。

默認值

編寫函數時，可給每個形參指定默認值。在調用函數中給形參提供了實參時，Python將使用指定的實參值;否則，將使用形參的默認值。因此，給形參指定默認值後，可在函數調用中省略相應的實參。使用默認值可簡化函數調用，還可清楚地指出函數的典型用法。

>>> def student(name, age=18):
...     print(‘Hello, My name is ‘ + name + ‘, I am ‘ + str(age) + ‘ years old‘)
...
>>> student(‘bob‘)
Hello, My name is bob, I am 18 years old
>>> student(‘nicole‘)
Hello, My name is nicole, I am 18 years old
>>> student(‘bob‘, 20)
Hello, My name is bob, I am 20 years old

如上，給?student()?函數定義的第二個參數?age?設置了默認值?18，如果調用時只傳一個參數，無論傳的是什麽?age?都是 18。當傳兩個參數時，傳遞的實參就會覆蓋掉默認值。

註意：使用默認值時，在形參列表中必須先列出沒有默認值的形參，再列出有默認值的實參。這讓Python依然能夠正確地解讀位置實參。

7.2 返回值

函數並非總是直接顯示輸出，相反，它可以處理一些數據，並返回一個或一組值。函數返回的值被稱為返回值。在函數中，可使用return語句將值返回到調用函數的代碼行。返回值讓你能夠將程序的大部分繁重工作移到函數中去完成，從而簡化主程序。

>>> def student(name):
...     return name
...
>>> name = student(‘solo‘)
>>> name
‘solo‘

返回字典

函數可返回任何類型的值，包括列表和字典等較復雜的數據結構。例如，下面的函數接受姓名和年齡，並返回一個表示人的字典:

>>> def build_person(name,age):
...     person = {‘name‘:name, ‘age‘:age}
...     return person
...
>>> p = build_person(‘solo‘,18)
>>> p
{‘name‘: ‘solo‘, ‘age‘: 18}

7.3 傳遞任意數量的實參

有時候，你預先不知道函數需要接受多少個實參，好在Python允許函數從調用語句中收集任意數量的實參。

>>> def person(*args):
...     print(args)
...
>>> person(‘name‘,‘age‘,‘address‘)
(‘name‘, ‘age‘, ‘address‘)

上面定義了一個函數?person()?，只有一個形參?*args?。形參名?*args?中的星號讓 Python 創建一個名為?args?的空元組，並將收到的所有值都封裝到這個元組中。

結合使用位置實參和任意數量實參

如果要讓函數接受不同類型的實參，必須在函數定義中將接納任意數量實參的形參放在最後。Python 先匹配位置實參和關鍵字實參，再將余下的實參都收集到最後一個形參中。

>>> def person(city, *args):
...     print(‘city: ‘ + city + ‘, other args:‘)
...     for value in args:
...             print(value)
...
>>> person(‘beijing‘, ‘name‘, ‘age‘, ‘tel‘)
city: beijing, other args:
name
age
tel

函數?person()?有兩個形參，第一個?city?是普通的位置實參，第二個?*args?是可變參數。

使用任意數量的關鍵字實參

有時候，需要接受任意數量的實參，但預先不知道傳遞給函數的會是什麽樣的信息。在這種情況下，可將函數編寫成能夠接受任意數量的鍵—值對——調用語句提供了多少就接受多少。一個這樣的示例是創建用戶簡介:你知道你將收到有關用戶的信息，但不確定會是什麽樣的信息。

def build_profile(first, last, **user_info):
    profile = {}
    profile[‘first_name‘] = first
    profile[‘last_name‘] = last

    for key,value in user_info.items():
        profile[key] = value

    return profile

user = build_profile(‘steven‘, ‘bob‘, city=‘beijing‘, age=18)

print(user)

執行代碼，輸出結果是：

{‘first_name‘: ‘steven‘, ‘last_name‘: ‘bob‘, ‘city‘: ‘beijing‘, ‘age‘: 18}

7.4 導入導出

可以將函數存儲在被稱為模塊的獨立文件中，再將模塊導入到主程序中。import語句允許在當前運行的程序文件中使用模塊中的代碼。

7.4.1 導入整個模塊

模塊是擴展名為.py的文件，包含要導入到程序中的代碼。

cat.py

def eat(food):
    print(‘I am cat, I eat ‘ + food)

animal.py

import cat

cat.eat(‘fish‘)

控制臺輸出

I am cat, I eat fish

7.4.2 導入特定的函數

你還可以導入模塊中的特定函數，這種導入方法的語法如下:

from module_name import function_name

通過用逗號分隔函數名，可根據需要從模塊中導入任意數量的函數:

from module_name import function_0, function_1, function_2

上面的例子只導入?cat.py?中的?eat()?方法

from cat import eat

eat(‘fish‘)

得到相同的結果。

7.4.3 使用 as 給函數指定別名

如果要導入的函數的名稱可能與程序中現有的名稱沖突，或者函數的名稱太長，可指定簡短而獨一無二的別名——函數的另一個名稱，類似於外號。要給函數指定這種特殊外號，需要在導入它時這樣做。

from cat import eat as cat_eat

cat_eat(‘fish‘)

將?cat.py?中的?eat()?方法導入並指定了別名?cat_eat，使用時可以直接用別名使用。

7.4.4 使用 as 給模塊指定別名

你還可以給模塊指定別名。通過給模塊指定簡短的別名，讓你能夠更輕松地調用模塊中的函數。

通用語法：import module_name as mn

import cat as c

c.eat(‘fish‘)

7.4.5 導入模塊中的所有函數

使用星號(*)運算符可讓Python導入模塊中的所有函數:

cat.py

def eat(food):
    print(‘I am cat, I eat ‘ + food)

def run():
    print(‘cat run‘)

animal.py

from cat import *

eat(‘fish‘)
run()

輸出結果

I am cat, I eat fish
cat run

由於導入了每個函數，可通過名稱來調用每個函數，而無需使用句點表示法。然而，使用並非自己編寫的大型模塊時，最好不要采用這種導入方法:如果模塊中有函數的名稱與你的項目中使用的名稱相同，可能導致意想不到的結果: Python 可能遇到多個名稱相同的函數或變量，進而覆蓋函數，而不是分別導入所有的函數。

最佳的做法是，要麽只導入你需要使用的函數，要麽導入整個模塊並使用句點表示法。這能讓代碼更清晰，更容易閱讀和理解。

7.5 函數編寫指南

應給函數指定描述性名稱
函數名應只包含小寫字母和下劃線
每個函數都應包含簡要地闡述其功能的註釋，該註釋應緊跟在函數定義後面，並采用文檔字符串格式。
給形參指定默認值時，等號兩邊不要有空格:
```
def function_name(parameter_0, parameter_1=‘default value‘)
```
對於函數調用中的關鍵字實參，也應遵循這種約定:
```
function_name(value_0, parameter_1=‘value‘)
```
如果程序或模塊包含多個函數，可使用兩個空行將相鄰的函數分開，這樣將更容易知道前一個函數在什麽地方結束，下一個函數從什麽地方開始。
所有的import語句都應放在文件開頭，唯一例外的情形是，在文件開頭使用了註釋來描述整個程序。

八、類

8.1 創建和使用類

class Cat():
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def eat(self):
        print(‘cat ‘ + self.name + ‘ color ‘ + self.color + ‘, now eat‘)

    def run(self):
        print(‘cat ‘ + self.name + ‘ color ‘ + self.color + ‘, now run‘)

my_cat = Cat(‘Spring‘, ‘white‘)
print(my_cat.name)
print(my_cat.color)
my_cat.eat()
my_cat.run()

上面創建了類?Cat?，並實例化了?my_cat，然後調用了類的方法?eat()?和?run()。輸出結果：

Spring
white
cat Spring color white, now eat
cat Spring color white, now run

類中的函數稱為方法。__init__()?是函數的構造方法，每檔創建新實例時 Python 都會自動運行它。註意構造方法名字必須是這個，是規定好的。

上面的例子中__init__(self, name, color)?有三個形參，第一個形參?self?必不可少，還必須位於其他形參的前面。其他的形參可以根據需要調整。self?是一個指向實例本身的引用，讓實例能夠訪問類中的屬性和方法。

還可以通過實例直接訪問屬性：my_cat.name。但在其他語言中並不建議這樣做。

在Python 2.7中創建類

在Python 2.7中創建類時，需要做細微的修改——在括號內包含單詞object:

class ClassName(object):

8.2 類的屬性

8.2.1 給屬性設置默認值

類中的每個屬性都必須有初始值，哪怕這個值是0或空字符串。在有些情況下，如設置默認值時，在方法__init__()?內指定這種初始值是可行的;如果你對某個屬性這樣做了，就無需包含為它提供初始值的形參。

重新定義?Cat?，在構造方法中給屬性?age?設置默認值。

class Cat():
    def __init__(self, name, color):
        self.name = name
        self.color = color
        self.age = 3

    def eat(self):
        print(‘cat ‘ + self.name + ‘ color ‘ + self.color + ‘, now eat‘)

    def run(self):
        print(‘cat ‘ + self.name + ‘ color ‘ + self.color + ‘, now run‘)

    def print_age(self):
        print(‘cat`s age is ‘ + str(self.age))

8.2.2 修改屬性的值

可以以三種不同的方式修改屬性的值：直接通過實例進行修改，通過方法進行設置。

1. 直接修改屬性的值

要修改屬性的值，最簡單的方式是通過實例直接訪問它。

class Cat():
    def __init__(self, name, color):
        self.name = name
        self.color = color
        self.age = 3

    def eat(self):
        print(‘cat ‘ + self.name + ‘ color ‘ + self.color + ‘, now eat‘)

    def run(self):
        print(‘cat ‘ + self.name + ‘ color ‘ + self.color + ‘, now run‘)

    def print_age(self):
        print(‘cat`s age is ‘ + str(self.age))

my_cat = Cat(‘Spring‘, ‘white‘)

my_cat.print_age()
my_cat.age = 4
my_cat.print_age()

輸出結果為

cat`s age is 3
cat`s age is 4
復制代碼

上例直接通過?my_cat.age = 4?修改了?age?屬性的值。

2. 通過方法修改屬性的值

再來更新代碼，加入?update_age()?方法來修改?age?的屬性。

class Cat():
    def __init__(self, name, color):
        self.name = name
        self.color = color
        self.age = 3

    def eat(self):
        print(‘cat ‘ + self.name + ‘ color ‘ + self.color + ‘, now eat‘)

    def run(self):
        print(‘cat ‘ + self.name + ‘ color ‘ + self.color + ‘, now run‘)

    def print_age(self):
        print(‘cat`s age is ‘ + str(self.age))

    def update_age(self, age):
        self.age = age

my_cat = Cat(‘Spring‘, ‘white‘)
my_cat.print_age()
my_cat.update_age(10)
my_cat.print_age()

運行代碼輸出：

cat`s age is 3
cat`s age is 10

8.3 繼承

一個類繼承另一個類時，它將自動獲得另一個類的所有屬性和方法;原有的類稱為父類，而新類稱為子類。子類繼承了其父類的所有屬性和方法，同時還可以定義自己的屬性和方法。

class Animal():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def run(self):
        print(‘Animal ‘ + self.name + ‘ run‘)

class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)

cat = Cat(‘Tony‘, 2)
cat.run()

運行程序，輸出：

Animal Tony run

先定義了類?Animal，又定義了?Cat?繼承自?Animal。?Animal稱為父類，?Cat?稱為子類。通過輸出可以驗證，子類繼承了父類的方法。

在子類的構造方法中要先實現父類的構造方法：super().__init__(name, age)。

還可以給子類定義自己的方法，或者重寫父類的方法。

class Animal():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def run(self):
        print(‘Animal ‘ + self.name + ‘ run‘)

class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)

    def play(self):
        print(‘Cat ‘ + self.name + ‘ play‘)

    def run(self):
        print(‘Cat ‘ + self.name + ‘ run‘)

cat = Cat(‘Tony‘, 2)
cat.run()
cat.play()

我們來修改下程序，Animal?類不變，Cat?類還是繼承了?Animal?，但定義了自己的方法?play()?並重寫了父類方法?run()?。運行程序，得到輸出：

Cat Tony run
Cat Tony play

Python2.7 中的繼承

在Python 2.7中，繼承語法稍有不同，ElectricCar類的定義類似於下面這樣:

class Car(object):
    def __init__(self, make, model, year):
        --snip--

class ElectricCar(Car):
    def __init__(self, make, model, year):
        super(ElectricCar, self).__init__(make, model, year)
        --snip--

函數super()需要兩個實參:子類名和對象self。為幫助Python將父類和子類關聯起來，這些實參必不可少。另外，在Python 2.7中使用繼承時，務必在定義父類時在括號內指定object。

8.4 導入類

當一個文件過長時，可以將其中一部分代碼抽離出去，然後導入到主文件中。

導入方式有多種：

導入單個類

假如?car.py?裏定義了類?Car
```
from car import Car
```
從一個模塊中導入多個類

假如?car.py?包含了三個類?Car?，?Battery?和?ElectricCar?。

只導入一個類：
```
from car import ElectricCar
```
導入多個類，中間用逗號隔開：
```
from car import Car, ElectricCar
```
導入整個模塊

還可以導入整個模塊，再使用句點表示法訪問需要的類。這種導入方法很簡單，代碼也易於閱讀。由於創建類實例的代碼都包含模塊名，因此不會與當前文件使用的任何名稱發生沖突。
```
import car
my_car = car.Car()
```
導入模塊中的所有類

要導入模塊中的每個類，可使用下面的語法:
```
from module_name import *
```
不推薦使用這種導入方式，其原因有二。

首先，如果只要看一下文件開頭的import語句，就能清楚地知道程序使用了哪些類，將大有裨益;但這種導入方式沒有明確地指出你使用了模塊中的哪些類。這種導入方式還可能引發名稱方面的困惑。如果你不小心導入了一個與程序文件中其他東西同名的類，將引發難以診斷的錯誤。這裏之所以介紹這種導入方式，是因為雖然不推薦使用這種方式，但你可能會在別人編寫的代碼中見到它。

需要從一個模塊中導入很多類時，最好導入整個模塊，並使用module_name.class_name語法來訪問類。這樣做時，雖然文件開頭並沒有列出用到的所有類，但你清楚地知道在程序的哪些地方使用了導入的模塊;你還避免了導入模塊中的每個類可能引發的名稱沖突。

九、文件和異常

9.1 從文件中讀取數據

要使用文本文件中的信息，首先需要將信息讀取到內存中。為此，你可以一次性讀取文件的全部內容，也可以以每次一行的方式逐步讀取。

9.1.1 讀取整個文件

with open(‘test.txt‘) as file_obj:
    contents = file_obj.read()
    print(contents)

open()?用於打開一個文件，參數為文件的路徑。

關鍵字?with?在不再需要訪問文件後將其關閉。有了?with?你只管打開文件，並在需要時使用它，Python自會在合適的時候自動將其關閉。

相比於原始文件，該輸出唯一不同的地方是末尾多了一個空行。為何會多出這個空行呢?因為?read()?到達文件末尾時返回一個空字符串，而將這個空字符串顯示出來時就是一個空行。要刪除多出來的空行，可在print語句中使用?rstrip()。

文件路徑可以是相對路徑，也可以是絕對路徑。

9.1.2 逐行讀取

with open(‘test.txt‘) as file_obj:
    for line in file_obj:
        print(line.rstrip())

要以每次一行的方式檢查文件，可對文件對象使用for循環。

9.2 寫入文件

with open(‘test.txt‘, ‘w‘) as file_obj:
    file_obj.write("I love python")

在這個示例中，調用open()時提供了兩個實參，第一個實參也是要打開的文件的名稱；第二個實參(‘w‘)告訴Python，我們要以寫入模式打開這個文件。

可選模式：

r?：只讀。
w?: 只寫。如果文件不存在則創建，如果文件存在則先清空，再寫入。
a?：附加模式，寫入的內容追加到原始文件後面。如果文件不存在則創建。
r+?：可讀可寫。

如果你省略了模式實參，Python將以默認的只讀模式打開文件。

9.3 異常

異常是使用try-except代碼塊處理的。try-except代碼塊讓Python執行指定的操作，同時告訴Python發生異常時怎麽辦。

try:
    print(5/0)
except ZeroDivisionError:
    print("You can‘t divide by zero!")

else 代碼塊

try:
    print(5/0)
except ZeroDivisionError:
    print("You can‘t divide by zero!")
else:
    print("no exception")

如果?try?中的代碼運行成功，沒有出現異常，則執行?else?代碼塊中的代碼。

9.4 用 json 存儲數據

Python 中使用?json.dump()?和?json.load()?來存儲和讀取 json 文件。

import json

userInfo = {‘username‘: ‘jack‘, ‘age‘: 18}

with open(‘test.txt‘, ‘w‘) as obj:
    json.dump(userInfo, obj)

with open(‘test.txt‘) as obj:
    content = json.load(obj)
    print(content)

上例中用?json.dump()?把數據存入到了?test.txt?中，又用?json.load()?把數據從文件中取出並打印。

註意使用前先導入 json 模塊。

十、單元測試

先定義一個拼接名字的函數?name_function.py

def get_formatted_name(first, last):
    full_name = first + ‘ ‘ + last
    return full_name.title()

再寫測試類來測試這個函數

import unittest
from name_function import get_formatted_name

class NamesTestCase(unittest.TestCase):

    def test_name_function(self):
        full_name = get_formatted_name(‘david‘, ‘alex‘)
        self.assertEqual(full_name, ‘David Alex‘)

unittest.main()

測試類要繼承?unittest.TestCase?，通過?self.assertEqual?斷言是否得到的結果和預期相等。

常見的斷言方法

方法	用途
assertEqual(a, b)	核實a == b
assertNotEqual(a, b)	核實a != b
assertTrue(x)	核實x為True
assertFalse(x)	核實x為False
assertIn(item, list)	核實item在list中
assertNotIn(item, list)	核實item不在list中

`setUp()`?方法

如果你在TestCase類中包含了方法?setUp()?，Python將先運行它，再運行各個以test_打頭的方法。

通常用於做一些初始化操作。

十分鐘快速入門 Python，看完即會，不用收藏！

win 等待變量命名 json stdin 要求收藏初始化 mage 本文以 Eric Matthes 的《Python編程：從入門到實踐》為基礎，以有一定其他語言經驗的程序員視角，對書中內容提煉總結，化繁為簡，將這本書的精髓融合成一篇10分鐘能讀完的文章。讀完本篇

十分鐘快速入門 Python，看完即會，不用收藏！

一、安裝與運行

命令行運行 python 文件

二、變量和簡單數據類型

2.1 變量命名規則

2.2 字符串

2.2.1 字符串的簡單運算

title()

upper()、lower()

2.2.2 合並（拼接）字符串

2.2.3 使用制表符或換行符來添加空白

2.2.4 刪除空白

2.2.5 Python 2 中的 print 語句

2.3 數字

2.3.1 整數

2.3.2 浮點數

2.3.3 使用函數str()避免類型錯誤

2.3.4 Python 2 中的整數

2.3.5 註釋

三、列表

3.1 列表的增刪改查

3.1.1 修改元素

3.1.2 添加元素

3.1.3 刪除元素

3.2 組織列表

3.2.1 使用方法sort()對列表進行永久性排序

3.2.2 使用函數sorted()對列表進行臨時排序

3.2.3 反轉列表

3.2.4 確定列表的長度

3.3 操作列表

3.3.1 循環

3.3.2 range()

3.3.3 對列表簡單的計算

3.3.4 列表解析

3.4 切片

3.5 復制列表

3.6 元組

四、條件判斷

if 語句

五、字典

5.1 字典的增刪改查

使用字典

訪問字典中的值

添加鍵值對

修改字典中的值

刪除鍵值對

5.2 遍歷字典

遍歷所有鍵值對?items()

遍歷所有鍵?keys()

遍歷所有值?values()

5.3 嵌套

六、用戶輸入和while循環

6.1 用戶輸入

6.2 while 循環

break

continue

七、函數

7.1 函數參數

位置實參

關鍵字實參

默認值

7.2 返回值

返回字典

7.3 傳遞任意數量的實參

結合使用位置實參和任意數量實參

使用任意數量的關鍵字實參

7.4 導入導出

7.4.1 導入整個模塊

7.4.2 導入特定的函數

7.4.3 使用 as 給函數指定別名

7.4.4 使用 as 給模塊指定別名

7.4.5 導入模塊中的所有函數

7.5 函數編寫指南

八、類

8.1 創建和使用類

在Python 2.7中創建類

8.2 類的屬性

8.2.1 給屬性設置默認值

8.2.2 修改屬性的值

1. 直接修改屬性的值

遍歷所有鍵值對?`items()`

遍歷所有鍵?`keys()`

遍歷所有值?`values()`

`setUp()`?方法