小数据池 is和== 再谈编码

时间 2019-11-13

原文原文链接

昨日回顾

上节课内容回顾
    1. 字典
        {key:value, key:value.....}
        成对的保存数据

        字典没有索引. 不能切片, 字典的key必须是可哈希的.不可变的
        1. 增长:
            dic[新key] = 值
            dic.setdefault(key, value) 新增, 查询
        2. 修改:
            dic[老key] = 值
            dic.update(d) 把d更新到dic中
        3. 删除;
            pop(key)
            popitem() 随机删除
            del dic[key]
            clear() 清空
        4. 查询
            for k in dic:
                k
                dic[k]

            get(key) 若是key不存在, 返回None
            dic[key] 若是key不存在, 报错

            setdefault(key, value)
            根据key查询出value
        5. 相关操做
            1. keys()     全部的key
            2. values()     全部的value
            3. items()      全部的key和value
            for k, v in dic.items(): # 自动解包
                k
                v
    set集合
        内部元素必须可哈希. 不可变
        内部元素不重复

        add() 添加

        frozenset() 冻结集合. 不可变的.(##通常的集合自己是可变的,可是要求其内部的元素是不可变的,而这个集合自己就是不可变的)

今日内容

今日主要内容
        1. 小数据池, id()
            小数据池针对的是: int, str, bool
            在py文件中几乎全部的字符串都会缓存.
            id() 查看变量的内存地址
        2. is和==的区别
            is 比较的是内存地址
            == 比较的是内容
            当两个变量指向同一个对象的时候. is是True, ==也是True

        3. 再谈编码
            回顾:
                1. ascii. 有: 数字, 字母, 特殊字符. 8bit  1byte 128  最前面是0
                2. gbk. 包含: ascii, 中文(主要), 日文, 韩文, 繁体文字. 16bit, 2byte.
                3. unicode. 包含gbk,ascii,big5... 32bit, 4byte
                4. utf-8. 可变长度的unicode.
                    1. 英文: 8bit,1byte
                    2. 欧洲文字: 16bit 2byte
                    3. 中文: 24bit 3byte
            不一样的编码之间不能随意转换. 中国人gbk和德国人utf-8骂 想要沟通必须经过英文(unicode)(媒介)

            在python3中. 默认的编码是unicode,咱们的字符串就是unicode
            在python2中. 默认的编码是ASCII.  Cpython是用 c 语言写的,c语言的默认编码是ASCII

            unicode弊端:在存储和传输的时候. 是很浪费的
            在存储和传输的时候不能直接使用unicode. 必需要对字符串进行编码. 编码成bytes类型
            bytes: 字节形式的字符串

                1. encode(编码格式) 编码
                2. decode(编码格式) 解码

            bytes是一种另类的字符串表示形式
            "哈哈哈" => \xee\xab\x13\xee\xab\x13\xee\xab\x13

一.小数据池

在说小数据池以前.咱们先看一个概念.什么是代码块:html

根据提示咱们从官方文档找到了这样的说法:
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 line with the‘-C‘ option) is a code bLock. The string argument
passed to the built-in functions evalO and execO) is a code block.
A code block is executed in an execution frame. A frame contains some
admi ni strative information (used for debugging) and determines where and
how execution continues after the code bLock's execution has compLeted.
粗略的翻译:
python程序是由代码块构成的.一个代码块的文本做为python程序执行的单元.
代码块:一个模块，一个函数，一个类，甚至每个command命令都是一个代码块.一个文件也是一个代码块，evalO)和exec( )执行的时候也是一个代码块

什么是命令行?
咱们在控制台CMD中输入python进入的就是python的command模式.在这里也能够写
python的程序.
而根据上面的官方的解释来看.一个command命令就是一个python代码块python

二.小数据池 is和==的区别

接下来咱们来看一下小数据池is和==的区别编程

# id()函数能够帮咱们查看一个变量的内存地址
a = 10
b = 30
print(id(a))  # 1515545088
print(id(b))  # 1515545728


