第1章 基礎知識
1.0 Python是一種怎樣的語言
- Python是一門跨平台、開源、免費的解釋型高級動態編程語言，支持偽編譯將Python源程序轉換為位元組碼來優化程序和提高運行速度，支持使用py2exe、pyinstaller或cx_Freeze工具將Python程序轉換為二進制可執行文件。
- Python支持命令式編程、函數式編程，完全支持面向對象程序設計，語法簡潔清晰，擁有大量的幾乎支持所有領域應用開發的成熟擴展庫。
- 膠水語言：可以把多種不同語言編寫的程序融合到一起實現無縫拼接，更好地發揮不同語言和工具的優勢，滿足不同應用領域的需求。
1.1 如何選擇Python版本
- 3.x：必然的趨勢，已經開始全面普及
- 多版本共存與切換簡便方法：更改系統環境變量path
1.2 Python安裝與簡單使用
幾個重要網址
- //www.python.org/
- //www.python.org/doc/
- //bugs.python.org/
- //hackerone.com/python
- //stackoverflow.com/questions/tagged/python
默認編程環境：IDLE，其他常用開發環境：
- Eclipse+PyDev
- pyCharm
- wingIDE
- Eric
- PythonWin
- Anaconda
在IDLE中，如果使用交互式編程模式，那麼直接在提示符「>>>」後面輸入相應的命令並回車執行即可，如果執行順利的話，馬上就可以看到執行結果，否則會拋出異常。
>>> 3+5
8
>>> import math
>>> math.sqrt(9)
3.0
>>> 3*(2+6)
24
>>> 2/0
Traceback (most recent call last):
File "<pyshell#18>", line 1, in <module>
2/0
ZeroDivisionError: integer division or modulo by zero
View Code
1.3 使用pip管理第三方包
- pip 工具常用命令（參考）
- 在IDLE環境下，快捷鍵
1.4 變量
1.4.1 Python的對象模型
1.4.2 Python變量
- 在Python中，不需要事先聲明變量名及其類型，直接賦值即可創建各種類型的對象變量。
#例如語句
>>> x = 3
#創建了整型變量x，並賦值為3，再例如語句
>>> x = 'Hello world.'
#創建了字符串變量x，並賦值為'Hello world.'。
View Code
- Python屬於強類型編程語言，Python解釋器會根據賦值或運算來自動推斷變量類型。Python還是一種動態類型語言，變量的類型也是可以隨時變化的。
>>> x = 3
>>> print(type(x))
<class 'int'>
>>> x = 'Hello world.'
>>> print(type(x)) #查看變量類型
<class 'str'>
>>> x = [1,2,3]
>>> print(type(x))
<class 'list'>
>>> isinstance(3, int) #測試對象是否是某個類型的實例
True
>>> isinstance('Hello world', str)
True
View Code
- 如果變量出現在賦值運算符或複合賦值運算符（例如+=、*=等等）的左邊則表示創建變量或修改變量的值，否則表示引用該變量的值。
>>> x = 3 #創建整型變量
>>> print(x**2)
9
>>> x += 6 #修改變量值
>>> print(x) #讀取變量值並輸出顯示
9
>>> x = [1,2,3] #創建列表對象
>>> x[1] = 5 #修改列表元素值
>>> print(x) #輸出顯示整個列表
[1, 5, 3]
>>> print(x[2]) #輸出顯示列表指定元素
3
View Code
- 字符串和元組屬於不可變序列，不能通過下標的方式來修改其中的元素值，試圖修改元組中元素的值時會拋出異常。
>>> x = (1,2,3)
>>> print(x)
(1, 2, 3)
>>> x[1] = 5
Traceback (most recent call last):
File "<pyshell#7>", line 1, in <module>
x[1] = 5
TypeError: 'tuple' object does not support item assignment
View Code
- 在Python中，允許多個變量指向同一個值，例如：
>>> x = 3
>>> id(x)
1786684560
>>> y = x
>>> id(y)
1786684560
View Code
- 當其中一個變量修改值以後，其內存地址將會變化，但這並不影響另一個變量，例如接着上面的代碼再繼續執行下面的代碼：
>>> x += 6
>>> id(x)
1786684752
>>> y
3
>>> id(y)
1786684560
View Code
- Python採用的是基於值的內存管理方式，如果為不同變量賦值為相同值，這個值在內存中只有一份，多個變量指向同一塊內存地址。
- Python具有自動內存管理功能，對於沒有任何變量指向的值，Python自動將其刪除。Python會跟蹤所有的值，並自動刪除不再有變量指向的值。
- 在定義變量名的時候，需要注意以下問題：
-
- 變量名必須以字母或下劃線開頭，但以下劃線開頭的變量在Python中有特殊含義；
- 變量名中不能有空格以及標點符號（括號、引號、逗號、斜線、反斜線、冒號、句號、問號等等）；
- 不能使用關鍵字作變量名，可以導入keyword模塊後使用print(keyword.kwlist)查看所有Python關鍵字；
- 不建議使用系統內置的模塊名、類型名或函數名以及已導入的模塊名及其成員名作變量名，這將會改變其類型和含義，可以通過dir(__builtins__)查看所有內置模塊、類型和函數；
- 變量名對英文字母的大小寫敏感，例如student和Student是不同的變量。
1.4.3 數字
- 數字是不可變對象，可以表示任意大小的數字。
>>> a=99999999999999999999999999999999
>>> a*a
9999999999999999999999999999999800000000000000000000000000000001
>>> a**3
999999999999999999999999999999970000000000000000000000000000000299999999999999999999999999999999
View Code
- Python的IDEL交互界面可以當做簡便計算器來使用。
>>> ((3**2) + (4**2)) ** 0.5
5.0
View Code
- Python中的整數類型可以分為：浮點數又稱小數浮點數又稱小數
- 十進制整數如，0、-1、9、123
- 十六進制整數，需要16個數字0、1、2、3、4、5、6、7、8、9、a、b、c、d、e、f來表示整數，必須以0x開頭，如0x10、0xfa、0xabcdef
- 八進制整數，只需要8個數字0、1、2、3、4、5、6、7來表示整數，必須以0o開頭，如0o35、0o11
- 二進制整數，只需要2個數字0、1來表示整數，必須以0b開頭如，0b101、0b100
15.0、0.37、-11.2、1.2e2、314.15e-2
- Python內置支持複數類型。
>>> a = 3+4j
>>> b = 5+6j
>>> c = a+b
>>> c
(8+10j)
>>> c.real #查看複數實部
8.0
>>> c.imag #查看複數虛部
10.0
>>> a.conjugate() #返回共軛複數
(3-4j)
>>> a*b #複數乘法
(-9+38j)
>>> a/b #複數除法
(0.6393442622950819+0.03278688524590165j)
View Code
1.4.4 字符串
- 用單引號、雙引號或三引號括起來的符號系列稱為字符串
- 單引號、雙引號、三單引號、三雙引號可以互相嵌套，用來表示複雜字符串，如：’abc’、’123’、’中國’、”Python”、”’Tom said, “Let’s go””’
- 字符串屬於不可變序列
- 空串表示為”或 “”
- 三引號”’或”””表示的字符串可以換行，支持排版較為複雜的字符串；三引號還可以在程序中表示較長的注釋。
- 字符串合併
>>> a = 'abc' + '123' #生成新對象
View Code
- 字符串格式化
>>> a = 3.6674
>>> '%7.3f' % a
' 3.667'
>>> "%d:%c"%(65,65)
'65:A'
>>> """My name is %s, and my age is %d""" % ('Dong Fuguo',39)
'My name is Dong Fuguo, and my age is 39'
View Code
- 常用轉義字符
- 轉義字符用法
>>> print('Hello\nWorld') #包含轉義字符的字符串
Hello
World
>>> print('\101') #三位八進制數對應的字符
A
>>> print('\x41') #兩位十六進制數對應的字符
A
>>> print('我是\u8463\u4ed8\u56fd') #四位十六進制數表示的Unicode字符
我是董付國
View Code
- 字符串界定符前面加字母 r 表示原始字符串，其中的特殊字符不進行轉義，但字符串的最後一個字符不能是 \ 。
>>> path = 'C:\Windows\notepad.exe'
>>> print(path) #字符\n被轉義為換行符
C:\Windows
otepad.exe
>>> path = r'C:\Windows\notepad.exe' #原始字符串，任何字符都不轉義
>>> print(path)
C:\Windows\notepad.exe
View Code
1.4.5 運算符和表達式
- +運算符除了用於算術加法以外，還可以用於列表、元組、字符串的連接，但不支持不同類型的對象之間相加或連接。
>>> [1, 2, 3] + [4, 5, 6] #連接兩個列表
[1, 2, 3, 4, 5, 6]
>>> (1, 2, 3) + (4,) #連接兩個元組
(1, 2, 3, 4)
>>> 'abcd' + '1234' #連接兩個字符串
'abcd1234'
>>> 'A' + 1 #不支持字符與數字相加，拋出異常
TypeError: Can't convert 'int' object to str implicitly
>>> True + 3 #Python內部把True當作1處理
4
>>> False + 3 #把False當作0處理
3
View Code
- *運算符不僅可以用於數值乘法，還可以用於列表、字符串、元組等類型，當列表、字符串或元組等類型變量與整數進行 「*」 運算時，表示對內容進行重複並返回重複後的新對象。
>>> 2.0 * 3 #浮點數與整數相乘
6.0
>>> (3+4j) * 2 #複數與整數相乘
(6+8j)
>>> (3+4j) * (3-4j) #複數與複數相乘
(25+0j)
>>> "a" * 10 #字符串重複
'aaaaaaaaaa'
>>> [1,2,3] * 3 #列表重複
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> (1,2,3) * 3 #元組重複
(1, 2, 3, 1, 2, 3, 1, 2, 3)
View Code
Python中的除法有兩種，「/」 和 「//」 分別表示除法和整除運算，並且Python 2.x和Python 3.x對「/」運算符的解釋也略有區別。在Python 3.5.2中運算結果如下：
>>> 3/5
0.6
>>> 3//5
0
>>> 3.0/5
0.6
>>> 3.0//5
0.0
>>> 13//10
1
>>> -13//10
-2
View Code
上面的表達式在Python 2.7.12中運算結果如下：
>>> 3/5
0
>>> 3//5
0
>>> 3.0/5
0.6
>>> 3.0//5
0.0
>>> 13//10
1
>>> -13//10
-2
View Code
- %運算符除去可以用於字符串格式化之外，還可以對整數和浮點數計算餘數。但是由於浮點數的精確度影響，計算結果可能略有誤差。
>>> 3.1%2
1.1
>>> 6.3%2.1
2.0999999999999996
>>> 6%2
0
>>> 6.0%2
0.0
>>> 6.0%2.0
0.0
>>> 5.7%4.8
0.9000000000000004
View Code
- 關係運算符可以連用
>>> 1 < 3 < 5 #等價於1 < 3 and 3 < 5
True
>>> 'Hello' > 'world' #比較字符串大小
False
>>> [1, 2, 3] < [1, 2, 4] #比較列表大小
True
>>> 'Hello' > 3 #字符串和數字不能比較
TypeError: unorderable types: str() > int()
>>> {1, 2, 3} < {1, 2, 3, 4} #測試是否子集
View Code
- 成員測試運算符 in 用於成員測試，即測試一個對象是否為另一個對象的元素。
>>> 3 in [1, 2, 3] #測試3是否存在於列表[1, 2, 3]中
True
>>> 5 in range(1, 10, 1) #range()是用來生成指定範圍數字的內置函數
True
>>> 'abc' in 'abcdefg' #子字符串測試
True
>>> for i in (3, 5, 7): #循環，成員遍歷
print(i, end='\t')
3 5 7
View Code
- 同一性測試運算符（identity comparison）is用來測試兩個對象是否是同一個，如果是則返回True，否則返回False。如果兩個對象是同一個，二者具有相同的內存地址。
>>> 3 is 3
True
>>> x = [300, 300, 300]
>>> x[0] is x[1] #基於值的內存管理，同一個值在內存中只有一份
True
>>> x = [1, 2, 3]
>>> y = [1, 2, 3]
>>> x is y #上面形式創建的x和y不是同一個列表對象
False
View Code
- 位運算符只能用於整數，其內部執行過程為：首先將整數轉換為二進制數，然後右對齊，必要的時候左側補0，按位進行運算，最後再把計算結果轉換為十進制數字返回
>>> 3 << 2 #把3左移2位
12
>>> 3 & 7 #位與運算
3
>>> 3 | 8 #位或運算
11
>>> 3 ^ 5 #位異或運算
6
View Code
- 集合的交集、並集、對稱差集等運算藉助於位運算符來實現，而差集則使用減號運算符實現（注意，並集運算符不是加號）。
>>> {1, 2, 3} | {3, 4, 5} #並集，自動去除重複元素
{1, 2, 3, 4, 5}
>>> {1, 2, 3} & {3, 4, 5} #交集
{3}
>>> {1, 2, 3} ^ {3, 4, 5} #對稱差集
{1, 2, 4, 5}
>>> {1, 2, 3} - {3, 4, 5} #差集
{1, 2}
View Code
- 邏輯運算符 and 和 or 具有惰性求值特點。
>>> 3>5 and a>3 #注意，此時並沒有定義變量a
False
>>> 3>5 or a>3 #3>5的值為False，所以需要計算後面表達式
NameError: name 'a' is not defined
>>> 3<5 or a>3 #3<5的值為True，不需要計算後面表達式
True
>>> 3 and 5 #最後一個計算的表達式的值作為整個表達式的值
5
>>> 3 and 5>2
True
>>> 3 not in [1, 2, 3] #邏輯非運算not
False
>>> 3 is not 5 #not的計算結果只能是True或False之一
True
View Code
- 矩陣相乘運算符@
>>> import numpy #numpy是用於科學計算的Python擴展庫
>>> x = numpy.ones(3) #ones()函數用於生成全1矩陣
>>> m = numpy.eye(3)*3 #eye()函數用於生成單位矩陣
>>> m[0,2] = 5 #設置矩陣指定位置上元素的值
>>> m[2, 0] =3
>>> x @ m #矩陣相乘
array([ 6., 3., 8.])
View Code
- 逗號並不是運算符，只是一個普通分隔符。
>>> 'a' in 'b', 'a'
(False, 'a')
>>> 'a' in ('b', 'a')
True
>>> x = 3, 5
>>> x
(3, 5)
>>> 3 == 3, 5
(True, 5)
>>> x = 3+5, 7
>>> x
(8, 7)
View Code
- 單個任何類型的對象或常數屬於合法表達式，使用運算符連接的變量和常量以及函數調用的任意組合也屬於合法的表達式。
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = a + b
>>> c
[1, 2, 3, 4, 5, 6]
>>> d = list(map(str, c))
>>> d
['1', '2', '3', '4', '5', '6']
>>> import math
>>> list(map(math.sin, c))
[0.8414709848078965, 0.9092974268256817, 0.1411200080598672, -0.7568024953079282, -0.9589242746631385, -0.27941549819892586]
>>> 'Hello' + ' ' + 'world'
'Hello world'
>>> 'welcome ' * 3
'welcome welcome welcome '
>>> ('welcome,'*3).rstrip(',')+'!'
'welcome,welcome,welcome!'
View Code
1.4.6 常用內置函數
- 內置函數不需要導入任何模塊即可使用
- 執行下面的命令可以列出所有內置函數
>>> dir(__builtins__)
View Code
- dir() 函數可以查看指定模塊中包含的所有成員或者指定對象類型所支持的操作。
- help() 函數則返回指定模塊或函數的說明文檔。
- ord() 和 chr() 是一對功能相反的函數，ord() 用來返回單個字符的序數或Unicode碼，而 chr() 則用來返回某序數對應的字符，str()則直接將其任意類型參數轉換為字符串。
>>> ord('a')
97
>>> chr(65)
'A'
>>> chr(ord('A')+1)
'B'
>>> str(1)
'1'
>>> str(1234)
'1234'
>>> str([1,2,3])
'[1, 2, 3]'
>>> str((1,2,3))
'(1, 2, 3)'
>>> str({1,2,3})
'set([1, 2, 3])'
View Code
- max()、min()、sum() 這三個內置函數分別用於計算列表、元組或其他可迭代對象中所有元素最大值、最小值以及所有元素之和，sum() 要求元素支持加法運算，max() 和 min() 則要求序列或可迭代對象中的元素之間可比較大小。
>>> import random
>>> a = [random.randint(1,100) for i in range(10)] #列表推導式
>>> a
[72, 26, 80, 65, 34, 86, 19, 74, 52, 40]
>>> print(max(a), min(a), sum(a))
86 19 548
View Code
- 如果需要計算該列表中的所有元素的平均值，可以直接這樣用：
>>> sum(a)*1.0/len(a) #Python 2.7.12
54.8
>>> sum(a)/len(a) #Python 3.5.2
54.8
View Code
- 內置函數 max() 和 min() 的 key 參數可以用來指定比較規則
>>> x = ['21', '1234', '9']
>>> max(x)
'9'
>>> max(x, key=len)
'1234'
>>> max(x, key=int)
'1234'
View Code
- 內置函數 type() 和 isinstance() 可以判斷數據類型。
>>> type([3]) #查看[3]的類型
<class 'list'>
>>> type({3}) in (list, tuple, dict) #判斷{3}是否為list,tuple或dict類型的實例
False
>>> isinstance(3, int) #判斷3是否為int類型的實例
True
>>> isinstance(3j, (int, float, complex)) #判斷3是否為int,float或complex類型
True
View Code
- sorted() 對列表、元組、字典、集合或其他可迭代對象進行排序並返回新列表，reversed()對可迭代對象（生成器對象和具有惰性求值特性的zip、map、filter、enumerate等類似對象除外）進行翻轉（首尾交換）並返回可迭代的reversed對象。
>>> x = ['aaaa', 'bc', 'd', 'b', 'ba']
>>> sorted(x, key=lambda item: (len(item), item))
#先按長度排序，長度一樣的正常排序
['b', 'd', 'ba', 'bc', 'aaaa']
>>> reversed(x) #逆序，返回reversed對象
<list_reverseiterator object at 0x0000000003089E48>
>>> list(reversed(x)) #reversed對象是可迭代的
[5, 1, 9, 3, 8, 7, 10, 6, 0, 4, 2]
View Code
- enumerate() 函數用來枚舉可迭代對象中的元素，返回可迭代的 enumerate 對象，其中每個元素都是包含索引和值的元組。
>>> list(enumerate('abcd')) #枚舉字符串中的元素
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> list(enumerate(['Python', 'Greate'])) #枚舉列表中的元素
[(0, 'Python'), (1, 'Greate')]
>>> list(enumerate({'a':97, 'b':98, 'c':99}.items())) #枚舉字典中的元素
[(0, ('c', 99)), (1, ('a', 97)), (2, ('b', 98))]
>>> for index, value in enumerate(range(10, 15)): #枚舉range對象中的元素
print((index, value), end=' ')
(0, 10) (1, 11) (2, 12) (3, 13) (4, 14)
View Code
- 內置函數 map() 把一個函數func依次映射到序列或迭代器對象的每個元素上，並返回一個可迭代的 map 對象作為結果，map對象中每個元素是原序列中元素經過函數func處理後的結果。
>>> list(map(str, range(5))) #把列表中元素轉換為字符串
['0', '1', '2', '3', '4']
>>> def add5(v): #單參數函數
return v+5
>>> list(map(add5, range(10))) #把單參數函數映射到一個序列的所有元素
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> def add(x, y): #可以接收2個參數的函數
return x+y
>>> list(map(add, range(5), range(5,10))) #把雙參數函數映射到兩個序列上
[5, 7, 9, 11, 13]
View Code
- 標準庫functools中的函數reduce()可以將一個接收2個參數的函數以迭代累積的方式從左到右依次作用到一個序列或迭代器對象的所有元素上，並且允許指定一個初始值。
>>> from functools import reduce
>>> seq = list(range(1, 10))
>>> reduce(lambda x, y: x+y, seq)
45
View Code
- 內置函數 filter() 將一個單參數函數作用到一個序列上，返回該序列中使得該函數返回值為True的那些元素組成的 filter 對象，如果指定函數為 None，則返回序列中等價於True的元素。
>>> seq = ['foo', 'x41', '?!', '***']
>>> def func(x):
return x.isalnum() #測試是否為字母或數字
>>> filter(func, seq) #返回filter對象
<filter object at 0x000000000305D898>
>>> list(filter(func, seq)) #把filter對象轉換為列表
['foo', 'x41']
View Code
- 內置函數 range() ，語法格式為 range([start,] end [, step] )。該函數返回具有惰性求值特點的range對象，其中包含左閉右開區間[start,end)內以step為步長的整數。參數 start 默認為0，step 默認為1。
>>> range(5) #start默認為0，step默認為1
range(0, 5)
>>> list(_)
[0, 1, 2, 3, 4]
>>> list(range(1, 10, 2)) #指定起始值和步長
[1, 3, 5, 7, 9]
>>> list(range(9, 0, -2)) #步長為負數時，start應比end大
[9, 7, 5, 3, 1]
View Code
- 內置函數 zip() 函數用來把多個可迭代對象中的元素壓縮到一起，返回一個可迭代的zip對象，其中每個元素都是包含原來的多個可迭代對象對應位置上元素的元組，如同拉拉鏈一樣。
>>> list(zip('abcd', [1, 2, 3])) #壓縮字符串和列表
[('a', 1), ('b', 2), ('c', 3)]
>>> list(zip('123', 'abc', ',.!')) #壓縮3個序列
[('1', 'a', ','), ('2', 'b', '.'), ('3', 'c', '!')]
>>> x = zip('abcd', '1234')
>>> list(x)
[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
View Code
1.4.7 對象的刪除
- 可以使用 del 命令來顯式刪除對象並解除與值之間的指向關係。刪除對象時，如果其指向的值還有別的變量指向則不刪除該值，如果刪除對象後該值不再有其他變量指向，則刪除該值。
>>> x = [1,2,3,4,5,6]
>>> y = 3
>>> z = y
>>> print(y)
3
>>> del y #刪除對象
>>> print(y)
NameError: name 'y' is not defined
>>> print(z)
3
>>> del z
>>> print(z)
NameError: name 'z' is not defined
>>> del x[1] #刪除列表中指定元素
>>> print(x)
[1, 3, 4, 5, 6]
>>> del x #刪除整個列表
>>> print(x)
NameError: name 'x' is not defined
View Code
- del命令無法刪除元組或字符串中的元素，只可以刪除整個元組或字符串，因為這兩者均屬於不可變序列。
>>> x = (1,2,3)
>>> del x[1]
Traceback (most recent call last):
File "<pyshell#62>", line 1, in <module>
del x[1]
TypeError: 'tuple' object doesn't support item deletion
>>> del x
>>> print(x)
Traceback (most recent call last):
File "<pyshell#64>", line 1, in <module>
print(x)
NameError: name 'x' is not defined
View Code
1.4.8 基本輸入輸出
- 輸入是通過input( )函數來實現的，imput( )的一般格式為：
x = input('提示：')
View Code
該函數返回輸入的對象。可輸入數字、字符串和其它任意類型對象。
- Python 2.x和Python 3.x對該函數的解釋略有不同。在Python 2.x中，該函數返回結果的類型由輸入值時所使用的界定符來決定，例如下面的Python 2.7.12代碼：
>>> x = input("Please input:")
Please input:3 #沒有界定符，整數
>>> print type(x)
<type 'int'>
>>> x = input("Please input:")
Please input:'3' #單引號，字符串
>>> print type(x)
<type 'str'>
>>> x = input("Please input:")
Please input:[1,2,3] #方括號，列表
>>> print type(x)
<type 'list'>
View Code
- 在Python 2.x中，還有另外一個內置函數 raw_input() 也可以用來接收用戶輸入的值。與input()函數不同的是，raw_input() 函數返回結果的類型一律為字符串，而不論用戶使用什麼界定符。例如：
>>> x = raw_input("Please input:")
Please input:[1,2,3]
>>> print type(x)
<type 'str'>
View Code
- 在Python 2.x中，使用print語句進行輸出。Python 3.x中使用print()函數進行輸出。
- 默認情況下，Python將結果輸出到IDLE或者標準控制台，在輸出時也可以進行重定向，例如可以把結果輸出到指定文件。在Python 2.7.12中使用下面的方法進行輸出重定向：
>>> fp = open(r'C:\mytest.txt', 'a+')
>>> print >>fp, "Hello,world"
>>> fp.close()
View Code
- 在Python 3.5.2中則需要使用下面的方法進行重定向：
>>> fp = open(r'D:\mytest.txt', 'a+')
>>> print('Hello,world!', file = fp)
>>> fp.close()
View Code
- 另外一個重要的不同是，對於Python 2.x而言，在print語句之後加上逗號「,」則表示輸出內容之後不換行，例如
>>> for i in range(10):
print i,
0 1 2 3 4 5 6 7 8 9
View Code
- 在Python 3.x中，為了實現上述功能則需要使用下面的方法：
>>> for i in range(10,20):
print(i, end=' ')
10 11 12 13 14 15 16 17 18 19
View Code
1.4.9 模塊導入與使用
- 在Python啟動時，僅加載了很少的一部分模塊，在需要時由程序員顯式地加載（可能需要先安裝）其他模塊。
- 減小運行的壓力，僅加載真正需要的模塊和功能，且具有很強的可擴展性。
- 可以使用sys.modules.items()顯示所有預加載模塊的相關信息。
- import 模塊名
>>>import math
>>>math.sin(0.5) #求0.5的正弦
>>>import random
>>>x=random.random( ) #獲得[0,1) 內的隨機小數
>>>y=random.random( )
>>>n=random.randint(1,100) #獲得[1,100]上的隨機整數
View Code
可以使用dir函數查看任意模塊中所有的對象列表，如果調用不帶參數的dir()函數，則返回當前所有名字列表。
可以使用help函數查看任意模塊或函數的使用幫助。
- from 模塊名 import 對象名[ as 別名] #可以減少查詢次數，提高執行速度
- from math import * #謹慎使用
>>> from math import sin
>>> sin(3)
0.1411200080598672
>>> from math import sin as f #別名
>>> f(3)
0.141120008059867
View Code
- Python首先在當前目錄中查找需要導入的模塊文件，如果沒有找到則從sys模塊的path變量所指定的目錄中查找。可以使用sys模塊的path變量查看python導入模塊時搜索模塊的路徑，也可以向其中append自定義的目錄以擴展搜索路徑。
- 在導入模塊時，會優先導入相應的pyc文件，如果相應的pyc文件與py文件時間不相符，則導入py文件並重新編譯該模塊。
- 導入模塊時的文件搜索順序
-
- 當前文件夾
- sys.path變量指定的文件夾
- 優先導入pyc文件
- 如果需要導入多個模塊，一般建議按如下順序進行導入：
- 標準庫
- 成熟的第三方擴展庫
- 自己開發的庫
1.5 Python代碼規範
- 縮進
- 類定義、函數定義、選擇結構、循環結構，行尾的冒號表示縮進的開始。
- python程序是依靠代碼塊的縮進來體現代碼之間的邏輯關係的，縮進結束就表示一個代碼塊結束了。
- 同一個級別的代碼塊的縮進量必須相同。
- 一般而言，以4個空格為基本縮進單位
- 注釋
- 以 # 開始，表示本行 # 之後的內容為注釋。
- 包含在一對三引號 ”’…”’ 或 “””…””” 之間且不屬於任何語句的內容將被解釋器認為是注釋。
- 每個import只導入一個模塊。
- 如果一行語句太長，可以在行尾加上\來換行分成多行，但是更建議使用括號來包含多行內容。
- 必要的空格與空行。
1.6 Python文件名
- .py：Python源文件，由Python解釋器負責解釋執行。
- .pyw：Python源文件，常用於圖形界面程序文件。
- .pyc：Python位元組碼文件，無法使用文本編輯器直接查看該類型文件內容，可用於隱藏Python源代碼和提高運行速度。對於Python模塊，第一次被導入時將被編譯成位元組碼的形式，並在以後再次導入時優先使用「.pyc」文件，以提高模塊的加載和運行速度。對於非模塊文件，直接執行時並不生成「.pyc」文件，但可以使用py_compile模塊的compile()函數進行編譯以提高加載和運行速度。另外，Python還提供了compileall模塊，其中包含compile_dir()、compile_file()和compile_path()等方法，用來支持批量Python源程序文件的編譯。
- .pyo：優化的Python位元組碼文件，同樣無法使用文本編輯器直接查看其內容。可以使用「python –O -m py_compile file.py」或「python –OO -m py_compile file.py」進行優化編譯。Python 3.5不再支持.pyo文件。
- .pyd：一般是由其他語言編寫並編譯的二進制文件，常用於實現某些軟件工具的Python編程接口插件或Python動態鏈接庫。
1.7 Python腳本的「__name__」屬性
- 每個Python腳本在運行時都有一個「__name__」屬性。如果腳本作為模塊被導入，則其「__name__」屬性的值被自動設置為模塊名；如果腳本獨立運行，則其「__name__」屬性值被自動設置為「__main__」。
- 利用「__name__」屬性即可控制Python程序的運行方式。例如，編寫一個包含大量可被其他程序利用的函數的模塊，而不希望該模塊可以直接運行，則可以在程序文件中添加以下代碼：
if __name__ == '__main__':
print('Please use me as a module.')
View Code
這樣一來，程序直接執行時將會得到提示 「Please use me as a module.」，而使用 import 語句將其作為模塊導入後可以使用其中的類、方法、常量或其他成員。
1.8 編寫自己的包與模塊
- 在包的每個目錄中都必須包含一個__init__.py文件，該文件可以是一個空文件，僅用於表示該目錄是一個包。
- __init__.py文件的主要用途是設置__all__變量以及所包含的包初始化所需的代碼。其中__all__變量中定義的對象可以在使用from …import *時全部正確導入。
看完點個關注唄！！（總結不易）
