pythonslots

Ⅰ python 中的 classmethod 和 staticmethod 有什麼具體用途

今天剛看了流暢的python，裡面有一章就講到這兩個的具體用例。

frommathimporthypot,atan2
fromarrayimportarray

classVector(object):
__slots__=('_x','_y')
typecode='d'

def__init__(self,x=0,y=0):
self._x=float(x)
self._y=float(y)

@property
defx(self):
returnself._x

@property
defy(self):
returnself._y

@classmethod
deffrombytes(cls,octets):
typecode=chr(octests[0])
memv=momoryview(octets[1:]).cast(typecode)
returncls(*memv)

def__hash__(self):
returnhash(self.x)^hash(self.y)

def__iter__(self):
return(iforiin(self.x,self.y))

def__repr__(self):
class_name=type(self).__name__
returnf'{class_name}({self.x},{self.y})'

def__str__(self):
returnstr(tuple(self))

defangle(self):
returnatan2(self.y,self.x)

def__format__(self,fmt_spec=''):
iffmt_spec.endswith('p'):
fmt_spec=fmt_spec[:-1]
coords=(abs(self),self.angel())
outer_fmt='<{}{}'
else:
coords=self
outer_fmt='({}{})'
components=(format(c,fmt_spec)forcinself)
returnouter_fmt.format(*components)

def__bytes__(self):
return(bytes([ord(self.typecode)])+
bytes(array(self.typecode,self)))

def__eq__(self,other):
returntuple(self)==tuple(self)

def__abs__(self):
'''abs(Vector(3,4))-->sqrt(vector.x,vector.y)=5'''
returnhypot(self.x,self.y)

def__bool__(self):
returnabs(self)!=0

def__add__(self,other):
x=self.x+other.x
y=self.y+other.y
returnVector(x,y)

def__mul__(self,scalar):
returnVector(self.x*scalar,self.y*scalar)

Ⅱ Python的基本術語有哪些

Python解釋器
Python文本編輯器
Python代碼運行助手
輸入和輸出
Python基礎
數據類型和變數
字元串和編碼
使用list和tuple
條件判斷
循環
使用dict和set
函數
調用函數
定義函數
函數的參數
遞歸函數
高級特性
切片
迭代
列表生成式
生成器
迭代器
函數式編程
高階函數
map/rece
filter
sorted
返回函數
匿名函數
裝飾器
偏函數
模塊
使用模塊
安裝第三方模塊
面向對象編程
類和實例
訪問限制
繼承和多態
獲取對象信息
實例屬性和類屬性
面向對象高級編程
使用__slots__
使用@property
多重繼承
定製類
使用枚舉類
使用元類
錯誤、調試和測試
錯誤處理
調試
單元測試
文檔測試
IO編程
文件讀寫
StringIO和BytesIO
操作文件和目錄
序列化
進程和線程
多進程
多線程
ThreadLocal
進程 vs. 線程
分布式進程
正則表達式
常用內建模塊
datetime
collections
base64
struct
hashlib
hmac
itertools
contextlib
urllib
XML
HTMLParser
常用第三方模塊
Pillow
requests
chardet
psutil
virtualenv
圖形界面
網路編程
TCP/IP簡介
TCP編程
UDP編程
電子郵件
SMTP發送郵件
POP3收取郵件
訪問資料庫
使用sqlite
使用MySQL
使用SQLAlchemy
Web開發
HTTP協議簡介
HTML簡介
WSGI介面
使用Web框架
使用模板
非同步IO
協程
asyncio
async/await
aiohttp

Ⅲ 風變編程的Python課程學完效果如何

一、Python簡介

Python是一種用來編寫應用程序的高級程序設計語言,TIOBE程序語言排行榜2015年12月的排名如下：

Python實現強勢逆襲，而且我相信，隨著時間的推移，國內Python語言未來前景也是一片向好。

Python的特點是優雅簡單，易學易用（雖然我感覺還是有一些概念不容易理解），Python的哲學是盡量用最少的，最簡單易懂的代碼實現需要的功能。Python適宜於開發網路應用，腳本寫作，日常簡單小工具等等。Python的缺點是效率較低，但是在大量的場合效率卻不是那麼重要或者說Python不是其性能瓶頸，所以不要太在意。其次是2.x-3.x的過渡使得許多3.x還缺少很多2.x下的模塊，不過也在完善中。其次就是源代碼無法加密，發布Python程序其實就是發布源代碼。

二、基礎語法要點

1.如果一個字元串中有許多需要轉義的字元，而又不想寫那麼多'',那麼可以用 r'...' 表示 '...'內的內容不轉義。

2.Python可用'''...'''來表示多行內容，如：

123456

