阿里的架構師將Python基礎總結為千行程式碼，只為讓更多的人學好Python
阿新 • • 發佈：2018-11-11
某天大佬很是自信的告訴我，只要學會這千行程式碼，不管你是零基礎還是弱基礎或是沒有接觸過程式設計，都可以快速入門Python！當時我就不信邪啊，等我看完之後，即使作為一個Python老鳥了，還是領會到了很多大佬的獨特見解！
麻省理工教授將Python基礎總結成千行程式碼，讓Python入門更簡單！
不管學習任何東西，入門方面都是比較快的，但是要深入的話，還是需要一個積累的過程，這是一個漫長且需要堅持的事情。不過自學入門這東西是可以加快學習速度的，一般我們都是到處查到處問，缺少一些比較優質的資料來正確的學習！
小編今天就給大家發一點福利吧！我這周整理了一份2018年Python最新的零基礎入門教程和資料，適用於剛開始學或者正準備學Python的你，都在這個群了大家可以加一下865597862在不忙的時候我也會大家解答問題的
這是一部分的資料：
麻省理工教授將Python基礎總結成千行程式碼，讓Python入門更簡單！
好了，我們來開始學習程式碼吧！
型別和運算
-- 尋求幫助:
dir(obj) # 簡單的列出物件obj所包含的方法名稱，返回一個字串列表
help(obj.func) # 查詢obj.func的具體介紹和用法
-- 測試型別的三種方法，推薦第三種
if type(L) == type([]): print("L is list") if type(L) == list: print("L is list") if isinstance(L, list): print("L is list")
-- Python資料型別：雜湊型別、不可雜湊型別
# 雜湊型別，即在原地不能改變的變數型別，不可變型別。可利用hash函式檢視其hash值，也可以作為字典的key
"數字型別：int, float, decimal.Decimal, fractions.Fraction, complex"
"字串型別：str, bytes"
"元組：tuple"
"凍結集合：frozenset"
"布林型別：True, False"
"None"
# 不可hash型別：原地可變型別：list、dict和set。它們不可以作為字典的key。
-- 數字常量
1234, -1234, 0, 999999999 # 整數 1.23, 1., 3.14e-10, 4E210, 4.0e+210 # 浮點數 0o177, 0x9ff, 0X9FF, 0b101010 # 八進位制、十六進位制、二進位制數字 3+4j, 3.0+4.0j, 3J # 複數常量，也可以用complex(real, image)來建立 hex(I), oct(I), bin(I) # 將十進位制數轉化為十六進位制、八進位制、二進位制表示的“字串” int(string, base) # 將字串轉化為整數，base為進位制數 # 2.x中，有兩種整數型別：一般整數（32位）和長整數（無窮精度）。可以用l或L結尾，迫使一般整數成為長整數 float('inf'), float('-inf'), float('nan') # 無窮大, 無窮小, 非數
-- 數字的表示式操作符
yield x # 生成器函式傳送協議
lambda args: expression # 生成匿名函式
x if y else z # 三元選擇表示式
x and y, x or y, not x # 邏輯與、邏輯或、邏輯非
x in y, x not in y # 成員物件測試
x is y, x is not y # 物件實體測試
x<y, x<=y, x>y, x>=y, x==y, x!=y # 大小比較，集合子集或超集值相等性操作符
1 < a < 3 # Python中允許連續比較
x|y, x&y, x^y # 位或、位與、位異或
x<<y, x>>y # 位操作：x左移、右移y位
+, -, *, /, //, %, ** # 真除法、floor除法：返回不大於真除法結果的整數值、取餘、冪運算
-x, +x, ~x # 一元減法、識別、按位求補（取反）
x[i], x[i:j:k] # 索引、分片
int(3.14), float(3) # 強制型別轉換
-- 整數可以利用bit_length函式測試所佔的位數
a = 1; a.bit_length() # 1
a = 1024; a.bit_length() # 11
-- repr和str顯示格式的區別
"""
repr格式：預設的互動模式回顯，產生的結果看起來它們就像是程式碼。
str格式：列印語句，轉化成一種對使用者更加友好的格式。
"""
-- 數字相關的模組
# math模組
# Decimal模組：小數模組
import decimal
from decimal import Decimal
Decimal("0.01") + Decimal("0.02") # 返回Decimal("0.03")
decimal.getcontext().prec = 4 # 設定全域性精度為4 即小數點後邊4位
# Fraction模組：分數模組
from fractions import Fraction
x = Fraction(4, 6) # 分數型別 4/6
x = Fraction("0.25") # 分數型別 1/4 接收字串型別的引數
-- 集合set
"""
set是一個無序不重複元素集, 基本功能包括關係測試和消除重複元素。
set支援union(聯合), intersection(交), difference(差)和symmetric difference(對稱差集)等數學運算。
set支援x in set, len(set), for x in set。
set不記錄元素位置或者插入點, 因此不支援indexing, slicing, 或其它類序列的操作
"""
s = set([3,5,9,10]) # 建立一個數值集合，返回{3, 5, 9, 10}
t = set("Hello") # 建立一個字元的集合，返回{'l', 'H', 'e', 'o'}
a = t | s; t.union(s) # t 和 s的並集
b = t & s; t.intersection(s) # t 和 s的交集
c = t – s; t.difference(s) # 求差集（項在t中, 但不在s中）
d = t ^ s; t.symmetric_difference(s) # 對稱差集（項在t或s中, 但不會同時出現在二者中）
t.add('x'); t.remove('H') # 增加/刪除一個item
s.update([10,37,42]) # 利用[......]更新s集合
x in s, x not in s # 集合中是否存在某個值
s.issubset(t); s <= t # 測試是否 s 中的每一個元素都在 t 中
s.issuperset(t); s >= t # 測試是否 t 中的每一個元素都在 s 中
s.copy();
s.discard(x); # 刪除s中x
s.clear() # 清空s
{x**2 for x in [1, 2, 3, 4]} # 集合解析，結果：{16, 1, 4, 9}
{x for x in 'spam'} # 集合解析，結果：{'a', 'p', 's', 'm'}
-- 集合frozenset，不可變物件
"""
set是可變物件，即不存在hash值，不能作為字典的鍵值。同樣的還有list等(tuple是可以作為字典key的)
frozenset是不可變物件，即存在hash值，可作為字典的鍵值
frozenset物件沒有add、remove等方法，但有union/intersection/difference等方法
"""
a = set([1, 2, 3])
b = set()
b.add(a) # error: set是不可雜湊型別
b.add(frozenset(a)) # ok，將set變為frozenset，可雜湊
-- 布林型別bool
type(True) # 返回<class 'bool'>
isinstance(False, int) # bool型別屬於整型，所以返回True
True == 1; True is 1 # 輸出(True, False)
-- 動態型別簡介
"""
變數名通過引用，指向物件。
Python中的“型別”屬於物件，而不是變數，每個物件都包含有頭部資訊，比如"型別標示符" "引用計數器"等
"""
#共享引用及在原處修改：對於可變物件，要注意儘量不要共享引用！
#共享引用和相等測試：
L = [1], M = [1], L is M # 返回False
L = M = [1, 2, 3], L is M # 返回True，共享引用
#增強賦值和共享引用：普通+號會生成新的物件，而增強賦值+=會在原處修改
L = M = [1, 2]
L = L + [3, 4] # L = [1, 2, 3, 4], M = [1, 2]
L += [3, 4] # L = [1, 2, 3, 4], M = [1, 2, 3, 4]
-- 常見字串常量和表示式
S = '' # 空字串
S = "spam’s" # 雙引號和單引號相同
S = "s\np\ta\x00m" # 轉義字元
S = """spam""" # 三重引號字串，一般用於函式說明
S = r'\temp' # Raw字串，不會進行轉義，抑制轉義
S = b'Spam' # Python3中的位元組字串
S = u'spam' # Python2.6中的Unicode字串
s1+s2, s1*3, s[i], s[i:j], len(s) # 字串操作
'a %s parrot' % 'kind' # 字串格式化表示式
'a {1} {0} parrot'.format('kind', 'red')# 字串格式化方法
for x in s: print(x) # 字串迭代，成員關係
[x*2 for x in s] # 字串列表解析
','.join(['a', 'b', 'c']) # 字串輸出，結果：a,b,c
-- 內建str處理函式：
str1 = "stringobject"
str1.upper(); str1.lower(); str1.swapcase(); str1.capitalize(); str1.title() # 全部大寫，全部小寫、大小寫轉換，首字母大寫，每個單詞的首字母都大寫
str1.ljust(width) # 獲取固定長度，左對齊，右邊不夠用空格補齊
str1.rjust(width) # 獲取固定長度，右對齊，左邊不夠用空格補齊
str1.center(width) # 獲取固定長度，中間對齊，兩邊不夠用空格補齊
str1.zfill(width) # 獲取固定長度，右對齊，左邊不足用0補齊
str1.find('t',start,end) # 查詢字串，可以指定起始及結束位置搜尋
str1.rfind('t') # 從右邊開始查詢字串
str1.count('t') # 查詢字串出現的次數
#上面所有方法都可用index代替，不同的是使用index查詢不到會拋異常，而find返回-1
str1.replace('old','new') # 替換函式，替換old為new，引數中可以指定maxReplaceTimes，即替換指定次數的old為new
str1.strip(); # 預設刪除空白符
str1.strip('d'); # 刪除str1字串中開頭、結尾處，位於 d 刪除序列的字元
str1.lstrip();
str1.lstrip('d'); # 刪除str1字串中開頭處，位於 d 刪除序列的字元
str1.rstrip();
str1.rstrip('d') # 刪除str1字串中結尾處，位於 d 刪除序列的字元
str1.startswith('start') # 是否以start開頭
str1.endswith('end') # 是否以end結尾
str1.isalnum(); str1.isalpha(); str1.isdigit(); str1.islower(); str1.isupper() # 判斷字串是否全為字元、數字、小寫、大寫
-- 三重引號編寫多行字串塊，並且在程式碼折行處嵌入換行字元\n
mantra = """hello world
hello python
hello my friend"""
# mantra為"""hello world \n hello python \n hello my friend"""
-- 索引和分片：
S[0], S[len(S)–1], S[-1] # 索引
S[1:3], S[1:], S[:-1], S[1:10:2] # 分片，第三個引數指定步長，如`S[1:10:2]`是從1位到10位沒隔2位獲取一個字元。
-- 字串轉換工具：
int('42'), str(42) # 返回(42, '42')
float('4.13'), str(4.13) # 返回(4.13, '4.13')
ord('s'), chr(115) # 返回(115, 's')
int('1001', 2) # 將字串作為二進位制數字，轉化為數字，返回9
bin(13), oct(13), hex(13) # 將整數轉化為二進位制/八進位制/十六進位制字串，返回('0b1101', '015', '0xd')
-- 另類字串連線
name = "wang" "hong" # 單行，name = "wanghong"
name = "wang" \
"hong" # 多行，name = "wanghong"
-- Python中的字串格式化實現1--字串格式化表示式
"""
基於C語言的'print'模型，並且在大多數的現有的語言中使用。
通用結構：%[(name)][flag][width].[precision]typecode
"""
"this is %d %s bird" % (1, 'dead') # 一般的格式化表示式
"%s---%s---%s" % (42, 3.14, [1, 2, 3]) # 字串輸出：'42---3.14---[1, 2, 3]'
"%d...%6d...%-6d...%06d" % (1234, 1234, 1234, 1234) # 對齊方式及填充："1234... 1234...1234 ...001234"
x = 1.23456789
"%e | %f | %g" % (x, x, x) # 對齊方式："1.234568e+00 | 1.234568 | 1.23457"
"%6.2f*%-6.2f*%06.2f*%+6.2f" % (x, x, x, x) # 對齊方式：' 1.23*1.23 *001.23* +1.23'
"%(name1)d---%(name2)s" % {"name1":23, "name2":"value2"} # 基於字典的格式化表示式
"%(name)s is %(age)d" % vars() # vars()函式呼叫返回一個字典，包含了所有本函式呼叫時存在的變數
-- Python中的字串格式化實現2--字串格式化呼叫方法
# 普通呼叫
"{0}, {1} and {2}".format('spam', 'ham', 'eggs') # 基於位置的呼叫
"{motto} and {pork}".format(motto = 'spam', pork = 'ham') # 基於Key的呼叫
"{motto} and {0}".format('ham', motto = 'spam') # 混合呼叫
# 新增鍵 屬性 偏移量 (import sys)
"my {1[spam]} runs {0.platform}".format(sys, {'spam':'laptop'}) # 基於位置的鍵和屬性
"{config[spam]} {sys.platform}".format(sys = sys, config = {'spam':'laptop'}) # 基於Key的鍵和屬性
"first = {0[0]}, second = {0[1]}".format(['A', 'B', 'C']) # 基於位置的偏移量
# 具體格式化
"{0:e}, {1:.3e}, {2:g}".format(3.14159, 3.14159, 3.14159) # 輸出'3.141590e+00, 3.142e+00, 3.14159'
"{fieldname:format_spec}".format(......)
# 說明:
"""
fieldname是指定引數的一個數字或關鍵字, 後邊可跟可選的".name"或"[index]"成分引用
format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type]
fill ::= <any character> #填充字元
align ::= "<" | ">" | "=" | "^" #對齊方式
sign ::= "+" | "-" | " " #符號說明
width ::= integer #字串寬度
precision ::= integer #浮點數精度
type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
"""
# 例子:
'={0:10} = {1:10}'.format('spam', 123.456) # 輸出'=spam = 123.456'
'={0:>10}='.format('test') # 輸出'= test='
'={0:<10}='.format('test') # 輸出'=test ='
'={0:^10}='.format('test') # 輸出'= test ='
'{0:X}, {1:o}, {2:b}'.format(255, 255, 255) # 輸出'FF, 377, 11111111'
'My name is {0:{1}}.'.format('Fred', 8) # 輸出'My name is Fred .' 動態指定引數
-- 常用列表常量和操作
L = [[1, 2], 'string', {}] # 巢狀列表
L = list('spam') # 列表初始化
L = list(range(0, 4)) # 列表初始化
list(map(ord, 'spam')) # 列表解析
len(L) # 求列表長度
L.count(value) # 求列表中某個值的個數
L.append(obj) # 向列表的尾部新增資料，比如append(2)，新增元素2
L.insert(index, obj) # 向列表的指定index位置新增資料，index及其之後的資料後移
L.extend(interable) # 通過新增iterable中的元素來擴充套件列表，比如extend([2])，新增元素2，注意和append的區別
L.index(value, [start, [stop]]) # 返回列表中值value的第一個索引
L.pop([index]) # 刪除並返回index處的元素，預設為刪除並返回最後一個元素
L.remove(value) # 刪除列表中的value值，只刪除第一次出現的value的值
L.reverse() # 反轉列表
L.sort(cmp=None, key=None, reverse=False) # 排序列表
a = [1, 2, 3], b = a[10:] # 注意，這裡不會引發IndexError異常，只會返回一個空的列表[]
a = [], a += [1] # 這裡實在原有列表的基礎上進行操作，即列表的id沒有改變
a = [], a = a + [1] # 這裡最後的a要構建一個新的列表，即a的id發生了變化
-- 用切片來刪除序列的某一段
a = [1, 2, 3, 4, 5, 6, 7]
a[1:4] = [] # a = [1, 5, 6, 7]
a = [0, 1, 2, 3, 4, 5, 6, 7]
del a[::2] # 去除偶數項(偶數索引的)，a = [1, 3, 5, 7]
-- 常用字典常量和操作
D = {}
D = {'spam':2, 'tol':{'ham':1}} # 巢狀字典
D = dict.fromkeys(['s', 'd'], 8) # {'s': 8, 'd': 8}
D = dict(name = 'tom', age = 12) # {'age': 12, 'name': 'tom'}
D = dict([('name', 'tom'), ('age', 12)]) # {'age': 12, 'name': 'tom'}
D = dict(zip(['name', 'age'], ['tom', 12])) # {'age': 12, 'name': 'tom'}
D.keys(); D.values(); D.items() # 字典鍵、值以及鍵值對
D.get(key, default) # get函式
D.update(D_other) # 合併字典，如果存在相同的鍵值，D_other的資料會覆蓋掉D的資料
D.pop(key, [D]) # 刪除字典中鍵值為key的項，返回鍵值為key的值，如果不存在，返回預設值D，否則異常
D.popitem() # pop字典中隨機的一項（一個鍵值對）
D.setdefault(k[, d]) # 設定D中某一項的預設值。如果k存在，則返回D[k]，否則設定D[k]=d，同時返回D[k]。
del D # 刪除字典
del D['key'] # 刪除字典的某一項
if key in D: if key not in D: # 測試字典鍵是否存在
# 字典注意事項：（1）對新索引賦值會新增一項（2）字典鍵不一定非得是字串，也可以為任何的不可變物件
# 不可變物件：呼叫物件自身的任意方法，也不會改變該物件自身的內容，這些方法會建立新的物件並返回。
# 字串、整數、tuple都是不可變物件，dict、set、list都是可變物件
D[(1,2,3)] = 2 # tuple作為字典的key
-- 字典解析
D = {k:8 for k in ['s', 'd']} # {'s': 8, 'd': 8}
D = {k:v for (k, v) in zip(['name', 'age'], ['tom', 12])} # {'age': 12, 'name': tom}
-- 字典的特殊方法missing：當查詢找不到key時，會執行該方法
class Dict(dict):
def __missing__(self, key):
self[key] = []
return self[key]
dct = dict()
dct["foo"].append(1) # 這有點類似於collections.defalutdict
dct["foo"] # [1]
-- 元組和列表的唯一區別在於元組是不可變物件，列表是可變物件
a = [1, 2, 3] # a[1] = 0, OK
a = (1, 2, 3) # a[1] = 0, Error
a = ([1, 2]) # a[0][1] = 0, OK
a = [(1, 2)] # a[0][1] = 0, Error
-- 元組的特殊語法: 逗號和圓括號
D = (12) # 此時D為一個整數 即D = 12
D = (12, ) # 此時D為一個元組 即D = (12, )
-- 檔案基本操作
output = open(r'C:\spam', 'w') # 開啟輸出檔案，用於寫
input = open('data', 'r') # 開啟輸入檔案，用於讀。開啟的方式可以為'w', 'r', 'a', 'wb', 'rb', 'ab'等
fp.read([size]) # size為讀取的長度，以byte為單位
fp.readline([size]) # 讀一行，如果定義了size，有可能返回的只是一行的一部分
fp.readlines([size]) # 把檔案每一行作為一個list的一個成員，並返回這個list。其實它的內部是通過迴圈呼叫readline()來實現的。如果提供size引數，size是表示讀取內容的總長。
fp.readable() # 是否可讀
fp.write(str) # 把str寫到檔案中，write()並不會在str後加上一個換行符
fp.writelines(seq) # 把seq的內容全部寫到檔案中(多行一次性寫入)
fp.writeable() # 是否可寫
fp.close() # 關閉檔案。
fp.flush() # 把緩衝區的內容寫入硬碟
fp.fileno() # 返回一個長整型的”檔案標籤“
fp.isatty() # 檔案是否是一個終端裝置檔案（unix系統中的）
fp.tell() # 返回檔案操作標記的當前位置，以檔案的開頭為原點
fp.next() # 返回下一行，並將檔案操作標記位移到下一行。把一個file用於for … in file這樣的語句時，就是呼叫next()函式來實現遍歷的。
fp.seek(offset[,whence]) # 將檔案開啟操作標記移到offset的位置。whence為0表示從頭開始計算，1表示以當前位置為原點計算。2表示以檔案末尾為原點進行計算。
fp.seekable() # 是否可以seek
fp.truncate([size]) # 把檔案裁成規定的大小，預設的是裁到當前檔案操作標記的位置。
for line in open('data'):
print(line) # 使用for語句，比較適用於開啟比較大的檔案
with open('data') as file:
print(file.readline()) # 使用with語句，可以保證檔案關閉
with open('data') as file:
lines = file.readlines() # 一次讀入檔案所有行，並關閉檔案
open('f.txt', encoding = 'latin-1') # Python3.x Unicode文字檔案
open('f.bin', 'rb') # Python3.x 二進位制bytes檔案
# 檔案物件還有相應的屬性：buffer closed encoding errors line_buffering name newlines等
-- 其他
# Python中的真假值含義：1. 數字如果非零，則為真，0為假。 2. 其他物件如果非空，則為真
# 通常意義下的型別分類：1. 數字、序列、對映。 2. 可變型別和不可變型別
語法和語句
-- 賦值語句的形式
spam = 'spam' # 基本形式
spam, ham = 'spam', 'ham' # 元組賦值形式
[spam, ham] = ['s', 'h'] # 列表賦值形式
a, b, c, d = 'abcd' # 序列賦值形式
a, *b, c = 'spam' # 序列解包形式（Python3.x中才有）
spam = ham = 'no' # 多目標賦值運算，涉及到共享引用
spam += 42 # 增強賦值，涉及到共享引用
-- 序列賦值 序列解包
[a, b, c] = (1, 2, 3) # a = 1, b = 2, c = 3
a, b, c, d = "spam" # a = 's', b = 'p', c = 'a', d = 'm'
a, b, c = range(3) # a = 0, b = 1, c = 2
a, *b = [1, 2, 3, 4] # a = 1, b = [2, 3, 4]
*a, b = [1, 2, 3, 4] # a = [1, 2, 3], b = 4
a, *b, c = [1, 2, 3, 4] # a = 1, b = [2, 3], c = 4
# 帶有*時 會優先匹配*之外的變數 如
a, *b, c = [1, 2] # a = 1, c = 2, b = []
-- print函式原型
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
# 流的重定向
print('hello world') # 等於sys.stdout.write('hello world')
temp = sys.stdout # 原有流的儲存
sys.stdout = open('log.log', 'a') # 流的重定向
print('hello world') # 寫入到檔案log.log
sys.stdout.close()
sys.stdout = temp # 原有流的復原
-- Python中and或or總是返回物件(左邊的物件或右邊的物件) 且具有短路求值的特性
1 or 2 or 3 # 返回 1
1 and 2 and 3 # 返回 3
-- if/else三元表達符（if語句在行內）
A = 1 if X else 2
A = 1 if X else (2 if Y else 3)
# 也可以使用and-or語句（一條語句實現多個if-else）
a = 6
result = (a > 20 and "big than 20" or a > 10 and "big than 10" or a > 5 and "big than 5") # 返回"big than 5"
-- Python的while語句或者for語句可以帶else語句 當然也可以帶continue/break/pass語句
while a > 1:
anything
else:
anything
# else語句會在迴圈結束後執行，除非在迴圈中執行了break，同樣的還有for語句
for i in range(5):
anything
else:
anything
-- for迴圈的元組賦值
for (a, b) in [(1, 2), (3, 4)]: # 最簡單的賦值
for ((a, b), c) in [((1, 2), 3), ((4, 5), 6)]: # 自動解包賦值
for ((a, b), c) in [((1, 2), 3), ("XY", 6)]: # 自動解包 a = X, b = Y, c = 6
for (a, *b) in [(1, 2, 3), (4, 5, 6)]: # 自動解包賦值
-- 列表解析語法
M = [[1,2,3], [4,5,6], [7,8,9]]
res = [sum(row) for row in M] # G = [6, 15, 24] 一般的列表解析 生成一個列表
res = [c * 2 for c in 'spam'] # ['ss', 'pp', 'aa', 'mm']
res = [a * b for a in [1, 2] for b in [4, 5]] # 多解析過程 返回[4, 5, 8, 10]
res = [a for a in [1, 2, 3] if a < 2] # 帶判斷條件的解析過程
res = [a if a > 0 else 0 for a in [-1, 0, 1]] # 帶判斷條件的高階解析過程
# 兩個列表同時解析：使用zip函式
for teama, teamb in zip(["Packers", "49ers"], ["Ravens", "Patriots"]):
print(teama + " vs. " + teamb)
# 帶索引的列表解析：使用enumerate函式
for index, team in enumerate(["Packers", "49ers", "Ravens", "Patriots"]):
print(index, team) # 輸出0, Packers \n 1, 49ers \n ......
-- 生成器表示式
G = (sum(row) for row in M) # 使用小括號可以建立所需結果的生成器generator object
next(G), next(G), next(G) # 輸出(6, 15, 24)
G = {sum(row) for row in M} # G = {6, 15, 24} 解析語法還可以生成集合和字典
G = {i:sum(M[i]) for i in range(3)} # G = {0: 6, 1: 15, 2: 24}
-- 文件字串:出現在Module的開端以及其中函式或類的開端 使用三重引號字串
"""
module document
"""
def func():
"""
function document
"""
print()
class Employee(object):
"""
class document
"""
print()
print(func.__doc__) # 輸出函式文件字串
print(Employee.__doc__) # 輸出類的文件字串
-- 命名慣例:
"""
以單一下劃線開頭的變數名(_X)不會被from module import*等語句匯入
前後有兩個下劃線的變數名(__X__)是系統定義的變數名，對直譯器有特殊意義
以兩個下劃線開頭但不以下劃線結尾的變數名(__X)是類的本地(私有)變數
"""
-- 列表解析 in成員關係測試 map sorted zip enumerate內建函式等都使用了迭代協議
'first line' in open('test.txt') # in測試 返回True或False
list(map(str.upper, open('t'))) # map內建函式
sorted(iter([2, 5, 8, 3, 1])) # sorted內建函式
list(zip([1, 2], [3, 4])) # zip內建函式 [(1, 3), (2, 4)]
-- del語句: 手動刪除某個變數
del X
-- 獲取列表的子表的方法:
x = [1,2,3,4,5,6]
x[:3] # 前3個[1,2,3]
x[1:5] # 中間4個[2,3,4,5]
x[-3:] # 最後3個[4,5,6]
x[::2] # 奇數項[1,3,5]
x[1::2] # 偶數項[2,4,6]
-- 手動迭代：iter和next
L = [1, 2]
I = iter(L) # I為L的迭代器
I.next() # 返回1
I.next() # 返回2
I.next() # Error:StopIteration
-- Python中的可迭代物件
"""
1.range迭代器
2.map、zip和filter迭代器
3.字典檢視迭代器：D.keys()), D.items()等
4.檔案型別
"""
函式語法規則
-- 函式相關的語句和表示式
myfunc('spam') # 函式呼叫
def myfunc(): # 函式定義
return None # 函式返回值
global a # 全域性變數
nonlocal x # 在函式或其他作用域中使用外層（非全域性）變數
yield x # 生成器函式返回
lambda # 匿名函式
-- Python函式變數名解析:LEGB原則，即:
"""
local(functin) --> encloseing function locals --> global(module) --> build-in(python)
說明:以下邊的函式maker為例 則相對於action而言 X為Local N為Encloseing
"""
-- 巢狀函式舉例:工廠函式
def maker(N):
def action(X):
return X ** N
return action
f = maker(2) # pass 2 to N
f(3) # 9, pass 3 to X
-- 巢狀函式舉例:lambda例項
def maker(N):
action = (lambda X: X**N)
return action
f = maker(2) # pass 2 to N
f(3) # 9, pass 3 to X
-- nonlocal和global語句的區別
# nonlocal應用於一個巢狀的函式的作用域中的一個名稱 例如:
start = 100
def tester(start):
def nested(label):
nonlocal start # 指定start為tester函式內的local變數 而不是global變數start
print(label, start)
start += 3
return nested
# global為全域性的變數 即def之外的變數
def tester(start):
def nested(label):
global start # 指定start為global變數start
print(label, start)
start += 3
return nested
-- 函式引數，不可變引數通過“值”傳遞，可變引數通過“引用”傳遞
def f(a, b, c): print(a, b, c)
f(1, 2, 3) # 引數位置匹配
f(1, c = 3, b = 2) # 引數關鍵字匹配
def f(a, b=1, c=2): print(a, b, c)
f(1) # 預設引數匹配
f(1, 2) # 預設引數匹配
f(a = 1, c = 3) # 關鍵字引數和預設引數的混合
# Keyword-Only引數:出現在*args之後 必須用關鍵字進行匹配
def keyOnly(a, *b, c): print('') # c就為keyword-only匹配 必須使用關鍵字c = value匹配
def keyOnly(a, *, b, c): ...... # b c為keyword-only匹配 必須使用關鍵字匹配
def keyOnly(a, *, b = 1): ...... # b有預設值 或者省略 或者使用關鍵字引數b = value
-- 可變引數匹配: * 和 **
def f(*args): print(args) # 在元組中收集不匹配的位置引數
f(1, 2, 3) # 輸出(1, 2, 3)
def f(**args): print(args) # 在字典中收集不匹配的關鍵字引數
f(a = 1, b = 2) # 輸出{'a':1, 'b':2}
def f(a, *b, **c): print(a, b, c) # 兩者混合使用
f(1, 2, 3, x=4, y=5) # 輸出1, (2, 3), {'x':4, 'y':5}
-- 函式呼叫時的引數解包: * 和 ** 分別解包元組和字典
func(1, *(2, 3)) <==> func(1, 2, 3)
func(1, **{'c':3, 'b':2}) <==> func(1, b = 2, c = 3)
func(1, *(2, 3), **{'c':3, 'b':2}) <==> func(1, 2, 3, b = 2, c = 3)
-- 函式屬性:(自己定義的)函式可以新增屬性
def func():.....
func.count = 1 # 自定義函式新增屬性
print.count = 1 # Error 內建函式不可以新增屬性
-- 函式註解: 編寫在def頭部行 主要用於說明引數範圍、引數型別、返回值型別等
def func(a:'spam', b:(1, 10), c:float) -> int :
print(a, b, c)
func.__annotations__ # {'c':<class 'float'>, 'b':(1, 10), 'a':'spam', 'return':<class 'int'>}
# 編寫註解的同時 還是可以使用函式預設值 並且註解的位置位於=號的前邊
def func(a:'spam'='a', b:(1, 10)=2, c:float=3) -> int :
print(a, b, c)
-- 匿名函式:lambda
f = lambda x, y, z : x + y + z # 普通匿名函式，使用方法f(1, 2, 3)
f = lambda x = 1, y = 1: x + y # 帶預設引數的lambda函式
def action(x): # 巢狀lambda函式
return (lambda y : x + y)
f = lambda: a if xxx() else b # 無引數的lambda函式，使用方法f()
-- lambda函式與map filter reduce函式的結合
list(map((lambda x: x + 1), [1, 2, 3])) # [2, 3, 4]
list(filter((lambda x: x > 0), range(-4, 5))) # [1, 2, 3, 4]
functools.reduce((lambda x, y: x + y), [1, 2, 3]) # 6
functools.reduce((lambda x, y: x * y), [2, 3, 4]) # 24
-- 生成器函式:yield VS return
def gensquare(N):
for i in range(N):
yield i** 2 # 狀態掛起 可以恢復到此時的狀態
for i in gensquare(5): # 使用方法
print(i, end = ' ') # [0, 1, 4, 9, 16]
x = gensquare(2) # x是一個生成物件
next(x) # 等同於x.__next__() 返回0
next(x) # 等同於x.__next__() 返回1
next(x) # 等同於x.__next__() 丟擲異常StopIteration
-- 生成器表示式:小括號進行列表解析
G = (x ** 2 for x in range(3)) # 使用小括號可以建立所需結果的生成器generator object
next(G), next(G), next(G) # 和上述中的生成器函式的返回值一致
#（1）生成器(生成器函式/生成器表示式)是單個迭代物件
G = (x ** 2 for x in range(4))
I1 = iter(G) # 這裡實際上iter(G) = G
next(I1) # 輸出0
next(G) # 輸出1
next(I1) # 輸出4
#（2）生成器不保留迭代後的結果
gen = (i for i in range(4))
2 in gen # 返回True
3 in gen # 返回True
1 in gen # 返回False，其實檢測2的時候，1已經就不在生成器中了，即1已經被迭代過了，同理2、3也不在了
-- 本地變數是靜態檢測的
X = 22 # 全域性變數X的宣告和定義
def test():
print(X) # 如果沒有下一語句 則該句合法 列印全域性變數X
X = 88 # 這一語句使得上一語句非法 因為它使得X變成了本地變數 上一句變成了列印一個未定義的本地變數(區域性變數)
if False: # 即使這樣的語句 也會把print語句視為非法語句 因為:
X = 88 # Python會無視if語句而仍然聲明瞭區域性變數X
def test(): # 改進
global X # 宣告變數X為全域性變數
print(X) # 列印全域性變數X
X = 88 # 改變全域性變數X
-- 函式的預設值是在函式定義的時候例項化的 而不是在呼叫的時候 例子:
def foo(numbers=[]): # 這裡的[]是可變的
numbers.append(9)
print(numbers)
foo() # first time, like before, [9]
foo() # second time, not like before, [9, 9]
foo() # third time, not like before too, [9, 9, 9]
# 改進:
def foo(numbers=None):
if numbers is None: numbers = []
numbers.append(9)
print(numbers)
# 另外一個例子 引數的預設值為不可變的:
def foo(count=0): # 這裡的0是數字, 是不可變的
count += 1
print(count)
foo() # 輸出1
foo() # 還是輸出1
foo(3) # 輸出4
foo() # 還是輸出1
函式例子
"""數學運算類"""
abs(x) # 求絕對值，引數可以是整型，也可以是複數，若引數是複數，則返回複數的模
complex([real[, imag]]) # 建立一個複數
divmod(a, b) # 分別取商和餘數，注意：整型、浮點型都可以
float([x]) # 將一個字串或數轉換為浮點數。如果無引數將返回0.0
int([x[, base]]) # 將一個字串或浮點數轉換為int型別，base表示進位制
long([x[, base]]) # 將一個字串或浮點數轉換為long型別
pow(x, y) # 返回x的y次冪
range([start], stop[, step]) # 產生一個序列，預設從0開始
round(x[, n]) # 四捨五入
sum(iterable[, start]) # 對集合求和
oct(x) # 將一個數字轉化為8進位制字串
hex(x) # 將一個數字轉換為16進位制字串
chr(i) # 返回給定int型別對應的ASCII字元
unichr(i) # 返回給定int型別的unicode
ord(c) # 返回ASCII字元對應的整數
bin(x) # 將整數x轉換為二進位制字串
bool([x]) # 將x轉換為Boolean型別
"""集合類操作"""
basestring() # str和unicode的超類，不能直接呼叫，可以用作isinstance判斷
format(value [, format_spec]) # 格式化輸出字串，格式化的引數順序從0開始，如“I am {0},I like {1}”
enumerate(sequence[, start=0]) # 返回一個可列舉的物件，注意它有第二個引數
iter(obj[, sentinel]) # 生成一個物件的迭代器，第二個引數表示分隔符
max(iterable[, args...][key]) # 返回集合中的最大值
min(iterable[, args...][key]) # 返回集合中的最小值
dict([arg]) # 建立資料字典
list([iterable]) # 將一個集合類轉換為另外一個集合類
set() # set物件例項化
frozenset([iterable]) # 產生一個不可變的set
tuple([iterable]) # 生成一個tuple型別
str([object]) # 轉換為string型別
sorted(iterable[, cmp[, key[, reverse]]]) # 集合排序
L = [('b',2),('a',1),('c',3),('d',4)]
sorted(L, key=lambda x: x[1], reverse=True) # 使用Key引數和reverse引數
sorted(L, key=lambda x: (x[0], x[1])) # 使用key引數進行多條件排序，即如果x[0]相同，則比較x[1]
"""邏輯判斷"""
all(iterable) # 集合中的元素都為真的時候為真，特別的，若為空串返回為True
any(iterable) # 集合中的元素有一個為真的時候為真，特別的，若為空串返回為False
cmp(x, y) # 如果x < y ,返回負數；x == y, 返回0；x > y,返回正數
"""IO操作"""
file(filename [, mode [, bufsize]]) # file型別的建構函式。
input([prompt]) # 獲取使用者輸入，推薦使用raw_input，因為該函式將不會捕獲使用者的錯誤輸入，意思是自行判斷型別
# 在 Built-in Functions 裡有一句話是這樣寫的：Consider using the raw_input() function for general input from users.
raw_input([prompt]) # 設定輸入，輸入都是作為字串處理
open(name[, mode[, buffering]]) # 開啟檔案，與file有什麼不同？推薦使用open
"""其他"""
callable(object) # 檢查物件object是否可呼叫
classmethod(func) # 用來說明這個func是個類方法
staticmethod(func) # 用來說明這個func為靜態方法
dir([object]) # 不帶引數時，返回當前範圍內的變數、方法和定義的型別列表；帶引數時，返回引數的屬性、方法列表。
help(obj) # 返回obj的幫助資訊
eval(expression) # 計算表示式expression的值，並返回
exec(str) # 將str作為Python語句執行
execfile(filename) # 用法類似exec()，不同的是execfile的引數filename為檔名，而exec的引數為字串。
filter(function, iterable) # 構造一個序列，等價於[item for item in iterable if function(item)]，function返回值為True或False的函式
list(filter(bool, range(-3, 4)))# 返回[-3, -2, -1, 1, 2, 3], 沒有0
hasattr(object, name) # 判斷物件object是否包含名為name的特性
getattr(object, name [, defalut]) # 獲取一個類的屬性
setattr(object, name, value) # 設定屬性值
delattr(object, name) # 刪除object物件名為name的屬性
globals() # 返回一個描述當前全域性符號表的字典
hash(object) # 如果物件object為雜湊表型別，返回物件object的雜湊值
id(object) # 返回物件的唯一標識，一串數字
isinstance(object, classinfo) # 判斷object是否是class的例項
isinstance(1, int) # 判斷是不是int型別
isinstance(1, (int, float)) # isinstance的第二個引數接受一個元組型別
issubclass(class, classinfo) # 判斷class是否為classinfo的子類
locals() # 返回當前的變數列表
map(function, iterable, ...) # 遍歷每個元素，執行function操作
list(map(abs, range(-3, 4))) # 返回[3, 2, 1, 0, 1, 2, 3]
next(iterator[, default]) # 類似於iterator.next()
property([fget[, fset[, fdel[, doc]]]]) # 屬性訪問的包裝類，設定後可以通過c.x=value等來訪問setter和getter
reduce(function, iterable[, initializer]) # 合併操作，從第一個開始是前兩個引數，然後是前兩個的結果與第三個合併進行處理，以此類推
def add(x,y):return x + y
reduce(add, range(1, 11)) # 返回55 (注:1+2+3+4+5+6+7+8+9+10 = 55)
reduce(add, range(1, 11), 20) # 返回75
reload(module) # 重新載入模組
repr(object) # 將一個物件變幻為可列印的格式
slice(start, stop[, step]) # 產生分片物件
type(object) # 返回該object的型別
vars([object]) # 返回物件的變數名、變數值的字典
a = Class(); # Class為一個空類
a.name = 'qi', a.age = 9
vars(a) # {'name':'qi', 'age':9}
zip([iterable, ...]) # 返回對應陣列
list(zip([1, 2, 3], [4, 5, 6])) # [(1, 4), (2, 5), (3, 6)]
a = [1, 2, 3], b = ["a", "b", "c"]
z = zip(a, b) # 壓縮：[(1, "a"), (2, "b"), (3, "c")]
zip(*z) # 解壓縮：[(1, 2, 3), ("a", "b", "c")]
unicode(string, encoding, errors) # 將字串string轉化為unicode形式，string為encoded string。
模組Moudle
-- Python模組搜尋路徑:
"""
(1)程式的主目錄 (2)PYTHONPATH目錄 (3)標準連結庫目錄 (4)任何.pth檔案的內容
"""
-- 檢視全部的模組搜尋路徑
import sys
sys.path
sys.argv # 獲得指令碼的引數
sys.builtin_module_names # 查詢內建模組
sys.platform # 返回當前平臺 出現如： "win32" "linux" "darwin"等
sys.modules # 查詢已匯入的模組
sys.modules.keys()
sys.stdout # stdout 和 stderr 都是類檔案物件，但是它們都是隻寫的。它們都沒有 read 方法，只有 write 方法
sys.stdout.write("hello")
sys.stderr
sys.stdin
-- 模組的使用程式碼
import module1, module2 # 匯入module1 使用module1.printer()
from module1 import printer # 匯入module1中的printer變數 使用printer()
from module1 import * # 匯入module1中的全部變數 使用不必新增module1字首
-- 過載模組reload: 這是一個內建函式 而不是一條語句
from imp import reload
reload(module)
-- 模組的包匯入:使用點號(.)而不是路徑(dir1\dir2)進行匯入
import dir1.dir2.mod # d匯入包(目錄)dir1中的包dir2中的mod模組 此時dir1必須在Python可搜尋路徑中
from dir1.dir2.mod import * # from語法的包匯入
-- init.py包檔案:每個匯入的包中都應該包含這麼一個檔案
"""
該檔案可以為空
首次進行包匯入時 該檔案會自動執行
高階功能:在該檔案中使用__all__列表來定義包(目錄)以from*的形式匯入時 需要匯入什麼
"""
-- 包相對匯入:使用點號(.) 只能使用from語句
from . import spam # 匯入當前目錄下的spam模組（Python2: 當前目錄下的模組, 直接匯入即可）
from .spam import name # 匯入當前目錄下的spam模組的name屬性（Python2: 當前目錄下的模組, 直接匯入即可，不用加.）
from .. import spam # 匯入當前目錄的父目錄下的spam模組
-- 包相對匯入與普通匯入的區別
from string import * # 這裡匯入的string模組為sys.path路徑上的 而不是本目錄下的string模組(如果存在也不是)
from .string import * # 這裡匯入的string模組為本目錄下的(不存在則匯入失敗) 而不是sys.path路徑上的
-- 模組資料隱藏:最小化from*的破壞
_X # 變數名前加下劃線可以防止from*匯入時該變數名被複製出去
__all__ = ['x', 'x1', 'x2'] # 使用__all__列表指定from*時複製出去的變數名(變數名在列表中為字串形式)
-- 可以使用name進行模組的單元測試:當模組為頂層執行檔案時值為'main' 當模組被匯入時為模組名
if __name__ == '__main__':
doSomething
# 模組屬性中還有其他屬性，例如：
__doc__ # 模組的說明文件
__file__ # 模組檔案的檔名，包括全路徑
__name__ # 主檔案或者被匯入檔案
__package__ # 模組所在的包
-- import語句from語句的as擴充套件
import modulename as name
from modulename import attrname as name
-- 得到模組屬性的幾種方法 假設為了得到name屬性的值
M.name
M.__dict__['name']
sys.modules['M'].name
getattr(M, 'name')
類與面向物件
-- 最普通的類
class C1(C2, C3):
spam = 42 # 資料屬性
def __init__(self, name): # 函式屬性:建構函式
self.name = name
def __del__(self): # 函式屬性:解構函式
print("goodbey ", self.name)
I1 = C1('bob')
-- Python的類沒有基於引數的函式過載
class FirstClass(object):
def test(self, string):
print(string)
def test(self): # 此時類中只有一個test函式 即後者test(self) 它覆蓋掉前者帶引數的test函式
print("hello world")
-- 子類擴充套件超類: 儘量呼叫超類的方法
class Manager(Person):
def giveRaise(self, percent, bonus = .10):
self.pay = int(self.pay*(1 + percent + bonus)) # 不好的方式 複製貼上超類程式碼
Person.giveRaise(self, percent + bonus) # 好的方式 儘量呼叫超類方法
-- 類內省工具
bob = Person('bob')
bob.__class__ # <class 'Person'>
bob.__class__.__name__ # 'Person'
bob.__dict__ # {'pay':0, 'name':'bob', 'job':'Manager'}
-- 返回1中 資料屬性spam是屬於類 而不是物件
I1 = C1('bob'); I2 = C2('tom') # 此時I1和I2的spam都為42 但是都是返回的C1的spam屬性
C1.spam = 24 # 此時I1和I2的spam都為24
I1.spam = 3 # 此時I1新增自有屬性spam 值為3 I2和C1的spam還都為24
-- 類方法呼叫的兩種方式
instance.method(arg...)
class.method(instance, arg...)
-- 抽象超類的實現方法
# (1)某個函式中呼叫未定義的函式 子類中定義該函式
def delegate(self):
self.action() # 本類中不定義action函式 所以使用delegate函式時就會出錯
# (2)定義action函式 但是返回異常
def action(self):
raise NotImplementedError("action must be defined")
# (3)上述的兩種方法還都可以定義例項物件 實際上可以利用@裝飾器語法生成不能定義的抽象超類
from abc import ABCMeta, abstractmethod
class Super(metaclass = ABCMeta):
@abstractmethod
def action(self): pass
x = Super() # 返回 TypeError: Can't instantiate abstract class Super with abstract methods action
-- # OOP和繼承: "is-a"的關係
class A(B):
pass
a = A()
isinstance(a, B) # 返回True, A是B的子類 a也是B的一種
# OOP和組合: "has-a"的關係
pass
# OOP和委託: "包裝"物件 在Python中委託通常是以"__getattr__"鉤子方法實現的, 這個方法會攔截對不存在屬性的讀取
# 包裝類(或者稱為代理類)可以使用__getattr__把任意讀取轉發給被包裝的物件
class wrapper(object):
def __init__(self, object):
self.wrapped = object
def __getattr(self, attrname):
print('Trace: ', attrname)
return getattr(self.wrapped, attrname)
# 注:這裡使用getattr(X, N)內建函式以變數名字串N從包裝物件X中取出屬性 類似於X.__dict__[N]
x = wrapper([1, 2, 3])
x.append(4) # 返回 "Trace: append" [1, 2, 3, 4]
x = wrapper({'a':1, 'b':2})
list(x.keys()) # 返回 "Trace: keys" ['a', 'b']
-- 類的偽私有屬性:使用__attr
class C1(object):
def __init__(self, name):
self.__name = name # 此時類的__name屬性為偽私有屬性 原理 它會自動變成self._C1__name = name
def __str__(self):
return 'self.name = %s' % self.__name
I = C1('tom')
print(I) # 返回 self.name = tom
I.__name = 'jeey' # 這裡無法訪問 __name為偽私有屬性
I._C1__name = 'jeey' # 這裡可以修改成功 self.name = jeey
-- 類方法是物件:無繫結類方法物件 / 繫結例項方法物件
class Spam(object):
def doit(self, message):
print(message)
def selfless(message)
print(message)
obj = Spam()
x = obj.doit # 類的繫結方法物件 例項 + 函式
x('hello world')
x = Spam.doit # 類的無繫結方法物件 類名 + 函式
x(obj, 'hello world')
x = Spam.selfless # 類的無繫結方法函式 在3.0之前無效
x('hello world')
-- 獲取物件資訊: 屬性和方法
a = MyObject()
dir(a) # 使用dir函式
hasattr(a, 'x') # 測試是否有x屬性或方法 即a.x是否已經存在
setattr(a, 'y', 19) # 設定屬性或方法 等同於a.y = 19
getattr(a, 'z', 0) # 獲取屬性或方法 如果屬性不存在 則返回預設值0
#這裡有個小技巧，setattr可以設定一個不能訪問到的屬性，即只能用getattr獲取
setattr(a, "can't touch", 100) # 這裡的屬性名帶有空格，不能直接訪問
getattr(a, "can't touch", 0) # 但是可以用getattr獲取
-- 為類動態繫結屬性或方法: MethodType方法
# 一般建立了一個class的例項後, 可以給該例項繫結任何屬性和方法, 這就是動態語言的靈活性
class Student(object):
pass
s = Student()
s.name = 'Michael' # 動態給例項繫結一個屬性
def set_age(self, age): # 定義一個函式作為例項方法
self.age = age
from types import MethodType
s.set_age = MethodType(set_age, s) # 給例項繫結一個方法 類的其他例項不受此影響
s.set_age(25) # 呼叫例項方法
Student.set_age = MethodType(set_age, Student) # 為類繫結一個方法 類的所有例項都擁有該方法
類的高階話題
-- 多重繼承: "混合類", 搜尋方式"從下到上 從左到右 廣度優先"
class A(B, C):
pass
-- 類的繼承和子類的初始化
# 1.子類定義了__init__方法時，若未顯示呼叫基類__init__方法，python不會幫你呼叫。
# 2.子類未定義__init__方法時，python會自動幫你呼叫首個基類的__init__方法，注意是首個。
# 3.子類顯示呼叫基類的初始化函式：
class FooParent(object):
def __init__(self, a):
self.parent = 'I\'m the Parent.'
print('Parent:a=' + str(a))
def bar(self, message):
print(message + ' from Parent')
class FooChild(FooParent):
def __init__(self, a):
FooParent.__init__(self, a)
print('Child:a=' + str(a))
def bar(self, message):
FooParent.bar(self, message)
print(message + ' from Child')
fooChild = FooChild(10)
fooChild.bar('HelloWorld')
-- #例項方法 / 靜態方法 / 類方法
class Methods(object):
def imeth(self, x): print(self, x) # 例項方法：傳入的是例項和資料，操作的是例項的屬性
def smeth(x): print(x) # 靜態方法：只傳入資料 不傳入例項，操作的是類的屬性而不是例項的屬性
def cmeth(cls, x): print(cls, x) # 類方法：傳入的是類物件和資料
smeth = staticmethod(smeth) # 呼叫內建函式，也可以使用@staticmethod
cmeth = classmethod(cmeth) # 呼叫內建函式，也可以使用@classmethod
obj = Methods()
obj.imeth(1) # 例項方法呼叫 <__main__.Methods object...> 1
Methods.imeth(obj, 2) # <__main__.Methods object...> 2
Methods.smeth(3) # 靜態方法呼叫 3
obj.smeth(4) # 這裡可以使用例項進行呼叫
Methods.cmeth(5) # 類方法呼叫 <class '__main__.Methods'> 5
obj.cmeth(6) # <class '__main__.Methods'> 6
-- 函式裝飾器:是它後邊的函式的執行時的宣告 由@符號以及後邊緊跟的"元函式"(metafunction)組成
@staticmethod
def smeth(x): print(x)
# 等同於:
def smeth(x): print(x)
smeth = staticmethod(smeth)
# 同理
@classmethod
def cmeth(cls, x): print(x)
# 等同於
def cmeth(cls, x): print(x)
cmeth = classmethod(cmeth)
-- 類修飾器:是它後邊的類的執行時的宣告 由@符號以及後邊緊跟的"元函式"(metafunction)組成
def decorator(aClass):.....
@decorator
class C(object):....
# 等同於:
class C(object):....
C = decorator(C)
-- 限制class屬性: slots屬性
class Student(object):
__slots__ = ('name', 'age') # 限制Student及其例項只能擁有name和age屬性
# __slots__屬性只對當前類起作用, 對其子類不起作用
# __slots__屬效能夠節省記憶體
# __slots__屬性可以為列表list，或者元組tuple
-- 類屬性高階話題: @property
# 假設定義了一個類:C，該類必須繼承自object類，有一私有變數_x
class C(object):
def __init__(self):
self.__x = None
# 第一種使用屬性的方法
def getx(self):
return self.__x
def setx(self, value):
self.__x = value
def delx(self):
del self.__x
x = property(getx, setx, delx, '')
# property函式原型為property(fget=None,fset=None,fdel=None,doc=None)
# 使用
c = C()
c.x = 100 # 自動呼叫setx方法
y = c.x # 自動呼叫getx方法
del c.x # 自動呼叫delx方法
# 第二種方法使用屬性的方法
@property
def x(self):
return self.__x
@x.setter
def x(self, value):
self.__x = value
@x.deleter
def x(self):
del self.__x
# 使用
c = C()
c.x = 100 # 自動呼叫setter方法
y = c.x # 自動呼叫x方法
del c.x # 自動呼叫deleter方法
-- 定製類: 重寫類的方法
# (1)__str__方法、__repr__方法: 定製類的輸出字串
# (2)__iter__方法、next方法: 定製類的可迭代性
class Fib(object):
def __init__(self):
self.a, self.b = 0, 1 # 初始化兩個計數器a，b
def __iter__(self):
return self # 例項本身就是迭代物件，故返回自己
def next(self):
self.a, self.b = self.b, self.a + self.b
if self.a > 100000: # 退出迴圈的條件
raise StopIteration()
return self.a # 返回下一個值
for n in Fib():
print(n) # 使用
# (3)__getitem__方法、__setitem__方法: 定製類的下標操作[] 或者切片操作slice
class Indexer(object):
def __init__(self):
self.data = {}
def __getitem__(self, n): # 定義getitem方法
print('getitem:', n)
return self.data[n]
def __setitem__(self, key, value): # 定義setitem方法
print('setitem:key = {0}, value = {1}'.format(key, value))
self.data[key] = value
test = Indexer()
test[0] = 1; test[3] = '3' # 呼叫setitem方法
print(test[0]) # 呼叫getitem方法
# (4)__getattr__方法: 定製類的屬性操作
class Student(object):
def __getattr__(self, attr): # 定義當獲取類的屬性時的返回值
if attr=='age':
return 25 # 當獲取age屬性時返回25
raise AttributeError('object has no attribute: %s' % attr)
# 注意: 只有當屬性不存在時 才會呼叫該方法 且該方法預設返回None 需要在函式最後引發異常
s = Student()
s.age # s中age屬性不存在 故呼叫__getattr__方法 返回25
# (5)__call__方法: 定製類的'可呼叫'性
class Student(object):
def __call__(self): # 也可以帶引數
print('Calling......')
s = Student()
s() # s變成了可呼叫的 也可以帶引數
callable(s) # 測試s的可呼叫性 返回True
# (6)__len__方法：求類的長度
def __len__(self):
return len(self.data)
-- 動態建立類type()
# 一般建立類 需要在程式碼中提前定義
class Hello(object):
def hello(self, name='world'):
print('Hello, %s.' % name)
h = Hello()
h.hello() # Hello, world
type(Hello) # Hello是一個type型別 返回<class 'type'>
type(h) # h是一個Hello型別 返回<class 'Hello'>
# 動態型別語言中 類可以動態建立 type函式可用於建立新型別
def fn(self, name='world'): # 先定義函式
print('Hello, %s.' % name)
Hello = type('Hello', (object,), dict(hello=fn)) # 建立Hello類 type原型: type(name, bases, dict)
h = Hello() # 此時的h和上邊的h一致
異常相關
-- #捕獲異常:
try:
except: # 捕獲所有的異常 等同於except Exception:
except name: # 捕獲指定的異常
except name, value: # 捕獲指定的異常和額外的資料(例項)
except (name1, name2):
except (name1, name2), value:
except name4 as X:
else: # 如果沒有發生異常
finally: # 總會執行的部分
# 引發異常: raise子句(raise IndexError)
raise <instance> # raise instance of a class, raise IndexError()
raise <class> # make and raise instance of a class, raise IndexError
raise # reraise the most recent exception
-- Python3.x中的異常鏈: raise exception from otherException
except Exception as X:
raise IndexError('Bad') from X