pythongetsizeof

『壹』 python3的int類型是幾位的

python3中的int類型是動態長度的，是長整型，理論支持無限大的數字。用sys.getsizeof()方法可以看int佔了幾位。例如：

sys.getsizeof(0)=24

sys.getsizeof(1)=28

所以，0佔了24個位元組，其它數字一般佔用28個位元組。以上結果是在64位操作系統上進行測試的結果。

(1)pythongetsizeof擴展閱讀：

int在python里是一個類，是不可變數據類型中的一種，一些性質和字元串是一樣的，是整型。Python int數字類型：整型int、長整型、布爾型bool、浮點數float、復數complex。

整型int的創建：創建一個新整型變數和給變數賦值是相同的過程。

整型的特點：既然是整型自然賦值時候的數據要是整數才行，整數簡單理解為（正整數和負整數）。

『貳』 python是幾比特

以python3版本為例說明， int 類型在python中是動態長度的。因為python3中int類型是長整型，理論支持大的數字，但它的結構其實也很簡單, 在 longintepr.h 中定義：

struct_longobject{
PyObject_VAR_HEAD
digitob_digit[1];
};

這結構是什麼意思呢，重點在於 ob_digit 它是一個數組指針。digit 可認為是 int的別名。python的整型存儲機制是這樣的。比方要表示一個很大的數:123456789 。而每個元素只能表示3位十進制數（為理解打的比方）。那麼python就會這樣存儲：

ob_digit[0]=789
ob_digit[1]=456
ob_digit[2]=123

低位存於低索引下。python中整型結構中的數組，每個元素存儲 15 位的二進制數（不同位數操作系統有差異32位系統存15位，64位系統是30位）。

因此，sys.getsizeof(0) 數組元素為0。此時佔用24位元組（PyObject_VAR_HEAD 的大小）。 sys.getsizeof(456) 需使用一個元素，因此多了4個位元組。

『叄』 python實現刪除重復行並計數

『肆』 python如何計算數組內存

數組定義為存儲在連續內存位置的項目的集合。這是一個可以容納固定數量項目的容器, 這些項目應為同一類型。數組在大多數編程語言(例如C / C ++, JavaScript等)中都很流行。

數組是將多個相同類型的項存儲在一起的想法, 並且只需在基本值上添加一個偏移量, 就可以更輕松地計算每個元素的位置。數組的組合可以通過減少代碼的整體大小來節省大量時間。它用於在單個變數中存儲多個值。如果你有一個存儲在其相應變數中的項目列表, 如下所示：

car1 =」蘭博基尼」

car2 =」布加迪」

car3 =」 Koenigsegg」

如果要遍歷汽車並找到特定的汽車, 可以使用該數組。

數組可以在Python中由名為array的模塊處理。當我們只需要操作特定的數據值時, 這很有用。以下是了解數組概念的術語：

元素-存儲在數組中的每個項目稱為元素。

索引-數組中元素的位置具有數字索引, 該數字索引用於標識元素的位置。

數組表示

數組可以用各種方式和不同的語言聲明。應考慮的重點如下：

索引從0開始。

我們可以通過其索引訪問每個元素。

數組的長度定義了存儲元素的能力。

數組運算

數組支持的一些基本操作如下：

遍歷-逐一列印所有元素。

插入-在給定的索引處添加一個元素。

刪除-刪除給定索引處的元素。

搜索-它使用給定的索引或值搜索元素。

更新-更新給定索引處的元素。

『伍』 sys是python中的標准庫嗎

是的，sys模塊主要是針對與Python解釋器相關的變數和方法。
下邊是sys常用的變數和方法說明：

sys.argv #獲取命令行參數列表，第一個元素是程序本身
sys.exit(n) #退出Python程序，exit(0)表示正常退出。當參數非0時，會引發一個SystemExit異常，可以在程序中捕獲該異常
sys.version #獲取Python解釋程器的版本信息
sys.maxsize #最大的Int值，64位平台是2**63 - 1
sys.path #返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變數的值
sys.platform #返回操作系統平台名稱
sys.stdin #輸入相關
sys.stdout #輸出相關
sys.stderr #錯誤相關
sys.exc_info() #返回異常信息三元元組
sys.getdefaultencoding() #獲取系統當前編碼，默認為utf-8
sys.setdefaultencoding() #設置系統的默認編碼
sys.getfilesystemencoding() #獲取文件系統使用編碼方式，默認是utf-8
sys.moles #以字典的形式返回所有當前Python環境中已經導入的模塊
sys.builtin_mole_names #返回一個列表，包含所有已經編譯到Python解釋器里的模塊的名字
sys.right #當前Python的版權信息
sys.flags #命令行標識狀態信息列表。只讀。
sys.getrefcount(object) #返回對象的引用數量
sys.getrecursionlimit() #返回Python最大遞歸深度，默認1000
sys.getsizeof(object[, default]) #返回對象的大小
sys.getswitchinterval() #返回線程切換時間間隔，默認0.005秒
sys.setswitchinterval(interval) #設置線程切換的時間間隔，單位秒
sys.getwindowsversion() #返回當前windwos系統的版本信息
sys.hash_info #返回Python默認的哈希方法的參數
sys.impleme

『陸』 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

內存結構如下：

欄位

大小(位元組)

『柒』 Python如何查看變數佔用空間大小

sys.getsizeof(object[, default])

下面是我摘錄的，希望對你有用。

以位元組（byte）為單位返回對象大小。 這個對象可以是任何類型的對象。 所以內置對象都能返回正確的結果 但不保證對第三方擴展有效，因為和具體實現相關。
getsizeof() 調用對象的 __sizeof__ 方法， 如果對象由垃圾收集器管理， 則會加上額外的垃圾收集器開銷。