python概述01

1、概述
Python是著名的「龜叔」Guido van Rossum在1989年聖誕節期間，爲了打發無聊的聖誕節而編寫的一個編程語言。
Python爲咱們提供了很是完善的基礎代碼庫，覆蓋了網絡、文件、GUI、數據庫、文本等大量內容，被形象地稱做「內置電池（batteries included）」。用Python開發，許多功能沒必要從零編寫，直接使用現成的便可。
龜叔給Python的定位是「優雅」、「明確」、「簡單」，因此Python程序看上去老是簡單易懂，初學者學Python，不但入門容易，並且未來深刻下去，能夠編寫那些很是很是複雜的程序。

那Python適合開發哪些類型的應用呢？
首選是網絡應用，包括網站、後臺服務等等； - PythonWeb
其次是許多平常須要的小工具，包括系統管理員須要的腳本任務等等； - Python
另外就是把其餘語言開發的程序再包裝起來，方便使用。 - 膠水語言
在 爬蟲 科學計算 等領域有獨特優點
AI

Python的優勢
簡單易學

完善的語言特性

自然開源

豐富的社區支持

Python的缺點。
第一個缺點就是運行速度慢，和C程序相比很是慢，由於Python是解釋型語言，你的代碼在執行時會一行一行地翻譯成CPU能理解的機器碼，這個翻譯過程很是耗時，因此很慢。而C程序是運行前直接編譯成CPU能執行的機器碼，因此很是快。
可是大量的應用程序不須要這麼快的運行速度，由於用戶根本感受不出來。例如開發一個下載MP3的網絡應用程序，C程序的運行時間須要0.001秒，而Python程序的運行時間須要0.1秒，慢了100倍，但因爲網絡更慢，須要等待1秒，你想，用戶能感受到1.001秒和1.1秒的區別嗎？這就比如F1賽車和普通的出租車在北京三環路上行駛的道理同樣，雖然F1賽車理論時速高達400千米，但因爲三環路堵車的時速只有20千米，所以，做爲乘客，你感受的時速永遠是20千米。
第二個缺點就是代碼不能加密。若是要發佈你的Python程序，實際上就是發佈源代碼，這一點跟C語言不一樣，C語言不用發佈源代碼，只須要把編譯後的機器碼（也就是你在Windows上常見的xxx.exe文件）發佈出去。要從機器碼反推出C代碼是不可能的，因此，凡是編譯型的語言，都沒有這個問題，而解釋型的語言，則必須把源碼發佈出去。

2、安裝配置
安裝包下載地址：
http://www.python.org/download/

Python目前分爲兩大版本，互不兼容：
2.x.x
3.x.x
下載的時候要注意區分 根據須要的版本進行下載 目前二者都有所使用
雙擊安裝

設置環境變量：
將python安裝位置配置到PATH環境變量下。

3、運行方式
shell方式：
在cmd窗口中輸入python進入命令行模式 在其中以交互式方式執行

shell方式調用py文件：
在文件中編寫Python腳本 文件後綴爲.py
進入該文件所在目錄 直接執行./xxx.py

IDE模式：
pycharm
pyDev for Eclipse

**Python編碼
Python默認讀取py文件時採用的編碼格式是 ASCII 格式，若是文件不是該格式極可能出現亂碼問題形成異常。
解決方法爲只要在文件開頭加入 # -*- coding: UTF-8 -*- 或者 #coding=utf-8 來通知Python解釋器在讀取文件時採用的編碼集

4、標識符
在 Python 中，全部標識符能夠包括英文、數字以及下劃線(_)，但不能以數字開頭。
Python 中的標識符是區分大小寫的。
如下劃線開頭的標識符是有特殊意義的。
以單下劃線開頭 _foo 的表明不能直接訪問的類屬性，需經過類提供的接口進行訪問，不能用 from xxx import * 而導入；
以雙下劃線開頭的 __foo 表明類的私有成員；以雙下劃線開頭和結尾的 __foo__ 表明 Python 裏特殊方法專用的標識，如 __init__() 表明類的構造函數。

5、語言細節
1.語句
Python一般一行爲一條語句 不須要分號標識
Python 能夠同一行顯示多條語句，方法是用分號 ;
案例:
print 'hello';print 'runoob';

也可使用反斜槓將一行語句分爲多行解釋：
案例:
total = item_one + \
item_two + \
item_three

可是語句中[] {} () 中的內容不須要使用多行鏈接符。
一個標識符也不能用多行鏈接符隔開

2.縮進
Python 中不使用{}來標識做用範圍，而是用縮進來標識，因此Python中縮進式要嚴格遵循結構。

3.註釋
使用#做爲單行註釋
使用三個單引號或三個雙引號做爲多行註釋

6、變量/常量類型
Python中的變量/常量不須要聲明符 直接寫便可
Python中的變量/常量不區分類型
同一個變量能夠被屢次賦值爲不一樣類型的值

x="abc"
x=123
x = y = z = 999
x,y,z=1,2,"abc"

Python中的變量一般用小寫表示
Python中的常量一般用大寫表示
Python中的常量並不會受到保護 若是真的改是不會報錯的 因此能夠認爲Python中並不真正存在語言意義上的常量 而是約定經過大寫的變量標明它是一個常量 後續不要修改。

7、數據類型
雖然引用沒有數據類型 可是Python是有數據類型的概念的

參看文檔
1.字符串
字符串直接量
能夠用單引號 雙引號 三引號引發來做爲字符串直接量
'abc'
"abc"
'''abc'''
"""abc"""
在聲明字符串直接量時單引號和雙引號沒什麼區別
而三引號聲明的字符串中能夠包含任意字符 這些字符會被直接看成字符串的內容