>>>print('''line1line2line3''')line1line2line3

3.Python的邏輯運算and, or, not 分別對應C語言中的&&, ||, !.

4.Python的整數與浮點數大小都沒有范圍。

5.Python中除法有兩種： '/'除出來必是浮點數， '//'除出來是整數，即地板除。

6.Python中一切皆引用。每個對象都有一個引用計數器（內部跟蹤變數）進行跟蹤，引用計數值表示該對象有多少個引用，當初次產生賦給變數時，引用計數為1，其後沒進行下列行為中的任意一種都會增加引用計數：

123

賦值： a=b用作函數參數傳遞： func(a)成為容器對象的一個元素： lis=[1,2,a]

以下任意一種行為都會減少引用計數：

1234

del銷毀：dela變數另賦給其他對象：a=False對象從容器中刪除: lis.remove(a)身在的容器被銷毀：dellis

7.深拷貝與淺拷貝的概念與對比，有點復雜，看這篇文章

8.list，tuple和dict，set

list：為列表，是一個有序集合，類似於數組但又比數組功能強大，可以隨時append,pop元素，下標從0開始，且下標為加n模n制，即lis[-1] = lis[len-1]，下標范圍[-len,len-1].

tuple：為元組，類似於list，但list為可變類型，而tuple不可變，即沒有append,pop等函數。一個建議是為了安全起見，能用tuple代替list盡量用tuple。如果tuple只有一個元素，要寫成如(1,)以避免歧義。

dict：字典類型，存放key-value鍵值對，可以根據key迅速地找出value，當然，key必須是不可變類型，如下是錯誤的：

12345

>>> dic={[1,2]:'value'}Traceback (most recent call last):File"<pyshell#10>", line1,in<mole>dic={[1,2]:'value'}TypeError: unhashabletype:'list'

list與dict的優劣對比：

1234567

dict:1.插入，查找速度快，跟key的數目無關2.需佔用大量內存，內存浪費嚴重list:1.插入，查找速度慢，O(n)的復雜度，隨元素個數增加而增加2.佔用內存小

dict內部存放的順序和key放入的順序是沒有關系的

set：set與dict類似，相當於只有key沒有value的dict，每個key不同，set間有 &， | 等操作對應集合的交，並操作。

三、函數

1.函數是對象，函數名即是指向對應函數對象的引用，所以可以將函數名賦給一個變數，相當於給函數起一個『別名』。

123

>>> mmm=max>>> mmm(1,2,3)3

2.Python函數可以返回」多個值「，之所以打引號，是因為實際上返回的多個值拼成了一個元組，返回這個元組。

3.定義默認參數需要牢記：默認參數必須指向不變對象。否則第一次調用和第二次調用結果會不一樣，因為可變的默認參數調用後改變了。

4.可變參數：傳入的參數個數是可變的，可以是0個或多個。可變參數會將你傳入的參數自動組裝為一個tuple。在你傳入的list或tuple名字前加一個 * 即說明傳入的是可變參數。習慣寫法為*args。

5.關鍵字參數：傳入0個或多個含參數名的參數，這些參數被自動組裝成一個dict。習慣寫法**kw，如**a表示把a中所有的鍵值對以關鍵字參數的形式傳入kw，獲得一個dict，這個dict是a的一份拷貝，對kw改動不會傳遞到a

6.命名關鍵字在函數定義中跟在一個*分割符後，如

12

deffunc(a,b,*,c,d):pass

c,d為命名關鍵字參數，可以限制調用者可以傳入的參數名，同時可以提供默認值。

7.參數定義順序：必選參數，默認參數，可變參數/命名關鍵字參數，關鍵字參數。

8.切片操作格式為lis[首下標：尾下標：間隔]，如果都不填，即lis[::]則代表整個容器lis

9.用圓括弧()括起來一個列表生成式創建一個生成器generator，generator保存生成演算法，我們可以用next(g)取得生成器g的下一個返回值。生成器的好處就是我們不需要提前生成所有列表元素，而是需要時再生成，這在某些情況下可以節省許多內存。演算法也可以不是列表生成式而是自定義函數，只需在函數定義中包含yield關鍵字。

10.map()和rece()： 二者都是高階函數。map()接收兩個參數，一個是函數，一個是Iterable序列，map將傳入的函數依次作用在序列每一個元素上，並把結果作為新的Iterator返回。rece()類似累積計算版的map()，把一個函數作用在一個序列上，每次接收兩個參數，將結果繼續與序列的下一個元素做累積計算。

利用map和rece編寫一個str2float函數，如把字元串'123.456'轉換成浮點數123.456：

123456789101112131415