lst = ['周杰伦', "麻花藤"]
print(id(lst))  # 166167624
print(lst)
lst = []  # 建立了一个新列表
lst.append("胡辣汤")
print(id(lst))  # 166167624
print(lst)

lst1 = [1,2,3] # 两个对象 内存地址是不同的
lst2 = [1,2,3]
print(id(lst1)) # 166167624
print(id(lst2)) # 166122376

s1 = "abc" # 内存中是没有"abc", 建立一个新的  0.0001
s2 = "abc" # 内存中是已经有了"abc", 直接把abc拿来用   0.0000001
print(id(s1), id(s2)) # 31096032 31096032

# 使用频率最高的数据类型: 字符串,为了可以快速的建立字符串.
# 节省内存. 把相同的规律的字符串进行缓存,当下次建立的时候就不在建立了
# 把字符串的缓存-> 小数据池 -> String iterning -> 常量池 -> 字符串缓存

# 在建立字符串以前. 先去小数据池对比. 是否已经存在了该字符串.若是存在了.
# 就不建立新的了. 直接拿原来存在的数据, 省略掉反复重复建立字符串的过程. 节约内存


# 什么数据会被缓存
# 数字, 字符串, 布尔值 =>  都是不可变的数据类型
# 1. 数字
a = 1000
b = 1000
print(id(a), id(b))  # 165830000 165830000

# 2. 字符串. 若是单纯的写字符串. 几乎都会被缓存
s1 = "a昨天上厕所没关门. 红冲进去了. 面筋歌出来了. 有故事a昨天上厕所没关门. 红冲进去了. 面筋歌出来了. 有故事a昨天上厕所没关门. 红冲进去了. 面筋歌出来了. 有故事"
s2 = "a昨天上厕所没关门. 红冲进去了. 面筋歌出来了. 有故事a昨天上厕所没关门. 红冲进去了. 面筋歌出来了. 有故事a昨天上厕所没关门. 红冲进去了. 面筋歌出来了. 有故事"

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

# 若是在py文件中写的字符串. 几乎都是缓存的
# 在黑窗口里的写的几乎都不会缓存
# 不一样的解释器. 缓存的机制也不同
#
# 优势: 能够帮咱们快速的建立对象.节省内存.
# 缺点: 缓存若是过大. 响应速度会比较慢
# 不要纠结.

# == 和 is 区别:
#
# == 比较的是数据, 外貌
# is 比较的是内存地址, 比较身份证号

lst1 = [1,2,3]
lst2 = [1,2,3]
# 列表没有小数据池
print(id(lst1), id(lst2)) #  166167560 166126408
print(lst1 == lst2) # True
print(lst1 is lst2) # False

s1 = "我叫周润发"
s2 = "我叫周润发"
print(s1 == s2)
print(s1 is s2) # 小数据池

tu1 = ("周一", "周二")
tu2 = ("周一", "周二")
print(tu1 is tu2) # 地址不相等 False
print(tu1 == tu2) # 内容相等 True

# == 比较的是内容
# is 比较内存地址

View Code

id()

经过id()咱们能够查看到一个变量表示的值在内存中的地址.缓存

s = 'alex'
print(id(s))  # 4326667072

is和==

==判断左右两端的值是否相等.是否是一致.
is判断左右两端内容的内存地址是否一致. 若是返回True,那能够肯定这两个变量使用的是同一个对象
网络

咱们能够这样认为. 若是内存地址相同,那么值必定是相等的. 若是值相等, 则不必定是同一个对象.app

小数据池,一种数据缓存机制,也被称为驻留机制.各大编程语言中都有相似的末西.在网上搜索常量池,小数据池指的都是同一个内容.

小数据池只针対:整数,字符串,布尓値.其余的数据类型不存在驻留机制编程语言

#对于整数，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.


#对于字符串:
Incomputer science, string interning is a method of storing only onecopy of each distinct string value, 
which must be immutable. Interning strings 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 ina string intern pool. –引⾃维基百科

在python中对-5到256之间的整数会被驻留在内存中,将必定规则的字符串缓存.在使用的时候，内存中只会建立一个该数据的对象,保存在小数据池中.当使用的时候直接从小数据池中获取对象的内存引用,而不须要建立一个新的数据,这样会节省更多的内存区域.