Python中並不存在相似java中char的字符類型 想要表示一個字符 寫成一個長度爲1的字符串便可
字符串操做符
+ 字符串鏈接
>>>a + b
'HelloPython'
* 重複輸出字符串
>>>a * 2
'HelloHello'
[] 經過索引獲取字符串中字符
>>>a[1]
'e'
[ : ] 截取字符串中的一部分
>>>a[1:4]
'ell'
in 成員運算符 - 若是字符串中包含給定的字符返回 True
>>>"H" in a
True
not in 成員運算符 - 若是字符串中不包含給定的字符返回 True
>>>"M" not in a
True
r/R 原始字符串 - 原始字符串：全部的字符串都是直接按照字面的意思來使用，沒有轉義特殊或不能打印的字符。 原始字符串除在字符串的第一個引號前加上字母"r"（能夠大小寫）之外，與普通字符串有着幾乎徹底相同的語法。
>>>print r'\n'
\n
>>> print R'\n'
\n
% 格式字符串
格式化字符串
%c 格式化字符及其ASCII碼
%s 格式化字符串
%d 格式化整數
%u 格式化無符號整型
%o 格式化無符號八進制數
%x 格式化無符號十六進制數
%X 格式化無符號十六進制數（大寫）
%f 格式化浮點數字，可指定小數點後的精度
%e 用科學計數法格式化浮點數
%E 做用同%e，用科學計數法格式化浮點數
%g %f和%e的簡寫
%G %f 和 %E 的簡寫
%p 用十六進制數格式化變量的地址
案例：
print "My name is %s and weight is %d kg!" % ('Zara', 21)

2.布爾類型
直接量只有兩個 True False
布爾類型的與或非 and or not
3.數值類型：
整型(Int) - 一般被稱爲是整型或整數，是正或負整數，不帶小數點。
長整型(long integers) - 無限大小的整數，整數最後是一個大寫或小寫的L。
浮點型(floating point real values) - 浮點型由整數部分與小數部分組成，浮點型也可使用科學計數法表示（2.5e2 = 2.5 x 102 = 250）
複數(complex numbers) - 複數由實數部分和虛數部分構成，能夠用a + bj,或者complex(a,b)表示， 複數的實部a和虛部b都是浮點型。

類型轉換：
!!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 ) 將一個整數轉換爲一個八進制字符串
數學函數：
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的平方根，數字能夠爲負數，返回類型爲實數，如math.sqrt(4)返回 2+0j
隨機數函數
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]範圍內。

數學常量
pi 數學常量 pi（圓周率，通常以π來表示）
e 數學常量 e，e即天然常數（天然常數）

4.空值
None

8、運算符
算術運算符
+ 加 - 兩個對象相加 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
比較（關係）運算符
== 等於 - 比較對象是否相等 (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。
賦值運算符
= 簡單的賦值運算符 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
位運算符
& 按位與運算符：參與運算的兩個值,若是兩個相應位都爲1,則該位的結果爲1,不然爲0 (a & b) 輸出結果 12 ，二進制解釋： 0000 1100
| 按位或運算符：只要對應的二個二進位有一個爲1時，結果位就爲1。 (a | b) 輸出結果 61 ，二進制解釋： 0011 1101
~ 按位取反運算符：對數據的每一個二進制位取反,即把1變爲0,把0變爲1 (~a ) 輸出結果 -61 ，二進制解釋： 1100 0011， 在一個有符號二進制數的補碼形式。
^ 按位異或運算符：當兩對應的二進位相異時，結果爲1 (a ^ b) 輸出結果 49 ，二進制解釋： 0011 0001
<< 左移動運算符：運算數的各二進位所有左移若干位，由"<<"右邊的數指定移動的位數，高位丟棄，低位補0。 a << 2 輸出結果 240 ，二進制解釋： 1111 0000
>> 右移動運算符：把">>"左邊的運算數的各二進位所有右移若干位，">>"右邊的數指定移動的位數 a >> 2 輸出結果 15 ，二進制解釋： 0000 1111
邏輯運算符
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
成員運算符
in 若是在指定的序列中找到值返回 True，不然返回 False。 x 在 y 序列中 , 若是 x 在 y 序列中返回 True。
not in 若是在指定的序列中沒有找到值返回 True，不然返回 False。 x 不在 y 序列中 , 若是 x 不在 y 序列中返回 True。
身份運算符
is is是判斷兩個標識符是否是引用自一個對象 x is y, 若是 id(x) 等於 id(y) , is 返回結果 1
is not is not是判斷兩個標識符是否是引用自不一樣對象 x is not y, 若是 id(x) 不等於 id(y). is not 返回結果 1

**運算符優先級
** 指數 (最高優先級)
~ + - 按位翻轉, 一元加號和減號 (最後兩個的方法名爲 +@ 和 -@)
* / % // 乘，除，取模和取整除
+ - 加法減法
>> << 右移，左移運算符
& 位 'AND'
^ | 位運算符
<= < > >= 比較運算符
<> == != 等於運算符
= %= /= //= -= += *= **= 賦值運算符
is is not 身份運算符
in not in 成員運算符
not or and 邏輯運算符
9、條件語句
if 判斷條件：
執行語句……
else：
執行語句……

if 判斷條件1:
執行語句1……
elif 判斷條件2:
執行語句2……
elif 判斷條件3:
執行語句3……
else:
執行語句4……

10、循環語句
1.while
while 判斷條件：
執行語句……

while 判斷條件：
執行語句……
else：
循環條件爲false時執行else語句塊

**支持continue、break、pass

2.for
for iterating_var in sequence:
執行語句……

for index in range:
執行語句……

for.... else... #循環條件爲false時執行else語句塊

**range()函數能夠生成一個整數序列包含指定範圍內的數據 再經過list()函數能夠轉換爲一個List
List(range(5))
sum = 0
for x in range(101):
sum = sum + x
print(sum)

3.列表生成式
生成[1x1, 2x2, 3x3, ..., 10x10]:
[x * x for x in range(1, 11)]
for循環後面還能夠加上if判斷:
[x * x for x in range(1, 11) if x % 2 == 0]
還可使用兩層循環
[m + n for m in 'ABC' for n in 'XYZ']
for循環其實能夠同時使用兩個甚至多個變量
d = {'x': 'A', 'y': 'B', 'z': 'C' }
[k + '=' + v for k, v in d.iteritems()]
生成['y=B', 'x=A', 'z=C']
11、集合
1.列表 - List
內容可變 長度可變 類型能夠不一樣 有序

定義列表：
list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
獲取列表數據：
list1[1]
list2[1:5]
更新列表：
list[2] = 2001;
刪除元素：
del list1[2];
列表函數：
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 迭代
列表截取：
L[2] 'SPAM!' 讀取列表中第三個元素
L[-2] 'Spam' 讀取列表中倒數第二個元素
L[1:] ['Spam', 'SPAM!'] 從第二個元素開始截取列表

其餘方法：
cmp(list1, list2)
比較兩個列表的元素
len(list)
列表元素個數
max(list)
返回列表元素最大值
min(list)
返回列表元素最小值
list(seq)
將元組轉換爲列表
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])
對原列表進行排序

