Author: Lijb

Email:[email protected]

http://www.runoob.com/python3/python3-tutorial.html

Base

• 輸出語句

  print()---在python3中需要加括號---內建函式 向控制檯輸出內容

• 輸入語句

  input(提示資訊) 將使用者在控制檯輸入的內容轉換城字串輸出

• 變數

  1. 賦值後使用---（先定義，後使用）
  2. 作用範圍：從定義開始到包含它的程式碼塊結束
  3. 變數相當於一個標籤貼在了資料上（貼在物件上）---python實際上是沒有型別的---只有一個型別（物件型別）（str,int,float） 書寫形式：變數名=變數值

• 識別符號

  名字：變數名，函式名，類名 語法：（強制性 ）

  1. 合法識別符號，字母，數字（不能開頭），下劃線 中文也是合法的識別符號（屬於字母） 例如：呵呵=10；---強烈不建議用，會出現中文亂碼 Python2:ASCII Python3:UTF-8(Unicode)
  2. 大小寫敏感
  3. 關鍵字不能使用
  4. 沒有長度限制

  開發習慣： 和Java一樣

• 資料型別

  1. 整型：int 32:-2^31~2^31-1 64:-2^63~2^63-1
  2. 浮點型：float大小沒有限制 inf:無限大 e計法：科學計數法 1e+10 1乘以10的10次方
  3. 字串：str:'a' "a" '''a''' """a"""(三引號可以換行)
  4. 布林型別：bool:True False
  5. 空值：None
  6. 複數：實部+虛部 a+bj 不可變資料型別

  ---

  可變資料型別

  7. 列表：list是一種有序的集合
  8. 元組：tuple是一種有序的集合（不可變）
  9. 字典：dict 集合set

• 字串

  1. 單引號，雙引號，三引號包含的內容---字串---由一個一個的字元組成
  2. 引號成對出現
  3. 轉義字元---r表示原始字串：不會發生轉義
  4. 長字串：指三引號包含的字串
  5. len():內建函式---引數長度

• <!--型別轉換-->

  1. 字串-->整型：用int()函式 --要求引數必須為數字(整數)的字串
  2. 字串-->浮點型：用float() ---底層整數部分和小數部分是分開的 如：".123"轉成浮點型為0.123
  3. 浮點型-->整型：用int()函式 --直接去掉小數部分
  4. 整型-->浮點型：用float()函式 --引數必須為數字，如果數字較大則採用e計法展示（科學記數法）
  5. 浮點型-->字串：用str()函式
  6. 整型-->字串：用str()函式

  int() float() str() list() 但凡與資料型別相關的內建函式-->都是工廠函式-->這種轉換模式也是工廠模式

• 獲取型別的資訊

  1. type():檢視資料的型別
  2. isinstance(); 引數一：具體當然資料 引數二：資料的型別 返回值：布林值--->判斷引數一和引數二是否匹配

• 表示式

  定義：變數和字面值用某個式子連線的模式

  表示式必須有固定的字面值

• 運算子

  1. 一般運算子：
     • • • /（真除法） % //（floor除法） **（冪運算）
  2. 賦值運算子： = += -= *= /= %= //=
  3. 布林運算子：（比較運算子）
  4. 邏輯運算子：配合布林運算子 and or not
  5. 位運算子：

     << & 按位求與，兩者都為1 結果為1否則為0 | 按位求或 ~ 按位求非 ^ 按位求異或

  6. 三元運算子： a=(10 if 1<0 else 20)

• 優先順序

  1. 先乘除，後加減

  2. 冪運算優先

  3. 元數越少，優先順序越高

      高--->低
      冪運算-->正負號-->算術運算子-->比較運算子-->邏輯運算子
     

流程控制

條件分支流程

• if-else

  if 布林表示式: 程式碼塊

  if 布林表示式: 程式碼塊 else: 程式碼塊

  if 布林表示式: 程式碼塊 elif: 程式碼塊 else: 程式碼塊

  三種結構：if if-else if-elif-elif-else 相互之間可以巢狀使用

• 斷言

  assert

  1. 這個關鍵字後面的條件為假，則系統自動奔潰，丟擲異常AssertionError
  2. 這個關鍵字後面的條件為真，則系統正常執行

迴圈流程

Python提供了for迴圈和while迴圈（在Python中沒有do..while迴圈）

while迴圈

1.語法：
	while 布林表示式：
		程式碼塊
        
  示例：
n=1
while n<10:
    print("while迴圈")
    n+=1
    
n=1
while True:
    print("while迴圈")
    n+=1
    if n==10:
        break
2.語法
	while 布林表示式：
    	程式碼塊1
    else :
        程式碼塊2
#注：布林表示式條件為真執行程式碼塊1，條件為假執行程式碼塊2

  示例：
count = 0
while count < 5:
   print count, " is  less than 5"
   count = count + 1
else:
   print count, " is not less than 5"


#補充：while後面可以跟True/False---> 0/1--->任何一個物件（只要物件不為空就一直迴圈）
list=[1,2,3,4]
while list:
    front,list=list[0],list[1:]
    print(front,list)

for迴圈

也稱之為：計數迴圈
Python中的for迴圈可以調方法、可以捕獲異常
語法：
	for 目標 in 表示式：
    目標：變數
    表示式：元組、列表、字串--->可迭代物件
示例1：#表示式為字串
for i in "hello":
    print(i)

示例2：#表示式為列表
list=[1,2,3,4,5,6,7,8,9,0]
for i in list:
    print(i)
    
示例3：#表示式為元組
tuple=(1,2,3,4,5,6,7,8,9,0)
for i in tuple:
    print(i)

• range()內建函式

  range([start=0],stop,[step=1]) 1.[]:可選引數 2.start:表示從start開始預設為0；stop表示到stop結束；step:表示步幅預設為1 3.range()函式返回一個range物件（Python2裡面返回的是列表）--->可迭代物件

  示例1：#如果step為1的話可以直接寫成for i in range(10): for i in range(0,10,2): print(i)

• break

  跳出當前迴圈

• continue

  跳過本次迴圈--->不會影響其他迴圈

• pass

  pass是空語句，是為了保持程式結構的完整性。