(s):deff1(x,y):returnx*10+ydefchar2num(s):return{'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}[s]deff2(x,y):returnx*0.1+ya,b=s.split('.')print('a=',a)print('b=',b)returnrece(f1,map(char2num,a))+0.1*rece(f2,map(char2num,b[::-1]))print('str2float('123.456') =', str2float('123.456'))

11.fliter()函數過濾序列，類似於map()作用於每一元素，根據返回值是True或者False決定舍棄還是保留該元素。函數返回一個Iterator。

12.sorted()函數可實現排序，類似於C++庫中的sort()函數，但是比其更加簡潔，語法為sorted(lis,key=func,reverse=T/F)

key函數可實現自定義的排序規則，reverse表示升序還是降序。

13.一個函數可以返回一個函數，但是返回時該函數並未執行，所以返回函數中不要引用任何可能發生變化的變數，否則會出現邏輯錯誤。

14.裝飾器(decorator): 當需要增強函數的功能卻不希望修改函數本身，那麼可以採用裝飾器這種運行時動態增加功能的方式，增加的功能卸載裝飾器函數中。如在執行前後列印'begin call'和'end call'，可以這樣做：

12345678910111213141516

importfunctoolsdeflog(func):@functools.wraps(func)#為了校正函數簽名，最好寫上defwrapper(*args,**kw):print('begin call')f=func(*args,**kw)print('end call')returnfreturnwrapper@logdefhah():print('hahahaha')hah()

123

begin callhahahahaend call

15.偏函數： functools.partial()，作用是將一個函數的某些參數固定住，作為新函數的參數，即固定住該參數，返回一個新函數，使調用更簡單。

四、面向對象編程

1.Python實例變數可以自由地綁定任何屬性

2.為了不讓內部屬性不被外部訪問，在屬性的名稱前加上兩個下劃線__，這樣就變成了一個私有變數(private)，注意，不能直接訪問不代表一定不能訪問，事實上，加雙下劃線後Python就會將其改名為『_class名__name』，所以還是可以這樣來訪問這個『私有』變數。

3.對於靜態語言，如果要求傳入一個class類型的對象，那麼傳入的對象必須是class類型或者其子類，否則將無法調用class中的方法，而Python這樣的動態語言有『鴨子類型』一說，即不一定要傳入class類型或其子類，而只要保證傳入的對象中有要使用的方法即可。

4.如果想要限制實例可以綁定的屬性，那麼在定義class時定義一個__slots__變數即可，例如：

12

classStudent(object):__slots__=(『name』,』age』)

注意，__slots__限制的屬性對當前類實例起完全限製作用，且與子類共同定義其__slots__，也就是說子類可以定義自己的__slots__，子類實例允許定義的屬性就是自身的__slots__加上父類的__slots__，即並集。

5.@ property裝飾器可以使一個getter方法變成屬性，如果方法名為me，那麼@me.setter裝飾器則可使一個setter方法變成屬性。這樣可以使代碼更簡短，同時可對參數進行必要的檢查。

6.通過多重繼承，可使子類擁有多個父類的所有功能。

7.在類中__call__方法可使實例對象像函數那樣直接調用，作用即是該方法定義的過程。

8.ORM(Object Relational Mapping 對象關系映射)，就是把關系資料庫的一行映射為一個對象，也就是一個類對應一個表。ORM的實現需要通過metaclass元類修改類的定義。元類可以改變類創建時的行為。

五、調試

1.Python調試方法：

(1)直接列印

(2)斷言

(3)pdb

(4)IDE

六、IO編程

1.序列化： 把變數從內存中變成可存儲或傳輸的過程稱之為序列化。Python用pickle模塊實現序列化。序列化之後，就可以把序列化後的內容存儲到磁碟上或者通過網路進行傳輸。pickle.mps()將對象序列化成一個bytes,而pickle.loads()可以根據bytes反序列化出對象。

2.pickle雖好，但是它專為Python而生，所以要在不同語言間傳遞對象，最好還是xml或者json，而json表示格式是一個字元串，更易讀取，且比xml快，所以更加適宜於對象序列化。Python內置了json模塊，相應方法仍然是mps()和loads()。

3.但是在默認情況下，有些對象是無法序列化的，所以我們有時還需要定製轉換方法，告訴json該如何將某類對象轉換成可序列為json格式的{}對象。如下即是一個轉換方法：

123456

defmantodict(std):return{'name': std.name,'age': std.age,'id': std.id}

七、進程與線程

1.Python用mutiprocessing模塊來實現多進程。

2.如果要大量創建子進程，可以使用進程池：

1

frommultiprocessingimportPool

示例如下：

12345678

....p=Pool(4)foriinrange(5):p.apply_async(long_time_task, args=(i,))print('Waiting for all subprocesses done...')p.close()p.join()print('All subprocesses done.')

要使用進程池需新建Pool對象，對Pool對象調用join()使等待池中所有子進程運行完畢，調用join()方法之前必須調用close()，且此後無法再新加子進程。

3.使用subprocess模塊可以方便的啟動並管理一個子進程，控制其輸入輸出。

4.進程間通信使用Queue,Pipes實現。

5.threading模塊管理線程。threading.lock()創建線程鎖，防止同時訪問互斥資源造成的錯誤，示例如下：

1234567

lock=threading.Lock()...lock.acquire()...change(mutex)...lock.release()

6.ThreadLocal可以解決參數在一個線程中各個函數之間互相傳遞的問題。

7.managers模塊實現分布式進程。

八、正則表達式與常用內建模塊

1.re模塊進行正則表達式編譯和匹配，如果該表達式需要匹配很多次，那麼最好進行編譯從而大大節省時間。

正則表達式匹配郵箱例子：

12345678910

importrehah=re.compile('[0-9a-zA-Z]+[.[0-9a-zA-Z]+]*@[0-9a-zA-Z]+.[a-z]{2,3}')print(hah.match('[email protected]').group())print(hah.match('[email protected]').group())i=1whilei <10:r=input('請輸入郵箱：')print(hah.match(r).group())i=i+1

2.datetime模塊進行日期和時間的處理，每一個時間對應一個timestamp，我們把1970年1月1日 00:00:00 UTC+00:00時區的時刻稱為epoch time，記為0（1970年以前的時間timestamp為負數），當前時間就是相對於epoch time的秒數，稱為timestamp。字元串和datetime也可以相互轉換，採用strptime()方法，字元串轉換為datetime時需要設定一個識別格式，其中

1

%Y-%m-%d%H:%M:%S

分別表示年-月-日 時-分-秒。

從datetime得出月份，星期等字元串用strftime()方法，其中：

1

%a,%b%d%H:%M

分別表示星期, 月份 日期 時:分。

示例：

12345678910

fromdatetimeimportdatetimer='2015-11-23 12:01'dt=datetime.strptime(r,'%Y-%m-%d %H:%M')print(dt)week=dt.strftime('%a %b %d, %H:%M')print(week)2015-11-2312:01:00Mon Nov23,12:01

3.collections是Python內建的一個集合模塊，提供了許多有用的集合類。

4.Base64是一種任意二進制到文本字元串的編碼方法，常用於在URL、Cookie、網頁中傳輸少量二進制數據。

5.struct模塊用來解決bytes和其他二進制數據類型的轉換。

6.Python的hashlib提供了常見的哈希演算法，如MD5，SHA1等等。hashlib實現簡單登錄：

importhashlibdb={'michael':'','bob':'','alice':''}defget_md5(ostr):md5=hashlib.md5()md5.update(ostr.encode())returnmd5.hexdigest()deflogin(user, password):r=get_md5(password)fornameindb:ifdb[name]==r:returnTruereturnFalseprint(login('bob','abc999'))True

7.Python的內建模塊itertools提供了非常有用的用於操作迭代對象的函數。

8.urllib提供了一系列用於操作URL的功能。如GET,POST...

9.PIL(Python Imaging Library Python圖像庫)是一個強大的圖像處理標准庫，功能強大卻又簡單易用。現在的名字叫做Pillow。可以如下安裝Pillow:

1

pip3 install pillow

從下面生成數字驗證碼的程序可以窺其一斑：

九、網路編程和電子郵件

1.網路編程主要是TCP和UDP的編程，示例見【Python網路編程】利用Python進行TCP、UDP套接字編程

2.SMTP是發送郵件的協議，Python內置對SMTP的支持，可以發送純文本郵件、HTML郵件以及帶附件的郵件。Python對SMTP支持有smtplib和email兩個模塊，email負責構造郵件，smtplib負責發送郵件。Python內置一個poplib模塊，實現了POP3協議，可以直接用來收郵件。由於現在絕大多數大型郵件服務商都採取了反垃圾郵件措施，所以這部分的簡單實驗並沒有成功，還需進一步研究，等遇到具體情況再說。

3.Python內嵌了sqlite資料庫，還可以自行安裝連接mysql，MySQL是當前最流行的開源資料庫，在行業內有著廣泛的應用。

十、Web開發和非同步IO

1.WSGI(Web Server Gateway Interface) 伺服器網關介面。

2.Python web 開發框架：

-Flask：流行的Web框架

-Django：全能型Web框架

-web.py：一個小巧的Web框架

-Bottle：和Flask類似的Web框架

-Tornado：Facebook的開源非同步Web框架

3.協程

Ⅳ Python中處理屬性的重要屬性和函數是什麼

處理屬性的重要屬性和函數

1、特殊屬性

__class__：對象所屬類的引用（即obj.__class__和type(obj)的作用相同）。Python中的某些特殊方法比如 __getattr__，只在對象的類中尋找，而不在實例中尋找。__dict__：一個映射，存儲對象或類的可寫屬性。__slots__：類可以定義這個屬性，限制實例有哪些屬性。

2、內置函數

dir([object])：列出對象的大多數屬性。getattr(object,name[,default])：從object對象中獲取name字元串對應的屬性。獲取的屬性可能來自對象所屬的類或超類。hasattr(object,name)：若object對象中存在指定的屬性，或者能以某種方式（如繼承）通過object對象獲取指定的屬性，返回True。setattr(object,name,value)：把object對象指定屬性的值設為value，前提是object對象能接受那個值。這個函數可能會創建一個新屬性，或者覆蓋現有的屬性。var([object])：返回object對象的__dict__屬性。

相關推薦：《Python視頻教程》

3、特殊方法

__delattr__(self,name)：只要使用del語句刪除屬性，就會調用這個方法。__dir__(self)：把對象傳給dir函數時調用，列出屬性。__getattr__（self,name)：僅當獲取指定的屬性失敗，搜索過obj，Class和超類之後調用。__getattribute__（self,name)：嘗試獲取指定的屬性時總會調用這個方法。不過尋找的屬性是特殊屬性或特殊方法時除外。為了防止無限遞歸，__getattribute__方法的實現要使用super().__getattribute__(obj,name)。__setattr__（self,name,value)：嘗試設置指定的屬性時總會調用這個方法。點號和setattr內置函數會觸發這個方法。