2.元組
不能修改的列表

定義元組：
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";
tup1 = ();
tup1 = (50,);#元組中只包含一個元素時，須要在元素後面添加逗號

訪問元組：
tup1[0]
tup2[1:5]

修改元組：
元組是不容許修改的 可是能夠進行鏈接組合
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
tup3 = tup1 + tup2;
print tup3;

刪除元組：
元組中的元素值是不容許刪除的，但咱們可使用del語句來刪除整個元組
tup = ('physics', 'chemistry', 1997, 2000);
del tup;

其餘運算：
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 迭代
L[2] 'SPAM!' 讀取第三個元素
L[-2] 'Spam' 反向讀取；讀取倒數第二個元素
L[1:] ('Spam', 'SPAM!') 截取元素
cmp(tuple1, tuple2)
比較兩個元組元素。
len(tuple)
計算元組元素個數。
max(tuple)
返回元組中元素最大值。
min(tuple)
返回元組中元素最小值。
tuple(seq)
將列表轉換爲元組。

3.字典 - 至關於java中的map
建立字典：
d = {key1 : value1, key2 : value2,... }
鍵必須是惟一的，但值則沒必要。
值能夠取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。
字典中的內容無序

訪問字典：
dict['Name']

修改字典:
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry

刪除字典：
del dict['Name']; # 刪除鍵是'Name'的條目
dict.clear(); # 清空詞典全部條目
del dict ; # 刪除詞典

其餘方法：
cmp(dict1, dict2)
比較兩個字典元素。
len(dict)
計算字典元素個數，即鍵的總數。
str(dict)
輸出字典可打印的字符串表示。
type(variable)
返回輸入的變量類型，若是變量是字典就返回字典類型。
dict.clear()
刪除字典內全部元素
dict.copy()
返回一個字典的淺複製
dict.fromkeys(seq[, val]))
建立一個新字典，以序列 seq 中元素作字典的鍵，val 爲字典全部鍵對應的初始值
dict.get(key, default=None)
返回指定鍵的值，若是值不在字典中返回default值
dict.has_key(key)
若是鍵在字典dict裏返回true，不然返回false
dict.items()
以列表返回可遍歷的(鍵, 值) 元組數組
dict.keys()
以列表返回一個字典全部的鍵
dict.setdefault(key, default=None)
和get()相似, 但若是鍵不存在於字典中，將會添加鍵並將值設爲default
dict.update(dict2)
把字典dict2的鍵/值對更新到dict裏
dict.values()
以列表返回字典中的全部值

4.set
set和dict相似，也是一組key的集合，但不存儲value。因爲key不能重複，因此，在set中，沒有重複的key。
要建立一個set，須要提供一個list做爲輸入集合：
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}
12、日期和時間
1.time 時間戳
ticks = time.time()
localtime = time.localtime(time.time())
0 tm_year 2008
1 tm_mon 1 到 12
2 tm_mday 1 到 31
3 tm_hour 0 到 23
4 tm_min 0 到 59
5 tm_sec 0 到 61 (60或61 是閏秒)
6 tm_wday 0到6 (0是週一)
7 tm_yday 1 到 366(儒略曆)
8 tm_isdst -1, 0, 1, -1是決定是否爲夏令時的旗幟

格式化時間：
localtime = time.asctime( time.localtime(time.time()) )
time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
其餘方法：
1 time.altzone
返回格林威治西部的夏令時地區的偏移秒數。若是該地區在格林威治東部會返回負值（如西歐，包括英國）。對夏令時啓用地區才能使用。
2 time.asctime([tupletime])
接受時間元組並返回一個可讀的形式爲"Tue Dec 11 18:07:14 2008"（2008年12月11日 週二18時07分14秒）的24個字符的字符串。
3 time.clock( )
用以浮點數計算的秒數返回當前的CPU時間。用來衡量不一樣程序的耗時，比time.time()更有用。
4 time.ctime([secs])
做用至關於asctime(localtime(secs))，未給參數至關於asctime()
5 time.gmtime([secs])
接收時間輟（1970紀元後通過的浮點秒數）並返回格林威治天文時間下的時間元組t。注：t.tm_isdst始終爲0
6 time.localtime([secs])
接收時間輟（1970紀元後通過的浮點秒數）並返回當地時間下的時間元組t（t.tm_isdst可取0或1，取決於當地當時是否是夏令時）。
7 time.mktime(tupletime)
接受時間元組並返回時間輟（1970紀元後通過的浮點秒數）。
8 time.sleep(secs)
推遲調用線程的運行，secs指秒數。
9 time.strftime(fmt[,tupletime])
接收以時間元組，並返回以可讀字符串表示的當地時間，格式由fmt決定。
10 time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')
根據fmt的格式把一個時間字符串解析爲時間元組。
11 time.time( )
返回當前時間的時間戳（1970紀元後通過的浮點秒數）。
12 time.tzset()
根據環境變量TZ從新初始化時間相關設置。

2.calendar 日曆
cal = calendar.month(2016, 1)

1 calendar.calendar(year,w=2,l=1,c=6)
返回一個多行字符串格式的year年年曆，3個月一行，間隔距離爲c。 每日寬度間隔爲w字符。每行長度爲21* W+18+2* C。l是每星期行數。
2 calendar.firstweekday( )
返回當前每週起始日期的設置。默認狀況下，首次載入caendar模塊時返回0，即星期一。
3 calendar.isleap(year)
是閏年返回True，不然爲false。
4 calendar.leapdays(y1,y2)
返回在Y1，Y2兩年之間的閏年總數。
5 calendar.month(year,month,w=2,l=1)
返回一個多行字符串格式的year年month月日曆，兩行標題，一週一行。每日寬度間隔爲w字符。每行的長度爲7* w+6。l是每星期的行數。
6 calendar.monthcalendar(year,month)
返回一個整數的單層嵌套列表。每一個子列表裝載表明一個星期的整數。Year年month月外的日期都設爲0;範圍內的日子都由該月第幾日表示，從1開始。
7 calendar.monthrange(year,month)
返回兩個整數。第一個是該月的星期幾的日期碼，第二個是該月的日期碼。日從0（星期一）到6（星期日）;月從1到12。
8 calendar.prcal(year,w=2,l=1,c=6)
至關於 print calendar.calendar(year,w,l,c).
9 calendar.prmonth(year,month,w=2,l=1)
至關於 print calendar.calendar（year，w，l，c）。
10 calendar.setfirstweekday(weekday)
設置每週的起始日期碼。0（星期一）到6（星期日）。
11 calendar.timegm(tupletime)
和time.gmtime相反：接受一個時間元組形式，返回該時刻的時間輟（1970紀元後通過的浮點秒數）。
12 calendar.weekday(year,month,day)
返回給定日期的日期碼。0（星期一）到6（星期日）。月份爲 1（一月） 到 12（12月）。

