python小数据池，代码块知识

一、什么是代码块？                                                                  

根据官网提示我们可以获知：

  A Python program is constructed from code blocks. A block is a piece of Python program text that is executed as a unit. The following are blocks: a module, a function body, and a class definition. Each command typed interactively is a block.
A script file ( a file given as standard input to the interpreter or specified as a command line argument to the interpreter ) is a code block. A script command ( a command specified on the interpreter command lin with the '-c' option ) is a code block. The string argument passed to the built-in function eval() and exec() is a code block.
   A python block is executed in an execution frame. A frame contains some administrative information (used for debugging) and determines where and how execution continues after the code block's execution has completed.

 Python 程序 是由代码块构造的。块是一个python程序的文本，它是作为一个执行单元的。

代码块：一个模块，一个函数，一个类，一个文件等都是一个代码块。

而作为交互方式输入的每个命令都是一个代码块。

什么叫交互方式呢？就是咱们在cmd中进入python解释器里同，每一行代码就是一个代码块。例如：

而对于一个文件中的两个函数 ，也分别是两个不同的代码块：

二、 id ,is , ==                                                                                                                                                           

在Pyhton中，id是什么？id是内存地址，比如得利用id()内置函数 去查一个数据的内存地址：

name = "chris"
print(id(name))  # 输出结果： 2314610443072
print(hex(2314610443072))  # 十进制数 转换为 十六进数  0x21ae9888340

print( int('0x21ae9888340',16) ) # 输出结果：2314610443072

 那边什么是 is ?  什么是 ‘==’ ？

‘==’ 是 比较 符号 两边表达式 的值是否相等，而 ‘is' 是比较两边的对象是否是同一个内存地址。如内存地址相等，那么这两边指向同一个内存空间。

可以说，如果内存地址相同，那么值一定相同； 值相同，内存地址不一定相同。

 

int1 = 1000
int2 = 1000
print( int1 is int2 ) # 输出结果： True
print(id(int1) is id(int2))  # 输出结果： False
ret = id(int1)   #  因为这里不是直接赋值，而通过函数调用返回值，所有值尽管相同，但内存地址不同
ret2 = id(int2)  #  因为这里不是直接赋值，而通过函数调用返回值，所有值尽管相同，但内存地址不同
print(ret,type(ret))
print(ret2,type(ret2))
print( ret is ret2 )  # 输出结果 ：False
int3 = 2673605569328
int4 = 2673605569328
print( int3 is int4 )

 三、小数据池                                                  

小数据池，也称为小整数缓存机制，或者称为驻留机制等等，只要你在网上查到的这些名字其实说的都是一个意思，叫什么因人而异。那么到底什么是小数据池呢？他有什么作用呢？

大前提： 小数据池，只针对，整数，字符串，bool值。

官方对于整数，字符串的小数据池是这么说的：

 

对于整数，Python官方文档中这么说：

The current implementation keeps an array of integer objects for all integers between -5 and 256,
when you create an int in that range you actually just get back a reference to the existing  object. 
So it should be possible to change the value of 1. I suspect the behaviour of Python in this case is undefined.

对于字符串：
   Incompute science, string interning  is method of storing only onecopy of each distinct string value,which must be immutable. 
Interning string makes some stringprocessing tasks more time- or space-efficient at the cost of requiring moretime when the string is created or interned. 
The distinct values are stored in a string intern pool. --引自维基百科

 

上面的意思就是：

Python自动将-5~256的整数进行了缓存，当你将这些整数赋值给变量时，并不会重新创建对象，而是使用已经创建好的缓存对象。

python会将一定规则的字符串在字符串驻留池中，创建一份，当你将这些字符串赋值给变量时，并不会重新创建对象， 而是使用在字符串驻留池中创建好的对象。

其实，无论是缓存还是字符串驻留池，都是python做的一个优化，就是将~5-256的整数，和一定规则的字符串，放在一个‘池’（容器，或者字典）中，无论程序中那些变量指向这些范围内的整数或者字符串，那么他直接在这个‘池’中引用，言外之意，就是内存中之创建一个。

优点：能够提高一些字符串，整数处理人物在时间和空间上的性能；需要值相同的字符串，整数的时候，直接从‘池’里拿来用，避免频繁的创建和销毁，提升效率，节约内存。

缺点：在‘池’中创建或插入字符串，整数时，会花费更多的时间。

 

补充：小数据池，可以理解为ORACLE数据库中的SGA,即共享全局区，所以python进程共享的。

 

int: 对于整数来说，当整数范围在 -5 ~ 256 这个闭区间时，会放进小数据池，此时多个变量同时指向同一个（在这个范围内的）数字，他们在内存中指向的都是一个内存地址。

 

那么对于字符串的规定呢？

str:字符串要从下面这几个大方向讨论：

1. 字符串的长度为0或1时，默认都采用驻留机制（小数据池）