优势:可以提升一些字符串，整数的处理速度.省略掉建立对象的过程.
缺点:在'池'中建立或者插入新的内容会花费更多的时间.ide

#对于数字: 
-5~256是会被加到小数据池中的,每次使用都是同一个对象.

#对于字符串: 
1.若是字符串的长度是0或者1,都会默认进行缓存 (也要是在同一个代码块中)
2.字符串长度大于1,可是字符串中只包含字母，数字，下划线时才会缓存
3.用乘法获得的字符串
①.乘数为1,仅包含数字，字母，下划线时会被缓存.若是包含其余字符，而长度<=1也会被驻存.
②.乘数大于1,仅包含数字，字母，下划线这个时候会被缓存.但字符串长度不能大于20
4.指定驻留.咱们能够经过sys模块中的intern()函数来指定要驻留的内容.

OK.到目前为止.咱们已经了解了python的小数据池的一些基本状况了.可是!!还有最后一个问题.小数据池和最开始的代码块有什么关系呢?

一样的一段代码在命令行窗口和在py文件中.出现的效果是彻底不同的.函数

a = 1000
b = 1000
print(a is b)
注意. 在py文件中,获得的结果是True, 可是在command(命令行)中就是False了.

在代码块内的缓存机制是不同的.在执行同一个代码块的初始化对象的命令时,会检查是否其值是否已经存在，若是存在，会将其重用.换句话说:执行同一个代码块时，遇到初始化对象的命令时，他会将初始化的这个变量与值存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，若是有一样的记录那么它会重复使用这个字典中的以前的这个值.因此在你给出的例子中，文件执行时(同一个代码块)会把a, b两个变量指向同一个对象.若是是不一样的代码块，他就会看这个两个变量是不是知足小数据池的数据，若是是知足小数据池的数据则会指向同一个地址.因此: a, b的赋值语句分别被看成两个代码块执行，可是他们不知足小数据池的数据因此会获得两个不一样的对象,于是is判断返回False.ui

三.编码补充

s = "我今天很是的困" # 21个utf-8
bs = s.encode("gbk") # 把字符串转化成utf-8格式bytes
# bytes不是给人看的. 给机器用的
# 14个字节   gbk
# b'\xce\xd2\xbd\xf1\xcc\xec\xb7\xc7\xb3\xa3\xb5\xc4\xc0\xa7'
# 21个字节   utf-8
# b'\xe6\x88\x91\xe4\xbb\x8a\xe5\xa4\xa9\xe9\x9d\x9e\xe5\xb8\xb8\xe7\x9a\x84\xe5\x9b\xb0'
print(bs)

# utf-8和gbk是不能直接转换的, 必须使用unicode来转换
bs = b'\xe6\x88\x91\xe4\xbb\x8a\xe5\xa4\xa9\xe9\x9d\x9e\xe5\xb8\xb8\xe7\x9a\x84\xe5\x9b\xb0'
# 把字节转化回字符串
s = bs.decode("utf-8")
print(s)



b'\xe6\x88\x91\xe4\xbb\x8a\xe5\xa4\xa9\xe9\x9d\x9e\xe5\xb8\xb8\xe7\x9a\x84\xe5\x9b\xb0'
# 把这个bytes转化成gbk的bytes
bs = b'\xe6\x88\x91\xe4\xbb\x8a\xe5\xa4\xa9\xe9\x9d\x9e\xe5\xb8\xb8\xe7\x9a\x84\xe5\x9b\xb0'
# 解码
s = bs.decode("utf-8")
print(s)

# 编码
bss = s.encode("gbk")
print(bss)


# 关于bytes, 非ascii中的内容. 展现的时候都是\x.. 若是是ascii中的内容. 原样输出
name = "alex昨天吃多了"
bs = name.encode("gbk") # b'alex\xd7\xf2\xcc\xec\xb3\xd4\xb6\xe0\xc1\xcb'
print(bs)

