# _*_ coding: utf-8 _*_
"""類型和運算----類型和運算----類型和運算----類型和運算----類型和運算----類型和運算----類型和運算----類型和運算----類型和運算----類型和運算----類型和運算"""
#-- 尋求幫助:
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") # 創建一個唯一字符的集合返回{}
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語句，比較適用於打開比較大的文件
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）
result = (a > 20 and "big than 20" or a > 10 and "big than 10" or a > 5 and "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:
"""
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，因爲該函數將不會捕獲用戶的錯誤輸入
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----模塊Moudle----模塊Moudle----模塊Moudle----模塊Moudle----模塊Moudle----模塊Moudle----模塊Moudle----模塊Moudle----模塊Moudle----模塊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模塊（錯誤: 當前目錄下的模塊, 直接導入即可）
from .spam import name # 導入當前目錄下的spam模塊的name屬性（錯誤: 當前目錄下的模塊, 直接導入即可，不用加.）
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:
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 值爲2 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:
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:
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:
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:
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:....
# 等同於:
class C:....
C = decorator(C)
#-- 限制class屬性: __slots__屬性
class Student:
__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
#-- assert子句: assert <test>, <data>
assert x < 0, 'x must be negative'
#-- with/as環境管理器:作爲常見的try/finally用法模式的替代方案
with expression [as variable], expression [as variable]:
# 例子:
with open('test.txt') as myfile:
for line in myfile: print(line)
# 等同於:
myfile = open('test.txt')
try:
for line in myfile: print(line)
finally:
myfile.close()
#-- 用戶自定義異常: class Bad(Exception):.....
"""
Exception超類 / except基類即可捕獲到其所有子類
Exception超類有默認的打印消息和狀態 當然也可以定製打印顯示:
"""
class MyBad(Exception):
def __str__(self):
return '定製的打印消息'
try:
MyBad()
except MyBad as x:
print(x)
#-- 用戶定製異常數據
class FormatError(Exception):
def __init__(self, line ,file):
self.line = line
self.file = file
try:
raise FormatError(42, 'test.py')
except FormatError as X:
print('Error at ', X.file, X.line)
# 用戶定製異常行爲(方法):以記錄日誌爲例
class FormatError(Exception):
logfile = 'formaterror.txt'
def __init__(self, line ,file):
self.line = line
self.file = file
def logger(self):
open(self.logfile, 'a').write('Error at ', self.file, self.line)
try:
raise FormatError(42, 'test.py')
except FormatError as X:
X.logger()
#-- 關於sys.exc_info:允許一個異常處理器獲取對最近引發的異常的訪問
try:
......
except:
# 此時sys.exc_info()返回一個元組(type, value, traceback)
# type:正在處理的異常的異常類型
# value:引發的異常的實例
# traceback:堆棧信息
#-- 異常層次
BaseException
+-- SystemExit
+-- KeyboardInterrupt
+-- GeneratorExit
+-- Exception
+-- StopIteration
+-- ArithmeticError
+-- AssertionError
+-- AttributeError
+-- BufferError
+-- EOFError
+-- ImportError
+-- LookupError
+-- MemoryError
+-- NameError
+-- OSError
+-- ReferenceError
+-- RuntimeError
+-- SyntaxError
+-- SystemError
+-- TypeError
+-- ValueError
+-- Warning
"""Unicode和字節字符串---Unicode和字節字符串----Unicode和字節字符串----Unicode和字節字符串----Unicode和字節字符串----Unicode和字節字符串----Unicode和字節字符串"""
#-- Python的字符串類型
"""Python2.x"""
# 1.str表示8位文本和二進制數據
# 2.unicode表示寬字符Unicode文本
"""Python3.x"""
# 1.str表示Unicode文本（8位或者更寬）
# 2.bytes表示不可變的二進制數據
# 3.bytearray是一種可變的bytes類型
#-- 字符編碼方法
"""ASCII""" # 一個字節，只包含英文字符，0到127，共128個字符，利用函數可以進行字符和數字的相互轉換
ord('a') # 字符a的ASCII碼爲97，所以這裏返回97
chr(97) # 和上邊的過程相反，返回字符'a'
"""Latin-1""" # 一個字節，包含特殊字符，0到255，共256個字符，相當於對ASCII碼的擴展
chr(196) # 返回一個特殊字符：Ä
"""Unicode""" # 寬字符，一個字符包含多個字節，一般用於亞洲的字符集，比如中文有好幾萬字
"""UTF-8""" # 可變字節數，小於128的字符表示爲單個字節，128到0X7FF之間的代碼轉換爲兩個字節，0X7FF以上的代碼轉換爲3或4個字節
# 注意：可以看出來，ASCII碼是Latin-1和UTF-8的一個子集
# 注意：utf-8是unicode的一種實現方式，unicode、gbk、gb2312是編碼字符集
#-- 查看Python中的字符串編碼名稱，查看系統的編碼
import encodings
help(encoding)
import sys
sys.platform # 'win64'
sys.getdefaultencoding() # 'utf-8'
sys.getdefaultencoding() # 返回當前系統平臺的編碼類型
sys.getsizeof(object) # 返回object佔有的bytes的大小
#-- 源文件字符集編碼聲明: 添加註釋來指定想要的編碼形式 從而改變默認值 註釋必須出現在腳本的第一行或者第二行
"""說明：其實這裏只會檢查#和coding:utf-8，其餘的字符都是爲了美觀加上的"""
# _*_ coding: utf-8 _*_
# coding = utf-8
#-- #編碼: 字符串 --> 原始字節 #解碼: 原始字節 --> 字符串
#-- Python3.x中的字符串應用
s = '...' # 構建一個str對象，不可變對象
b = b'...' # 構建一個bytes對象，不可變對象
s[0], b[0] # 返回('.', 113)
s[1:], b[1:] # 返回('..', b'..')
B = B"""
xxxx
yyyy
"""
# B = b'\nxxxx\nyyyy\n'
# 編碼，將str字符串轉化爲其raw bytes形式：
str.encode(encoding = 'utf-8', errors = 'strict')
bytes(str, encoding)
# 編碼例子：
S = 'egg'
S.encode() # b'egg'
bytes(S, encoding = 'ascii') # b'egg'
# 解碼，將raw bytes字符串轉化爲str形式：
bytes.decode(encoding = 'utf-8', errors = 'strict')
str(bytes_or_buffer[, encoding[, errors]])
# 解碼例子：
B = b'spam'
B.decode() # 'spam'
str(B) # "b'spam'"，不帶編碼的str調用，結果爲打印該bytes對象
str(B, encoding = 'ascii')# 'spam'，帶編碼的str調用，結果爲轉化該bytes對象
#-- Python2.x的編碼問題
u = u'漢'
print repr(u) # u'\xba\xba'
s = u.encode('UTF-8')
print repr(s) # '\xc2\xba\xc2\xba'
u2 = s.decode('UTF-8')
print repr(u2) # u'\xba\xba'
# 對unicode進行解碼是錯誤的
s2 = u.decode('UTF-8') # UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)
# 同樣，對str進行編碼也是錯誤的
u2 = s.encode('UTF-8') # UnicodeDecodeError: 'ascii' codec can't decode byte 0xc2 in position 0: ordinal not in range(128)
#-- bytes對象
B = b'abc'
B = bytes('abc', 'ascii')
B = bytes([97, 98, 99])
B = 'abc'.encode()
# bytes對象的方法調用基本和str類型一致 但:B[0]返回的是ASCII碼值97, 而不是b'a'
#-- #文本文件: 根據Unicode編碼來解釋文件內容，要麼是平臺的默認編碼，要麼是指定的編碼類型
# 二進制文件：表示字節值的整數的一個序列 open('bin.txt', 'rb')
#-- Unicode文件
s = 'A\xc4B\xe8C' # s = 'A?BèC' len(s) = 5
#手動編碼
l = s.encode('latin-1') # l = b'A\xc4B\xe8C' len(l) = 5
u = s.encode('utf-8') # u = b'A\xc3\x84B\xc3\xa8C' len(u) = 7
#文件輸出編碼
open('latindata', 'w', encoding = 'latin-1').write(s)
l = open('latindata', 'rb').read() # l = b'A\xc4B\xe8C' len(l) = 5
open('uft8data', 'w', encoding = 'utf-8').write(s)
u = open('uft8data', 'rb').read() # u = b'A\xc3\x84B\xc3\xa8C' len(u) = 7
#文件輸入編碼
s = open('latindata', 'r', encoding = 'latin-1').read() # s = 'A?BèC' len(s) = 5
s = open('latindata', 'rb').read().decode('latin-1') # s = 'A?BèC' len(s) = 5
s = open('utf8data', 'r', encoding = 'utf-8').read() # s = 'A?BèC' len(s) = 5
s = open('utf8data', 'rb').read().decode('utf-8') # s = 'A?BèC' len(s) = 5
"""其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他"""
#-- Python實現任意深度的賦值 例如a[0] = 'value1'; a[1][2] = 'value2'; a[3][4][5] = 'value3'
class MyDict(dict):
def __setitem__(self, key, value): # 該函數不做任何改動 這裏只是爲了輸出
print('setitem:', key, value, self)
super().__setitem__(key, value)
def __getitem__(self, item): # 主要技巧在該函數
print('getitem:', item, self) # 輸出信息
# 基本思路: a[1][2]賦值時 需要先取出a[1] 然後給a[1]的[2]賦值
if item not in self: # 如果a[1]不存在 則需要新建一個dict 並使得a[1] = dict
temp = MyDict() # 新建的dict: temp
super().__setitem__(item, temp) # 賦值a[1] = temp
return temp # 返回temp 使得temp[2] = value有效
return super().__getitem__(item) # 如果a[1]存在 則直接返回a[1]
# 例子:
test = MyDict()
test[0] = 'test'
print(test[0])
test[1][2] = 'test1'
print(test[1][2])
test[1][3] = 'test2'
print(test[1][3])
#-- Python中的多維數組
lists = [0] * 3 # 擴展list，結果爲[0, 0, 0]
lists = [[]] * 3 # 多維數組，結果爲[[], [], []]，但有問題，往下看
lists[0].append(3) # 期望看到的結果[[3], [], []]，實際結果[[3], [3], [3]]，原因：list*n操作，是淺拷貝，如何避免？往下看
lists = [[] for i in range(3)] # 多維數組，結果爲[[], [], []]
lists[0].append(3) # 結果爲[[3], [], []]
lists[1].append(6) # 結果爲[[3], [6], []]
lists[2].append(9) # 結果爲[[3], [6], [9]]
lists = [[[] for j in range(4)] for i in range(3)] # 3行4列，且每一個元素爲[]python基礎學習
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章