相關推薦：

Python中的屬性和特性是什麼

Ⅳ Python 為什麼要繼承 object 類

沒有規定必須繼承OBJECT類。OBJECT類只是面向對象語言繼承精神的一種表現。例如OBJECTC，C++等語言在標准庫中都將所有類的基類定義位OBJECT,這樣的好處就是最大限度的利用代碼重用的的精神。但是不通語言中的OBJECT類的作用又很不一樣所以看看下面的介紹：回到PYTHON中為什麼要集成OBJECT：low-levelconstructorsnamed__new__()–低級別的構造函數.Note:Python的class__init__並不是其他語言意義上的構造函數,在new創建實例後對實例屬性初始化的函數.descriptors,–描述符.或者說描述符協議支持.descriptorprotocol__get__,__set__,__delete__等,可以閱讀descriptor文檔staticmethodsandclassmethods－靜態方法和類方法properties(computedattributes)–屬性訪問settergetter.decorators(introcedinPython2.4)–裝飾器.現在裝飾器語法糖遍布各Python框架.slots–用戶設置後可以限定實例的屬性.在Python2中替代__dict__,可以節省近2/3內存,Python3中可以不因為優化內存使用率而使用slots,因為__dict__結構內存做了優化,Note:__dict__並不是Python意義上的內置的dict,其實是一個proxy類.anewMethodResolutionOrder(MRO)–MRO方法解析次序改變(由左遞歸改為C3演算法)可能上面的你看著不太理解。通俗說一下py2.2後繼承object的目的是使這個類成為newstyleclass,沒有繼承object的為傳統classicclass,在本機進行了測試,環境為py2.7.3classFoo(object):passclassFoo1:passprinttype(Foo),type(Foo1)printdir(Foo)printdir(Foo1)printisinstance(Foo,object)printisinstance(Foo1,object)結果如下:['__class__','__delattr__','__dict__','__doc__','__format__','__getattribute__','__hash__','__init__','__mole__','__new__','__rece__','__rece_ex__','__repr__','__setattr__','__sizeof__','__str__','__subclasshook__','__weakref__']['__doc__','__mole__']TrueTrue(這個True有些疑問,Foo1不應是object的實例啊)