bss = name.encode("utf-8") # b'alex\xe6\x98\xa8\xe5\xa4\xa9\xe5\x90\x83\xe5\xa4\x9a\xe4\xba\x86'
print(bss)

View Code

1. python2中默认使用的是ASCII码,因此不支持中文.若是须要在Python2中更改编码须要在文件的开始编写:

# -*- encoding:utf-8 -*-

2. python3中: 内存中使用的是unicode码.

#编码回顾:
1. ASCII: 最先的编码.里面有英文大写字母，小写字母,数字,一些特殊字符. 没有中文,8个01代码, 8个bit, 1个byte
2. GBK:中文国标码，里面包含了ASCII编码和中文经常使用编码.16个bit, 2个byte
3. UNICODE: 万国码,里面包含了全世界全部国家文字的编码.32个bit, 4个byte,包含了ASCII
4. UTF-8:可变长度的万国码.是unicode的一种实现.最小字符占8位
    1.英文:      8bit    1byte
    2.欧洲文字:16bit   2byte
    3.中文:      24bit   3byte
综上,除了ASCII码之外,其余信息不能直接转换.要经过Unicode转换

在python3的内存中,在程序运行阶段使用的是unicode编码.由于unicode是万国码,什么内容均可以进行显示.那么在数据传输和存储的时候因为unicode比较浪费空间和资源.须要把unicode转存成UTF-8或者GBK进行存储.怎么转换呢.在python中能够把文字信息进行编码,编码以后的内容就能够进行传输了,编码以后的数据是bytes类型的数据.其实啊,仍是原来的数据只是通过编码以后表现形式发生了改变而已.
bytes的表现形式:

1.英文b'alex'  英文的表现形式和字符串没什么两样
2.中文b"\xe4\xb8\xad' 这是一个汉字的UTF-8的bytes表现形式

字符串在传输时转化成bytes=> encode(字符集)来完成

s = "alex"
print(s.encode("utf-8")) #将字符串编码成UTF-8 
print(s.encode("GBK")) #将字符串编码成GBK
#结果:
b'alex'
b'alex'


s = "中"
print(s.encode("UTF-8")) #中文编码成UTF-8 
print(s.encode("GBK")) # 中文编码成GBK
#结果: 
b'\xe4\xb8\xad' 
b'\xd6\xd0'

记住:英文编码以后的结果和源字符串一致.中文编码以后的结果根据编码的不一样,编码结果也不一样.咱们能看到,一个中文的UTF-8编码是3个字节,一个GBK的中文编码是2个字节.
编码以后的类型就是bytes类型.在网络传输和存储的时候咱们python是保存和存储的bytes类型.那么在对方接收的时候,也是接收的bytes类型的数据.
咱们可使用decode0来进行解码操做.把bytes类型的数据还原回咱们熟悉的字符串:

s = "我叫李嘉诚"
print(s.encode("utf-8")) # b'\xe6\x88\x91\xe5\x8f\xab\xe6\x9d\x8e\xe5\x98\x89\xe8\xaf\x9a'
print(b'\xe6\x88\x91\xe5\x8f\xab\xe6\x9d\x8e\xe5\x98\x89\xe8\xaf\x9a'.decod e("utf-8")) # 解码

编码和解码的时候都须要制定编码格式.

s = "我是文字"
bs = s.encode("GBK") # 咱们这样能够获取到GBK的文字 

# 把GBK转换成UTF-8
# 首先要把GBK转换成unicode. 也就是须要解码
s = bs.decode("GBK") # 解码成unicode
# 而后须要进⾏从新编码成UTF-8
bss = s.encode("UTF-8") # 从新编码
print(bss)

Python2和Python3的比较:

- 字符串和字节不一样
    py2:   name=u"alex"(用unicode进行编码)                   name='alex'(utf-8/gbk/ascii)   
                unicode(就是py3中的str类型)                     str(就是py3中的bytes类型)

    py3: name='alex'(用unicode进行编码)                      name=b'alex'(utf-8/gbk/ascii)
                str                                                  bytes

今日做业

今日做业及默写