• 迴圈巢狀使用

  1.#九九乘法表 for i in range(1,10): for j in range(1,i+1): print("%d*%d=%2d" % (j,i,j*i),end=" ") print (" ")

  11= 1
  12= 2 22= 4
  13= 3 23= 6 33= 9
  14= 4 24= 8 34=12 44=16
  15= 5 25=10 35=15 45=20 55=25
  16= 6 26=12 36=18 46=24 56=30 66=36
  17= 7 27=14 37=21 47=28 57=35 67=42 77=49
  18= 8 28=16 38=24 48=32 58=40 68=48 78=56 88=64
  19= 9 29=18 39=27 49=36 59=45 69=54 79=63 89=72 9*9=81

  2.#輸出2~100之間的素數： i = 2 while (i < 100): j = 2 while (j <= (i / j)): if not (i % j): break j = j + 1 if (j > i / j): print(i, " 是素數") i = i + 1 print("Good bye!")

列表

列表：可以存放任何形式的資料（最常用的資料型別之一）
list--->關鍵字 

• 建立列表

  三種列表：

  1. 普通列表 l=[1,2,3] l=['python','java','scala']
  2. 混合列表： l=[1,2,3,'hehe'] l=[1,2,3,'hhe',[4,5,'hehe']]
  3. 空列表 l=[] 列表長度：len(1)

• 向列表中新增元素

  1. append(object): object:任何物件（萬物皆物件） 作用：向列表中新增一個元素，並將元素新增到末尾 呼叫形式：list.append(元素)
  2. extend(iterable): iterable:可迭代物件 作用：將可迭代物件中的元素新增到列表中
  3. insert(index,object): index:索引下標 objec：要插入的元素

• 刪除列表元素

  1. remove(value): 從列表中刪除一個元素 value:元素 注：如果元素不在列表中則會報錯丟擲異常ValueError
  2. pop(): 彈棧：指的就是把棧頂的元素拿出去 刪除並返回最後一個元素，如果設定了index則刪除並返回index下標處的元素 如果列表為空或者下標越界則丟擲異常IndexError
  3. del:不是一個方法，而是一個語句 del 變數名：作用是刪除變數，並不會刪除列表本身 可以使用 del 語句來刪除列表的元素，如下例項： list1 = ['physics', 'chemistry', 1997, 2000]

  print list1 del list1[2] print "After deleting value at index 2 : " print list1

• 從列表中獲取元素

  通過下標獲取元素: list[index] 訪問： 1. 讀取資料 2. 修改資料 遍歷： 將列表中的元素全部訪問一遍，不充分不遺漏

  list=[1,2,3,4,5,6] for i in list: print(i)

• 列表的分片

  slice:分片/切片 利用索引，獲取全部元素 書寫方式： list[起始下標 ：結束下標]--->[start:end] 切片沒有下標限制 簡寫： 如果起始下標為0；則可省略 list[:end] 如果結束下標為leng-1;則可省略 list[start:] 如果全部省略表示整個列表選用 list[:]--->做一些拷貝工作

    list[起始下標:結束下標:步長]
  

Python列表擷取

Python 表示式 結果 描述
L[2] 'Taobao' 讀取列表中第三個元素
L[-2] 'Runoob' 讀取列表中倒數第二個元素 L[1:] ['Runoob', 'Taobao'] 從第二個元素開始擷取列表

Python列表操作符

列表對 + 和 * 的操作符與字串相似。+ 號用於組合列表，* 號用於重複列表。

如下所示：

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 迭代

• 列表常用運算子

  1. 比較運算子 布林運算子：> < >= <= != == 比較每一個元素，從下標為0開始比較，如果相等，則比較下一個元素
  2. 邏輯運算子 and or not
  3. 列表拼接 +
  4. 重複操作符（運算子） *
  5. 成員關係運算符： in /not in

Python列表函式&方法

Python包含以下函式:

序號 函式
1 cmp(list1, list2) 比較兩個列表的元素 2 len(list) 列表元素個數
3 max(list) 返回列表元素最大值
4 min(list) 返回列表元素最小值
5 list(seq) 將元組轉換為列表

Python包含以下方法:

序號 方法
1 list.append(obj) 在列表末尾新增新的物件
2 list.count(obj) 統計某個元素在列表中出現的次數
3 list.extend(seq) 在列表末尾一次性追加另一個序列中的多個值（用新列表擴充套件原來的列表） 4 list.index(obj) 從列表中找出某個值第一個匹配項的索引位置
5 list.insert(index, obj) 將物件插入列表
6 [list.pop(index=-1]) 移除列表中的一個元素（預設最後一個元素），並且返回該元素的值 7 list.remove(obj) 移除列表中某個值的第一個匹配項
8 list.reverse() 反向列表中元素
9 list.sort(cmp=None, key=None, reverse=False) 對原列表進行排序

• 列表的淺拷貝

  copy() list切片也是淺拷貝

• 二位列表

一維列表中的一維列表，和Java一樣

• 排序

  #氣泡排序 list=[5,4,3,9,2,8,6,7,1] n=len(list) for i in range(1,n): for j in range(n-i): if list[j]>list[j+1]: #list[j]^=list[j+1] #list[j+1]^=list[j] #list[j]^=list[j+1] list[j],list[j+1]=list[j+1],list[j] print(list)

  #選擇排序 list=[5,4,3,9,2,8,6,7,1] n=len(list) for i in range(0,n-1): for j in range(i+1,n): if list[i]>list[j]: #list[i]^=list[j] #list[j]^=list[i] #list[i]^=list[j] list[j],list[i]=list[i],list[j] print(list)

  #兩個變數的資料進行交換： 在Java裡有中間變數、異或運算、加發運算 在Python裡除了Java優的方法之外還可以寫成：a,b=b,a的形式 a=1 b=2 a,b=b,a 交換之後a=2,b=1

元組

• 圓括號（括號運算子）

  作用：

  1. 控制優先順序 括號的優先順序最高，可以控制優先順序
  2. 可以作為元組的組成部分

• 元組

  tuple 列表：可以存放任何資料，可以修改 元組：可以存放任何資料，不能修改 元組：不可變型別

    元組最重要的符號是逗號
  