十3、函數
函數定義：
普通函數定義：
函數代碼塊以 def 關鍵詞開頭，後接函數標識符名稱和圓括號()和冒號。
任何傳入參數和自變量必須放在圓括號中間。圓括號之間能夠用於定義參數。
函數的第一行語句能夠選擇性地使用文檔字符串—用於存放函數說明。
函數內容須要縮進。
return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return至關於返回 None。

def functionname( parameters ):
"函數_文檔字符串"
function_suite
return [expression]
匿名函數定義 - lambda表達式 - 函數直接量：
# 可寫函數說明
sum = lambda arg1, arg2: arg1 + arg2;

# 調用sum函數
print "相加後的值爲 : ", sum( 10, 20 )
print "相加後的值爲 : ", sum( 20, 20 )

函數調用：
定義一個函數只給了函數一個名稱，指定了函數裏包含的參數，和代碼塊結構。
def printme( str ):
"打印任何傳入的字符串"
print str;
return;

printme("My string");
printme(str = "My string");

缺省參數：
def printinfo( name, age = 35 ):
"打印任何傳入的字符串"
print "Name: ", name;
print "Age ", age;
return;
printinfo( age=50, name="miki" );
printinfo( name="miki" );

不定長參數 - 可變參數：
def functionname([formal_args,] *var_args_tuple ):
"函數_文檔字符串"
function_suite
return [expression]

空函數
若是想定義一個什麼事也不作的空函數，能夠用pass語句：
def nop():
pass
pass語句什麼都不作，那有什麼用？實際上pass能夠用來做爲佔位符，好比如今還沒想好怎麼寫函數的代碼，就能夠先放一個pass，讓代碼能運行起來。
pass還能夠用在其餘語句裏，好比：
if age >= 18:
pass
缺乏了pass，代碼運行就會有語法錯誤。

函數是一等公民
能夠做爲類的成員使用
能夠做爲局部成員定義在另外一個函數的內部
能夠被賦值給常量變量
能夠做爲另外一個函數的參數被傳遞 被看成另外一個函數的返回值被返回
閉包問題

十4、模塊
Python 模塊(Module)，是一個 Python 文件，以 .py 結尾，包含了 Python 對象定義和Python語句。
模塊讓你可以有邏輯地組織你的 Python 代碼段。
把相關的代碼分配到一個模塊裏能讓你的代碼更好用，更易懂。
模塊能定義函數，類和變量，模塊裏也能包含可執行的代碼。

引入模塊
import module1[, module2[,... moduleN]
好比要引用模塊 math，就能夠在文件最開始的地方用 import math 來引入。在調用 math 模塊中的函數時，必須這樣引用：
模塊名.函數名
From…import 語句
Python 的 from 語句讓你從模塊中導入一個指定的部分到當前命名空間中。語法以下：
from modname import name1[, name2[, ... nameN]]
From…import* 語句
把一個模塊的全部內容全都導入到當前的命名空間也是可行的，只需使用以下聲明：
from modname import *
搜索路徑
當你導入一個模塊，Python 解析器對模塊位置的搜索順序是：
一、當前目錄
二、若是不在當前目錄，Python 則搜索在 shell 變量 PYTHONPATH 下的每一個目錄。
三、若是都找不到，Python會察看默認路徑。UNIX下，默認路徑通常爲/usr/local/lib/python/。

十5、包
包是一個分層次的文件目錄結構，它定義了一個由模塊及子包，和子包下的子包等組成的 Python 的應用環境。
簡單來講，包就是文件夾，但該文件夾下必須存在 __init__.py 文件, 該文件的內容能夠爲空。__init__.py用於標識當前文件夾是一個包。

考慮一個在 package_runoob 目錄下的 runoob1.py、runoob2.py、__init__.py 文件，test.py 爲測試調用包的代碼，目錄結構以下：
test.py
package_runoob
|-- __init__.py
|-- runoob1.py
|-- runoob2.py

package_runoob/runoob1.py
#!/usr/bin/python
# -*- coding: UTF-8 -*-
def runoob1():
print "I'm in runoob1"

package_runoob/runoob2.py
#!/usr/bin/python
# -*- coding: UTF-8 -*-

def runoob2():
print "I'm in runoob2"

package_runoob/__init__.py
#!/usr/bin/python
# -*- coding: UTF-8 -*-

if __name__ == '__main__':
print '做爲主程序運行'
else:
print 'package_runoob 初始化'

test.py
#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 導入 Phone 包
from package_runoob.runoob1 import runoob1
from package_runoob.runoob2 import runoob2

runoob1()
runoob2()

以上實例輸出結果：
package_runoob 初始化
I'm in runoob1
I'm in runoob2

十6、IO
1.打印到屏幕
print "aaa";

2.讀取鍵盤輸入
raw_input函數
str = raw_input("請輸入：");
input函數 - input([prompt]) 函數和 raw_input([prompt]) 函數基本相似，可是 input 能夠接收一個Python表達式做爲輸入，並將運算結果返回。
str = input("請輸入：");
輸入:[x*5 for x in range(2,10,2)]
str: [10, 20, 30, 40]

3.打開和關閉文件
open 函數
file = open(file_name [, access_mode][, buffering])
file_name：file_name變量是一個包含了你要訪問的文件名稱的字符串值。
access_mode：access_mode決定了打開文件的模式：只讀，寫入，追加等。全部可取值見以下的徹底列表。這個參數是非強制的，默認文件訪問模式爲只讀(r)。
buffering:若是buffering的值被設爲0，就不會有寄存。若是buffering的值取1，訪問文件時會寄存行。若是將buffering的值設爲大於1的整數，代表了這就是的寄存區的緩衝大小。若是取負值，寄存區的緩衝大小則爲系統默認。

r 以只讀方式打開文件。文件的指針將會放在文件的開頭。這是默認模式。
rb 以二進制格式打開一個文件用於只讀。文件指針將會放在文件的開頭。這是默認模式。
r+ 打開一個文件用於讀寫。文件指針將會放在文件的開頭。
rb+ 以二進制格式打開一個文件用於讀寫。文件指針將會放在文件的開頭。
w 打開一個文件只用於寫入。若是該文件已存在則將其覆蓋。若是該文件不存在，建立新文件。
wb 以二進制格式打開一個文件只用於寫入。若是該文件已存在則將其覆蓋。若是該文件不存在，建立新文件。
w+ 打開一個文件用於讀寫。若是該文件已存在則將其覆蓋。若是該文件不存在，建立新文件。
wb+ 以二進制格式打開一個文件用於讀寫。若是該文件已存在則將其覆蓋。若是該文件不存在，建立新文件。
a 打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容以後。若是該文件不存在，建立新文件進行寫入。
ab 以二進制格式打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容以後。若是該文件不存在，建立新文件進行寫入。
a+ 打開一個文件用於讀寫。若是該文件已存在，文件指針將會放在文件的結尾。文件打開時會是追加模式。若是該文件不存在，建立新文件用於讀寫。
ab+ 以二進制格式打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。若是該文件不存在，建立新文件用於讀寫。

file對象屬性
file.closed 返回true若是文件已被關閉，不然返回false。
file.mode 返回被打開文件的訪問模式。
file.name 返回文件的名稱。
file.softspace 若是用print輸出後，必須跟一個空格符，則返回false。不然返回true。

關閉文件：
fileObject.close();

寫文件：
fileObject.write(string);

讀文件：
fileObject.read([count]);

文件隨機讀寫：
tell()方法告訴你文件內的當前位置；換句話說，下一次的讀寫會發生在文件開頭這麼多字節以後。
seek(offset [,from])方法改變當前文件的位置。Offset變量表示要移動的字節數。From變量指定開始移動字節的參考位置。
若是from被設爲0，這意味着將文件的開頭做爲移動字節的參考位置。若是設爲1，則使用當前的位置做爲參考位置。若是它被設爲2，那麼該文件的末尾將做爲參考位置。

重命名文件：
os.rename(current_file_name, new_file_name)
刪除文件：
os.remove(file_name)

建立目錄：
import os
os.mkdir("newdir")

改變的當前目錄：
os.chdir("newdir")

刪除目錄：
os.rmdir('dirname')

File其餘方法:
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)
向文件寫入一個序列字符串列表，若是須要換行則要本身加入每行的換行符。

