瞭解python
1. 瞭解PythonPython是一種解釋型（這意味著開發過程中沒有了編譯這個環節）、面向物件（支援面向物件的風格或程式碼封裝在物件的程式設計技術）、動態資料型別的互動式（可在命令列中透過Python提示符及直接程式碼執行程式）高階程式設計語言。
2. Python識別符號識別符號由字母、數字、下劃線組成，但不能以數字開頭，且區分大小寫。
以下劃線開頭的識別符號是有特殊意義的。以單下劃線開頭 _foo 的代表不能直接訪問的類屬性，需透過類提供的介面進行訪問，不能用 from xxximport * 而匯入；
以雙下劃線開頭的 __foo 代表類的私有成員；以雙下劃線開頭和結尾的 __foo__ 代表 Python 裡特殊方法專用的標識，如__init__() 代表類的建構函式。
Python 可以同一行顯示多條語句，方法是用分號 ; 分開。
3. Python中的保留字元這些保留字不能用作常數或變數，或任何其他識別符號名稱。所有 Python的關鍵字只包含小寫字母。
and
exec
not
assert
finally
or
break
for
pass
class
from
continue
global
raise
def
if
return
del
import
try
elif
in
while
else
is
with
except
lambda
yield
4. Python的縮排與多行語句寫法4.1 Python中的縮排要求非常嚴格，必須嚴格對齊。因為Python的程式碼塊不由{}控制，而是由縮排就可以控制。
4.2 使用斜槓（ \）將一行的語句分為多行顯示，如下所示：當然，使用各類括號括起語句之後不需要斜槓換行。
total = item_one + \
item_two + \
item_three
英文三個雙引號用在等式中也可以寫多行文字，直接使用和三個單引號作用一樣，可以做多行註釋。
5. Python中的不換行與換行輸出# 換行輸出
print(x)
# 不換行輸出
print(x,end='')
Python變數型別建立變數就意味著會在記憶體中開闢空間，同時變數必須賦值才會被建立。
1. Python中的變數賦值單變數賦值：
counter = 100#賦值整型變數
miles = 1000.0#浮點型
name = "John"#字串
多變數賦值：
a = b = c= 1 #三個變數的值都為1
a, b, c =1, 2, "john" #分別為三個變數賦值
2. Python中的資料型別Python有五個標準的資料型別：
1. Numbers（數字）1）不可改變的資料型別：
2）Python支援的數字型別：
int（有符號整型，如0x69，10）；long（長整型[也可以代表八進位制和十六進位制]，如-4721885298529L，Python用數字後面的L表示長整型）；float（浮點型，如70.2E-12）；complex（複數，如4.53e-7j）。
3）Python資料型別轉換：
int(x [,base ]) 將x轉換為一個整數 long(x [,base ]) 將x轉換為一個長整數 float(x ) 將x轉換到一個浮點數 complex(real [,imag ]) 建立一個複數 str(x ) 將物件 x 轉換為字串 repr(x ) 將物件 x 轉換為表示式字串 eval(str ) 用來計算在字串中的有效Python表示式,並返回一個物件 tuple(s ) 將序列 s 轉換為一個元組 list(s ) 將序列 s 轉換為一個列表 chr(x ) 將一個整數轉換為一個字元 unichr(x ) 將一個整數轉換為Unicode字元 ord(x ) 將一個字元轉換為它的整數值 hex(x ) 將一個整數轉換為一個十六進位制字串 oct(x ) 將一個整數轉換為一個八進位制字串 4）Python數學函式
函式
返回值 ( 描述 )
abs(x)
返回數字的絕對值，如abs(-10) 返回 10
ceil(x)
返回數字的向上取整值，如math.ceil(4.1) 返回 5
cmp(x, y)
比較函式，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)
返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045
fabs(x)
返回數字的絕對值，如math.fabs(-10) 返回10.0
floor(x)
返回向下取整值，如math.floor(4.9)返回 4
log(x)
如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)
返回以10為基數的x的對數，如math.log10(100)返回 2.0
max(x1, x2,...)
返回給定引數的最大值，引數可以為序列。
min(x1, x2,...)
返回給定引數的最小值，引數可以為序列。
modf(x)
返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。
pow(x, y)
x**y 運算後的值。
round(x [,n])
返回浮點數x的四捨五入值，如給出n值，則代表舍入到小數點後的位數。
sqrt(x)
返回數字x的平方根
5）Python隨機數函式
常用於遊戲、數學、安全等領域。
函式
描述
choice(seq)
從序列的元素中隨機挑選一個元素，比如random.choice(range(10))，從0到9中隨機挑選一個整數。
randrange ([start,] stop [,step])
從指定範圍內，按指定基數遞增的集合中獲取一個隨機數，基數預設值為1
random()
隨機生成下一個實數，它在[0,1)範圍內。
seed([x])
改變隨機數生成器的種子seed。如果你不瞭解其原理，你不必特別去設定seed，Python會幫你選擇seed。
shuffle(lst)
將序列的所有元素隨機排序
uniform(x, y)
隨機生成下一個實數，它在[x,y]範圍內。
6） Python三角函式
函式
描述
acos(x)
返回x的反餘弦弧度值。
asin(x)
返回x的反正弦弧度值。
atan(x)
返回x的反正切弧度值。
atan2(y, x)
返回給定的 X 及 Y 座標值的反正切值。
cos(x)
返回x的弧度的餘弦值。
hypot(x, y)
返回歐幾里德範數 sqrt(x*x + y*y)。
sin(x)
返回的x弧度的正弦值。
tan(x)
返回x弧度的正切值。
degrees(x)
將弧度轉換為角度,如degrees(math.pi/2) ， 返回90.0
radians(x)
將角度轉換為弧度
7） Python數學常量
常量
描述
pi
數學常量 pi（圓周率，一般以π來表示）
e
數學常量 e，e即自然常數（自然常數）。
2. String（字串）由數字、字母、下劃線組成。
1） 字串擷取
Python字串從左至右擷取：索引範圍（0，長度-1），從右至左擷取（-1，字串開頭）。
2） Python中不存在單字元
Python中即使有單字元，也會被當作字串處理。
3） Python跳脫字元
跳脫字元
描述
\
出現在行尾時表現為續行符，出現在行中時，用於“翻譯”特殊字元表示特殊含義，如下面選項所示
\\
反斜槓符號
\'
單引號
\"
雙引號
\a
響鈴
\b
退格(Backspace)
\e
轉義
\000
空
\n
換行
\v
縱向製表符
\t
橫向製表符
\r
回車
\f
換頁
\oyy
八進位制數，yy代表的字元，例如：\o12代表換行
\xyy
十六進位制數，yy代表的字元，例如：\x0a代表換行
\other
其它的字元以普通格式輸出
4） Python字串運算
下表例項變數 a 值為字串 "Hello"，b 變數值為 "Python"：
運算子
描述
+
字串連線。
*
重複輸出字串。
[]
透過索引獲取字串中字元
[ : ]
擷取字串中的一部分
in
成員運算子 - 如果字串中包含給定的字元返回 True
not in
成員運算子 - 如果字串中不包含給定的字元返回 True
r/R
原始字串 - 原始字串：所有的字串都是直接按照字面的意思來使用，沒有轉義特殊或不能列印的字元。 原始字串除在字串的第一個引號前加上字母"r"（可以大小寫）以外，與普通字串有著幾乎完全相同的語法。
a='hello'b='world'print(a+b) #helloworld，+號連線字串print(a*2) #hellohello，*號重複字串print(a[1]) #e，[]索引字元print(a[1:4]) #ell，[:]擷取字串print("h" in a) #True，in是否包含print("M" not in a) #True，not in是否不包含print(r'\n') #\n，r原始字串（不解析跳脫字元）5） Python字串格式化（方便print時定義型別，如C語言中printf字串時在引號內寫%s一樣）
print("My name is %s and weight is %d kg!" % ('Zara', 21) )輸出： My name is Zara and weight is 21 kg!符 號
描述
%c
格式化字元及其ASCII碼
%s
格式化字串
%d
格式化整數
%u
格式化無符號整型
%o
格式化無符號八進位制數
%x
格式化無符號十六進位制數
%X
格式化無符號十六進位制數（大寫）
%f
格式化浮點數字，可指定小數點後的精度
%e
用科學計數法格式化浮點數
%E
作用同%e，用科學計數法格式化浮點數
%g
%f和%e的簡寫
%G
%f 和 %E的簡寫
%p
用十六進位制數格式化變數的地址
6）使用三引號輸出一大串帶特殊字元的字串
當使用三引號將字串框起來時，就不需要再透過跳脫字元打很多換行符等符號了，可以直接打換行。對比如下：
>>> hi = '''hi
there'''
>>> hi = 'hi\nthere'
這兩種輸出的結果都是換行的字串，但是使用單引號時，當跳脫字元很多時，會很痛苦。
9） String可使用的內建函式
方法
描述
string.capitalize()
把字串的第一個字元大寫
string.center(width)
返回一個原字串居中,並使用空格填充至長度 width 的新字串
string.count(str, beg=0, end=len(string))
返回 str 在 string 裡面出現的次數，如果 beg 或者 end 指定則返回指定範圍內 str 出現的次數
string.decode(encoding='UTF-8', errors='strict')
以 encoding 指定的編碼格式解碼 string，如果出錯預設報一個 ValueError 的 異 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace'
string.encode(encoding='UTF-8', errors='strict')
以 encoding 指定的編碼格式編碼 string，如果出錯預設報一個ValueError 的異常，除非 errors 指定的是'ignore'或者'replace'
string.endswith(obj, beg=0, end=len(string))
檢查字串是否以 obj 結束，如果beg 或者 end 指定則檢查指定的範圍內是否以 obj 結束，如果是，返回 True,否則返回 False.
string.expandtabs(tabsize=8)
把字串 string 中的 tab 符號轉為空格，tab 符號預設的空格數是 8。
string.find(str, beg=0, end=len(string))
檢測 str 是否包含在 string 中，如果 beg 和 end 指定範圍，則檢查是否包含在指定範圍內，如果是返回開始的索引值，否則返回-1
string.format()
格式化字串
string.index(str, beg=0, end=len(string))
跟find()方法一樣，只不過如果str不在 string中會報一個異常.
string.isalnum()
如果 string 至少有一個字元並且所有字元都是字母或數字則返
回 True,否則返回 False
string.isalpha()
如果 string 至少有一個字元並且所有字元都是字母則返回 True,
否則返回 False
string.isdecimal()
如果 string 只包含十進位制數字則返回 True 否則返回 False.
string.isdigit()
如果 string 只包含數字則返回 True 否則返回 False.
string.islower()
如果 string 中包含至少一個區分大小寫的字元，並且所有這些(區分大小寫的)字元都是小寫，則返回 True，否則返回 False
string.isnumeric()
如果 string 中只包含數字字元，則返回 True，否則返回 False
string.isspace()
如果 string 中只包含空格，則返回 True，否則返回 False.
string.istitle()
如果 string 是標題化的(見 title())則返回 True，否則返回 False
string.isupper()
如果 string 中包含至少一個區分大小寫的字元，並且所有這些(區分大小寫的)字元都是大寫，則返回 True，否則返回 False
string.join(seq)
以 string 作為分隔符，將 seq 中所有的元素(的字串表示)合併為一個新的字串
string.ljust(width)
返回一個原字串左對齊,並使用空格填充至長度 width 的新字串
string.lower()
轉換 string 中所有大寫字元為小寫.
string.lstrip()
截掉 string 左邊的空格
string.maketrans(intab, outtab])
maketrans() 方法用於建立字元對映的轉換表，對於接受兩個引數的最簡單的呼叫方式，第一個引數是字串，表示需要轉換的字元，第二個引數也是字串表示轉換的目標。
max(str)
返回字串 str 中最大的字母。
min(str)
返回字串 str 中最小的字母。
string.partition(str)
有點像 find()和 split()的結合體,從 str 出現的第一個位置起,把 字 符 串 string 分 成 一 個 3 元 素 的 元 組 (string_pre_str,str,string_post_str),如果 string 中不包含str 則 string_pre_str == string.
string.replace(str1, str2, num=string.count(str1))
把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次.
string.rfind(str, beg=0,end=len(string) )
類似於 find()函式，不過是從右邊開始查詢.
string.rindex( str, beg=0,end=len(string))
類似於 index()，不過是從右邊開始.
string.rjust(width)
返回一個原字串右對齊,並使用空格填充至長度 width 的新字串
string.rpartition(str)
類似於 partition()函式,不過是從右邊開始查詢.
string.rstrip()
string.split(str="", num=string.count(str))
以 str 為分隔符切片 string，如果 num有指定值，則僅分隔 num 個子字串
string.splitlines([keepends])
按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表，如果引數 keepends 為 False，不包含換行符，如果為 True，則保留換行符。
string.startswith(obj, beg=0,end=len(string))
檢查字串是否是以 obj 開頭，是則返回 True，否則返回 False。如果beg 和 end 指定值，則在指定範圍內檢查.
string.strip([obj])
在 string 上執行 lstrip()和 rstrip()
string.swapcase()
翻轉 string 中的大小寫
string.title()
返回"標題化"的 string,就是說所有單詞都是以大寫開始，其餘字母均為小寫(見 istitle())
string.translate(str, del="")
根據 str 給出的表(包含 256 個字元)轉換 string 的字元,
要過濾掉的字元放到 del 引數中
string.upper()
轉換 string 中的小寫字母為大寫
string.zfill(width)
返回長度為 width 的字串，原字串 string 右對齊，前面填充0
string.isdecimal()
isdecimal()方法檢查字串是否只包含十進位制字元。這種方法只存在於unicode物件。
3. List（列表）使用非常頻繁，支援數字、字元、字串甚至列表的集合結構。
直接重新賦值給根據索引值取出的值，或透過append（）函式來新增。
2） 列表的指令碼運算子
和對字串的操作類似。
Python 表示式
結果
描述
len([1, 2, 3])
3
長度
[1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
組合
['Hi!'] * 4
['Hi!', 'Hi!', 'Hi!', 'Hi!']
重複
3 in [1, 2, 3]
True
判斷元素是否存在於列表中
for x in [1, 2, 3]: print x,
1 2 3
迭代
3） 列表的擷取
Python 表示式
結果
描述
L[2]
'Taobao'
讀取列表中第三個元素
L[-2]
'Runoob'
讀取列表中倒數第二個元素
L[1:]
['Runoob', 'Taobao']
從第二個元素開始擷取列表
4） Python中列表的函式及方法
Python包含以下函式:
函式
描述
cmp(list1, list2)
比較兩個列表的元素
len(list)
列表元素個數
max(list)
返回列表元素最大值
min(list)
返回列表元素最小值
list(seq)
將元組轉換為列表
Python包含以下方法:
函式
描述
list.append(obj)
在列表末尾新增新的物件
list.count(obj)
統計某個元素在列表中出現的次數
list.extend(seq)
在列表末尾一次性追加另一個序列中的多個值（用新列表擴充套件原來的列表）
list.index(obj)
從列表中找出某個值第一個匹配項的索引位置
list.insert(index, obj)
將物件插入列表
list.pop(obj=list[-1])
移除列表中的一個元素（預設最後一個元素），並且返回該元素的值
list.remove(obj)
移除列表中某個值的第一個匹配項
list.reverse()
反向列表中元素
list.sort([func])
對原列表進行排序
4. Tuple（元組）1）與列表的區別
類似列表，但列表用[ ]標識，元組用()標識，並且列表元素可二次賦值，但元組元素不能。
2）元組的建立
建立空元組：tuple（） 。
建立只有一個元素的元組：tuple（a，），必須要在元素後加逗號。
3）元素的訪問
雖然建立時用（）包含，但是在訪問單個元素時，與列表一樣，透過[ 索引號 ]來訪問。
5）元組運算子（同列表）
6）任意無符號的物件，以逗號隔開，預設為元組（無關閉分隔符）
7）元組內建函式
函式
描述
cmp(tuple1, tuple2)
比較兩個元組元素。
len(tuple)
計算元組元素個數。
max(tuple)
返回元組中元素最大值。
min(tuple)
返回元組中元素最小值。
tuple(seq)
將列表轉換為元組。
5. Dictionary（字典）1） 與列表的差別
列表是有序的物件集合，字典是無序的物件結合。字典中的元素透過Key來獲取，而列表中的元素透過位移來獲取。
2） 字典的定義
下面是兩種定義字典的方法，兩種方法都與列表的定義方法類似。
dict = {}
dict['one'] ="This is one"
dict[2] ="This is two"
tinydict = {'name':'john','code':6734,'dept':'sales'}
3） 資料型別的轉換
函式
描述
int(x [,base])
將x轉換為一個整數
long(x [,base] )
將x轉換為一個長整數
float(x)
將x轉換到一個浮點數
complex(real [,imag])
建立一個複數
str(x)
將物件 x 轉換為字串
repr(x)
將物件 x 轉換為表示式字串
eval(str)
用來計算在字串中的有效Python表示式,並返回一個物件
tuple(s)
將序列 s 轉換為一個元組
list(s)
將序列 s 轉換為一個列表
set(s)
轉換為可變集合
dict(d)
建立一個字典。d 必須是一個序列 (key,value)元組。
frozenset(s)
轉換為不可變集合
chr(x)
將一個整數轉換為一個字元
unichr(x)
將一個整數轉換為Unicode字元
ord(x)
將一個字元轉換為它的整數值
hex(x)
將一個整數轉換為一個十六進位制字串
oct(x)
將一個整數轉換為一個八進位制字串
Python運算子Python支援以下八種運算子：
1. 算數運算子假設a=10，b=20
運算子
描述
例項
+
加 - 兩個物件相加
a + b 輸出結果 30
-
減 - 得到負數或是一個數減去另一個數
a - b 輸出結果 -10
*
乘 - 兩個數相乘或是返回一個被重複若干次的字串
a * b 輸出結果 200
/
除 - x除以y
b / a 輸出結果 2（整數除整數，只能得整數，要求小數需要將其中一個改為浮點數）
%
取模 - 返回除法的餘數
b % a 輸出結果 0
**
冪 - 返回x的y次冪
a**b 為10的20次方， 輸出結果 100000000000000000000
//
取整除 - 返回商的整數部分
9//2 輸出結果 4 , 9.0//2.0輸出結果 4.0
2. 比較運算子運算子
描述
例項
==
等於 - 比較物件是否相等
(a == b) 返回 False。
!=
不等於 - 比較兩個物件是否不相等
(a != b) 返回 true.
<>
不等於 - 比較兩個物件是否不相等
(a <> b) 返回 true。這個運算子類似 != 。
>
大於 - 返回x是否大於y
(a > b) 返回 False。
<
小於 - 返回x是否小於y。所有比較運算子返回1表示真，返回0表示假。這分別與特殊的變數True和False等價。注意，這些變數名的大寫。
(a < b) 返回 true。
>=
大於等於 - 返回x是否大於等於y。
(a >= b) 返回 False。
<=
小於等於 - 返回x是否小於等於y。
(a <= b) 返回 true。
3. Python賦值運算子運算子
描述
例項
=
簡單的賦值運算子
c = a + b 將 a + b的運算結果賦值為 c
+=
加法賦值運算子
c += a 等效於 c = c + a
-=
減法賦值運算子
c -= a 等效於 c = c - a
*=
乘法賦值運算子
c *= a 等效於 c = c * a
/=
除法賦值運算子
c /= a 等效於 c = c / a
%=
取模賦值運算子
c %= a 等效於 c = c % a
**=
冪賦值運算子
c **= a 等效於 c = c ** a
//=
取整除賦值運算子
c //= a 等效於 c = c // a
4. Python位運算子按位運算子是把數字看作二進位制來進行計算的。Python中的按位運演算法則如下：
運算子
描述
例項
&
按位與運算子：參與運算的兩個值,如果兩個相應位都為1,則該位的結果為1,否則為0
(a & b) 輸出結果 12，二進位制解釋： 0000 1100
|
按位或運算子：只要對應的二個二進位有一個為1時，結果位就為1。
(a | b) 輸出結果 61，二進位制解釋： 0011 1101
^
按位異或運算子：當兩對應的二進位相異時，結果為1
(a ^ b) 輸出結果 49，二進位制解釋： 0011 0001
~
按位取反運算子：對資料的每個二進位制位取反,即把1變為0,把0變為1 。~x 類似於 -x-1
(~a ) 輸出結果 -61，二進位制解釋： 1100 0011，在一個有符號二進位制數的補碼形式。
<<
左移動運算子：運算數的各二進位全部左移若干位，由"<<"右邊的數指定移動的位數，高位丟棄，低位補0。
a << 2 輸出結果 240，二進位制解釋： 1111 0000
>>
右移動運算子：把">>"左邊的運算數的各二進位全部右移若干位，">>"右邊的數指定移動的位數
a >> 2 輸出結果 15，二進位制解釋： 0000 1111
5. Python邏輯運算子運算子
邏輯表示式
描述
例項
and
x and y
布林"與" - 如果 x 為 False，x and y 返回 False，否則它返回 y 的計算值。
(a and b) 返回 20。
or
x or y
布林"或" - 如果 x 是非 0，它返回 x 的值，否則它返回 y 的計算值。
(a or b) 返回 10。
not
not x
布林"非" - 如果 x 為 True，返回 False 。如果 x 為 False，它返回 True。
not(a and b) 返回 False
6. Python成員運算子運算子
描述
例項
in
如果在指定的序列中找到值返回 True，否則返回 False。
x 在 y序列中 , 如果 x 在 y 序列中返回 True。
not in
如果在指定的序列中沒有找到值返回 True，否則返回 False。
x 不在 y序列中 , 如果 x 不在 y 序列中返回 True。
7. Python身份運算子（判斷引用的物件）1） is與==的區別==判斷兩者是否完全相等，而is判斷兩個物件引用的物件是否是同一個。
運算子
描述
例項
is
is 是判斷兩個識別符號是不是引用自一個物件
x is y,類似 id(x) == id(y) , 如果引用的是同一個物件則返回 True，否則返回 False
is not
is not 是判斷兩個識別符號是不是引用自不同物件
x is not y ， 類似 id(a) != id(b)。如果引用的不是同一個物件則返回結果 True，否則返回 False。
8. Python運算子優先順序運算子
描述
**
指數 (最高優先順序)
~ + -
按位翻轉, 一元加號和減號 (最後兩個的方法名為 +@ 和 -@)
* / % //
乘，除，取模和取整除
+ -
加法減法
>> <<
右移，左移運算子
&
位 'AND'
^ |
位運算子
<= < > >=
比較運算子
<> == !=
等於運算子
= %= /= //= -= += *= **=
賦值運算子
is is not
身份運算子
in not in
成員運算子
not or and
邏輯運算子
Python語句1. 條件語句Python不支援switch語句，因此判斷結果對應多種執行方式時，只能用elif來做。
num = 5if num ==3: #判斷num的值 print('boss')elif num ==2: print('user')elif num ==1: print('worker')2. 迴圈語句
Python中沒有do while迴圈。
迴圈型別
描述
while迴圈
在給定的判斷條件為 true 時執行迴圈體，否則退出迴圈體。
for迴圈
重複執行語句
巢狀迴圈
你可以在while迴圈體中巢狀for迴圈（for中也可以巢狀for吧）
迴圈控制語句：
控制語句
描述
break語句
在語句塊執行過程中終止迴圈，並且跳出整個迴圈
continue語句
在語句塊執行過程中終止當前迴圈，跳出該次迴圈，執行下一次迴圈。
pass語句
pass是空語句，是為了保持程式結構的完整性。
1）pass語句在函式中的作用當你在編寫一個程式時，執行語句部分思路還沒有完成，這時你可以用pass語句來佔位，也可以當做是一個標記，是要過後來完成的程式碼。比如下面這樣：
def iplaypython(): pass定義一個函式iplaypython，但函式體部分暫時還沒有完成，又不能空著不寫內容，因此可以用pass來替代佔個位置。
2）pass語句在迴圈中的作用pass也常用於為複合語句編寫一個空的主體，比如說你想一個while語句的無限迴圈，每次迭代時不需要任何操作，你可以這樣寫：
while True: pass以上只是舉個例子，現實中最好不要寫這樣的程式碼，因為執行程式碼塊為pass也就是空什麼也不做，這時python會進入死迴圈。
3）pass語句用法總結1、空語句，什麼也不做 2、在特別的時候用來保證格式或是語義的完整性
4）While迴圈（可在迴圈中使用else語句）# continue 和 break用法
i=1while i<10: i+= 1 if i%2>0: # 非雙數時跳過輸出 continue print(i) # 輸出雙數2、4、6、8、10 i = 1while 1: # 迴圈條件為1必定成立 print(i) # 輸出1~10 i+= 1 if i>10: # 當i大於10時跳出迴圈 break在迴圈中使用else語句，即當條件不滿足之後，結束迴圈，執行else語句
count = 0while count <5: print(count," is less than 5") count = count +1else: print(count," is not less than 5")可以透過直接取值迭代，也可以透過序列索引迭代
取值迭代：
for letter in 'Python': # 逐個輸出字串中的字元 print('當前字母 :', letter) fruits = ['banana', 'apple', 'mango']for fruit in fruits: # 逐個輸出列表中的元素 print('當前水果 :', fruit)print("Good bye!")索引迭代：
fruits = ['banana','apple','mango']#透過len（）函式獲得列表的長度，透過range（）函式獲得了一個值不超過長度-1的索引序列for index in range(len(fruits)): print('當前水果 :',fruits[index]) print("Good bye!")Python是以時間戳來記錄時間的，也就是當前時間距離1970年1月1日過去了多少秒，因此獲取時間的方法一般是先獲取時間戳，再將時間戳轉換為時間元組，再將時間元組轉換為不同格式的時間資料。
1.獲取時間戳import time; #引入time模組
ticks = time.time()
2.獲取時間什麼是時間元組？
很多Python函式用一個元組裝起來的9組數字處理時間，也就是struct_time元組：
屬性
欄位
值
tm_year
4位數年
2008
tm_mon
月
1 到 12
tm_mday
日
1到31
tm_hour
小時
0到23
tm_min
分鐘
0到59
tm_sec
秒
0到61 (60或61 是閏秒)
tm_wday
一週的第幾日
0到6 (0是週一)
tm_yday
一年的第幾日
1到366 (儒略曆)
tm_isdst
夏令時
-1, 0, 1, -1是決定是否為夏令時的旗幟
程式碼接上，將獲取的時間戳轉換為時間元組：
localtime = time.localtime(time.time())
print("本地時間為 :", localtime)
3.獲取格式化的時間localtime = time.asctime( time.localtime(time.time()))
print("本地時間為 :", localtime)
4.獲取更多格式的格式化時間time.strftime(format[, t]) #總的程式碼形式
# 格式化成2016-03-20 11:45:39形式
print(time.strftime("%Y-%m-%d%H:%M:%S", time.localtime()))
python中時間日期格式化符號：
· %y兩位數的年份表示（00-99）
· %Y四位數的年份表示（000-9999）
· %m月份（01-12）
· %d月內中的一天（0-31）
· %H 24小時制小時數（0-23）
· %I 12小時制小時數（01-12）
· %M分鐘數（00=59）
· %S秒（00-59）
· %a本地簡化星期名稱
· %A本地完整星期名稱
· %b本地簡化的月份名稱
· %B本地完整的月份名稱
· %c本地相應的日期表示和時間表示
· %j年內的一天（001-366）
· %p本地A.M.或P.M.的等價符
· %U一年中的星期數（00-53）星期天為星期的開始
· %w星期（0-6），星期天為星期的開始
· %W一年中的星期數（00-53）星期一為星期的開始
· %x本地相應的日期表示
· %X本地相應的時間表示
· %Z當前時區的名稱
· %% %號本身
5.獲取某個月的日曆import calendar
cal = calendar.month(2016,1)
6.Time和Calendar模組的函式及屬性函式
描述
time.altzone
返回格林威治西部的夏令時地區的偏移秒數。如果該地區在格林威治東部會返回負值（如西歐，包括英國）。對夏令時啟用地區才能使用。
time.asctime([tupletime])
接受時間元組並返回一個可讀的形式為"Tue Dec 11 18:07:14 2008"（2008年12月11日 週二18時07分14秒）的24個字元的字串。
time.clock( )
用以浮點數計算的秒數返回當前的CPU時間。用來衡量不同程式的耗時，比time.time()更有用。
time.ctime([secs])
作用相當於asctime(localtime(secs))，未給引數相當於asctime()
time.gmtime([secs])
接收時間輟（1970紀元後經過的浮點秒數）並返回格林威治天文時間下的時間元組t。注：t.tm_isdst始終為0
time.localtime([secs])
接收時間輟（1970紀元後經過的浮點秒數）並返回當地時間下的時間元組t（t.tm_isdst可取0或1，取決於當地當時是不是夏令時）。
time.mktime(tupletime)
接受時間元組並返回時間輟（1970紀元後經過的浮點秒數）。
time.sleep(secs)
推遲呼叫執行緒的執行，secs指秒數。
time.strftime(fmt[,tupletime])
接收以時間元組，並返回以可讀字串表示的當地時間，格式由fmt決定。
time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')
根據fmt的格式把一個時間字串解析為時間元組。
time.time( )
返回當前時間的時間戳（1970紀元後經過的浮點秒數）。
time.tzset()
根據環境變數TZ重新初始化時間相關設定
Time模組包含了以下2個非常重要的屬性：
屬性
描述
time.timezone
屬性time.timezone是當地時區（未啟動夏令時）距離格林威治的偏移秒數（>0，美洲;<=0大部分歐洲，亞洲，非洲）。
time.tzname
屬性time.tzname包含一對根據情況的不同而不同的字串，分別是帶夏令時的本地時區名稱，和不帶的。
函式
描述
calendar.calendar(year,w=2,l=1,c=6)
返回一個多行字串格式的year年年曆，3個月一行，間隔距離為c。 每日寬度間隔為w字元。每行長度為21* W+18+2* C。l是每星期行數。
calendar.firstweekday( )
返回當前每週起始日期的設定。預設情況下，首次載入caendar模組時返回0，即星期一。
calendar.isleap(year)
是閏年返回True，否則為false。
calendar.leapdays(y1,y2)
返回在Y1，Y2兩年之間的閏年總數。
calendar.month(year,month,w=2,l=1)
返回一個多行字串格式的year年month月日曆，兩行標題，一週一行。每日寬度間隔為w字元。每行的長度為7* w+6。l是每星期的行數。
calendar.monthcalendar(year,month)
返回一個整數的單層巢狀列表。每個子列表裝載代表一個星期的整數。Year年month月外的日期都設為0;範圍內的日子都由該月第幾日表示，從1開始。
calendar.monthrange(year,month)
返回兩個整數。第一個是該月的星期幾的日期碼，第二個是該月的日期碼。日從0（星期一）到6（星期日）;月從1到12。
calendar.prcal(year,w=2,l=1,c=6)
相當於 print calendar.calendar(year,w,l,c).
calendar.prmonth(year,month,w=2,l=1)
相當於 print calendar.calendar（year，w，l，c）。
calendar.setfirstweekday(weekday)
設定每週的起始日期碼。0（星期一）到6（星期日）。
calendar.timegm(tupletime)
和time.gmtime相反：接受一個時間元組形式，返回該時刻的時間輟（1970紀元後經過的浮點秒數）。
calendar.weekday(year,month,day)
返回給定日期的日期碼。0（星期一）到6（星期日）。月份為 1（一月） 到 12（12月）。
7.其他可以處理時間的模組· datetime模組
· pytz模組
· dateutil模組
Python函式函式是組織好的，可重複使用的，用來實現單一，或相關聯功能的程式碼段。
函式能提高應用的模組性，和程式碼的重複利用率。
1.Python函式定義def functionname(parameters):
"函式_文件字串"
function_suite
return [expression]
2.物件建立在 python 中，型別屬於物件，變數是沒有型別的：
a=[1,2,3] #賦值後這個物件就已經建立好了
a="Runoob"
以上程式碼中，[1,2,3] 是 List 型別，"Runoob" 是 String 型別，而變數 a 是沒有型別，她僅僅是一個物件的引用（一個指標），可以是 List 型別物件，也可以指向 String 型別物件。
3.可更改物件和不可更改物件在 python 中，strings,tuples, 和 numbers 是不可更改（重新賦值後，原值不再存在）的物件，而 list,dict等則是可以修改（重新賦值後，原來的值依舊存在，依舊可以獲取到）的物件。
· 不可變型別：變數賦值 a=5 後再賦值 a=10，這裡實際是新生成一個 int 值物件 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當於新生成了a。
· 可變型別：變數賦值 la=[1,2,3,4] 後再賦值 la[2]=5 則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。
4.可更改物件和不可更改物件的引數傳遞python函式的引數傳遞：
不可變型別：類似 c++的值傳遞，如 整數、字串、元組。如fun（a），傳遞的只是a的值，沒有影響a物件本身。比如在fun（a）內部修改 a 的值，只是修改另一個複製的物件，不會影響 a本身。
def ChangeInt(a): a = 10 b = 2 ChangeInt(b) print(b) #結果是 2
int2物件指向變數b，而呼叫changeInt函式時，變數a就是變數b，此時的變數a和變數b都對應int 2物件，但是在之後a被重新賦值為10，此時變數a指向物件int 10，產生了一個新的int型物件，而變數b所指向的物件不變。
可變型別：類似 c++的引用傳遞，如 列表，字典。如 fun（la），則是將 la真正的傳過去，修改後fun外部的la也會受影響
python 中一切都是物件，嚴格意義我們不能說值傳遞還是引用傳遞，我們應該說傳不可變物件和傳可變物件。
def changeme( mylist): mylist.append([1,2,3,4]); #"修改傳入的列表" print("函式內取值: ", mylist) return # 呼叫changeme函式 mylist = [10,20,30]; changeme(mylist); print("函式外取值: ", mylist)
因為上面的程式碼傳遞的是可變物件，因此在函式內取值和函式外取值都是同樣的結果。
5.呼叫函式時的引數使用1）必備引數必須與函式宣告時一致的順序來傳遞引數。
2）關鍵字引數傳引數時可與函式宣告的順序不一樣，因為Python直譯器可以用引數名來匹配引數值。
3）預設引數傳入引數時未給引數賦值，則保持預設值。
#可寫函式說明
def printinfo( name, age=35): print("Name: ", name); #"列印任何傳入的字串" print("Age ", age); return; #呼叫printinfo函式 printinfo(age=50,name="miki"); printinfo(name="miki");
這裡第二句的age沒有輸入值，則輸出預設值35。
4）不定長引數（也就是包含非必備引數的引數定義）當不確定會傳入引數的個數時，可以對可以不輸入的引數名前面加“*”號，按順序輸入時進行對應即可。
def printinfo( arg1,*vartuple): print("輸出: ",arg1) #"列印任何傳入的引數" for var in vartuple: print var return; # 呼叫printinfo函式 printinfo(10); printinfo(70,60,50);
5.匿名函式（使用lambda建立）python 使用 lambda來建立匿名函式。
lambda只是一個表示式，函式體比def簡單很多。
lambda的主體是一個表示式，而不是一個程式碼塊。僅僅能在lambda表示式中封裝有限的邏輯進去。
lambda函式擁有自己的名稱空間，且不能訪問自有引數列表之外或全域性命名空間裡的引數（只能訪問自己的命名空間裡的引數）。
雖然lambda函式看起來只能寫一行，卻不等同於C或C++的行內函數，後者的目的是呼叫小函式時不佔用棧記憶體從而增加執行效率。
# 用一個語句來定義一個Sum函式
sum = lambda arg1, arg2: arg1+ arg2; # 呼叫sum函式 print("相加後的值為 : ", sum(10,20)) print("相加後的值為 : ", sum(20,20))
6.變數作用域1）全域性變數定義在所有函式外則為全域性變數，可在所有程式碼中使用。
當需要在函式內定義全域性變數時，必須用global語句。
2）區域性變數定義在函式內則為區域性變數，只能在相應的程式碼塊內使用。
total = 0; # 這是一個全域性變數 # 可寫函式說明 def sum( arg1, arg2): #返回2個引數的和." total = arg1 + arg2; # total在這裡是區域性變數. print("函式內是區域性變數 : ", total) return(total); #呼叫sum函式 sum( 10, 20); print("函式外是全域性變數 : ", total)
在上面的例子中，在函式內部，total是區域性變數，而在外部total是全域性變數，區域性變數的改變不會改變全域性變數的值，因此第一個列印結果是30，而第二個是0。
Python模組Python 模組(Module)，是一個Python 檔案，以 .py 結尾，包含了 Python 物件定義和Python語句。
模組讓你能夠有邏輯地組織你的Python 程式碼段。
把相關的程式碼分配到一個模組裡能讓你的程式碼更好用，更易懂。
1.匯入模組的三種方法的區別1）import匯入import support # 匯入模組，並不匯入單個函式
# 現在可以呼叫模組裡包含的函數了 ，但是必須透過模組名.函式名的方式呼叫
support.print_func("Runoob")
2）From … import匯入下面的語句可以將模組中的某一部分匯入，它只會將裡這個部分單個引入到執行這個宣告的模組的全域性符號表。這個部分可以是某個函式塊，也可以是函式塊的子函式塊。
from modname import name1[, name2[, ... nameN]]前兩種語句都是匯入模組的部分，只是部分匯入的位置不同，而使用From …import*則是匯入模組的全部專案，儘量少用，太耗記憶體。
2.名稱空間和作用域變數是擁有匹配物件的名字（識別符號）。
名稱空間是一個包含了變數名稱們（鍵）和它們各自相應的物件們（值）的字典。每個函式都會有自己的名稱空間，當變量出現在函式內部時，Python預設其為區域性變數，若存在一個與區域性變數重名的全域性變數，則由區域性變數覆蓋全域性變數。
Python的名稱空間分區域性名稱空間和全域性名稱空間。
3.找出模組中所有的模組名、函式名、變數名（dir()函式）# 匯入內建math模組import mathcontent = dir(math)print content; 以上例項輸出結果：
['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan','atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp','fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log','log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh','sqrt', 'tan', 'tanh']在這裡，特殊字串變數__name__指向模組的名字，__file__指向該模組的匯入檔名。
4.檢視全域性變數和區域性變數名稱空間根據呼叫地方的不同，globals()和 locals()函式可被用來返回全域性和區域性命名空間裡的名字。
如果在函式內部呼叫 locals()，返回的是所有能在該函數里訪問的命名。
如果在函式內部呼叫 globals()，返回的是所有在該函數里能訪問的全域性名字。
兩個函式的返回型別都是字典。所以名字們能用 keys() 函式摘取。
5. reload() 函式當一個模組被匯入到一個指令碼，模組頂層部分的程式碼只會被執行一次。
因此，如果你想重新執行模組裡頂層部分的程式碼，可以用 reload() 函式。該函式會重新匯入之前匯入過的模組。語法如下：在這裡，module_name要直接放模組的名字，而不是一個字串形式。
reload(module_name)讀取輸入的行：
str = input("請輸入：");print("你輸入的內容是: ", str) input() 函式可以接受Python表示式的輸入，並輸出表達式的計算結果請輸入：[x*5 for x in range(2,10,2)]你輸入的內容是: [10, 20, 30, 40]可以用file物件對大多數檔案進行操作。
1）開啟檔案你必須先用Python內建的open()函式開啟一個檔案，建立一個file物件，相關的方法才可以呼叫它進行讀寫。
file object = open(file_name [, access_mode][, buffering])· file_name：file_name變數是一個包含了你要訪問的檔名稱的字串值。
· access_mode：access_mode決定了開啟檔案的模式：只讀，寫入，追加等。所有可取值見如下的完全列表。這個引數是非強制的，預設檔案訪問模式為只讀(r)。
· buffering:如果buffering的值被設為0，就不會有寄存。如果buffering的值取1，訪問檔案時會寄存行。如果將buffering的值設為大於1的整數，表明了這就是的寄存區的緩衝大小。如果取負值，寄存區的緩衝大小則為系統預設。
· 當檔案不存在但透過open函式開啟時，如果是寫入則會自動建立檔案，如果是讀取內容則會報錯。
開啟檔案的模式
描述
r
以只讀方式開啟檔案。檔案的指標將會放在檔案的開頭。這是預設模式。
rb
以二進位制格式開啟一個檔案用於只讀。檔案指標將會放在檔案的開頭。這是預設模式。
r+
開啟一個檔案用於讀寫。檔案指標將會放在檔案的開頭。
rb+
以二進位制格式開啟一個檔案用於讀寫。檔案指標將會放在檔案的開頭。
w
開啟一個檔案只用於寫入。如果該檔案已存在則將其覆蓋。如果該檔案不存在，建立新檔案。
wb
以二進位制格式開啟一個檔案只用於寫入。如果該檔案已存在則將其覆蓋。如果該檔案不存在，建立新檔案。
w+
開啟一個檔案用於讀寫。如果該檔案已存在則將其覆蓋。如果該檔案不存在，建立新檔案。
wb+
以二進位制格式開啟一個檔案用於讀寫。如果該檔案已存在則將其覆蓋。如果該檔案不存在，建立新檔案。
a
開啟一個檔案用於追加。如果該檔案已存在，檔案指標將會放在檔案的結尾。也就是說，新的內容將會被寫入到已有內容之後。如果該檔案不存在，建立新檔案進行寫入。
ab
以二進位制格式開啟一個檔案用於追加。如果該檔案已存在，檔案指標將會放在檔案的結尾。也就是說，新的內容將會被寫入到已有內容之後。如果該檔案不存在，建立新檔案進行寫入。
a+
開啟一個檔案用於讀寫。如果該檔案已存在，檔案指標將會放在檔案的結尾（不然怎麼追加呢）。檔案開啟時會是追加模式。如果該檔案不存在，建立新檔案用於讀寫。
ab+
以二進位制格式開啟一個檔案用於追加。如果該檔案已存在，檔案指標將會放在檔案的結尾。如果該檔案不存在，建立新檔案用於讀寫。
2）File物件的屬性檔案被開啟後就會建立一個File物件。
物件屬性
描述
file.closed
返回true如果檔案已被關閉，否則返回false。
file.mode
返回被開啟檔案的訪問模式。
file.name
返回檔案的名稱。
file.softspace
如果用print輸出後，必須跟一個空格符，則返回false。否則返回true。
3）關閉檔案當一個檔案物件的引用被重新指定給另一個檔案時，Python 會關閉之前的檔案（Python會自動地關閉之前的檔案物件，這樣不那麼耗費記憶體）。用close（）方法關閉檔案是一個很好的習慣。
4）讀寫檔案無論讀、寫、還是關閉檔案，都需要先用open開啟檔案。
# 寫一個檔案fo = open("foo.txt", "wb")fo.write( "www.runoob.com!\nVery good site!\n"); # 關閉開啟的檔案fo.close()# 讀一個檔案fo = open("foo.txt", "r+")str = fo.read(10); #這裡的引數10表示的是被讀取的位元組數print("讀取的字串是 : ", str)# 關閉開啟的檔案fo.close()tell()方法告訴你檔案內的當前位置（那應該就是告訴你檔案指標在哪個位置）；換句話說，下一次的讀寫會發生在檔案開頭這麼多位元組之後。
seek(offset [,from])方法改變當前檔案的位置。Offset變量表示要移動的位元組數。From變數指定開始移動位元組的參考位置。如果from被設為0，這意味著將檔案的開頭作為移動位元組的參考位置。如果設為1，則使用當前的位置作為參考位置。如果它被設為2，那麼該檔案的末尾將作為參考位置。
# 開啟一個檔案fo = open("foo.txt", "r+")str = fo.read(10);print("讀取的字串是 : ", str) # 查詢當前位置position = fo.tell();print("當前檔案位置 : ", position) # 把指標再次重新定位到檔案開頭position = fo.seek(0, 0);str = fo.read(10);print("重新讀取字串 : ", str)# 關閉開啟的檔案fo.close()方法
描述
file.close()
關閉檔案。關閉後文件不能再進行讀寫操作。
file.flush()
重新整理檔案內部緩衝，直接把內部緩衝區的資料立刻寫入檔案, 而不是被動的等待輸出緩衝區寫入。
file.fileno()
返回一個整型的檔案描述符(file descriptor FD 整型), 可以用在如os模組的read方法等一些底層操作上。
file.isatty()
如果檔案連線到一個終端裝置返回 True，否則返回 False。
file.next()
返回檔案下一行。
file.read([size])
從檔案讀取指定的位元組數，如果未給定或為負則讀取所有。
file.readline([size])
讀取整行，包括 "\n" 字元。
file.readlines([sizehint])
讀取所有行並返回列表，若給定sizeint>0，返回總和大約為sizeint位元組的行, 實際讀取值可能比sizhint較大, 因為需要填充緩衝區。
file.seek(offset[, whence])
設定檔案當前位置
file.tell()
返回檔案當前位置。
file.truncate([size])
擷取檔案，擷取的位元組透過size指定，預設為當前檔案位置。
file.write(str)
將字串寫入檔案，沒有返回值。
file.writelines(sequence)
向檔案寫入一個序列字串列表，如果需要換行則要自己加入每行的換行符。
4.檔案OS（Python中處理檔案和目錄的模組）方法
描述
os.access(path, mode)
檢驗許可權模式
os.chdir(path)
改變當前工作目錄
os.chflags(path, flags)
設定路徑的標記為數字標記。
os.chmod(path, mode)
更改許可權
os.chown(path, uid, gid)
更改檔案所有者
os.chroot(path)
改變當前程序的根目錄
os.close(fd)
關閉檔案描述符 fd
os.closerange(fd_low, fd_high)
關閉所有檔案描述符，從 fd_low (包含) 到 fd_high (不包含), 錯誤會忽略
os.dup(fd)
複製檔案描述符 fd
os.dup2(fd, fd2)
將一個檔案描述符 fd 複製到另一個 fd2
os.fchdir(fd)
透過檔案描述符改變當前工作目錄
os.fchmod(fd, mode)
改變一個檔案的訪問許可權，該檔案由引數fd指定，引數mode是Unix下的檔案訪問許可權。
os.fchown(fd, uid, gid)
修改一個檔案的所有權，這個函式修改一個檔案的使用者ID和使用者組ID，該檔案由檔案描述符fd指定。
os.fdatasync(fd)
強制將檔案寫入磁碟，該檔案由檔案描述符fd指定，但是不強制更新檔案的狀態資訊。
os.fdopen(fd[, mode[, bufsize]])
透過檔案描述符 fd 建立一個檔案物件，並返回這個檔案物件
os.fpathconf(fd, name)
返回一個開啟的檔案的系統配置資訊。name為檢索的系統配置的值，它也許是一個定義系統值的字串，這些名字在很多標準中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
os.fstat(fd)
返回檔案描述符fd的狀態，像stat()。
os.fstatvfs(fd)
返回包含檔案描述符fd的檔案的檔案系統的資訊，像 statvfs()
os.fsync(fd)
強制將檔案描述符為fd的檔案寫入硬碟。
os.ftruncate(fd, length)
裁剪檔案描述符fd對應的檔案, 所以它最大不能超過檔案大小。
os.getcwd()
返回當前工作目錄
os.getcwdu()
返回一個當前工作目錄的Unicode物件
os.isatty(fd)
如果檔案描述符fd是開啟的，同時與tty(-like)裝置相連，則返回true, 否則False。
os.lchflags(path, flags)
設定路徑的標記為數字標記，類似 chflags()，但是沒有軟連結
os.lchmod(path, mode)
修改連線檔案許可權
os.lchown(path, uid, gid)
更改檔案所有者，類似 chown，但是不追蹤連結。
os.link(src, dst)
建立硬連結，名為引數 dst，指向引數 src
os.listdir(path)
返回path指定的資料夾包含的檔案或資料夾的名字的列表。
os.lseek(fd, pos, how)
設定檔案描述符 fd當前位置為pos, how方式修改: SEEK_SET 或者 0 設定從檔案開始的計算的pos; SEEK_CUR或者 1 則從當前位置計算; os.SEEK_END或者2則從檔案尾部開始. 在unix，Windows中有效
os.lstat(path)
像stat(),但是沒有軟連結
os.major(device)
從原始的裝置號中提取裝置major號碼 (使用stat中的st_dev或者st_rdev field)。
os.makedev(major, minor)
以major和minor裝置號組成一個原始裝置號
os.makedirs(path[, mode])
遞迴資料夾建立函式。像mkdir(), 但建立的所有intermediate-level資料夾需要包含子資料夾。
os.minor(device)
從原始的裝置號中提取裝置minor號碼 (使用stat中的st_dev或者st_rdev field )。
os.mkdir(path[, mode])
以數字mode的mode建立一個名為path的資料夾.預設的 mode 是 0777 (八進位制)。
os.mkfifo(path[, mode])
建立命名管道，mode 為數字，預設為 0666 (八進位制)
os.mknod(filename[, mode=0600, device])
建立一個名為filename檔案系統節點（檔案，裝置特別檔案或者命名pipe）。
os.open(file, flags[, mode])
開啟一個檔案，並且設定需要的開啟選項，mode引數是可選的
os.openpty()
開啟一個新的偽終端對。返回 pty 和 tty的檔案描述符。
os.pathconf(path, name)
返回相關檔案的系統配置資訊。
os.pipe()
建立一個管道. 返回一對檔案描述符(r, w) 分別為讀和寫
os.popen(command[, mode[, bufsize]])
從一個 command 開啟一個管道
os.read(fd, n)
從檔案描述符 fd 中讀取最多 n 個位元組，返回包含讀取位元組的字串，檔案描述符 fd對應檔案已達到結尾, 返回一個空字串。
os.readlink(path)
返回軟連結所指向的檔案
os.remove(path)
os.removedirs(path)
os.rename(src, dst)
重新命名檔案或目錄，從 src 到 dst
os.renames(old, new)
遞迴地對目錄進行更名，也可以對檔案進行更名。
os.rmdir(path)
os.stat(path)
獲取path指定的路徑的資訊，功能等同於C API中的stat()系統呼叫。
os.stat_float_times([newvalue])
決定stat_result是否以float物件顯示時間戳
os.statvfs(path)
獲取指定路徑的檔案系統統計資訊
os.symlink(src, dst)
建立一個軟連結
os.tcgetpgrp(fd)
返回與終端fd（一個由os.open()返回的開啟的檔案描述符）關聯的程序組
os.tcsetpgrp(fd, pg)
設定與終端fd（一個由os.open()返回的開啟的檔案描述符）關聯的程序組為pg。
os.tempnam([dir[, prefix]])
返回唯一的路徑名用於建立臨時檔案。
os.tmpfile()
os.tmpnam()
為建立一個臨時檔案返回一個唯一的路徑
os.ttyname(fd)
返回一個字串，它表示與檔案描述符fd 關聯的終端裝置。如果fd 沒有與終端裝置關聯，則引發一個異常。
os.unlink(path)
os.utime(path, times)
返回指定的path檔案的訪問和修改的時間。
os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]])
輸出在資料夾中的檔名透過在樹中游走，向上或者向下。
os.write(fd, str)
寫入字串到檔案描述符 fd中. 返回實際寫入的字串長度
Python中的異常處理1.異常型別異常名稱
描述
BaseException
所有異常的基類
SystemExit
直譯器請求退出
KeyboardInterrupt
使用者中斷執行(通常是輸入^C)
Exception
常規錯誤的基類
StopIteration
迭代器沒有更多的值
GeneratorExit
生成器(generator)發生異常來通知退出
StandardError
所有的內建標準異常的基類
ArithmeticError
所有數值計算錯誤的基類
FloatingPointError
浮點計算錯誤
OverflowError
數值運算超出最大限制
ZeroDivisionError
除(或取模)零 (所有資料型別)
AssertionError
斷言語句失敗
AttributeError
物件沒有這個屬性
EOFError
沒有內建輸入,到達EOF 標記
EnvironmentError
作業系統錯誤的基類
IOError
輸入/輸出操作失敗
OSError
作業系統錯誤
WindowsError
系統呼叫失敗
ImportError
匯入模組/物件失敗
LookupError
無效資料查詢的基類
IndexError
序列中沒有此索引(index)
KeyError
對映中沒有這個鍵
MemoryError
記憶體溢位錯誤(對於Python 直譯器不是致命的)
NameError
未宣告/初始化物件 (沒有屬性)
UnboundLocalError
訪問未初始化的本地變數
ReferenceError
弱引用(Weak reference)試圖訪問已經垃圾回收了的物件
RuntimeError
一般的執行時錯誤
NotImplementedError
尚未實現的方法
SyntaxError
Python 語法錯誤
IndentationError
縮排錯誤
TabError
Tab 和空格混用
SystemError
一般的直譯器系統錯誤
TypeError
對型別無效的操作
ValueError
傳入無效的引數
UnicodeError
Unicode 相關的錯誤
UnicodeDecodeError
Unicode 解碼時的錯誤
UnicodeEncodeError
Unicode 編碼時錯誤
UnicodeTranslateError
Unicode 轉換時錯誤
Warning
警告的基類
DeprecationWarning
關於被棄用的特徵的警告
FutureWarning
關於構造將來語義會有改變的警告
OverflowWarning
舊的關於自動提升為長整型(long)的警告
PendingDeprecationWarning
關於特性將會被廢棄的警告
RuntimeWarning
可疑的執行時行為(runtime behavior)的警告
SyntaxWarning
可疑的語法的警告
UserWarning
使用者程式碼生成的警告
2.異常處理1）try/except語句捕捉異常通常用try（捕捉錯誤）/except（處理錯誤）語句。如果你不想在異常發生時結束你的程式，只需在try裡捕獲它。異常可帶引數，用於說明異常原因
try: fh = open("testfile", "w") fh.write("這是一個測試檔案，用於測試異常!!") except (IOError,RuntimeError): # 當出現這兩種error中的一種時，執行except後面的操作 print("Error: 沒有找到檔案或讀取檔案失敗") except Exception as e: # 使用異常基類捕獲 print("Error: 出錯") else: print("內容寫入檔案成功") fh.close()try-finally 語句無論是否發生異常都將執行最後的程式碼。
try: fh = open("testfile", "w") fh.write("這是一個測試檔案，用於測試異常!!") finally: print("Error: 沒有找到檔案或讀取檔案失敗") 我們可以使用raise語句自己觸發異常
raise語法格式如下：
raise [Exception [, args [, traceback]]]語句中Exception是異常的型別（例如，NameError）引數是一個異常引數值。該引數是可選的，如果不提供，異常的引數是"None"。
最後一個引數是可選的（在實踐中很少使用），如果存在，是跟蹤異常物件。例子如下：
def functionName( level ): if level < 1: raise Exception("Invalid level!", level) # 觸發異常後，後面的程式碼就不會再執行 對於自定義的異常，在使用except語句處理異常時，一定要將Exception中的異常名作為except語句的一個引數。例子如下：
try: #正常邏輯 except "Invalid level!": #觸發自定義異常 else: #其餘程式碼 一個異常可以是一個字串，類或物件。
class Networkerror(RuntimeError): # 基於RuntimeError類建立一個新的類 def __init__(self, arg): # 定義一個函式 self.args = arg try: raise Networkerror("Bad hostname") #丟擲一個Networkerror異常 except Networkerror as e: #匹配異常的型別，當出現了Networkerror型異常時，執行該except語句，並傳遞變數e，變數 e 是用於建立Networkerror類的例項，這裡的e應該就是這個異常物件？ print(e.args) 內建函式
abs()
divmod()
input()
open()
staticmethod()
all()
enumerate()
int()
ord()
str()
any()
eval()
isinstance()
pow()
sum()
basestring()
execfile()
issubclass()
print()
super()
bin()
file()
iter()
property()
tuple()
bool()
filter()
len()
range()
type()
bytearray()
float()
list()
raw_input()
unichr()
callable()
format()
locals()
reduce()
unicode()
chr()
frozenset()
long()
reload()
vars()
classmethod()
getattr()
map()
repr()
xrange()
cmp()
globals()
max()
reversed()
zip()
compile()
hasattr()
memoryview()
round()
__import__()
complex()
hash()
min()
set()
delattr()
help()
next()
setattr()
dict()
hex()
object()
slice()
dir()
id()
oct()
sorted()
exec內建表示式
Python面向物件1.面向物件技術簡介· 類(Class): 用來描述具有相同的屬性和方法的物件的集合。它定義了該集合中每個物件所共有的屬性和方法。物件是類的例項（物件是類例項化之後的結果）。
· 類變數：類變數在整個例項化的物件中是公用的。類變數定義在類中且在函式體之外。類變數通常不作為例項變數使用。
· 資料成員：類變數或者例項變數用於處理類及其例項物件的相關的資料。
· 方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。
· 例項變數：定義在方法中的變數，只作用於當前例項的類。
· 繼承：即一個派生類（derived class）繼承基類（base class）的欄位和方法。繼承也允許把一個派生類的物件作為一個基類物件對待。例如，有這樣一個設計：一個Dog型別的物件派生自Animal類，這是模擬"是一個（is-a）"關係（例圖，Dog是一個Animal）。
· 例項化：建立一個類的例項，類的具體物件。
· 方法：類中定義的函式。
· 物件：透過類定義的資料結構例項。物件包括兩個資料成員（類變數和例項變數）和方法。
2.建立類'所有員工的基類'class Employee: empCount = 0 def __init__(self, name, salary): #建構函式 self.name = name # 新增例項屬性 self.salary = salary # 新增例項屬性 Employee.empCount += 1 # 修改類屬性 def displayCount(self): # 新增例項方法 print("TotalEmployee %d" % Employee.empCount) # 讀取類屬性 def displayEmployee(self): # 新增例項方法 print("Name:", self.name, ", Salary:", self.salary) # 讀取例項屬性· empCount變數是一個類變數，它的值將在這個類的所有例項之間共享。你可以在內部類或外部類使用 Employee.empCount訪問。
· 第一種方法__init__()方法是一種特殊的方法，被稱為類的建構函式或初始化方法，當建立了這個類的例項時就會呼叫該方法
· self代表類的例項，self在定義類的方法時是必須有的，雖然在呼叫時不必傳入相應的引數。Self代表了一件事情，那就是：類的方法與普通的函式只有一個特別的區別——它們必須有一個額外的第一個引數名稱,按照慣例它的名稱是 self。
3.建立例項物件例項化類其他程式語言中一般用關鍵字 new，但是在 Python中並沒有這個關鍵字，類的例項化類似函式呼叫方式。
以下使用類的名稱Employee 來例項化，並透過 __init__ 方法接受引數。
"建立 Employee類的第一個物件"emp1 = Employee("Zara",2000)"建立 Employee類的第二個物件"emp2 = Employee("Manni",5000)下面是讀取物件屬性的例項：
'所有員工的基類'class Employee: empCount = 0 def __init__(self, name, salary): #建構函式 self.name = name # 新增例項屬性 self.salary = salary # 新增例項屬性 Employee.empCount += 1 # 修改類屬性 def displayCount(self): # 新增例項方法 print("TotalEmployee %d" % Employee.empCount) # 讀取類屬性 def displayEmployee(self): # 新增例項方法 print("Name:", self.name, ", Salary:", self.salary) # 讀取例項屬性 # "建立 Employee 類的第一個物件"emp1 =Employee("Zara",2000)# "建立 Employee 類的第二個物件"emp2 =Employee("Manni",5000)emp1.displayEmployee()emp2.displayEmployee()print("TotalEmployee %d" %Employee.empCount) 以下函式還可以對屬性進行讀取之外的操作：
· getattr(obj,name[, default]) :訪問物件的屬性。
· hasattr(obj,name):檢查是否存在一個屬性。
· setattr(obj,name,value):設定一個屬性。如果屬性不存在，會建立一個新屬性。
5.Python內建的類屬性· __dict__ :類的屬性（包含一個字典，由類的資料屬性組成）
· __doc__ :類的文件字串
· __name__:類名
· __module__:類定義所在的模組（類的全名是'__main__.className'，如果類位於一個匯入模組mymod中，那麼className.__module__ 等於 mymod）
· __bases__ :類的所有父類構成元素（包含了一個由所有父類組成的元組）
6.類的繼承面向物件的程式設計帶來的主要好處之一是程式碼的重用，實現這種重用的方法之一是透過繼承機制。繼承完全可以理解成類之間的型別和子型別關係。
在python中繼承中的一些特點：
· 1：在繼承中基類的構造（__init__()方法）不會被自動呼叫，它需要在其派生類的構造中親自專門呼叫。
· 2：在呼叫基類的方法時，需要加上基類的類名字首，且需要帶上self引數變數。區別於在類中呼叫普通函式時並不需要帶上self引數
· 3：Python總是首先查詢對應型別的方法，如果它不能在派生類中找到對應的方法，它才開始到基類中逐個查詢。（先在本類中查詢呼叫的方法，找不到才去基類中找）。
如果在繼承元組中列了一個以上的類，那麼它就被稱作"多重繼承" 。
class Parent: # 定義父類 parentAttr =100 def __init__(self): print("呼叫父類建構函式") def parentMethod(self): print('呼叫父類方法') def setAttr(self,attr): Parent.parentAttr =attr def getAttr(self): print("父類屬性 :",Parent.parentAttr) class Child(Parent): # 定義子類 def __init__(self): print("呼叫子類構造方法") #無論子類還是父類，都要單獨寫一次_init_ def childMethod(self): print('呼叫子類方法') def getAttr (self): print('重寫父類方法，因為父類方法不能滿足需求') c = Child() #例項化子類c.childMethod()#呼叫子類的方法c.parentMethod()#呼叫父類方法c.setAttr(200) #再次呼叫父類的方法 -設定屬性值c.getAttr()#再次呼叫父類的方法 -獲取屬性值你可以使用issubclass()或者isinstance()方法來檢測，一個類或物件是否為其他類或物件的子類。
· issubclass() -布林函式判斷一個類是另一個類的子類或者子孫類，語法：issubclass(sub,sup)
· isinstance(obj, Class)布林函式如果obj是Class類的例項物件或者是一個Class子類的例項物件則返回true。
7.運算子過載Python同樣支援運算子過載，例項如下：
class Vector: def __init__(self, a, b): self.a = a self.b = b def __str__(self): return 'Vector(%d, %d)' % (self.a, self.b) def __add__(self, other): return Vector(self.a + other.a, self.b + other.b)v1 = Vector(2, 10)v2 = Vector(5, -2)print(v1 + v2)以上程式碼執行結果如下所示:
Vector(7, 8)__private_attrs：兩個下劃線開頭，宣告該屬性為私有，不能在類的外部被使用或直接訪問。在類內部的方法中使用是self.__private_attrs。
2）類的私有方法__private_method：兩個下劃線開頭，宣告該方法為私有方法，不能在類地外部呼叫。在類的內部呼叫self.__private_methods
3）例項class JustCounter: __secretCount = 0 # 私有變數 publicCount = 0 # 公開變數 def count(self): self.__secretCount += 1 self.publicCount += 1 print(self.__secretCount) # 在內部使用私有化屬性，不會產生錯誤 counter = JustCounter()counter.count()counter.count()print(counter.publicCount)print(counter.__secretCount)# 報錯，例項不能訪問私有變數· __foo__:定義的是特列方法，類似 __init__() 之類的。
· _foo:以單下劃線開頭的表示的是 protected型別的變數，即保護型別只能允許其本身與子類進行訪問，不能用於 from module import *
· __foo:雙下劃線的表示的是私有型別(private)的變數,只能是允許這個類本身進行訪問了。