• 建立並訪問一個元組

  1. 直接訪問 t=(元素1，元素2)--->建立多個元素的元組 t=元素1，元素2 --->建立多個元素的元組 t=元素 --->建立一個元素的元組 t=(元素，) --->建立一個元素的元組
  2. tuple()工廠函式建立 tuple()--->返回空元組 tuple(可迭代物件)--->新元組（元素是可迭代物件中的元素）
  3. 訪問一個元組 通過下標訪問（和列表是一樣的）
  4. 元組的切片 t[1:5]
  5. 不可以修改 直接修改會報錯：TypeError 可以利用元組的拼接修改
  6. 刪除元組 del 變數--->刪除的是變數--->元組本身還在
  7. 更新一個元組 第一步：利用切片和拼接操作建立新元組 第二步：改名
  8. 空元組 t=() t=tuple()

元組操作符

與字串一樣，元組之間可以使用 + 號和 * 號進行運算。這就意味著他們可以組合和複製，運算後會生成一個新的元組。

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 迭代

• 常見操作符

元組索引和擷取

因為元組也是一個序列，所以我們可以訪問元組中的指定位置的元素，也可以擷取索引中的一段元素，如下所示：

元組：

L = ('spam', 'Spam', 'SPAM!')

Python 表示式 結果 描述
L[2] 'SPAM!' 讀取第三個元素
L[-2] 'Spam' 反向讀取，讀取倒數第二個元素 L[1:] ('Spam', 'SPAM!') 擷取元素

無關閉分隔符

任意無符號的物件，以逗號隔開，預設為元組，如下例項：

print 'abc', -4.24e93, 18+6.6j, 'xyz'
x, y = 1, 2
print "Value of x , y : ", x,y

#執行結果
abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2

元組內建函式

Python元組包含了以下內建函式

序號 方法及描述
1 cmp(tuple1, tuple2) 比較兩個元組元素。 2 len(tuple) 計算元組元素個數。
3 max(tuple) 返回元組中元素最大值。
4 min(tuple) 返回元組中元素最小值。
5 tuple(seq) 將列表轉換為元組。

字串

天生具有跨平臺性--os--支援字串（內因：文字、字母、數字、符號	外因：編碼表	a=95）
應用
編輯程式碼
傳輸資訊

• Python中的字串

  s='abc' s="abc" s='''abc''' 可以換行--->預設添加了\n--->多行字串--->還可以表示文件註釋 s="""abc""" 可以換行--->預設添加了\n--->多行字串--->還可以表示文件註釋

  1. 字串支援分片操作
  2. 字串時不可變型別--->元組、數字、字串都是不可變型別 列表為可變型別

Python字串轉義字元

在需要在字元中使用特殊字元時，python用反斜槓()轉義字元。如下表：

轉義字元 描述
(在行尾時) 續行符
\ 反斜槓符號
' 單引號
" 雙引號
\a 響鈴
\b 退格(Backspace)
\e 轉義
\000 空
\n 換行
\v 縱向製表符
\t 橫向製表符
\r 回車
\f 換頁
\oyy 八進位制數，yy代表的字元，例如：\o12代表換行 \xyy 十六進位制數，yy代表的字元，例如：\x0a代表換行 \other 其它的字元以普通格式輸出

Python字串運算子

下表例項變數 a 值為字串 "Hello"，b 變數值為 "Python"：

操作符 描述 例項

• 	字串連線                                   	>>>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 % 格式字串
not/or 邏輯操作符

Python 字串格式化

Python 支援格式化字串的輸出 。儘管這樣可能會用到非常複雜的表示式，但最基本的用法是將一個值插入到一個有字串格式符 %s 的字串中。

在 Python 中，字串格式化使用與 C 中 sprintf 函式一樣的語法。

如下例項：

print "My name is %s and weight is %d kg!" % ('Zara', 21) 

#以上例項輸出結果：
My name is Zara and weight is 21 kg!

• python字串格式化符號

  符 號 描述
  %c 格式化字元及其ASCII碼
  %s 格式化字串
  %d 格式化整數
  %u 格式化無符號整型
  %o 格式化無符號八進位制數
  %x 格式化無符號十六進位制數
  %X 格式化無符號十六進位制數（大寫）
  %f 格式化浮點數字，可指定小數點後的精度 %e 用科學計數法格式化浮點數
  %E 作用同%e，用科學計數法格式化浮點數 %g %f和%e的簡寫
  %G %f 和 %E 的簡寫
  %p 用十六進位制數格式化變數的地址

• 格式化操作符輔助指令

  符號 功能

  • 定義寬度或者小數點精度                             
    

  • 用做左對齊                                   
    

  • 在正數前面顯示加號( + )                          
    

  <sp> 在正數前面顯示空格

  在八進位制數前面顯示零('0')，在十六進位制前面顯示'0x'或者'0X'(取決於用的是'x'還是'X')

  0 顯示的數字前面填充'0'而不是預設的空格
  % '%%'輸出一個單一的'%'
  (var) 對映變數(字典引數)
  m.n. m 是顯示的最小總寬度,n 是小數點後的位數(如果可用的話)

Python2.6 開始，新增了一種格式化字串的函式 str.format()，它增強了字串格式化的功能。

• 格式化函式

str.format()

字串格式化：按照一定的格式輸出
format():
	可變長引數 ：*args **kwargs
1. 用{}表示字串引數，花括號中的數字表示位置引數
        對傳遞進來的引數進行格式化整理，並展示最終結果
        s='{[0]呵呵[1]}'.format('hello','world')--->#hello呵呵world
2. 用{}表示字串引數，花括號中的字母表示關鍵字引數
        s='{a}{b}'.format(a='hello',b='world')--->#helloworld

        注：如果關鍵字引數和未知引數混用，則位置引數要放在前邊

Python的字串內建函式

字串方法是從python1.6到2.0慢慢加進來的——它們也被加到了Jython中。

這些方法實現了string模組的大部分方法，如下表所示列出了目前字串內建支援的方法，所有的方法都包含了對Unicode的支援，有一些甚至是專門用於Unicode的。

方法 描述
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 字串末尾的空格.
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

序列(Sequence)

• 列表、元組、字串

  共同點： 1.可迭代物件 2.可以通過索引獲得相應的元素 3.都可以使用分片操作 4.有共同的操作符

  特點： 1.可以通過下標操作 2.有一一對應的元素

  序列：列表、元組、字串