十7、異常處理
===========================================
python標準異常
異常名稱 描述
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 用戶代碼生成的警告
===========================================

try:
<語句> #運行別的代碼
except <名字>：
<語句> #若是在try部份引起了'name'異常
except <名字>，<數據>:
<語句> #若是引起了'name'異常，得到附加的數據
else:
<語句> #若是沒有異常發生

若是當try後的語句執行時發生異常，python就跳回到try並執行第一個匹配該異常的except子句，異常處理完畢，控制流就經過整個try語句（除非在處理異常時又引起新的異常）。
若是在try後的語句裏發生了異常，卻沒有匹配的except子句，異常將被遞交到上層的try，或者到程序的最上層（這樣將結束程序，並打印缺省的出錯信息）。
若是在try子句執行時沒有發生異常，python將執行else語句後的語句（若是有else的話），而後控制流經過整個try語句。

try:
fh = open("testfile", "w")
fh.write("這是一個測試文件，用於測試異常!!")
except IOError:
print "Error: 沒有找到文件或讀取文件失敗"
else:
print "內容寫入文件成功"
fh.close()

使用except而不帶任何異常類型
你能夠不帶任何異常類型使用except，以下實例：
try:
正常的操做
......................
except:
發生異常，執行這塊代碼
......................
else:
若是沒有異常執行這塊代碼

try-finally 語句
try-finally 語句不管是否發生異常都將執行最後的代碼。
try:
<語句>
finally:
<語句> #退出try時總會執行
異常參數
一個異常能夠帶上參數，可做爲輸出的異常信息參數。
你能夠經過except語句來捕獲異常的參數，以下所示：
try:
正常的操做
......................
except ExceptionType, Argument:
你能夠在這輸出 Argument 的值...
觸發異常
咱們可使用raise語句本身觸發異常
raise語法格式以下：
raise [Exception [, args [, traceback]]]

def functionName( level ):
if level < 1:
raise Exception("Invalid level!", level)
# 觸發異常後，後面的代碼就不會再執行

用戶自定義異常
經過建立一個新的異常類，程序能夠命名它們本身的異常。異常應該是典型的繼承自Exception類，經過直接或間接的方式。
如下爲與RuntimeError相關的實例,實例中建立了一個類，基類爲RuntimeError，用於在異常觸發時輸出更多的信息。
在try語句塊中，用戶自定義的異常後執行except塊語句，變量 e 是用於建立Networkerror類的實例。
class Networkerror(RuntimeError):
def __init__(self, arg):
self.args = arg
在你定義以上類後，你能夠觸發該異常，以下所示：
try:
raise Networkerror("Bad hostname")
except Networkerror,e:
print e.args

十8、面向對象
1.建立類
使用class語句來建立一個新類，class以後爲類的名稱並以冒號結尾，以下實例:
class ClassName:
'類的幫助信息' #類文檔字符串
class_suite #類體

類的幫助信息能夠經過ClassName.__doc__查看。
class_suite 由類成員，方法，數據屬性組成。

實例
#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
'全部員工的基類'
empCount = 0

def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1

def displayCount(self):
print "Total Employee %d" % Employee.empCount

def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary

empCount 變量是一個類變量，它的值將在這個類的全部實例之間共享。你能夠在內部類或外部類使用 Employee.empCount 訪問。
第一種方法__init__()方法是一種特殊的方法，被稱爲類的構造函數或初始化方法，當建立了這個類的實例時就會調用該方法

self 表明類的實例，self 在定義類的方法時是必須有的，雖然在調用時沒必要傳入相應的參數。
self表明類的實例，而非類
類的方法與普通的函數只有一個特別的區別——它們必須有一個額外的第一個參數名稱, 按照慣例它的名稱是 self。
class Test:
def prt(self):
print(self)
print(self.__class__)

t = Test()
t.prt()
#self 不是 python 關鍵字，咱們把他換成 runoob 也是能夠正常執行的:
實例
class Test:
def prt(runoob):
print(runoob)
print(runoob.__class__)

t = Test()
t.prt()

