歡迎點擊右上角關注小編。除了分享技術文章外，還有很多好處。私人學習資料包括python實戰(zhàn)練習、PDF電子文件、面試亮點、學習資料等。

# _*_ coding: utf-8 _*_

"""類型和運算----類型和運算----類型和運算----類型和運算----類型和運算----"""

#-- 尋求幫助:

dir(obj) # 簡單的列出對象obj所包含的方法名稱，返回一個字符串列表

hel) # 查詢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數據類型：哈希類型、不可哈希類型

# 哈希類型，即在原地不能改變的變量類型，不可變類型?？衫胔ash函數查看其hash值，也可以作為字典的key

"數字類型：int, float, decimal.Decimal, , 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)來創(chuàng)建

hex(I), oct(I), bin(I) # 將十進制數轉化為十六進制、八進制、二進制表示的“字符串”

int(string, base) # 將字符串轉化為整數，base為進制數

# 2.x中，有兩種整數類型：一般整數（32位）和長整數（無窮精度）?？梢杂胠或L結尾，迫使一般整數成為長整數

float('inf'), float('-inf'), float('nan') # 無窮大, 無窮小, 非數

#-- 數字的表達式操作符

yield x # 生成器函數發(fā)送協(xié)議

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ù)比較

x|y, x&y, x^y # 位或、位與、位異或

x<<y, x>>y # 位操作：x左移、右移y位

+, -, *, /, //, %, ** # 真除法、floor除法：返回不大于真除法結果的整數值、取余、冪運算

-x, +x, ~x # 一元減法、識別、按位求補（取反）

x[i], x[i:j:k] # 索引、分片

in), float(3) # 強制類型轉換

#-- 整數可以利用bit_length函數測試所占的位數

a = 1; a.bit_length() # 1

a = 1024; a.bit_length() # 11

#-- repr和str顯示格式的區(qū)別

"""

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]) # 創(chuàng)建一個數值集合，返回{3, 5, 9, 10}

t = set("Hello") # 創(chuàng)建一個字符的集合，返回{'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值，不能作為字典的鍵值。同樣的還有l(wèi)ist等(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變?yōu)閒rozenset，可哈希

#-- 布爾類型bool

type(True) # 返回<class 'bool'>

isinstance(False, int) # bool類型屬于整型，所以返回True

True == 1; True is 1 # 輸出(True, False)

#-- 動態(tài)類型簡介

"""

變量名通過引用，指向對象。

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 = "snptax00m" # 轉義字符

S = """spam""" # 三重引號字符串，一般用于函數說明

S = r'temp' # Raw字符串，不會進行轉義，抑制轉義

S = b'Spam' # Python3中的字節(jié)字符串

S = u'spam' # Py中的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"

(); (); (); (); () # 全部大寫，全部小寫、大小寫轉換，首字母大寫，每個單詞的首字母都大寫

(width) # 獲取固定長度，左對齊，右邊不夠用空格補齊

(width) # 獲取固定長度，右對齊，左邊不夠用空格補齊

(width) # 獲取固定長度，中間對齊，兩邊不夠用空格補齊

(width) # 獲取固定長度，右對齊，左邊不足用0補齊

('t',start,end) # 查找字符串，可以指定起始及結束位置搜索

('t') # 從右邊開始查找字符串

('t') # 查找字符串出現的次數

#上面所有方法都可用index代替，不同的是使用index查找不到會拋異常，而find返回-1

('old','new') # 替換函數，替換old為new，參數中可以指定maxReplaceTimes，即替換指定次數的old為new

(); # 默認刪除空白符

('d'); # 刪除str1字符串中開頭、結尾處，位于 d 刪除序列的字符

();

('d'); # 刪除str1字符串中開頭處，位于 d 刪除序列的字符

();

('d') # 刪除str1字符串中結尾處，位于 d 刪除序列的字符

('start') # 是否以start開頭

('end') # 是否以end結尾

(); (); (); (); () # 判斷字符串是否全為字符、數字、小寫、大寫