• 序列相關的函式

  內建函式：BIF 列表、元組、字串中的內建函式

  1. list(): list():建立一個空列表 list(iterable):建立一個列表
  2. tuple(): tuple:建立一個元組 tuple(iterable):建立元組
  3. str(obj=''): 將obj轉換成字串
  4. len(obj): 獲取物件obj的長度
  5. max(iterable) 返回可迭代的物件中最大的元素（數值大，編碼大）
  6. min(iterable) 返回可迭代的物件中最小的元素（數值小，編碼小）
  7. sum(iterable,start=0) 從start開始加起，逐個加迭代物件中的數字
  8. sorted() 排序（預設升序）
  9. reversed(): 原地翻轉 返回一個list_reverseiterator物件 檢視該物件： 利用工廠函式進行轉換(list(),tuple()) 利用for迴圈檢視
  10. enumerate(iterable[,start]): 返回元組序列：（下標，元素）
  11. zip(iter1[,iter2[...]])-->): 打包

字典（Dictionary）

字典是另一種可變容器模型，且可儲存任意型別物件。

字典的每個鍵值 key=>value 對用冒號 : 分割，每個鍵值對之間用逗號 , 分割，整個字典包括在花括號 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }
	關鍵字：dict
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
1. 鍵一般是唯一的，如果重複最後的一個鍵值對會替換前面的，值不需要唯一。
2. 值可以取任何資料型別，但鍵必須是不可變的，如字串，數字或元組。
3. 字典不是序列--->是對映型別--->是可迭代物件

• 字典的建立

  1. 直接建立 d = {key1 : value1, key2 : value2 }
  2. 利用函式建立 1.空字典：dict() 2.dict(mapping):引數是一個對映 3.dict(*元組)：引數是一個可迭代物件

• 字典的訪問

讀取+修改

1. 讀取：字典名[key]
2. 修改：字典名[key]=新值
3. 新增鍵值對：字典名[key]=value

字典內建函式&方法

Python字典包含了以下內建函式：

序號 函式及描述
1 cmp(dict1, dict2) 比較兩個字典元素。
2 len(dict) 計算字典元素個數，即鍵的總數。
3 str(dict) 輸出字典可列印的字串表示。
4 type(variable) 返回輸入的變數型別，如果變數是字典就返回字典型別。

Python字典包含了以下內建方法：

序號 函式及描述
1 dict.clear() 刪除字典內所有元素
2 dict.copy() 返回一個字典的淺複製
3 [dict.fromkeys(seq, val]) 建立一個新字典，以序列 seq 中元素做字典的鍵，val 為字典所有鍵對應的初始值 4 dict.get(key, default=None) 返回指定鍵的值，如果值不在字典中返回default值 5 dict.has_key(key) 如果鍵在字典dict裡返回true，否則返回false 6 dict.items() 以列表返回可遍歷的(鍵, 值) 元組陣列
7 dict.keys() 以列表返回一個字典所有的鍵
8 dict.setdefault(key, default=None) 和get()類似, 但如果鍵不存在於字典中，將會新增鍵並將值設為default 9 dict.update(dict2) 把字典dict2的鍵/值對更新到dict裡 10 dict.values() 以列表返回字典中的所有值
11 [pop(key,default]) 刪除字典給定鍵 key 所對應的值，返回值為被刪除的值。key值必須給出。 否則，返回default值。（彈棧） 12 popitem() 隨機返回並刪除字典中的一對鍵和值。彈出鍵值對

函式

• 結果化程式設計

  關鍵字：def 函式的建立： def 函式名 (形參列表)： 邏輯程式碼 函式的呼叫： 函式名(實參列表)

• 函式的特點、執行機制同Java和Scala中的函式一樣

  1. 避免程式碼冗餘
  2. 提高程式的靈活性
  3. 提高程式的可維護性
  4. 提高程式碼的重用性

• 函式的定義位置

  1. 可以定義在檔案頂頭
  2. 函式可以定義在函式內部 參考變數定義函式 作用範圍： 從定義開始到包含它的程式碼塊結束---作為指令碼執行

• 函式的結構

  1. 函式的宣告（定義） def 函式名（引數列表）：多個引數用逗號分開，引數個數無限制
  2. 函式的內容： 程式碼 沒有內容：pass
  3. 函式的返回值 關鍵字：return ---如果不寫系統自動新增--任何函式一定有返回值

函式的引數

• 位置引數

  #和java一樣嚴格按照引數的位置進行呼叫和資料傳遞 def fun(a,b): 內容

  fun(a,b)

• 關鍵字引數

  定義了關鍵字的引數，與位置無關 def fun(a,b): print(a,b)

  fun(b='B',a='A')

  1. 利用關鍵字引數傳遞與位置無關
  2. 位置引數必須在關鍵字引數前面。（系統為會認為從關鍵字引數開始後面的引數均為關鍵字引數）
  3. 關鍵字引數不能多次賦值

• 預設引數

  是定義了預設值的引數 #預設引數 def fun(a='A',b='B'): print(a,b)

  fun('C','D')

• 可變長引數

  收集引數

  1. 在引數前面加* 將所有的引數打包成元組，輸出--->不能使用關鍵字引數
  2. 在引數前面加** 將所有引數打包成字典。輸出--->只能使用關鍵字引數傳遞

• 命名關鍵字引數

  *後面定義的形式 def fun(*param,a): print(a) fun('A','B',a='C')

  1. 可變長引數和位置引數共用 如果位置引數在後，則實參在指定為位置使用關鍵字引數 如果位置引數在前，直接傳參不能使用關鍵字引數

• 函式的文件

  文件的讀取

  1. help()
  2. 函式名.doc

函式與過程

1. 函式：函式的宣告，函式的返回值
2. 過程：函式的實現（內容）

	函式與過程是相互分離的

返回值

python的返回值是動態的，編譯器動態的確定具體型別

1. return 語句後面一定要有一個引數
2. 函式如果沒有書寫return則系統會自動的增加一個return None
3. 函式如果沒有書寫return後面的值，則系統會自動的增加一個None
4. return可以返回多個返回值，多個數據之間用逗號分隔開，本質上封裝成了元組
5. return可以返回一個容器型別的資料（容器中可以裝多個數據）
6. return後面可以書寫一個表示式，函式的呼叫，返回一個值

• 函式變數的作用域

  區域性變數、全域性變數、作用範圍和java裡面一樣使用

• global

全域性變數有關

#可以在函式內部訪問全域性變數 
a=10
def fun():
    global a
    a=20
    print(a)

fun()
print(a)
#20  20

• nonlocal

區域性變數有關

#可以在內部函式的內部訪問外部函式的區域性變數
def fun():
    a=10

    def fun1():
        nonlocal a
        a = 20
        print(a)
    fun1()
    print(a)