建立實例對象
實例化類的對象在其餘編程語言中通常用關鍵字 new，可是在 Python 中並無這個關鍵字，在python中實例化類的對象似函數的調用。
如下使用類的名稱 Employee 來實例化，並經過 __init__ 方法接受參數。
"建立 Employee 類的第一個對象"
emp1 = Employee("Zara", 2000)
"建立 Employee 類的第二個對象"
emp2 = Employee("Manni", 5000)
訪問屬性
您可使用點(.)來訪問對象的屬性。使用以下類的名稱訪問類變量:
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

你能夠添加，刪除，修改類的屬性，以下所示：
emp1.age = 7 # 添加一個 'age' 屬性
emp1.age = 8 # 修改 'age' 屬性
del emp1.age # 刪除 'age' 屬性
你也可使用如下函數的方式來訪問屬性：
getattr(obj, name[, default]) : 訪問對象的屬性。
hasattr(obj,name) : 檢查是否存在一個屬性。
setattr(obj,name,value) : 設置一個屬性。若是屬性不存在，會建立一個新屬性。
delattr(obj, name) : 刪除屬性。
hasattr(emp1, 'age') # 若是存在 'age' 屬性返回 True。
getattr(emp1, 'age') # 返回 'age' 屬性的值
setattr(emp1, 'age', 8) # 添加屬性 'age' 值爲 8
delattr(empl, 'age') # 刪除屬性 'age'
Python內置類屬性
__dict__ : 類的屬性（包含一個字典，由類的數據屬性組成）
__doc__ :類的文檔字符串
__name__: 類名
__module__: 類定義所在的模塊（類的全名是'__main__.className'，若是類位於一個導入模塊mymod中，那麼className.__module__ 等於 mymod）
__bases__ : 類的全部父類構成元素（包含了一個由全部父類組成的元組）
實例
#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
'全部員工的基類'
empCount = 0

def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1

def displayCount(self):
print "Total Employee %d" % Employee.empCount

def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary

print "Employee.__doc__:", Employee.__doc__
print "Employee.__name__:", Employee.__name__
print "Employee.__module__:", Employee.__module__
print "Employee.__bases__:", Employee.__bases__
print "Employee.__dict__:", Employee.__dict__
執行以上代碼輸出結果以下：
Employee.__doc__: 全部員工的基類
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount': <function displayCount at 0x10a939c80>, 'empCount': 0, 'displayEmployee': <function displayEmployee at 0x10a93caa0>, '__doc__': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', '__init__': <function __init__ at 0x10a939578>}

*閱讀*python對象銷燬(垃圾回收)
Python 使用了引用計數這一簡單技術來跟蹤和回收垃圾。
在 Python 內部記錄着全部使用中的對象各有多少引用。
一個內部跟蹤變量，稱爲一個引用計數器。
當對象被建立時， 就建立了一個引用計數， 當這個對象再也不須要時， 也就是說， 這個對象的引用計數變爲0 時， 它被垃圾回收。可是回收不是"當即"的， 由解釋器在適當的時機，將垃圾對象佔用的內存空間回收。
a = 40 # 建立對象 <40>
b = a # 增長引用， <40> 的計數
c = [b] # 增長引用. <40> 的計數

del a # 減小引用 <40> 的計數
b = 100 # 減小引用 <40> 的計數
c[0] = -1 # 減小引用 <40> 的計數
垃圾回收機制不只針對引用計數爲0的對象，一樣也能夠處理循環引用的狀況。循環引用指的是，兩個對象相互引用，可是沒有其餘變量引用他們。這種狀況下，僅使用引用計數是不夠的。Python 的垃圾收集器其實是一個引用計數器和一個循環垃圾收集器。做爲引用計數的補充， 垃圾收集器也會留心被分配的總量很大（及未經過引用計數銷燬的那些）的對象。 在這種狀況下， 解釋器會暫停下來， 試圖清理全部未引用的循環。
實例
析構函數 __del__ ，__del__在對象銷燬的時候被調用，當對象再也不被使用時，__del__方法運行：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Point:
def __init__( self, x=0, y=0):
self.x = x
self.y = y
def __del__(self):
class_name = self.__class__.__name__
print class_name, "銷燬"

pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # 打印對象的id
del pt1
del pt2
del pt3
以上實例運行結果以下：
3083401324 3083401324 3083401324
Point 銷燬
類的繼承
面向對象的編程帶來的主要好處之一是代碼的重用，實現這種重用的方法之一是經過繼承機制。繼承徹底能夠理解成類之間的類型和子類型關係。
須要注意的地方：繼承語法 class 派生類名（基類名）：//... 基類名寫在括號裏，基本類是在類定義的時候，在元組之中指明的。
在python中繼承中的一些特色：
1：在繼承中基類的構造（__init__()方法）不會被自動調用，它須要在其派生類的構造中親自專門調用。
2：在調用基類的方法時，須要加上基類的類名前綴，且須要帶上self參數變量。區別於在類中調用普通函數時並不須要帶上self參數
3：Python老是首先查找對應類型的方法，若是它不能在派生類中找到對應的方法，它纔開始到基類中逐個查找。（先在本類中查找調用的方法，找不到纔去基類中找）。
若是在繼承元組中列了一個以上的類，那麼它就被稱做"多重繼承" 。
語法：
派生類的聲明，與他們的父類相似，繼承的基類列表跟在類名以後，以下所示：
class SubClassName (ParentClass1[, ParentClass2, ...]):
'Optional class documentation string'
class_suite
實例
#!/usr/bin/python
# -*- coding: UTF-8 -*-

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 "調用子類構造方法"

def childMethod(self):
print '調用子類方法 child method'

c = Child() # 實例化子類
c.childMethod() # 調用子類的方法
c.parentMethod() # 調用父類方法
c.setAttr(200) # 再次調用父類的方法
c.getAttr() # 再次調用父類的方法
以上代碼執行結果以下：
調用子類構造方法
調用子類方法 child method
調用父類方法
父類屬性 : 200
你能夠繼承多個類
class A: # 定義類 A
.....

class B: # 定義類 B
.....

class C(A, B): # 繼承類 A 和 B
.....
你可使用issubclass()或者isinstance()方法來檢測。
issubclass() - 布爾函數判斷一個類是另外一個類的子類或者子孫類，語法：issubclass(sub,sup)
isinstance(obj, Class) 布爾函數若是obj是Class類的實例對象或者是一個Class子類的實例對象則返回true。
方法重寫
若是你的父類方法的功能不能知足你的需求，你能夠在子類重寫你父類的方法：
實例
#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Parent: # 定義父類
def myMethod(self):
print '調用父類方法'