#-- 三重引號編寫多行字符串塊，并且在代碼折行處嵌入換行字符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')

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]} {}".format(sys = sys, config = {'spam':'laptop'}) # 基于Key的鍵和屬性

"first = {0[0]}, second = {0[1]}".format(['A', 'B', 'C']) # 基于位置的偏移量

# 具體格式化

"{0:e}, {1:.3e}, {2:g}".forma159, 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 .' 動態(tài)指定參數

#-- 常用列表常量和操作

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的區(qū)別

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:] # 注意，這里不會引發(fā)IndexError異常，只會返回一個空的列表[]

a = [], a += [1] # 這里實在原有列表的基礎上進行操作，即列表的id沒有改變

a = [], a = a + [1] # 這里最后的a要構建一個新的列表，即a的id發(fā)生了變化

#-- 用切片來刪除序列的某一段

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）字典鍵不一定非得是字符串，也可以為任何的不可變對象

# 不可變對象：調用對象自身的任意方法，也不會改變該對象自身的內容，這些方法會創(chuàng)建新的對象并返回。

# 字符串、整數、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時，會執(zhí)行該方法

class Dict(dict):

def __missing__(self, key):

self[key] = []

return self[key]

dct = dict()

dct["foo"].append(1) # 這有點類似于collec

dct["foo"] # [1]

#-- 元組和列表的唯一區(qū)別在于元組是不可變對象，列表是可變對象

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'等

([size]) # size為讀取的長度，以byte為單位

line([size]) # 讀一行，如果定義了size，有可能返回的只是一行的一部分

lines([size]) # 把文件每一行作為一個list的一個成員，并返回這個list。其實它的內部是通過循環(huán)調用readline()來實現的。如果提供size參數，size是表示讀取內容的總長。

able() # 是否可讀

(str) # 把str寫到文件中，write()并不會在str后加上一個換行符

lines(seq) # 把seq的內容全部寫到文件中(多行一次性寫入)

able() # 是否可寫

() # 關閉文件。

() # 把緩沖區(qū)的內容寫入硬盤

() # 返回一個長整型的”文件標簽“

() # 文件是否是一個終端設備文件（unix系統(tǒng)中的）

() # 返回文件操作標記的當前位置，以文件的開頭為原點

() # 返回下一行，并將文件操作標記位移到下一行。把一個file用于for … in file這樣的語句時，就是調用next()函數來實現遍歷的。

(offset[,whence]) # 將文件打開操作標記移到offset的位置。whence為0表示從頭開始計算，1表示以當前位置為原點計算。2表示以文件末尾為原點進行計算。

able() # 是否可以seek

([size]) # 把文件裁成規(guī)定的大小，默認的是裁到當前文件操作標記的位置。

for line in open('data'):

print(line) # 使用for語句，比較適用于打開比較大的文件

with open('data') as file:

prin()) # 使用with語句，可以保證文件關閉

with open('data') as file:

lines = () # 一次讀入文件所有行，并關閉文件

open('f.txt', encoding = 'latin-1') # Py Unicode文本文件

open('f.bin', 'rb') # Py 二進制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' # 序列解包形式（Py中才有）

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

# 帶有*時 會優(yōu)先匹配*之外的變量 如

a, *b, c = [1, 2] # a = 1, c = 2, b = []

#-- print函數原型

print(value, ..., sep=' ', end='n', file=, flush=False)

# 流的重定向

print('hello world') # 等于.write('hello world')

temp = # 原有流的保存

= open('log.log', 'a') # 流的重定向

print('hello world') # 寫入到文件log.log

.close()

= 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語句會在循環(huán)結束后執(zhí)行，除非在循環(huán)中執(zhí)行了break，同樣的還有for語句

for i in range(5):

anything

else:

anything

#-- for循環(huán)的元組賦值

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) # 使用小括號可以創(chuàng)建所需結果的生成器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()

prin) # 輸出函數文檔字符串

prin) # 輸出類的文檔字符串

#-- 命名慣例:

"""

以單一下劃線開頭的變量名(_X)不會被from module import*等語句導入

前后有兩個下劃線的變量名(__X__)是系統(tǒng)定義的變量名，對解釋器有特殊意義

以兩個下劃線開頭但不以下劃線結尾的變量名(__X)是類的本地(私有)變量

"""

#-- 列表解析 in成員關系測試 map sorted zip enumerate內置函數等都使用了迭代協(xié)議

'first line' in open(';) # in測試 返回True或False

list(ma, 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.文件類型

"""

"""函數語法規(guī)則----函數語法規(guī)則----函數語法規(guī)則----函數語法規(guī)則----函數語法規(guī)則----函數語法規(guī)則----函數語法規(guī)則----函數語法規(guī)則----函數語法規(guī)則----函數語法規(guī)則"""

#-- 函數相關的語句和表達式

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語句的區(qū)別

# 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():.....

= 1 # 自定義函數添加屬性

= 1 # Error 內置函數不可以添加屬性

#-- 函數注解: 編寫在def頭部行 主要用于說明參數范圍、參數類型、返回值類型等

def func(a:'spam', b:(1, 10), c:float) -> int :

print(a, b, c)

# {'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]

((lambda x, y: x + y), [1, 2, 3]) # 6

((lambda x, y: x * y), [2, 3, 4]) # 24

#-- 生成器函數:yield VS return

def gensquare(N):

for i in range(N):

yield i** 2 # 狀態(tài)掛起 可以恢復到此時的狀態(tài)

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)) # 使用小括號可以創(chuàng)建所需結果的生成器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也不在了

#-- 本地變量是靜態(tài)檢測的

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]]) # 創(chuàng)建一個復數

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]) # 創(chuàng)建數據字典

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為靜態(tài)方法

dir([object]) # 不帶參數時，返回當前范圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。

help(obj) # 返回obj的幫助信息

eval(expression) # 計算表達式expression的值，并返回

exec(str) # 將str作為Python語句執(zhí)行

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, ...) # 遍歷每個元素，執(zhí)行function操作

list(map(abs, range(-3, 4))) # 返回[3, 2, 1, 0, 1, 2, 3]

next(iterator[, default]) # 類似于i()

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

# 獲得腳本的參數

# 查找內建模塊

# 返回當前平臺 出現如： "win32" "linux" "darwin"等

# 查找已導入的模塊

.keys()

# stdout 和 stderr 都是類文件對象，但是它們都是只寫的。它們都沒有 read 方法，只有 write 方法

.write("hello")

#-- 模塊的使用代碼

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)

#-- 模塊的包導入:使用點號(.)而不是路徑(dir1dir2)進行導入

import dir1.dir2.mod # d導入包(目錄)dir1中的包dir2中的mod模塊 此時dir1必須在Python可搜索路徑中

from dir1.dir2.mod import * # from語法的包導入

#-- __ini包文件:每個導入的包中都應該包含這么一個文件

"""

該文件可以為空

首次進行包導入時 該文件會自動執(zhí)行

高級功能:在該文件中使用__all__列表來定義包(目錄)以from*的形式導入時 需要導入什么

"""

#-- 包相對導入:使用點號(.) 只能使用from語句

from . import spam # 導入當前目錄下的spam模塊（Python2: 當前目錄下的模塊, 直接導入即可）

from .spam import name # 導入當前目錄下的spam模塊的name屬性（Python2: 當前目錄下的模塊, 直接導入即可，不用加.）

from .. import spam # 導入當前目錄的父目錄下的spam模塊

#-- 包相對導入與普通導入的區(qū)別

from string import * # 這里導入的string模塊為路徑上的 而不是本目錄下的string模塊(如果存在也不是)

from .string import * # 這里導入的string模塊為本目錄下的(不存在則導入失敗) 而不是路徑上的

#-- 模塊數據隱藏:最小化from*的破壞

_X # 變量名前加下劃線可以防止from*導入時該變量名被復制出去

__all__ = ['x', 'x1', 'x2'] # 使用__all__列表指定from*時復制出去的變量名(變量名在列表中為字符串形式)

#-- 可以使用__name__進行模塊的單元測試:當模塊為頂層執(zhí)行文件時值為'__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']

['M'].name

getattr(M, 'name')

"""類與面向對象----類與面向對象----類與面向對象----類與面向對象----類與面向對象----類與面向對象----類與面向對象----類與面向對象----類與面向對象----類與面向對象"""

#-- 最普通的類

class C1(C2, C3):

spam = 42 # 數據屬性

def __init__(self, name): # 函數屬性:構造函數

= name

def __del__(self): # 函數屬性:析構函數

print("goodbey ", )

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):

= int(*(1 + percent + bonus)) # 不好的方式 復制粘貼超類代碼

Per(self, percent + bonus) # 好的方式 盡量調用超類方法

#-- 類內省工具

bob = Person('bob')

bob.__class__ # <class 'Person'>

bob.__cla # '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

#-- 類方法調用的兩種方式

in(arg...)

cla(instance, arg...)

#-- 抽象超類的實現方法

# (1)某個函數中調用未定義的函數 子類中定義該函數

def delegate(self):

() # 本類中不定義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__把任意讀取轉發(fā)給被包裝的對象

class wrapper(object):

def __init__(self, object):

= object

def __getattr(self, attrname):

print('Trace: ', attrname)

return getattr(, 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})

li()) # 返回 "Trace: keys" ['a', 'b']

#-- 類的偽私有屬性:使用__attr

class C1(object):

def __init__(self, name):

= name # 此時類的__name屬性為偽私有屬性 原理 它會自動變成 = name

def __str__(self):

return ' = %s' %

I = C1('tom')

print(I) # 返回 = tom

I.__name = 'jeey' # 這里無法訪問 __name為偽私有屬性

I._C1__name = 'jeey' # 這里可以修改成功 = jeey

#-- 類方法是對象:無綁定類方法對象 / 綁定實例方法對象

class Spam(object):

def doit(self, message):

print(message)

def selfless(message)

print(message)

obj = Spam()

x = obj.doit # 類的綁定方法對象 實例 + 函數

x('hello world')

x = S # 類的無綁定方法對象 類名 + 函數

x(obj, 'hello world')

x = S # 類的無綁定方法函數 在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獲取

#-- 為類動態(tài)綁定屬性或方法: MethodType方法

# 一般創(chuàng)建了一個class的實例后, 可以給該實例綁定任何屬性和方法, 這就是動態(tài)語言的靈活性

class Student(object):

pass

s = Student()

s.name = 'Michael' # 動態(tài)給實例綁定一個屬性

def set_age(self, age): # 定義一個函數作為實例方法

= age

from types import MethodType

s.set_age = MethodType(set_age, s) # 給實例綁定一個方法 類的其他實例不受此影響

s.set_age(25) # 調用實例方法

S = MethodType(set_age, Student) # 為類綁定一個方法 類的所有實例都擁有該方法

"""類的高級話題----類的高級話題----類的高級話題----類的高級話題----類的高級話題----類的高級話題----類的高級話題----類的高級話題----類的高級話題----類的高級話題"""

#-- 多重繼承: "混合類", 搜索方式"從下到上 從左到右 廣度優(yōu)先"

class A(B, C):

pass

#-- 類的繼承和子類的初始化

# 1.子類定義了__init__方法時，若未顯示調用基類__init__方法，python不會幫你調用。

# 2.子類未定義__init__方法時，python會自動幫你調用首個基類的__init__方法，注意是首個。

# 3.子類顯示調用基類的初始化函數：

class FooParent(object):

def __init__(self, a):

= '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)

('HelloWorld')

#-- #實例方法 / 靜態(tài)方法 / 類方法

class Methods(object):

def imeth(self, x): print(self, x) # 實例方法：傳入的是實例和數據，操作的是實例的屬性

def smeth(x): print(x) # 靜態(tài)方法：只傳入數據 不傳入實例，操作的是類的屬性而不是實例的屬性

def cmeth(cls, x): print(cls, x) # 類方法：傳入的是類對象和數據

smeth = staticmethod(smeth) # 調用內置函數，也可以使用@staticmethod

cmeth = classmethod(cmeth) # 調用內置函數，也可以使用@classmethod

obj = Methods()

obj.imeth(1) # 實例方法調用 <__main__.Methods object...> 1

Me(obj, 2) # <__main__.Methods object...> 2

Me(3) # 靜態(tài)方法調用 3

obj.smeth(4) # 這里可以使用實例進行調用

Me(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__屬性能夠節(jié)省內存

# __slots__屬性可以為列表list，或者元組tuple

#-- 類屬性高級話題: @property

# 假設定義了一個類:C，該類必須繼承自object類，有一私有變量_x

class C(object):

def __init__(self):

= None

# 第一種使用屬性的方法

def getx(self):

return

def setx(self, value):

= value

def delx(self):

del

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

@x.setter

def x(self, value):

= value

@x.deleter

def x(self):

del

# 使用

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):

, = 0, 1 # 初始化兩個計數器a，b

def __iter__(self):

return self # 實例本身就是迭代對象，故返回自己

def next(self):

, = , +

if > 100000: # 退出循環(huán)的條件

raise StopIteration()

return # 返回下一個值

for n in Fib():

print(n) # 使用

# (3)__getitem__方法、__setitem__方法: 定制類的下標操作[] 或者切片操作slice

class Indexer(object):

def __init__(self):

= {}

def __getitem__(self, n): # 定義getitem方法

print('getitem:', n)

return [n]

def __setitem__(self, key, value): # 定義setitem方法

print('setitem:key = {0}, value = {1}'.format(key, value))

[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 需要在函數最后引發(fā)異常

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()

#-- 動態(tài)創(chuàng)建類type()

# 一般創(chuàng)建類 需要在代碼中提前定義

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'>

# 動態(tài)類型語言中 類可以動態(tài)創(chuàng)建 type函數可用于創(chuàng)建新類型

def fn(self, name='world'): # 先定義函數

print('Hello, %s.' % name)

Hello = type('Hello', (object,), dict(hello=fn)) # 創(chuàng)建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: # 如果沒有發(fā)生異常

finally: # 總會執(zhí)行的部分

# 引發(fā)異常: 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

#-- Py中的異常鏈: 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環(huán)境管理器:作為常見的try/finally用法模式的替代方案

with expression [as variable], expression [as variable]:

# 例子:

with open(';) as myfile:

for line in myfile: print(line)

# 等同于:

myfile = open(';)

try:

for line in myfile: print(line)

finally:

my()

#-- 用戶自定義異常: class Bad(Exception):.....

"""

Exception超類 / except基類即可捕獲到其所有子類

Exception超類有默認的打印消息和狀態(tài) 當然也可以定制打印顯示:

"""

class MyBad(Exception):

def __str__(self):

return '定制的打印消息'

try:

MyBad()

except MyBad as x:

print(x)

#-- 用戶定制異常數據

class FormatError(Exception):

def __init__(self, line ,file):

= line

= file

try:

raise FormatError(42, ';)

except FormatError as X:

print('Error at ', X.file, X.line)

# 用戶定制異常行為(方法):以記錄日志為例

class FormatError(Exception):

logfile = ';

def __init__(self, line ,file):

= line

= file

def logger(self):

open, 'a').write('Error at ', , )

try:

raise FormatError(42, ';)

except FormatError as X:

X.logger()

#-- 關于:允許一個異常處理器獲取對最近引發(fā)的異常的訪問

try:

......

except:

# 此時()返回一個元組(type, value, traceback)

# type:正在處理的異常的異常類型

# value:引發(fā)的異常的實例

# 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和字節(jié)字符串---Unicode和字節(jié)字符串----Unicode和字節(jié)字符串----Unicode和字節(jié)字符串----Unicode和字節(jié)字符串----Unicode和字節(jié)字符串----Unicode和字節(jié)字符串"""

#-- Python的字符串類型

"""Py;""

# 1.str表示8位文本和二進制數據

# 2.unicode表示寬字符Unicode文本

"""Py"""

# 1.str表示Unicode文本（8位或者更寬）

# 2.bytes表示不可變的二進制數據

# 3.bytearray是一種可變的bytes類型

#-- 字符編碼方法

"""ASCII""" # 一個字節(jié)，只包含英文字符，0到127，共128個字符，利用函數可以進行字符和數字的相互轉換

ord('a') # 字符a的ASCII碼為97，所以這里返回97

chr(97) # 和上邊的過程相反，返回字符'a'

"""Latin-1""" # 一個字節(jié)，包含特殊字符，0到255，共256個字符，相當于對ASCII碼的擴展

chr(196) # 返回一個特殊字符：?

"""Unicode""" # 寬字符，一個字符包含多個字節(jié)，一般用于亞洲的字符集，比如中文有好幾萬字

"""UTF-8""" # 可變字節(jié)數，小于128的字符表示為單個字節(jié)，128到0X7FF之間的代碼轉換為兩個字節(jié)，0X7FF以上的代碼轉換為3或4個字節(jié)

# 注意：可以看出來，ASCII碼是Latin-1和UTF-8的一個子集

# 注意：utf-8是unicode的一種實現方式，unicode、gbk、gb2312是編碼字符集

#-- 查看Python中的字符串編碼名稱，查看系統(tǒng)的編碼

import encodings

help(encoding)

import sys

# 'win64'

() # 'utf-8'

() # 返回當前系統(tǒng)平臺的編碼類型

(object) # 返回object占有的bytes的大小

#-- 源文件字符集編碼聲明: 添加注釋來指定想要的編碼形式 從而改變默認值 注釋必須出現在腳本的第一行或者第二行

"""說明：其實這里只會檢查#和coding:utf-8，其余的字符都是為了美觀加上的"""

# _*_ coding: utf-8 _*_

# coding = utf-8

#-- #編碼: 字符串 --> 原始字節(jié) #解碼: 原始字節(jié) --> 字符串

#-- Py中的字符串應用

s = '...' # 構建一個str對象，不可變對象

b = b'...' # 構建一個bytes對象，不可變對象

s[0], b[0] # 返回('.', 113)

s[1:], b[1:] # 返回('..', b'..')

B = B"""

xxxx

yyyy

"""

# B = b'nxxxxnyyyyn'

# 編碼，將str字符串轉化為其raw bytes形式：

(encoding = 'utf-8', errors = 'strict')

bytes(str, encoding)

# 編碼例子：

S = 'egg'

S.encode() # b'egg'

bytes(S, encoding = 'ascii') # b'egg'

# 解碼，將raw bytes字符串轉化為str形式：

by(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對象

#-- Py的編碼問題

u = u'漢'

print repr(u) # u'xbaxba'

s = u.encode('UTF-8')

print repr(s) # 'xc2xbaxc2xba'

u2 = s.decode('UTF-8')

print repr(u2) # u'xbaxba'

# 對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編碼來解釋文件內容，要么是平臺的默認編碼，要么是指定的編碼類型

# 二進制文件：表示字節(jié)值的整數的一個序列 open('bin.txt', 'rb')

#-- Unicode文件

s = 'Axc4Bxe8C' # s = 'A?BèC' len(s) = 5

#手動編碼

l = s.encode('latin-1') # l = b'Axc4Bxe8C' len(l) = 5

u = s.encode('utf-8') # u = b'Axc3x84Bxc3xa8C' len(u) = 7

#文件輸出編碼

open('latindata', 'w', encoding = 'latin-1').write(s)

l = open('latindata', 'rb').read() # l = b'Axc4Bxe8C' len(l) = 5

open('uft8data', 'w', encoding = 'utf-8').write(s)

u = open('uft8data', 'rb').read() # u = b'Axc3x84Bxc3xa8C' 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列，且每一個元素為[]