>>> s1 = '$'
>>> s2 = '$'
>>> print(id(s1),id(s2))
2647489083856 2647489083856
>>> print(s1 is s2 )
True
>>>

2. 字符串的长度>1,且只含有大小写字母，数字，下划线时，才会默认驻留。

>>> s1 ='chris_is_a_old_boy_driver'
>>> s2 = 'chris_is_a_old_boy_driver'
>>> print(s1 is s2)
True
>>>

3.  用乘法得到的字符串，分两种情况：

    3.1 乘数为1时:

仅含大小写字母，数字，下划线，默认驻留。

>>>
>>> a = 'abcedfgjihiklsodopqrstuvwxyz_8989'
>>> b = a * 1
>>> print(a is b)
True
>>>

含其他字符，长度>1, 默认驻留。

>>> a = 'abcedfgjihiklsodopqrstuvwxyz_8989##'
>>> b = a * 1
>>> print(a is b)
True
>>>

    3.2 乘数 >= 2 时：

仅含大小写字母、数字、下划线，总长度<=20，默认驻留。

>>> a = 'abcedfgjihiklsodopqrstuvwxyz_8989'
>>> b = a * 2
>>> c = a * 2
>>> print(b is c )
False

4. 指定驻留

>>> from sys import intern
>>> a = intern('hello!@' * 20 )
>>> b = intern('hello!@' * 20 )
>>> print(a is b)
True
>>>

满足以上字符串的规则时，就符合小数据的概念。

bool值 就是True,False,无论你创建多少个变量指向True,False,那么他在内存中只存在一个。

看一下用了小数据池（驻留机制）的效率有多高：

显而易见，节省大量内存在字符串比较时，非驻留比较效率o(n)，驻留时比较效率o(1)。

好，那么现在咱们知道了小数据池的概念，知道了代码块，那么还有什么问题呢？有！有！有！

下面就是咱们的关键部分，也是这篇博客的高潮部分，瞪大眼睛看~

 

四，代码块与小数据池的关系。

同样一段代码，为什么在交互方式中执行，和通过python代码的文件执行结果不同呢？

# pycharm 通过运行文件的方式执行下列代码：
i1 = 1000
i2 = 1000
print(i1 is i2)  # 结果为True

通过交互方式中执行下面代码：
>>> i1 = 1000
>>> i2 = 1000
>>> print(i1 is i2)
False

结果为什么不同呢？难道是解释器出问题，还是pycharm软件出问题了？？？ NONONO，Too Young Too Simple!

这是因为代码块内的缓存机制，和代码块与代码块之间的缓存机制不同！

　　Python在执行同一个代码块的初始化对象的命令时，会检查是否其值是否已经存在，如果存在，会将其重用。换句话说：执行同一个代码块时，遇到初始化对象的命令时，他会将初始化的这个变量与值存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，如果有同样的记录那么它会重复使用这个字典中的之前的这个值。所以在你给出的例子中，文件执行时（同一个代码块）会把i1、i2两个变量指向同一个对象。

　　如果是不同的代码块，他就会看这个两个变量是否是满足小数据池的数据，如果是满足小数据池的数据则会指向同一个地址。所以：i1、i2赋值语句分别被当作两个代码块执行，但是他们不满足小数据池的数据所以会得到两个不同的对象，因而is判断返回False。

更多验证：

# 虽然在同一个文件中，但是是不同的代码块，不满足小数据池（驻存机制），则指向两个不同的地址。
def func():
    i1 = 1000
    print(id(i1))  # 2288555806672

def func2():
    i1 = 1000
    print(id(i1))  # 2288557317392

func()
func2()

最后，在深入一点，对于同一个代码块的变量复用的问题，只能针对于数字，字符串，bool值，而对于其他数据类型是不成立的。

# 同一个代码块下，数字，字符串，bool值的复用成立。
a1 = 1000
a2 = 1000
print(id(a1),id(a2))  # 2419837390800 2419837390800

s1 = 'alexsb@'
s2 = 'alexsb@'

print(id(s1),id(s2))  # 2278732245624 2278732245624  

f1 = True
f2 = True
print(id(f1),id(f2))  # 1672093872 1672093872

# 同一个代码块下，元祖，列表，字典的复用不成立。
tu1 = (1,2,3)
tu2 = (1,2,3)
print(id(tu1),id(tu2))  # 2278732278088 2278732279312

l1 = [1, 2, 3]
l2 = [1, 2, 3]
print(id(l1),id(l2))  # 2278733685000 2278733685192

dic1 = {'name':'taibai'}
dic2 = {'name':'taibai'}
print(id(dic1),id(dic2))  # 2278728382728 2278728382856

 本文大量引用和参考链接如下： 

https://zhidao.baidu.com/question/494120409773699052.html  

http://mini.eastday.com/bdmip/180405084648167.html

 

参考网址：https://ww.cnblogs.com/jin-xin/articles/9439483.html