Ⅵ python新建一個網頁insertDept.html,添加input元素,配置action屬性

咨詢記錄 · 回答於2021-10-21

Ⅶ python中flask如何降低內存

Dict
在小型程序中，特別是在腳本中，使用Python自帶的dict來表示結構信息非常簡單方便：

>>> ob = {'x':1, 'y':2, 'z':3}

>>> x = ob['x']

>>> ob['y'] = y

由於在Python 3.6中dict的實現採用了一組有序鍵，因此其結構更為緊湊，更深得人心。但是，讓我們看看dict在內容中佔用的空間大小：

>>> print(sys.getsizeof(ob))

240

如上所示，dict佔用了大量內存，尤其是如果突然虛需要創建大量實例時：

實例數

對象大小

1 000 000

240 Mb

10 000 000

2.40 Gb

100 000 000

24 Gb

類實例

有些人希望將所有東西都封裝到類中，他們更喜歡將結構定義為可以通過屬性名訪問的類：

class Point:

#

def __init__(self, x, y, z):

self.x = x

self.y = y

self.z = z

>>> ob = Point(1,2,3)

>>> x = ob.x

>>> ob.y = y

類實例的結構很有趣：

欄位

大小(比特)

PyGC_Head

24

PyObject_HEAD

16

__weakref__