class Child(Parent): # 定義子類
def myMethod(self):
print '調用子類方法'

c = Child() # 子類實例
c.myMethod() # 子類調用重寫方法
執行以上代碼輸出結果以下：
調用子類方法
基礎重寫方法
下表列出了一些通用的功能，你能夠在本身的類重寫：
1 __init__ ( self [,args...] )
構造函數
簡單的調用方法: obj = className(args)
2 __del__( self )
析構方法, 刪除一個對象
簡單的調用方法 : dell obj
3 __repr__( self )
轉化爲供解釋器讀取的形式
簡單的調用方法 : repr(obj)
4 __str__( self )
用於將值轉化爲適於人閱讀的形式
簡單的調用方法 : str(obj)
5 __cmp__ ( self, x )
對象比較
簡單的調用方法 : cmp(obj, x)
運算符重載
Python一樣支持運算符重載，實例以下：
實例
#!/usr/bin/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。
類的私有方法
__private_method：兩個下劃線開頭，聲明該方法爲私有方法，不能在類地外部調用。在類的內部調用 self.__private_methods
實例
#!/usr/bin/python
# -*- coding: UTF-8 -*-

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: 雙下劃線的表示的是私有類型(private)的變量, 只能是容許這個類自己進行訪問了。
__foo__: 定義的是特列方法，相似 __init__() 之類的。

使用類相關函數:
type() 判斷對象類型
type(123)
type('abc')==types.StringType
isinstance(對象,類) 判斷class的類型
isinstance(p,Person)
dir() 得到一個對象的全部屬性和方法
dir('ABC')
十9、python基礎爬蟲之Urllib庫
1.入門案例
案例1：訪問url讀取返回結果
import urllib2
response = urllib2.urlopen("http://www.baidu.com")
print response.read()

說明：
urlopen(url, data, timeout)
第一個參數url即爲URL，第二個參數data是訪問URL時要傳送的數據，第三個timeout是設置超時時間。
第二三個參數是能夠不傳送的，data默認爲空None，timeout默認爲 socket._GLOBAL_DEFAULT_TIMEOUT
第一個參數URL是必需要傳送的，在這個例子裏面咱們傳送了百度的URL，執行urlopen方法以後，返回一個response對象，返回信息便保存在這裏面

案例2：構造request訪問url讀取返回結果
import urllib2
request = urllib2.Request("http://www.baidu.com")
response = urllib2.urlopen(request)
print response.read()
運行結果是徹底同樣的，只不過中間多了一個request對象，更加面向對象

案例3：Get提交
import urllib
import urllib2
values={'username':'park','password'='123'}
data = urllib.urlencode(values)
url = "http://www.baidu.com" + "?"+data
request = urllib2.Request(url)
response = urllib2.urlopen(request)
print response.read()

案例4：Post提交
import urllib
import urllib2
values = {"username":"park","password":"123"}
data = urllib.urlencode(values)
url = "https://www.baidu.com"
request = urllib2.Request(url,data)
response = urllib2.urlopen(request)
print response.read()

案例5：設置Headers
有些網站不會贊成程序直接用上面的方式進行訪問，若是識別有問題，那麼站點根本不會響應，因此爲了徹底模擬瀏覽器的工做，咱們須要設置一些Headers 的屬性。
import urllib
import urllib2
url = 'http://www.xxxx.com/xxx'
values = {'username' : 'pq', 'password' : 'xxx' }
headers = { 'User-Agent' : 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)' ,
'Referer':'http://www.baidu.com/' }
data = urllib.urlencode(values)
request = urllib2.Request(url, data, headers)
response = urllib2.urlopen(request)
page = response.read()

案例6：代理設置
urllib2 默認會使用環境變量 http_proxy 來設置 HTTP Proxy。
假如一個網站它會檢測某一段時間某個IP 的訪問次數，若是訪問次數過多，它會禁止你的訪問。
因此你能夠設置一些代理服務器來幫助你作工做，每隔一段時間換一個代理，以此繞過ip檢測。
import urllib2
enable_proxy = True
proxy_handler = urllib2.ProxyHandler({"http" : 'http://some-proxy.com:8080'})
null_proxy_handler = urllib2.ProxyHandler({})
if enable_proxy:
opener = urllib2.build_opener(proxy_handler)
else:
opener = urllib2.build_opener(null_proxy_handler)
urllib2.install_opener(opener)

案例7：超時時間設置
import urllib2
response = urllib2.urlopen('http://www.baidu.com', timeout=10)
或
import urllib2
response = urllib2.urlopen('http://www.baidu.com',data, 10)

案例8：使用DebugLog
能夠經過下面的方法把 Debug Log 打開，這樣收發包的內容就會在屏幕上打印出來，方便調試

import urllib2
httpHandler = urllib2.HTTPHandler(debuglevel=1)
httpsHandler = urllib2.HTTPSHandler(debuglevel=1)
opener = urllib2.build_opener(httpHandler, httpsHandler)
urllib2.install_opener(opener)
response = urllib2.urlopen('http://www.baidu.com')

案例9：使用cookie
當你獲取一個URL你使用一個opener(一個urllib2.OpenerDirector的實例)。在前面，咱們都是使用的默認的opener，也就是urlopen。它是一個特殊的opener，能夠理解成opener的一個特殊實例，傳入的參數僅僅是url，data，timeout。
若是咱們須要用到Cookie，只用這個opener是不能達到目的的，因此咱們須要建立更通常的opener來實現對Cookie的設置。

import cookielib
import urllib2
#設置保存cookie的文件，同級目錄下的cookie.txt
filename = 'cookie.txt'
#聲明一個MozillaCookieJar對象實例來保存cookie，以後寫入文件
cookie = cookielib.MozillaCookieJar(filename)
#利用urllib2庫的HTTPCookieProcessor對象來建立cookie處理器
handler = urllib2.HTTPCookieProcessor(cookie)
#經過handler來構建opener
opener = urllib2.build_opener(handler)
#建立一個請求，原理同urllib2的urlopen
response = opener.open("http://www.baidu.com")
#保存cookie到文件
#ignore_discard的意思是即便cookies將被丟棄也將它保存下來，ignore_expires的意思是若是在該文件中cookies已經存在，則覆蓋原文件寫入，在這裏，咱們將這兩個所有設置爲True。
cookie.save(ignore_discard=True, ignore_expires=True)