fun()

注意：
	函式不能對全域性變數進行增強賦值運算（a=a+1	a+=1）
	內部函式不能對外部函式的區域性變數進行增強運算（a=a+1 a+=1）

解決方案：可以利用gloabl和nonlocal宣告一下

lambda表示式與匿名函式

匿名函式

python 使用 lambda 來建立匿名函式。

• lambda只是一個表示式，函式體比def簡單很多。

• lambda的主體是一個表示式，而不是一個程式碼塊。僅僅能在lambda表示式中封裝有限的邏輯進去。

• lambda函式擁有自己的名稱空間，且不能訪問自有引數列表之外或全域性名稱空間裡的引數。

• 雖然lambda函式看起來只能寫一行，卻不等同於C或C++的行內函數，後者的目的是呼叫小函式時不佔用棧記憶體從而增加執行效率。

• 語法

lambda函式的語法只包含一個語句，如下：

語法：
	lambda [arg1 [,arg2,.....argn]]:expression
	：左邊是引數	：右邊式返回值

如下例項：

# 可寫函式說明 
sum = lambda arg1, arg2: arg1 + arg2;   
# 呼叫sum函式
print "相加後的值為 : ", sum( 10, 20 ) 
print "相加後的值為 : ", sum( 20, 20 )

#以上例項輸出結果：
相加後的值為 :  30
相加後的值為 :  40

#普通函式
def fun(x):
    return 2*x+1
print(fun(5))

#lambda表示式改寫
a=lambda x:2*x+1
print(a(5))

注意

1.使用場景：只是用一次之後就不用的這種函式就可以用lambda表示式取建立。
2.lambda表示式的執行效率較普通函式更低。
3.lambda表示式的優先順序最低。

補充點：（閉包的延時繫結python深層次的知識點）**

概念：
	1.閉包：函數語言程式設計中的重要語法結構，函數語言程式設計是一種程式設計正規化
	2.程式設計正規化：對程式碼進行提煉和抽象的概括，使得程式碼的重用性更高
# 如果在一個內部函式裡面對外部函式的區域性變數進行引用，外部函式以內部函式名呼叫，則這個內部函式就是一個閉包
條件：
	1.只要內部函式使用了外部函式的區域性變數
	2.如果外層函式返回值為內層函式物件
作用：
	1.可以在宣告較少引數情況下，傳遞更多的引數
	2.可以使用內部的函式
	3.多應用於叢集

def fun1():
    a=10
    def fun2(x):
        return a+x
    return fun2
print(fun1()(10))
#結果為：20

Python中的作用域洩露

for i in range(3):	# i區域性變數--->作用域洩露--->危險
	a=i*2	# i最終將變成2
print(a)	# 4

閉包的延時繫結

def fun():
    return [lambda x:i*x for i in range(4)] #此處i相對於該函式來說是全域性變數
print([m(2) for m in fun()])

#結果
[6, 6, 6, 6]
'''
Python 中文件說明：
	如果i 被賦值（執行for迴圈），那麼可以在for迴圈之外分享變數
	如果i並沒有被賦值，那麼則訪問不到
'''

#等價於
def fun():
    list=[]
    for i in range(4):
        def lam(x):
            return x*i
        list.append(lam)
    return list
print([m(2) for m in fun()])

• 閉包的延時繫結問題的解決辦法

  def fun(): return [lambda x,n=i:x*n for i in range(4)] print([m(2) for m in fun()])

  def fun(): list=[] for i in range(4): def lam(x,n=i): return x*n list.append(lam) return list print([m(2) for m in fun()]) #只需要取每一次遍歷的i即可，不要取最終的i

Python中的高階函式

• filter()

  filter(function or None,iterable) 引數一：是一個函式或者None 引數二：是一個可迭代物件 如果第一個引數為函式，則將第二個引數中的每一個元素作為引數傳遞給第一個函式引數

    注意：
    	1.如果第一個引數為None，則返回第二引數（可迭代物件）中的非False(0,False,所有的空值)
    	2.第一個引數的返回值--->只返回True或者False--->布林函式
  

  def fun(x): return x%2 print(list(filter(fun,[1,2,3,4,5,6,7,8,9,10]))) #結果為：[1, 3, 5, 7, 9]

  def fun1(x): if x%2==0: return True else: return False print(list(filter(fun1,[1,2,3,4,5,6,7,8,9,10]))) #結果為：[2, 4, 6, 8, 10]

  filter()函式要做的事情就是把所有為False的去除

• map()

  map(func,*iterable) 引數一：函式 引數二：多個可迭代物件

  1. 將每一個引數的元素進行運算，直到每個元素都進行運算完畢，將運算後的整體構建成新的序列

  def fun(x): return x*2 print(list(map(fun,[1,2,3,4,5])))

  #結果為：[2, 4, 6, 8, 10] 改成lambda形式 print(list(map(lambda x:x*2,[1,2,3,4,5])))

• reduce()

  Python3:functiontools.reduce() #需要引入該模組

  1. reduce(function(),sequence[,initial]) 對序列中的一對元素進行計算,這個計算結果將和第三個元素繼續進行計算，以此類推。 第一個引數：函式 第二個引數：序列 第三個引數：初始值，如果給了初始值則先計算初始值

  #沒有初始值情況： import functools def fun(x,y): return x+y print(functools.reduce(fun,[1,2,3,4,5,6]))

  結果為：21

  #有初始值情況 import functools def fun(x,y): return x+y print(functools.reduce(fun,[1,2,3,4,5,6],10))

  結果為：31

函式巢狀和遞迴

函式巢狀：在一個函式裡面呼叫另一個函式
執行流程和java一樣的

• 一元二次方程

ax^2+bx+c=0

x=\frac{-b\pm\sqrt{b^2-4ac}}{2a}

# 解一元二次方程
def fun(a, b, c):
    # 判斷是否有解
    delta = b ** 2 - 4 * a * c
    if existSolution(a, b, c):
        x1 = (-b + delta ** 0.5) / 2 * a
        x2 = (-b + delta ** 0.5) / 2 * a
        print('方程有解，x1=%s x2=%s' %(x1,x2))
    else:
        print("方程無解")

# 判斷是否有解,有解返回True無解返回False
def existSolution(a, b, c):
    delta = b ** 2 - 4 * a * c
    if delta >= 0:
        return True
    else:
        return False