8

__dict__
8

合計：

56

在上表中，__weakref__是該列表的引用，稱之為到該對象的弱引用(weak reference)；欄位__dict__是該類的實例字典的引用，其中包含實例屬性的值(注意在64-bit引用平台中佔用8位元組)。從Python3.3開始，所有類實例的字典的鍵都存儲在共享空間中。這樣就減少了內存中實例的大小：

>>> print(sys.getsizeof(ob), sys.getsizeof(ob.__dict__))

56 112

因此，大量類實例在內存中佔用的空間少於常規字典(dict)：

實例數

大小

1 000 000
168 Mb
10 000 000
1.68 Gb
100 000 000

16.8 Gb

不難看出，由於實例的字典很大，所以實例依然佔用了大量內存。

帶有__slots__的類實例

為了大幅降低內存中類實例的大小，我們可以考慮幹掉__dict__和__weakref__。為此，我們可以藉助 __slots__：

class Point:

__slots__ = 'x', 'y', 'z'

def __init__(self, x, y, z):

self.x = x

self.y = y
self.z = z
>>> ob = Point(1,2,3)
>>> print(sys.getsizeof(ob))

64

如此一來，內存中的對象就明顯變小了：

欄位

大小(比特)

PyGC_Head

24

PyObject_HEAD
16
x
8

y

8
z
8
總計：

64

在類的定義中使用了__slots__以後，大量實例占據的內存就明顯減少了：

實例數

大小

1 000 000

64 Mb

10 000 000

640 Mb

100 000 000
6.4 Gb
目前，這是降低類實例佔用內存的主要方式。
這種方式減少內存的原理為：在內存中，對象的標題後面存儲的是對象的引用(即屬性值)，訪問這些屬性值可以使用類字典中的特殊描述符：

>>> pprint(Point.__dict__)

mappingproxy(

....................................

'x': ,

'y': ,

'z': })