import cookielib
import urllib2
#建立MozillaCookieJar實例對象
cookie = cookielib.MozillaCookieJar()
#從文件中讀取cookie內容到變量
cookie.load('cookie.txt', ignore_discard=True, ignore_expires=True)
#建立請求的request
req = urllib2.Request("http://www.baidu.com")
#利用urllib2的build_opener方法建立一個opener
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie))
response = opener.open(req)
print response.read()
3、Python爬蟲框架
基於Python的爬蟲框架有不少，比較知名的是Scrapy 和PySpider。
pyspider上手更簡單，操做更加簡便，由於它增長了 WEB 界面，寫爬蟲迅速，集成了phantomjs，能夠用來抓取js渲染的頁面。
Scrapy自定義程度高，比 PySpider更底層一些，適合學習研究，須要學習的相關知識多，不過本身拿來研究分佈式和多線程等等是很是合適的。

咱們主要介紹pyspider

1.pyspider安裝配置
(1)安裝pip
pip是python的包管理工具 相似RedHat裏面的yum
訪問https://pypi.python.org/pypi/pip#downloads
下載pip安裝包
解壓pip-9.0.1.tar.gz
在該目錄下執行 setup.py install
將python安裝目錄下的Scripts配置到PATH環境變量

(2)安裝phantomjs
訪問http://phantomjs.org/download.html
下載對應版本phantomjs
解壓phantomjs-2.1.1-windows.zip
將其bin目錄配置到PATH環境變量中

(3)使用pip安裝pyspider
pip install pyspider

(4)運行pyspider
pyspider all

(5)經過瀏覽器訪問pyspider
http://localhost:5000

2.PySpider語法
http://docs.pyspider.org/en/latest/
略

3.PySpider案例
http://cuiqingcai.com/2652.html
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
# Created on 2017-11-17 10:28:34
# Project: MM_TT

from pyspider.libs.base_handler import *
import os
import random

class Handler(BaseHandler):
crawl_config = {
}

baseDir = 'E:\\tbmm';

def __init__(self):
pass

@every(minutes=24 * 60)
def on_start(self):
for x in range(30):
self.crawl('https://mm.taobao.com/json/request_top_list.htm?page='+str(x+1), callback=self.index_page,validate_cert=False)

@config(age=10 * 24 * 60 * 60)
def index_page(self, response):
for each in response.doc('.lady-name').items():
self.crawl(each.attr.href,callback=self.mm_page,validate_cert=False,fetch_type='js')

@config(age=10 * 24 * 60 * 60)
def mm_page(self, response):
self.crawl("https:"+response.doc('.mm-p-domain-info li > span').text(),callback=self.mm_detail_page,validate_cert=False,fetch_type='js')

@config(age=10 * 24 * 60 * 60)
def mm_detail_page(self, response):
#獲取mm名字 建立對應文件夾
mm_name = response.doc('.mm-p-model-info-left-top dd>a').text().encode("gbk")
if not os.path.exists(self.baseDir+'\\'+mm_name):
os.mkdir(self.baseDir+'\\'+mm_name)
#建立desc.txt寫出描述信息
mm_desc = response.doc('.mm-aixiu-content').text().encode("gbk")
f = open(self.baseDir+'\\'+mm_name+"\\desc.txt",'w')
f.write(mm_desc)
f.flush()
f.close()
#獲取mm全部圖片地址 加入爬取
mm_imgs = response.doc('.mm-aixiu-content > div > img').items()
for mm_img in mm_imgs:
self.crawl(mm_img.attr.src, callback=self.download_img_page,validate_cert=False,save={'imgdir':self.baseDir+'\\'+mm_name+'\\'+mm_img.attr.src.split("/")[-1]})

@config(age=10 * 24 * 60 * 60)
def download_img_page(self, response):
imgcontent=response.content
imgfile=open(response.save['imgdir'],"wb")
imgfile.write(imgcontent)
imgfile.flush()
imgfile.close()

4.PySpider案例
https://movie.douban.com/explore#!type=movie&tag=%E7%83%AD%E9%97%A8&sort=recommend&page_limit=20&page_start=0

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
# Created on 2018-07-28 16:28:24
# Project: DBDY

from pyspider.libs.base_handler import *
import json
import os

class Handler(BaseHandler):
base_dir="D:\\DBDY"

@every(minutes=24 * 60)
def on_start(self):
self.crawl('https://movie.douban.com/j/search_subjects?type=movie&tag=%E7%83%AD%E9%97%A8&sort=rank&page_limit=100&page_start=0',validate_cert=False, callback=self.mv_j_page)

@config(age=10 * 24 * 60 * 60) def mv_j_page(self, response): jdata = json.loads(response.text) for each in jdata["subjects"]: self.crawl(each["url"],validate_cert=False, callback=self.mv_detail_page) @config(age=10 * 24 * 60 * 60) def mv_detail_page(self, response): #獲取電影標題 title = response.doc("h1 > span").text().encode("gbk") #建立以電影標題爲名字的文件夾 if not os.path.exists(self.base_dir+"\\"+title): os.mkdir(self.base_dir+"\\"+title) #獲取電影的描述信息 info = response.doc("#info").text().encode("gbk") #將電影描述信息寫出到電影對應的文件夾中 f = open(self.base_dir+"\\"+title+"\\info.txt","w+"); f.write(info) f.flush() f.close() #獲得當前電影對應的圖片頁面 self.crawl(response.doc(".related-pic .pl :nth-child(3)").attr.href,validate_cert=False, callback=self.mv_all_photos_page,save={"mv_dir":self.base_dir+"\\"+title}) @config(age=10 * 24 * 60 * 60) def mv_all_photos_page(self, response): for each in response.doc(".article li a").items(): self.crawl(each.attr.href,validate_cert=False, callback=self.mv_detail_photo_page,save=response.save) @config(age=10 * 24 * 60 * 60) def mv_detail_photo_page(self, response): self.crawl(response.doc(".mainphoto > img").attr.src,validate_cert=False, callback=self.download_photo_page,save={"img_dir":response.save["mv_dir"]+"\\"+response.doc(".mainphoto > img").attr.src.split("/")[-1]}) @config(age=10 * 24 * 60 * 60) def download_photo_page(self, response): img_data = response.content f = open(response.save["img_dir"],"wb"); f.write(img_data) f.flush() f.close()