#呼叫
fun(1,0,-4)

#結果：方程有解，x1=2.0 x2=2.0

• 遞迴

  和Java一樣，遞迴是一種特殊的函式巢狀呼叫，自己呼叫自己 避免無窮遞迴--->要加收斂條件

  def fact(n): if n == 1: return 1 else: ret = n * fact(n - 1) return ret n = int(input("請輸入一個數：")) print('%s 的階乘為%s' %(n,fact(n)))

  #結果為： 請輸入一個數：5 5 的階乘為120

• 斐波那契數列

  #斐波那契額數列 def feibo(n): a=1 b=1 for i in range(1,n+1): if i<3: print(1,end=' ') else: a,b=b,a+b print(b,end=' ') feibo(12)

  #結果為：1 1 2 3 5 8 13 21 34 55 89 144

  #用遞迴實現 def feibo(n): if n<3: return 1 else: return feibo(n-1)+feibo(n-2) for i in range(1,13): print(feibo(i),end=' ') #結果為：1 1 2 3 5 8 13 21 34 55 89 144

• 漢諾塔問題

遞迴中的經典問題

#a,b,c柱子名稱（從a將n個盤子挪到b,藉助c）;n表示共有幾個盤子
def hannoi(a,b,c,n):
    if n==1:
        print('%s --->%s'%(a,b))
        return
    hannoi(a,c,b,n-1)
    print('%s ---> %s' %(a,b))
    hannoi(c,b,a,n-1)

hannoi('A','B','C',3)

#結果為：
A --->B
A ---> C
B --->C
A ---> B
C --->A
C ---> B
A --->B

Python 內建函式

           	           	內建函式        	           	              

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() reverse() zip()
compile() hasattr() memoryview() round() import()
complex() hash() min() set()
delattr() help() next() setattr()
dict() hex() object() slice()
dir() id() oct() sorted() exec 內建表示式

__init__ : 建構函式，在生成物件時呼叫
__new__ :建立物件
__del__ : 解構函式，釋放物件時使用，析構器/垃圾回收器
__repr__ : 列印，轉換
__setitem__ : 按照索引賦值
__getitem__: 按照索引獲取值
__len__: 獲得長度
__cmp__: 比較運算
__call__: 函式呼叫
__add__: 加運算
__sub__: 減運算
__mul__: 乘運算
__truediv__: 除運算
__mod__: 求餘運算
__pow__: 乘方

集合

1. 集合中的元素是無序的、唯一的
		字典的key是集合實現的 所以是無序的唯一的不重複的

• 集合的建立

集合（set）是一個無序的不重複元素序列。 可以使用大括號 { } 或者 set() 函式建立集合，注意：建立一個空集合必須用 set() 而不是 { }，因為 { } 是用來建立一個空字典。

1. 直接建立
2. 使用set()工廠函式：
        set()：返回一個空集合物件--->沒有空集合
        set(iterable):去重轉集合

• 集合的訪問

  其他訪問的函式下表總結

  1. 遍歷： 利用for迴圈進行遍歷
  2. 成員運算子： in 包含 not in 不包含
  3. 比較運算子： 參考數學中集合的比較概念：比大小是比包含關係的不是拿元素內容比的

• 並集、交集、差集

  和數學中的概念是一樣的

  1. 交集：&
  2. 並集：or python2中支援+
  3. 差集：-

• 不可變集合

  關鍵字：frozenset a=frozenset([1,2,3]) 返回一個frozenset物件

• enumerate

  enumerate(iterable[,start]) 返回一個enumerate物件，該物件封裝可迭代物件的元素和下標--->封裝成了(index,value)形式

  list=[1,2,3,4,5] for i in enumerate(list): print(i)

  #結果為： (0, 1) (1, 2) (2, 3) (3, 4) (4, 5)

集合內建方法

方法 描述
add() 為集合新增元素,如果該元素存在則不新增
clear() 移除集合中的所有元素
copy() 拷貝一個集合
difference() 返回多個集合的差集
difference_update() 移除集合中的元素，該元素在指定的集合也存在。
discard() 刪除集合中指定的元素
intersection() 返回集合的交集
intersection_update() 刪除集合中的元素，該元素在指定的集合中不存在。
isdisjoint() 判斷兩個集合是否包含相同的元素，如果沒有返回 True，否則返回 False。 issubset() 判斷指定集合是否為該方法引數集合的子集。
issuperset() 判斷該方法的引數集合是否為指定集合的子集
pop() 隨機移除元素
remove() 移除指定元素
symmetric_difference() 返回兩個集合中不重複的元素集合。
symmetric_difference_update() 移除當前集合中在另外一個指定集合相同的元素，並將另外一個指定集合中不同的元素插入到當前集合中。 union() 返回兩個集合的並集
update() 給集合新增元素

面向物件

面向物件的幾個概念

1. 類(Class): 用來描述具有相同的屬性和方法的物件的集合。它定義了該集合中每個物件所共有的屬性和方法。物件是類的例項。
2. 方法：類中定義的函式。
3. 類變數：類變數在整個例項化的物件中是公用的。類變數定義在類中且在函式體之外。類變數通常不作為例項變數使用。
4. 資料成員：類變數或者例項變數用於處理類及其例項物件的相關的資料。
5. 方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。
6. 區域性變數：定義在方法中的變數，只作用於當前例項的類。
7. 例項變數：在類的宣告中，屬性是用變數來表示的。這種變數就稱為例項變數，是在類宣告的內部但是在類的其他成員方法之外宣告的。
8. 繼承：即一個派生類（derived class）繼承基類（base class）的欄位和方法。繼承也允許把一個派生類的物件作為一個基類物件對待。例如，有這樣一個設計：一個Dog型別的物件派生自Animal類，這是模擬"是一個（is-a）"關係（例圖，Dog是一個Animal）。
9. 例項化：建立一個類的例項，類的具體物件。
10. 物件：通過類定義的資料結構例項。物件包括兩個資料成員（類變數和例項變數）和方法。

• 類的定義

  #定義類 class Student: name='lijb' age=18 sex=True

    #定義方法
    def learn(self,name):
        print('Students %s are learning...' %(name))
  

  #建立物件 s=Student() #呼叫物件的屬性 print(s.name) #呼叫物件的方法 s.learn('luanp')