為了自動化使用__slots__創建類的過程，你可以使用庫namedlist(https://pypi.org/project/namedlist)。namedlist.namedlist函數可以創建帶有__slots__的類：

>>> Point = namedlist('Point', ('x', 'y', 'z'))

還有一個包attrs(https://pypi.org/project/attrs)，無論使用或不使用__slots__都可以利用這個包自動創建類。

元組

Python還有一個自帶的元組(tuple)類型，代表不可修改的數據結構。元組是固定的結構或記錄，但它不包含欄位名稱。你可以利用欄位索引訪問元組的欄位。在創建元組實例時，元組的欄位會一次性關聯到值對象：

>>> ob = (1,2,3)

>>> x = ob[0]

>>> ob[1] = y # ERROR

元組實例非常緊湊：

>>> print(sys.getsizeof(ob))

72

由於內存中的元組還包含欄位數，因此需要佔據內存的8個位元組，多於帶有__slots__的類：

欄位

大小(位元組)

PyGC_Head

24

PyObject_HEAD

16

ob_size

8

[0]

8

[1]

8

[2]
8
總計：
72
命名元組

由於元組的使用非常廣泛，所以終有一天你需要通過名稱訪問元組。為了滿足這種需求，你可以使用模塊collections.namedtuple。

namedtuple函數可以自動生成這種類：

>>> Point = namedtuple('Point', ('x', 'y', 'z'))

如上代碼創建了元組的子類，其中還定義了通過名稱訪問欄位的描述符。對於上述示例，訪問方式如下：
class Point(tuple):
#

@property

def _get_x(self):

return self[0]
@property
def _get_y(self):

return self[1]

@property

def _get_z(self):
return self[2]
#
def __new__(cls, x, y, z):
return tuple.__new__(cls, (x, y, z))
這種類所有的實例所佔用的內存與元組完全相同。但大量的實例佔用的內存也會稍稍多一些：

實例數

大小
1 000 000
72 Mb

10 000 000

720 Mb

100 000 000

7.2 Gb

記錄類：不帶循環GC的可變更命名元組

由於元組及其相應的命名元組類能夠生成不可修改的對象，因此類似於ob.x的對象值不能再被賦予其他值，所以有時還需要可修改的命名元組。由於Python沒有相當於元組且支持賦值的內置類型，因此人們想了許多辦法。在這里我們討論一下記錄類(recordclass，https://pypi.org/project/recordclass)，它在StackoverFlow上廣受好評(https://stackoverflow.com/questions/29290359/existence-of-mutable-named-tuple-in)。

此外，它還可以將對象佔用的內存量減少到與元組對象差不多的水平。

recordclass包引入了類型recordclass.mutabletuple，它幾乎等價於元組，但它支持賦值。它會創建幾乎與namedtuple完全一致的子類，但支持給屬性賦新值(而不需要創建新的實例)。recordclass函數與namedtuple函數類似，可以自動創建這些類：

>>>Point = recordclass('Point', ('x', 'y', 'z'))

>>>ob = Point(1, 2, 3)

類實例的結構也類似於tuple，但沒有PyGC_Head：

欄位

大小(位元組)

PyObject_HEAD

16

ob_size

8

x

8

y

8

z
8
總計：
48
在默認情況下，recordclass函數會創建一個類，該類不參與垃圾回收機制。一般來說，namedtuple和recordclass都可以生成表示記錄或簡單數據結構(即非遞歸結構)的類。在Python中正確使用這二者不會造成循環引用。因此，recordclass生成的類實例默認情況下不包含PyGC_Head片段(這個片段是支持循環垃圾回收機制的必需欄位，或者更准確地說，在創建類的PyTypeObject結構中，flags欄位默認情況下不會設置Py_TPFLAGS_HAVE_GC標志)。

大量實例佔用的內存量要小於帶有__slots__的類實例：

實例數

大小

1 000 000

48 Mb10 000 000

480 Mb

100 000 000
4.8 Gb
dataobject
recordclass庫提出的另一個解決方案的基本想法為：內存結構採用與帶__slots__的類實例同樣的結構，但不參與循環垃圾回收機制。這種類可以通過recordclass.make_dataclass函數生成：
>>> Point = make_dataclass('Point', ('x', 'y', 'z'))

這種方式創建的類默認會生成可修改的實例。

另一種方法是從recordclass.dataobject繼承：

class Point(dataobject):

x:int

y:int

z:int

這種方法創建的類實例不會參與循環垃圾回收機制。內存中實例的結構與帶有__slots__的類相同，但沒有PyGC_Head：

欄位

大小(位元組)

PyObject_HEAD

16

ob_size

8

x

8

y

8

z

8

總計：

48

>>> ob = Point(1,2,3)

>>> print(sys.getsizeof(ob))

40

如果想訪問欄位，則需要使用特殊的描述符來表示從對象開頭算起的偏移量，其位置位於類字典內：

mappingproxy({'__new__': ,

.......................................

'x': ,

'y': ,

'z': })

大量實例佔用的內存量在CPython實現中是最小的：

實例數

大小

1 000 000

40 Mb

10 000 000

400 Mb

100 000 000

4.0 Gb

Cython

還有一個基於Cython(https://cython.org/)的方案。該方案的優點是欄位可以使用C語言的原子類型。訪問欄位的描述符可以通過純Python創建。例如：

cdef class Python:

cdef public int x, y, z

def __init__(self, x, y, z):

self.x = x

self.y = y

self.z = z

本例中實例佔用的內存更小：

>>> ob = Point(1,2,3)

>>> print(sys.getsizeof(ob))

32

內存結構如下：

欄位

大小(位元組)

Ⅷ python2.7.3和3.3.2的區別

轉自：http://my.oschina.net/chihz/blog/123437
這邊只說明面向對象方面的，其他方面見上面鏈接

面向對象
(1) 經典類和新式類
Python OO最神奇的地方就是有兩種類，經典類和新式類。
新式類跟經典類的差別主要是以下幾點:
1. 新式類對象可以直接通過__class__屬性獲取自身類型:type
2. 繼承搜索的順序發生了改變,經典類多繼承屬性搜索順序: 先深入繼承樹左側，再返回，開始找右側;新式類多繼承屬性搜索順序: 先水平搜索，然後再向上移動
3. 新式類增加了__slots__內置屬性, 可以把實例屬性的種類鎖定到__slots__規定的范圍之中。
4. 新式類增加了__getattribute__方法
Python 2.x中默認都是經典類，只有顯式繼承了object才是新式類
Python 3.x中默認都是新式類，不必顯式的繼承object
python 2.x:
>>> ClassicClass.__class__
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
AttributeError: class ClassicClass has no attribute '__class__'
>>> class NewClass(object):
... pass
...
>>> NewClass.__class__

python 3.x:
>>> class NewClass:pass
...
>>> NewClass.__class__
<class 'type'>
(2) 無綁定方法
在Python 2.x中除了類方法和靜態方法，其餘的方法都必須在第一個參數傳遞self跟實例綁定，但是在Python 3.x中廢除了這條規定，允許方法不綁定實例，這樣的方法跟普通的函數沒有區別：
Python 2.x:
>>> class MyClass:
... def function():
... print "function"
...
>>> MyClass.function()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: unbound method function() must be called with MyClass instance as first argument (got nothing instead)
>>> m = MyClass()
>>> m.function()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: function() takes no arguments (1 given)
Python 3.x:
>>> class MyClass:
... def function():
... print("function")
...
>>> MyClass.function()
function
>>> m = MyClass()
>>> m.function()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: function() takes no arguments (1 given)
(3) 重要的重載
1. next()和__next__():這應該是繼print之後第二大坑爹的不兼容吧，Python程序漫山遍野都是迭代器，但是2和3之間迭代器的實現介面方法名是不同的……嗯，啥都不說了。
2. 分片攔截:Python 3.x之前, 類可以定義__getslice__和__setslice__方法來專門攔截分片，並且這兩個方法優先於__getitem__和__setitem__, 但是Python 3.x時代這倆方法再也不存在了，全部的工作都交給了__getitem__和__setitem__，因此在使用這兩個方法之前要先判斷傳遞進參數的類型是不是slice對象。
3. __bool__方法:我們知道Python中默認將所有的空對象定義為布爾意義上的False,在自己定義的類中我們也可以加入自定義的布爾判斷標准，在2.x中這個方法名叫做__nonzero__, 這個名字顯然非常不直觀並且不科學！所有考試交白卷的孩子我們都要否定他們的才能么？顯然不能！因此Python 3.x中這個方法被重名命為__bool__
4. 3.x 取消了用於大小比較的__cmp__方法，取而代之的是：__lt__、__gt__、__le__、__ge__、__eq__、__ne__，嗯，我感覺這個想法真是不能苟同……有誰能說服我給我洗腦讓我愛上這一堆__lt__、__gt__、__le__、__ge__、__eq__、__ne__么。。。
(4) 類修飾器
在我的上一篇博客中秀了一把函數裝飾器在表單驗證中的使用，http://my.oschina.net/chihz/blog/122897
在3.x的時代，類也有裝飾器了，這個裝飾器威力巨大，能把裝飾的類搞的面目全非，總之想怎麼搞就怎麼搞，用法同函數裝飾器基本一致，只不過傳遞的參數是類型:
>>> def shutdown(cls):
... def shutdown_func(self):
... print("do something...")
... cls.shutdown = shutdown_func
... return cls
...
>>> @shutdown
... class Test:pass
...
>>> t = Test()
>>> t.shutdown()
do something...

異常

先來看一段代碼
python 2.x:
>>> class Person:
... def __init__(self, msg):
... self.msg = msg
...
>>> try:
... raise Person, "woca"
... except Person as p:
... print p.msg
...
woca
python 3.x:
>>> class Person:
... def __init__(self, msg):
... self.msg = msg
...
>>> try:
... raise Person("woca")
... except Person as p:
... print(p.msg)
Traceback (most recent call last):
File "<stdin>", line 2, in <mole>
TypeError: exceptions must derive from BaseException

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
File "<stdin>", line 3, in <mole>
TypeError: catching classes that do not inherit from BaseException is not allowed
>>>
接下來說不同:
1. 在2.x時代，所有類型的對象都是可以被直接拋出的，在3.x時代，只有繼承自BaseException的對象才可以被拋出。
2. 2.x raise語句使用逗號將拋出對象類型和參數分開，3.x取消了這種奇葩的寫法，直接調用構造函數拋出對象即可。
在2.x時代，異常在代碼中除了表示程序錯誤，還經常做一些普通控制結構應該做的事情，在3.x中可以看出，設計者讓異常變的更加專一，只有在錯誤發生的情況才能去用異常捕獲語句來處理。

Ⅸ slots關鍵字可以省略嗎

不可以省略。
slots關鍵字的作用如下：
1、限制用戶的使用。由於Python是動態語言，所以類的成員甚至可以在類創建好了之後動態創建。這在靜態語言當中是絕對不行的，我們只能調用類當中已有的屬性，是不能或者很難添加新屬性的。
2、節省內存。使用dict來維護實例，會消耗大量的內存，額外存儲了許多數據，而使用__slots__之後，Python內部將不再為實例創建一個字典來維護，而是會使用一個固定大小的數組，這樣就節省了大量的空間。這個節省可不是一點半點，一般可以節省一半以上。也就是說犧牲了一定的靈活性，保證了性能。