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__ 方法， 如果对象由垃圾收集器管理， 则会加上额外的垃圾收集器开销。