• 屬性

  1. 屬性的分類（變數） 示例屬性：在方法內部定義，定義方式（self.屬性名=屬性值） 類屬性：在類的內部，方法的外部定義
  2. 訪問形式: 物件.屬性名
  3. 類屬性 建立：直接定義，需要預設值 訪問形似：物件.屬性名
  4. 例項屬性： 建立：通過self.屬性名 優勢：直接使用屬性而不用定義，該定義形式可以避免建立時必須賦值的情況 在類的內部訪問：self.屬性名 利用物件去訪問：物件名.屬性名

• 例項屬性和類屬性的區分

  例項屬性：每個例項各自擁有，互不影響 類屬性：全類所有

• 方法

  1. 方法：宣告+實現
  2. self（指當前物件） 方法可以多個引數，用逗號隔開 self:在呼叫時，自動傳遞，不需要手動傳遞
  3. 方法： 只能在建立物件之後呼叫，放法繫結到物件（例項）上

• 構造方法

  1. init(self): 在建立物件時預設呼叫1次，可以手工呼叫但是不需要手工呼叫
  2. init(self,param1,param2,...): 構造方法可以有多個引數，用逗號隔開
  3. 如果一個類中沒有任何構造方法，預設呼叫的是父類的構造方法
  4. 一個類中可以定義多個構造方法，但是隻會執行最後一個構造方法（後面的構造方法將前面的覆蓋）
  5. 構造方法的返回值為None

• 建立物件

  1. 建立物件 變數名=類名（構造引數） d=Dog() Dog()這種沒有引用的物件會被標記為垃圾，垃圾回收機制
  2. 建立的物件統稱為例項--instance 和例項相關的屬性：例項屬性---繫結屬性 和例項相關的方法：例項方法---繫結方法

• 組合

  一個類的屬性是另一個物件稱之為組合 注意： 1.如果例項屬性和方法發生命名衝突，則方法無法呼叫 2.如果類屬性和方法發生命名衝突，則類屬性無法被呼叫（呼叫時顯示為同名方法的地址）

• 公有和私有問題

  成員私有化

  1. 私有化：name mangling---名字重造

  2. 在成員名前加__兩個下劃線

  3. 私有成員 不能在類之外被訪問，只能在本類重訪問 成員私有化後要提供對應的get/set方法

  4. python的私有化為偽私有化 將成員名修改為：_類名_成員名

  5. 類的私有屬性 __private_attrs：兩個下劃線開頭，宣告該屬性為私有，不能在類的外部被使用或直接訪問。在類內部的方法中使用時 self.__private_attrs。 類的方法 在類的內部，使用 def 關鍵字來定義一個方法，與一般函式定義不同，類方法必須包含引數 self，且為第一個引數，self 代表的是類的例項。 self 的名字並不是規定死的，也可以使用 this，但是最好還是按照約定是用 self。

  6. 類的私有方法 __private_method：兩個下劃線開頭，宣告該方法為私有方法，只能在類的內部呼叫 ，不能在類的外部呼叫。self.__private_methods。

封裝

和Java一樣，資料隱藏，屬性私有化

繼承

定義形式：
	class 子類類名（父類類名）：#父類類名不寫預設為object
繼承特點：
1. 子類可以繼承父類的方法和屬性
2. 可擴充套件性
3. 父類中的私有成員不能被繼承（不能直接訪問）
4. 子類中沒有構造方放時預設呼叫父類的構造方法
子類呼叫父類的構造方法：
    A.父類名.__init__(self):   ---在子類內部呼叫
    B.父類名.__init__(當前物件):---在子類外部呼叫
    C.super().__init__():	 ---利用super()函式---不用傳self引數因為系統自動給super傳了
5. 子類有構造方法時呼叫自己的構造方法

	其特點和Java一樣

單繼承

class DerivedClassName(BaseClassName1):
    <statement-1>
    .
    .
    .
    <statement-N>

需要注意圓括號中基類的順序，若是基類中有相同的方法名，而在子類使用時未指定，python從左至右搜尋 即方法在子類中未找到時，從左到右查詢基類中是否包含方法。

BaseClassName（示例中的基類名）必須與派生類定義在一個作用域內。除了類，還可以用表示式，基類定義在另一個模組中時這一點非常有用:

#類定義
class people:
    #定義基本屬性
    name = ''
    age = 0
    #定義私有屬性,私有屬性在類外部無法直接進行訪問
    __weight = 0
    #定義構造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 說: 我 %d 歲。" %(self.name,self.age))
 
#單繼承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #呼叫父類的構函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆寫父類的方法
    def speak(self):
        print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
  
s = student('ken',10,60,3)
s.speak()

多繼承

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

需要注意圓括號中父類的順序，若是父類中有相同的方法名，而在子類使用時未指定，python從左至右搜尋 即方法在子類中未找到時，從左到右查詢父類中是否包含方法。

特點：多繼承要不斷的建立父類物件佔記憶體浪費資源

#類定義
class people:
    #定義基本屬性
    name = ''
    age = 0
    #定義私有屬性,私有屬性在類外部無法直接進行訪問
    __weight = 0
    #定義構造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 說: 我 %d 歲。" %(self.name,self.age))
 
#單繼承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #呼叫父類的構函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆寫父類的方法
    def speak(self):
        print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
 
#另一個類，多重繼承之前的準備
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一個演說家，我演講的主題是 %s"%(self.name,self.topic))
 
#多重繼承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，預設呼叫的是在括號中排前地父類的方法

Python中的繼承時多繼承---鑽石繼承問題--多繼承要不斷的建立父類物件佔記憶體浪費資源--解決辦法為：super()
super()底層是mro核心（繼承鏈關係）實現的

方法重寫

如果父類方法的功能不能滿足你的需求，你可以在子類重寫你父類的方法，例項如下：

class Parent:        # 定義父類
   def myMethod(self):
      print ('呼叫父類方法')
 
class Child(Parent): # 定義子類
   def myMethod(self):
      print ('呼叫子類方法')
 
c = Child()          # 子類例項
c.myMethod()         # 子類呼叫重寫方法
super(Child,c).myMethod() #用子類物件呼叫父類已被覆蓋的方法

執行以上程式輸出結果為：

呼叫子類方法
呼叫父類方法

多型

多型

多型指一類事物具有多種形態（繼承關係）
序列：列表、元組、字串
動物：貓、狗。。。

多型性

是指不同功能的函式，可以使用同一個函式名，可以使用同一個函式名呼叫不同的內容
向不同的物件傳送同一條訊息，不同的物件在接受時會產生不同的形式為。

函式

• issubclass()

  issubclass(cls,class_or_tuple):

  1. 如果cls類是class類的子類返回True,相同也返回True,不是則返回False
  2. 如果cls是tuple元素的子類則返回True

• isinstance()

  isinstance(obj,class_or_tuple):

  1. 如果obj是class的例項物件則返回True
  2. 如果obj繼承了class則返回True
  3. 如果obj是tuple中的元素例項則返回True

• hasattr()

  hasattr(obj,name,/): 判斷obj物件中是否有name這個屬性---name是str

• getattr()

  getattr(object,name[,default]):

  1. 從object中獲取一個屬性值---name
  2. 如果name不存在則返回default中的資訊
  3. 如果default沒有定義則丟擲異常

• setattr()

  setattr(obj,name,value): 設定obj中的name屬性值為value

• delattr()

  delattr(object,name): 刪除object中name屬性

• property（）

  property（fget=None,fset=None,fdel=None,doc=None）:

  1. 通過屬性設定屬性
  2. 將屬性和另一個屬性做關聯，修改一個屬性，則另一個屬性也隨之更改
  3. fget,fset,fdel分別代表關聯屬性的get,set,del
  4. 方法的返回值用於關聯另一個屬性

修飾器（修飾符）

作用：可以為已經存在的程式碼增加額外功能

修飾器：Decorator:
關鍵字：@
1. 修飾器只能出現在函式定義的前一行，不允許和函式定義在同一行
2. 只能在模組或類中定義，並且不能修飾類，只能是對函式或方法進行修飾
3. 裝飾器本身是一個函式，是將被修飾的函式當作引數傳遞給裝飾器，返回的是修飾之後的函式

• 基本定義形式

  #基本定義形式 class B: #定義修飾器 def A(fun): print("修飾器") return fun #返回一個函式 #修飾器修飾方法 @A def m1(self): print('執行m1()') #建立物件並呼叫方法 b=B() b.m1() #結果： 修飾器 執行m1()

• 利用內嵌函式

  #利用內嵌函式 def funA(f): def funB(): print("inner function B") funB() return f

  @funA def funC(): print('function C')

  funC() #結果： inner function B function C

• 利用閉包

  #利用閉包 def funD(f): def funE(): print('inner function E') f() return None return funE

  @funD def funF(): print('function F') return None funF() #結果： inner function E function F

• 利用類

  #利用類 class G: def init(self,f): self.f=f def call(self): print('class G') return self.f()

  @G def funH(): print('function H') return None

  funH() #結果： class G function H

• 使用案例

計算程式執行的時間

#計算程式執行的時間
import time
def timelong(f):
    start=time.clock()
    print('time start')
    f()
    end=time.clock()
    print('time end')
    print('程式執行的時間為：%s s'%(end-start))

    return lambda :None

@timelong
def sum1():
    ret=0
    for i in range(100):
        ret +=i

    print('計算的結果為：%s'%(ret))

sum1()
#結果：
    time start
    計算的結果為：4950
    time end
    程式執行的時間為：4.758972406575423e-05 s

Python中內建的裝飾器

1. classmethond:修飾類方法	
2. property
3. staticmethond:靜態方法（和函式的使用完全一樣）

專題

專題1：Python中的賦值

運算 解釋
a='hehe' 基本形式
a,b=1,2 元組賦值（位置性）
[a,b]=[1,2] 列表賦值（位置性）
a,b,c,d='spark' 序列賦值（通用性）
a,b,c=[1,2,3] 序列賦值（通用性）
a,*b='spark' 擴充套件的序列解包（Python3獨有的） a=b=c=d='spark' 多目標賦值
a+=1 增強賦值：相當於a=a+1

• 高階序列賦值

1. 高階序列賦值--->賦值巢狀序列

   s='spark' (a,b),c=s[:2],s[2:] print((a,b),c)

   #結果： ('s', 'p') ark

2. 高階序列賦值--->利用range()函式

   a,b,c=range(3) print(a,b,c)

3. 利用切片進行序列的分割

   list=[1,2,3,4] while list: front,list=list[0],list[1:] print(front,list) #結果如下：
   1 [2, 3, 4] 2 [3, 4] 3 [4] 4 []

• Python3中擴充套件的序列解包

1. a,*b a匹配第一個元素元素 b匹配剩餘的元素

   a,*b=[1,2,3,4] print(a,b) #結果： （1,[2,3,4]）

2. *a,b b匹配最後一項 a匹配前面的剩餘項

   *a,b=[1,2,3,4] print(a,b) #結果： ([1,2,3],4)

3. a,*b,c a匹配第一項 b匹配中間專案 c匹配最後一項

   a,*b,c=[1,2,3,4] print(a,b,c) #結果： (1,[2,3],4)

4. 序列分割

   list=[1,2,3,4] while list: front,*list=list print(front,list) #結果如下：
   1 [2, 3, 4] 2 [3, 4] 3 [4] 4 []

專題2：可迭代物件

字串、列表、元組、集合、字典

• 容器

  容器是一種把多個元素組織在一起的資料結構，容器中的元素可以逐個的迭代獲取 特點:可以通過in/not in 成員關係操作符 檢測元素是否在容器之內 常見的容器型別： list/str/tuple/set/dict/frozenset

專題3：Python中的推導式

列表推導式
字典推導式
集合推導式

推導式可以從一個數據序列構建另一個數據序列

• 列表推導式

  推導式--->解析式

  1. 格式： 變數名=[表示式 for 變數 in 可迭代物件 if 布林表示式] if可以省略
  2. 案例： s=[i for i in range(10)] print(s) #結果為：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9

• 字典推導式

  1. 格式 變數={鍵:值 for 變數 in 可迭代物件 if 表示式}

  2. 案例： d={k:v for k,v in [('one',1),('two',2),('three',3)] if k!='one'} print(d)

      #結果為：
      {'two': 2, 'three': 3}
     

  #大小寫合併 將字典s轉成不區分大小寫的新字典輸出，避免覆蓋key相同時value相加 s={'a':10,'b':20,'A':100,'B':200} d={k.lower():s[k.lower()]+s[k.upper()]for k in s} print(d)

  #結果為：{'a': 110, 'b': 220}