一，数据类型

蔚落 2021-10-23 07:32 458阅读 0赞

## 一.什么是数据类型？ ##

什么是数据类型？

我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种，如下：

整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).

*   int。数字：主要用于运算。1 ，2，3...
 *   bool。判断真假：True, False.
 *   str。简单少量的储存数据，并进行相应的操作。name = 'grace',
 *   tuple。只读，不能更改。(1,'grace') 
 *   list：大量有序数据，\[1,'ses',True,\[1,2,3\],\{'name':'jinxin'\}\]
 *   dict：大量数据，且是关联性比较强的数据  \{'name':'jinxin','age':18,'name\_list':\['张三'，'李四'\]\}

## 二.基础数据类型。 ##

#### 2.1数字int。 ####

int，就是咱们常见的数据类型，主要是用于各种运算，加减乘数等这里就不给你举例说明了。

首先要给大家讲下是十进制与二进制之间的转换。

**   2.1.1 十进制二进制转换**

**十进制整数转换为二进制整数**采用"除2取余，逆序排列"法。具体做法是：用2整除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为小于1时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。

![IMAGE_7ZjVE7w.PNG][]

**　　十进制小数转换成二进制小数**采用"乘2取整，顺序排列"法。具体做法是：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，此时0或1为二进制的最后一位。或者达到所要求的精度为止。

![IMAGE_NubXAX6.PNG][]

**　　二进制转化成十进制: **

要从右到左用二进制的每个数去乘以2的相应次方,小数点后则是从左往右

例如：二进制数1101.01转化成十进制

1101.01（2）=1\*20+0\*21+1\*22+1\*23 +0\*2-1+1\*2-2=1+0+4+8+0+0.25=13.25（10）

所以总结起来通用公式为：

abcd.efg(2)=d\*20+c\*21+b\*22+a\*23+e\*2-1+f\*2-2+g\*2-3（10）

或者是：

把二进制数首先写成加权系数展开式，然后按十进制加法规则求和。这种做法称为"按权相加"法。

[![9213b07eca8065388a8973be97dda144ad348238.jpg][]][9213b07eca8065388a8973be97dda144ad348238.jpg 1]

此时，1101=8+4+0+1=13

再比如：二进制数100011转成十进制数可以看作这样：

数字中共有三个1 即第一位一个，第五位一个，第六位一个，然后对应十进制数即2的0次方+2的1次方+2的5次方， 即

100011=32+0+0+0+2+1=35

**2.2.2 int操作方法**

因为数字主要是用于计算，所以针对于数字可以使用的方法除了那些运算之外，没有什么经常会用的方法，python给咱们提供了一种方法：bit\_length()就是帮助你快速的计算整数在内存中占用的二进制码的长度.

num = 10
    print(num.bit_length())  # 当十进制用二进制表示时，最少使用的位数

# 运行结果: 4

#### 2.2布尔值bool。 ####

布尔值就两种：True，False。就是反应条件的正确与否。

真   1   True。

假   0   False。

这里补充一下int str bool 三者数据类型之间的转换。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# int ---> bool
    i = 100
    print(bool(i))  # True  # 非零即True
    i1 = 0
    print(bool(i1))  # False 零即False
    
    # bool ---> int
    t = True
    print(int(t))  # 1  True --> 1
    t = False
    print(int(t))  # 0  False --> 0
    
    # int ---> str
    i1 = 100
    print(str(i1))  # '100'
    
    # str ---> int  # 全部由数字组成的字符串才可以转化成数字
    s1 = '90'
    print(int(s1))  # 90
    
    # str ---> bool
    s1 = '太白'
    s2 = ''
    print(bool(s1))  # True 非空即True
    print(bool(s2))  # False
    # bool ---> str
    t1 = True
    print(str(True))  # 'True'

#### 2.3字符串str。 ####

Python中凡是用引号引起来的数据可以称为字符串类型，组成字符串的每个元素称之为字符，将这些字符一个一个连接起来，然后在用引号起来就是字符串。

s1 = '太白nb'
    # 对于s1这个字符串来说，它由四个字符组成：太, 白, n, b。

2.3.1、字符串的索引与切片。

组成字符串的字符从左至右，依次排列，他们都是有顺序的，就好比是部队的队列，从左至右依次报号(从零开始) ：0,1,2,3....

![988316-20190321161218486-291122921.png][]

索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。

a = 'ABCDEFGHIJK'
    print(a[0])
    print(a[3])
    print(a[5])
    print(a[7])

切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。

a = 'ABCDEFGHIJK'
    print(a[0:3])  # print(a[:3]) 从开头开始取0可以默认不写
    print(a[2:5])
    print(a[:]) #默认到最后
    print(a[:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
    print(a[:5:2]) #加步长
    print(a[-1:-5:-2]) #反向加步长

2.3.2、字符串常用方法。

字符串除了可以用切片（步长）之外，还有一些其他的操作方法。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#数字符串中的元素出现的个数。
    # ret3 = a1.count("a",0,4) # 可切片
    # print(ret3)
    
    a4 = "dkfjdkfasf54"
    #startswith 判断是否以...开头
    #endswith 判断是否以...结尾
    # ret4 = a4.endswith('jdk',3,6)  # 顾头不顾腚
    # print(ret4)  # 返回的是布尔值
    # ret5 = a4.startswith("kfj",1,4)
    # print(ret5)
    
    #split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
    # ret9 = 'title,Tilte,atre,'.split('t')
    # print(ret9)
    # ret91 = 'title,Tilte,atre,'.rsplit('t',1)
    # print(ret91)
    
    #format的三种玩法 格式化输出
    res='{} {} {}'.format('egon',18,'male')
    res='{1} {0} {1}'.format('egon',18,'male')
    res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)
    
    #strip
    name='*barry**'
    print(name.strip('*'))
    print(name.lstrip('*'))
    print(name.rstrip('*'))
    
    #replace
    name='alex say :i have one tesla,my name is alex'
    print(name.replace('alex','SB',1))
    
    #####is系列
    name='taibai123'
    print(name.isalnum()) #字符串由字母或数字组成
    print(name.isalpha()) #字符串只由字母组成
    print(name.isdecimal()) #字符串只由十进制组成
    
    
    #############下面这些方法在数据类型补充时会讲到，现在不讲####################
    #寻找字符串中的元素是否存在
    # ret6 = a4.find("fjdk",1,6)
    # print(ret6)  # 返回的找到的元素的索引，如果找不到返回-1
    
    # ret61 = a4.index("fjdk",4,6)
    # print(ret61) # 返回的找到的元素的索引，找不到报错。
    
    #captalize,swapcase,title
    print(name.capitalize()) #首字母大写
    print(name.swapcase()) #大小写翻转
    msg='taibai say hi'
    print(msg.title()) #每个单词的首字母大写
    
    # 内同居中，总长度，空白处填充
    ret2 = a1.center(20,"*")
    print(ret2)

####  2.4列表list ####

**Why: **我们现在已经学过的数据类型有：数字，布尔值，字符串，大家都知道数字主要用于计算，bool值主要是条件判断，只有字符串可以用于数据的存储，这些数据类型够用么？对于一门语言来说，肯定是不够用的。就说字符串：

1，字符串只能存储少量的数据，对于大量的数据用字符串操作不方便也不易存储。

2，字符串存储的数据类型太单一，只能是字符串类型。

例如：‘1 True grace’ 像这样的字符串，我如果通过切片或者其他方法将1 True alex 取出来，他也只能是字符串，但是我想要得到数字的1，布尔值的True，必须还要转化，是不是很麻烦。

所以python给咱们也提供了一类数据类型，他能承载多种数据类型，这类数据类型被称作容器类数据类型可以存储大量的数据。列表就属于容器类的数据类型。

**What:**这个数据类型就是list列表。

列表是python的基础数据类型之一 ,其他编程语言也有类似的数据类型.比如JS中的数 组, java中的数组等等. 它是以\[ \]括起来, 每个元素用' , '隔开而且可以存放各种数据类型: 列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类

型，比如js中叫数组，他是以\[\]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

li = \[‘grace’,123,Ture,(1,2,3,’wusir’),\[1,2,3,’小明’,\],\{‘name’:’grace’\}\]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

**How**：那么这个列表如何使用呢？咱们从这几方面去深入研究这个列表。

2.4.1 **列表的创建**

# 创建一个列表有三种方式：
    
    # 方式一：（常用）
    l1 = [1, 2, '太白']
    
    
    # 方式二：（不常用）
    l1 = list()  # 空列表
    # l1 = list(iterable)  # 可迭代对象
    l1 = list('123')
    print(l1)  # ['1', '2', '3']
    
    # 方式三：列表推导式（后面的课程会讲到）
    l1 = [i for i in range(1,5)]
    print(l1)  # [1, 2, 3, 4]

2.4.2 **列表的索引切片**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

l1 = ['a', 'b', '太白', 3, 666]
    print(l1[0])  # 'a'
    print(l1[-1])  # 666
    print(l1[1:3])  # ['b', '太白']
    print(l1[:-1])  # ['a', 'b', '太白', 3]
    print(l1[::2])  # ['a', '太白', 666]
    print(l1[::-1])  # [666, 3, '太白', 'b', 'a']

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

li = [1, 3, 2, "a", 4, "b", 5,"c"]
    通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
    通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
    通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
    通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]

练习

2.4.3. **增**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# append 追加，给列表的最后面追加一个元素
    l = [1, 2, 'a']
    l.append(666)
    print(l) # [1, 2, 'a', 666]
    
    # insert  插入在列表的任意位置插入元素
    l = [1, 2, 'a']
    l.insert(1,'太白')
    print(l) # [1, '太白', 2, 'a']
    
    # extend  迭代着追加，在列表的最后面迭代着追加一组数据
    l = [1, 2, 'a']
    l.extend('太白a')
    print(l)

2.4.4. **删**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# pop  通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素
    l = ['太白', 'alex', 'WuSir', '女神']
    ret = l.pop(1)
    print(ret,l) # alex ['太白', 'WuSir', '女神']
    
    # remove  通过元素删除列表中该元素
    l = ['太白', 'alex', 'WuSir', '女神']
    l.remove('alex')
    print(l) # ['太白', 'WuSir', '女神']
    
    # clear 清空列表
    l = ['太白', 'alex', 'WuSir', '女神']
    l.clear()
    print(l) # []  
    
    # del
    #按照索引删除该元素
    l = ['太白', 'alex', 'WuSir', '女神']
    del l[2]
    print(l) # ['太白', 'alex', '女神']
    
    # 切片删除该元素
    l = ['太白', 'alex', 'WuSir', '女神']
    del l[1:]
    print(l) # ['太白']
    
    # 切片(步长)删除该元素
    l = ['太白', 'alex', 'WuSir', '女神']
    del l[::2]
    print(l) # ['alex', '女神']

2.4.5. **改**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# 按照索引改值
    l = ['太白', 'alex', 'WuSir', '女神']
    l[0] = '男神'
    print(l) # ['男神', 'alex', 'WuSir', '女神']
    
    # 按照切片改值(迭代着增加)
    l = ['太白', 'alex', 'WuSir', '女神']
    l[1:3] = 'abcdefg'
    print(l) # ['太白', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '女神'] 
    
    # 按照切片(步长)改值(必须一一对应)
    l = ['太白', 'alex', 'WuSir', '女神']
    l[::2] = '对应'
    print(l) # ['对', 'alex', '应', '女神']

2.4.6. **查**

切片去查，或者循环去查。

**2.4.5 其他操作这些方法会在数据类型的补充时再给大家讲~**

2.4.5、**其他操作**

count（数）（方法统计某个元素在列表中出现的次数）。

1 a = ["q","w","q","r","t","y"]
    2 print(a.count("q"))

index（方法用于从列表中找出某个值第一个匹配项的索引位置）

1 a = ["q","w","r","t","y"]
    2 print(a.index("r"))

sort （方法用于在原位置对列表进行排序）。

reverse （方法将列表中的元素反向存放）。

1 a = [2,1,3,4,5]
    2 a.sort()# 他没有返回值，所以只能打印a
    3 print(a)
    4 a.reverse()#他也没有返回值，所以只能打印a
    5 print(a)

**列表也可以相加与整数相乘**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

l1 = [1, 2, 3]
    l2 = [4, 5, 6]
    # print(l1+l2)  # [1, 2, 3, 4, 5, 6]
    print(l1*3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

列表可以相加与int相乘

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
    计算列表的长度并输出
    列表中追加元素"seven",并输出添加后的列表
    请在列表的第1个位置插入元素"Tony",并输出添加后的列表
    请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
    请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
    请将字符串s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
    请删除列表中的元素"ritian",并输出添加后的列表
    请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
    请删除列表中的第2至4个元素，并输出删除元素后的列表

**2.4.6 列表的嵌套**

l1 = [1, 2, 'taibai', [1, 'WuSir', 3,]]
    1, 将l1中的'taibai'变成大写并放回原处。
    2，给小列表[1,'alex',3,]追加一个元素,'grace'。
    3，将列表中的'alex'通过字符串拼接的方式在列表中变成'alexsb'

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
    将列表lis中的"tt"变成大写（用两种方式）。
    将列表中的数字3变成字符串"100"（用两种方式）。
    将列表中的字符串"1"变成数字101（用两种方式）。

**Where**:(这个知识点用在什么地方)：

你需要存储大量的数据，且需要这些数据有序的时候。

制定一些特殊的数据群体：按顺序，按规则，自定制设计数据。

#### 2.5元组tuple。 ####

**Why**:对于容器型数据类型list，无论谁都可以对其增删改查，那么有一些重要的数据放在list中是不安全的，所以需要一种容器类的数据类型存放重要的数据，创建之初只能查看而不能增删改，这种数据类型就是元组。

**what**:这个容器型数据类型就是元组。

元组:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改.

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

儿子不能改，孙子能改
    tu = ("a","b",["aa","bb",12])
    tu[2].append("cc")
    print(tu)
    
    #结果  ('a', 'b', ['aa', 'bb', 12, 'bn'])

2.5.1 **元组的索引切片**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

tu1 = ('a', 'b', '太白', 3, 666)
    print(tu1[0])  # 'a'
    print(tu1[-1])  # 666
    print(tu1[1:3])  # ('b', '太白')
    print(tu1[:-1])  # ('a', 'b', '太白', 3)
    print(tu1[::2])  # ('a', '太白', 666)
    print(tu1[::-1])  # (666, 3, '太白', 'b', 'a')

** **

2.5.2 **元组其他操作方法**

因为元组的特性，直接从属于元组的元素不能更改，所以元组只能查看。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# 可以利用for循环查询
    
    tu1 = ('a', 'b', '太白', 3, 666)
    for i in tu1:
        print(i)

**index**：通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

tu = ('太白', [1, 2, 3, ], 'WuSir', '女神')
    print(tu.index('太白')) # 0

**count**: 获取某元素在列表中出现的次数

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

tu = ('太白', '太白', 'WuSir', '吴超')
    print(tu.count('太白')) # 2

2.5.3 len

tu1 = (1,2,3,4,84,5,2,8,2,11,88,2)
    print(len(tu1))
    
    结果:
    12

**一个和多个元素的元组**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

创建包含一个元素的元组
    在单个元素后跟逗号表示单个元素的元组,下面两行代码创建的都是只包含一个元素的元组。
    a,        #这是单个元素的元组
    (a,)       #这是单个元素的元组
    
    
    创建包含多个元素的元组
    如果元组包含多个元素，那么，多个元素之间需要使用逗号分隔，示例如下:
    a,b,C       #这是一个元组，包含3个元素
    (a,b,c)      #这是一个元组，包含3个元素

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

元组里面如果只有一个元素且没有逗号，则该数据的数据类型与里面的元素相同
    tu1 = ([1,2,3])      #int
    tu2 = ([1,2,3],)     #tuple

注意

**Where**:

1，就是将一些非常重要的不可让人改动的数据放在元组中，只供查看。

2，常用于元组的拆包（数据类型补充的时候会给大家讲到）。

#### 2.6字典dict。 ####

**　　2.6.1 字典的初识**

**Why:**咱们目前已经学习到的容器型数据类型只有list，那么list够用？他有什么缺点呢？

1. 列表可以存储大量的数据类型，但是如果数据量大的话，他的查询速度比较慢。

2. 列表只能按照顺序存储，数据与数据之间关联性不强。

所以针对于上的缺点，说咱们需要引入另一种容器型的数据类型，解决上面的问题，这就需要dict字典。

**what：**

数据类型可以按照多种角度进行分类，就跟咱们人一样，人按照地域可以划分分为亚洲人，欧洲人，美洲人等，但是按照肤色又可以分为白种人，黄种人，黑种人，等等，数据类型可以按照不同的角度进行分类，先给大家按照可变与不可变的数据类型的分类：

不可变（可哈希）的数据类型：int，str，bool，tuple。

可变（不可哈希）的数据类型：list，dict，set。

字典是Python语言中的映射类型，他是以\{ \}括起来，里面的内容是以键值对的形式储存的：

**Key:  不可变（可哈希）的数据类型.并且键是唯一的，不重复的。**

**Value: 任意数据(int，str，bool，tuple，list，dict，set)**，包括后面要学的实例对象等。

在Python3.5版本（包括此版本）之前，字典是无序的。

在Python3.6版本之后，字典会按照初建字典时的顺序排列(即第一次插入数据的顺序排序)。

当然，字典也有缺点：他的缺点就是内存消耗巨大。

**字典查询之所以快的解释：（了解）**

**字典的查询速度非常快，简单解释一下原因**：字典的键值对会存在一个散列表（稀疏数组）这样的空间中，每一个单位称作一个表元，表元里面记录着key：value,如果你想要找到这个key对应的值，先要对这个key进行hash获取一串数字咱们简称为门牌号（非内存地址），然后通过门牌号，确定表元，对比查询的key与被锁定的key是否相同，如果相同，将值返回，如果不同，报错。（这里只是简单的说一下过程，其实还是比较复杂的。），下面我已图形举例：

![1388404-20190723221056754-993610549.png][]

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# 此段解释来源于《流畅的python》.
    这一节笼统地描述了 Python 如何用散列表来实现 dict 类型，有些细节只是一笔带过，像
    CPython 里的一些优化技巧 就没有提到。但是总体来说描述是准确的。
    Python 源码 dictobject.c 模块（http://hg.python.org/cpython/file/tip/Objects/dictobject.c）里有丰富的注释，另外延伸阅
    读中有对《代码之美》一书的引用。
    为了简单起见，这里先集中讨论 dict 的内部结构，然后再延伸到集合上面。
    散列表其实是一个稀疏数组（总是有空白元素的数组称为稀疏数组）。在一般的数据结构
    教材中，散列表里的单元通常叫作表元（bucket）。在 dict 的散列表当中，每个键值对
    都占用一个表元，每个表元都有两个部分，一个是对键的引用，另一个是对值的引用。因
    为所有表元的大小一致，所以可以通过偏移量来读取某个表元。
    因为 Python 会设法保证大概还有三分之一的表元是空的，所以在快要达到这个阈值的时
    候，原有的散列表会被复制到一个更大的空间里面。
    如果要把一个对象放入散列表，那么首先要计算这个元素键的散列值。Python 中可以用
    hash() 方法来做这件事情，接下来会介绍这一点。
    01. 散列值和相等性
    内置的 hash() 方法可以用于所有的内置类型对象。如果是自定义对象调用 hash()
    的话，实际上运行的是自定义的 __hash__。如果两个对象在比较的时候是相等的，
    那它们的散列值必须相等，否则散列表就不能正常运行了。例如，如果 1 == 1.0 为
    8
    8
    真，那么 hash(1) == hash(1.0) 也必须为真，但其实这两个数字（整型和浮点）
    的内部结构是完全不一样的。
    为了让散列值能够胜任散列表索引这一角色，它们必须在索引空间中尽量分散开来。
    这意味着在最理想的状况下，越是相似但不相等的对象，它们散列值的差别应该越
    大。示例 3-16 是一段代码输出，这段代码被用来比较散列值的二进制表达的不同。
    注意其中 1 和 1.0 的散列值是相同的，而 1.0001、1.0002 和 1.0003 的散列值则非常不
    同。
    示例 3-16 在32 位的 Python 中，1、1.0001、1.0002 和 1.0003 这几个数的散列
    值的二进制表达对比（上下两个二进制间不同的位被 ! 高亮出来，表格的最右
    列显示了有多少位不相同）
    32-bit Python build
    1 00000000000000000000000000000001
    != 0
    1.0 00000000000000000000000000000001
    ------------------------------------------------
    1.0 00000000000000000000000000000001
    ! !!! ! !! ! ! ! ! !! !!! != 16
    1.0001 00101110101101010000101011011101
    ------------------------------------------------
    1.0001 00101110101101010000101011011101
    !!! !!!! !!!!! !!!!! !! ! != 20
    1.0002 01011101011010100001010110111001
    ------------------------------------------------
    1.0002 01011101011010100001010110111001
    ! ! ! !!! ! ! !! ! ! ! !!!! != 17
    1.0003 00001100000111110010000010010110
    ------------------------------------------------
    用来计算示例 3-16 的程序见于附录 A。尽管程序里大部分代码都是用来整理输出格
    式的，考虑到完整性，我还是把全部的代码放在示例 A-3 中了。
    从 Python 3.3 开始，str、bytes 和 datetime 对象的散列值计算过程中多
    了随机的“加盐”这一步。所加盐值是 Python 进程内的一个常量，但是每次启动
    Python 解释器都会生成一个不同的盐值。随机盐值的加入是为了防止 DOS 攻击
    而采取的一种安全措施。在 __hash__ 特殊方法的文档
    （https://docs.python.org/3/reference/datamodel.html#object.__hash__) 里有相关的详
    细信息。
    了解对象散列值相关的基本概念之后，我们可以深入到散列表工作原理背后的算法
    了。
    02. 散列表算法
    为了获取 my_dict[search_key] 背后的值，Python 首先会调用 hash(search_key)来计算 search_key 的散列值，把这个值最低的几位数字当作偏移量，在散列表里查找表元（具体取几位，得看当前散列表的大小）。若找到的表元是空的，则抛出KeyError 异常。若不是空的，则表元里会有一对 found_key:found_value。这时候 Python 会检验 search_key == found_key 是否为真，如果它们相等的话，就会返回 found_value。如果 search_key 和 found_key 不匹配的话，这种情况称为散列冲突。发生这种情况是因为，散列表所做的其实是把随机的元素映射到只有几位的数字上，而散列表本身的索引又只依赖于这个数字的一部分。为了解决散列冲突，算法会在散列值中另外再取几位，然后用特殊的方法处理一下，把新得到的数字再当作索引来寻找表元。若这次找到的表元是空的，则同样抛出 KeyError；若非空，或者键匹配，则返回这个值；或者又发现了散列冲突，则重复以上的步骤。图 3-3 展示了这个算法的示意
    图。图 3-3：从字典中取值的算法流程图；给定一个键，这个算法要么返回一个值，要么抛出 KeyError 异常添加新元素和更新现有键值的操作几乎跟上面一样。只不过对于前者，在发现空表元的时候会放入一个新元素；对于后者，在找到相对应的表元后，原表里的值对象会被替换成新值。
    另外在插入新值时，Python 可能会按照散列表的拥挤程度来决定是否要重新分配内存为它扩容。如果增加了散列表的大小，那散列值所占的位数和用作索引的位数都会随之增加，这样做的目的是为了减少发生散列冲突的概率。表面上看，这个算法似乎很费事，而实际上就算 dict 里有数百万个元素，多数的搜索过程中并不会有冲突发生，平均下来每次搜索可能会有一到两次冲突。在正常情况下，就算是最不走运的键所遇到的冲突的次数用一只手也能数过来。了解 dict 的工作原理能让我们知道它的所长和所短，以及从它衍生而来的数据类型

详解

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

由于字典使用了散列表，而散列表又必须是稀疏的，这导致它在空间上的效率低下。举例而言，如果你需要存放数量巨大的记录，那么放在由元组或是具名元组构成的列表中会是比较好的选择；最好不要根据 JSON 的风格，用由字典组成的列表来存放这些记录。用元组取代字典就能节省空间的原因有两个：其一是避免了散列表所耗费的空间，其二是无需把记录中字段的名字在每个元素里都存一遍。记住我们现在讨论的是空间优化。如果你手头有几百万个对象，而你的机器有几个GB 的内存，那么空间的优化工作可以等到真正需要的时候再开始计划，因为优化往往是可维护性的对立面。

字典内开销大（了解）

**2.6.2 创建字典的几种方式：**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# 创建字典的几种方式：
    
    # 方式1:
    dic = dict((('one', 1),('two', 2),('three', 3)))
    # dic = dict([('one', 1),('two', 2),('three', 3)])
    print(dic)  # {'one': 1, 'two': 2, 'three': 3}
    
    
    # 方式2:
    dic = dict(one=1,two=2,three=3)
    print(dic)  # {'one': 1, 'two': 2, 'three': 3}
    
    
    # 方式3:
    dic = dict({
         'one': 1, 'two': 2, 'three': 3})
    print(dic)  # {'one': 1, 'two': 2, 'three': 3}
    
    # 方式5: 后面会讲到先了解
    dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))
    print(dic)
    
    # 方式6: 字典推导式 后面会讲到
    # dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
    # print(dic)
    
    # 方式7:利用fromkey后面会讲到。
    # dic = dict.fromkeys('abcd','太白')
    # print(dic)  # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}

**2.6.3 验证字典的合法性**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# 合法
    dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帅
    哥', '美⼥'], (1, 2, 3): '麻花藤'}
    print(dic[123])
    print(dic[True])
    print(dic['id'])
    print(dic['stu'])
    print(dic[(1, 2, 3)])
    
    # 不合法
    # dic = {[1, 2, 3]: '周杰伦'} # list是可变的. 不能作为key
    # dic = {
          {1: 2}: "哈哈哈"} # dict是可变的. 不能作为key

**2.6.4 字典的常用操作方法**

**　　接下来咱们就进入字典的学习环节，字典对于咱们小白来说可能相对于列表是不好理解的，因为列表是有序的一个一个排列的，但是字典的键值对对于大家来说是比较陌生的，所以咱们可以把字典比喻成一个公寓，公寓里面有N多个房间，房间号就是键，房间里面具体的东西就值：比如房间001号：对应的房间住着两个人，也就是2person，简称2P，房间99号：3P， 房间78号：有人还有小动物....... 这样，咱们就能通过房间号（也就是键）找到对应的房间，查看里面的内容，也就是值。**

**    那么首先先从字典的增删改查开始学习。**

**增**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# 通过键值对直接增加
    dic = {
         'name': '太白', 'age': 18}
    dic['weight'] = 75 # 没有weight这个键，就增加键值对
    print(dic) # {'name': '太白', 'age': 18, 'weight': 75}
    dic['name'] = 'barry' # 有name这个键，就成了字典的改值
    print(dic) # {'name': 'barry', 'age': 18, 'weight': 75}
    
    # setdefault
    dic = {
         'name': '太白', 'age': 18}
    dic.setdefault('height',175) # 没有height此键，则添加
    print(dic) # {'name': '太白', 'age': 18, 'height': 175}
    dic.setdefault('name','barry') # 有此键则不变
    print(dic) # {'name': '太白', 'age': 18, 'height': 175}
    #它有返回值
    dic = {
         'name': '太白', 'age': 18}
    ret = dic.setdefault('name')
    print(ret)  # 太白

**删**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# pop 通过key删除字典的键值对，有返回值，可设置返回值。
    dic = {
         'name': '太白', 'age': 18}
    # ret = dic.pop('name')
    # print(ret,dic) # 太白 {'age': 18}
    ret1 = dic.pop('n',None)
    print(ret1,dic) # None {'name': '太白', 'age': 18}
    
    #popitem 3.5版本之前，popitem为随机删除，3.6之后为删除最后一个，有返回值
    dic = {
         'name': '太白', 'age': 18}
    ret = dic.popitem()
    print(ret,dic) # ('age', 18) {'name': '太白'}
    
    #clear 清空字典
    dic = {
         'name': '太白', 'age': 18}
    dic.clear()
    print(dic) # {}
    
    # del
    # 通过键删除键值对
    dic = {
         'name': '太白', 'age': 18}
    del dic['name']
    print(dic) # {'age': 18}
    #删除整个字典
    del dic

**改**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# 通过键值对直接改
    dic = {
         'name': '太白', 'age': 18}
    dic['name'] = 'barry'
    print(dic) # {'name': 'barry', 'age': 18}
    
    # update
    dic = {
         'name': '太白', 'age': 18}
    dic.update(sex='男', height=175)
    print(dic) # {'name': '太白', 'age': 18, 'sex': '男', 'height': 175}
    
    dic = {
         'name': '太白', 'age': 18}
    dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
    print(dic) # {'name': '太白', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}
    
    dic1 = {
         "name":"jin","age":18,"sex":"male"}
    dic2 = {
         "name":"alex","weight":75}
    dic1.update(dic2)
    print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
    print(dic2) # {'name': 'alex', 'weight': 75}

**查**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# 通过键查询
    # 直接dic[key](没有此键会报错)
    dic = {
         'name': '太白', 'age': 18}
    print(dic['name']) # 太白
    
    # get
    dic = {
         'name': '太白', 'age': 18}
    v = dic.get('name')
    print(v) # '太白'
    v = dic.get('name1')
    print(v) # None
    v = dic.get('name2','没有此键')
    print(v) # 没有此键 
    
    
    keys()
    dic = {
         'name': '太白', 'age': 18}
    print(dic.keys()) # dict_keys(['name', 'age']) 
    
    values()
    dic = {
         'name': '太白', 'age': 18}
    print(dic.values()) # dict_values(['太白', 18])
    
    items()
    dic = {
         'name': '太白', 'age': 18}
    print(dic.items()) # dict_items([('name', '太白'), ('age', 18)])

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

dic = {
         'k1': "v1", "k2": "v2", "k3": [11,22,33]}
    请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
    请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
    请在k3对应的值中追加一个元素 44，输出修改后的字典
    请在k3对应的值的第 1 个位置插入个元素 18，输出修改后的字典

练习

fromkeys  数据类型

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

dic = dict.fromkeys('abcd','太白')
    print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}
    
    dic = dict.fromkeys([1, 2, 3],'太白')
    print(dic) # {1: '太白', 2: '太白', 3: '太白'}

其他操作

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

key_list = dic.keys()    
    print(key_list)
    
    结果:
    dict_keys(['剑圣', '哈啥给', '大宝剑'])
    # 一个高仿列表,存放的都是字典中的key
    
    # 并且这个高仿的列表可以转化成列表
    print(list(key_list))
    
    # 它还可以循环打印
    
    dic = {
         '剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
    
    for i in dic:
        print(i)
    
    
    
    value_list = dic.values()
    print(value_list)
    
    结果:
    dict_values(['易', '剑豪', '盖伦'])
    #一个高仿列表,存放都是字典中的value
    # 并且这个高仿的列表可以转化成列表
    print(list(value_list))
    
    # 它还可以循环打印
    for i in dic.values():   
        print(i)
    
    
    key_value_list = dic.items()
    print(key_value_list)
    结果:
    dict_items([('剑圣', '易'), ('哈啥给', '剑豪'), ('大宝剑', '盖伦')])
    
    # 一个高仿列表,存放是多个元祖,元祖中第一个是字典中的键,第二个是字典中的值　　
    
    # 并且这个高仿的列表可以转化成列表
    print(list(key_value_list ))
    
    # 它还可以循环打印
    dic = {
         '剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
    for i in dic.items():
        print(i)
    结果：
    ('剑圣', '易')
    ('哈啥给', '剑豪')
    ('大宝剑', '盖伦')

**这里补充一个知识点：分别赋值，也叫拆包**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

a,b = 1,2
    print(a,b)
    结果:
    1 2
    
    a,b = ('你好','世界')  # 这个用专业名词就叫做元组的拆包
    print(a,b)
    结果:
    你好 世界
    
    
    a,b = ['你好','大飞哥']
    print(a,b)
    结果:
    你好 世界
    
    
    a,b = {
         '汪峰':'北京北京','王菲':'天后'}
    print(a,b)
    结果:
    汪峰 王菲

**所以利用上面刚学的拆包的概念，我们循环字典时还可以这样获取字典的键，以及值：**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

for k,v in dic.items():
        print('这是键',k)
        print('这是值',v)
    
    结果:
    这是键 剑圣
    这是值 易
    这是键 哈啥给
    这是值 剑豪
    这是键 大宝剑
    这是值 盖伦

**4.1.5字典的嵌套**

字典的嵌套是非常重要的知识点，这个必须要建立在熟练使用字典的增删改查的基础上，而且字典的嵌套才是咱们在工作中经常会遇到的字典，工作中遇到的字典不是简简单单一层，而就像是葱头一样，一层接一层，但一般都是很有规律的嵌套，那么接下来我们就学习一下字典的嵌套：

**    现在有如下字典，完成一下需求：**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

dic = {
        'name':'汪峰',
        'age':48,
        'wife':[{
         'name':'国际章','age':38}],
        'children':{
         'girl_first':'小苹果','girl_second':'小怡','girl_three':'顶顶'}
    }
    
    1. 获取汪峰的名字。
    
    2.获取这个字典：{
         'name':'国际章','age':38}。
    
    3. 获取汪峰妻子的名字。
    
    4. 获取汪峰的第三个孩子名字

解题思路：

1.获取汪峰的名字。: 这个比较简单，汪峰就是dic的一个键对应的值，我们通过这个key就可以获取到汪峰这个值。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

name = dic['name']
    print(name)

2. 获取这个字典\{'name':'国际章','age':38\}: 想要获取这个字典，先要看字典从属于谁？这个字典从属于一个列表，而这个列表是字典wife对应的键，所以咱们应该先通过wife获取到对应的这个列表，然后通过这个列表按照所以取值取到对应的这个字典。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

l1 = dic['wife']  # 先获取到这个列表
    di = l1[0]  # 列表按照索引取值，这个字典是列表的第一个元素，所以通过索引获取到这个字典
    print(di)
    
    # 当然上面是分布获取的，我们还可以合并去写：
    di = dic['wife'][0]
    print(di)

3. 获取汪峰的妻子名字: 还是按照上一题的思路：想要获取汪峰妻子的名字：国际章，那么他是一个字典的键对应的值，所以我们通过'name'这个键就可以获取到对应的值，这个题的难点是获取到这个小字典，而上一个题我们已经获取了这个小字典，所以在上面的基础上再执行就可以了。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

di = dic['wife'][0]  # 这个是上一次题获取的小字典的代码
    wife_name= di['name']  # 通过小字典然后再通过键就能获取到对应的值
    print(wife_name)
    
    # 当然咱们可以简化：
    wife_name = dic['wife'][0]['name]
    print(wife_name)

4. 获取汪峰的第三个孩子名字: 汪峰的孩子们是在一个字典中的，你要想获取汪峰的第三个孩子，你应该先获取到它从属于的这个字典，然后再通过这个字典获取第三个孩子的名字。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

dic2 = dic['children']  # 先获取这个字典
    name = dic2['girl_three']  # 在通过这个字典获取第三个孩子的名字
    print(name)
    
    # 当然你可以简化：
    name = dic['children']['girl_three']
    print(name)

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

dic1 = {
     'name':['alex',2,3,5],
     'job':'teacher',
     'beiwang':{
         'alex':['python1','python2',100]}
     }
    1，将name对应的列表追加⼀个元素’wusir’。
    2，将name对应的列表中的alex⾸字⺟⼤写。
    3，beiwang对应的字典加⼀个键值对’bw’,’linux’。
    4，将beiwang对应的字典中的alex对应的列表中的python2删除

#### 2.7集合set (了解) ####

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合**本身**是不可哈希（**可变的**）（所以集合做不了字典的键）的。以下是集合最重要的两点：

去重，把一个列表变成集合，就自动去重了。

关系测试，测试两组数据之前的交集、差集、并集等关系。

集合只有**增删查，没有改**

1，集合的创建。

set1 = set({1,2,'barry'})
    set2 = {1,2,'barry'}
    print(set1,set2)  # {1, 2, 'barry'} {1, 2, 'barry'}

2，集合的增。

set1 = {'alex','wusir','ritian','egon','barry'}
    set1.add('景女神')
    print(set1)
    
    #update：迭代着增加
    set1.update('A')
    print(set1)
    set1.update('老师')
    print(set1)
    set1.update([1,2,3])
    print(set1)

3，集合的删。

set1 = {'alex','wusir','ritian','egon','barry'}
    
    set1.remove('alex')  # 删除一个元素
    print(set1)
    
    set1.pop()  # 随机删除一个元素
    print(set1)
    
    set1.clear()  # 清空集合
    print(set1)
    
    del set1  # 删除集合
    print(set1)

4，集合的其他操作：

4.1 交集。（&  或者 intersection）

set1 = {1,2,3,4,5}
    set2 = {4,5,6,7,8}
    print(set1 & set2)  # {4, 5}
    print(set1.intersection(set2))  # {4, 5}

4.2 并集。（| 或者 union）

set1 = {1,2,3,4,5}
    set2 = {4,5,6,7,8}
    print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7,8}
    
    print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7,8}

4.3 差集。（- 或者 difference）

set1 = {1,2,3,4,5}
    set2 = {4,5,6,7,8}
    print(set1 - set2)  # {1, 2, 3}
    print(set1.difference(set2))  # {1, 2, 3}

4.4反交集。 （^ 或者 symmetric\_difference）

set1 = {1,2,3,4,5}
    set2 = {4,5,6,7,8}
    print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
    print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

4.5子集与超集

set1 = {1,2,3}
    set2 = {1,2,3,4,5,6}
    
    print(set1 < set2)
    print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。
    
    print(set2 > set1)
    print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

5，frozenset不可变集合，让集合变成不可变类型。

s = frozenset('barry')
    print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

## 三.其他（for，enumerate，range） ##

for循环：用户按照顺序循环可迭代对象的内容。

msg = '北网是最好的学校'
    for item in msg:
        print(item)
    
    li = ['alex','银角','女神','egon','太白']
    for i in li:
        print(i)
    
    dic = {'name':'太白','age':18,'sex':'man'}
    for k,v in dic.items():
        print(k,v)

enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

li = ['alex','银角','女神','egon','太白']
    for i in enumerate(li):
        print(i)
    for index,name in enumerate(li,1):
        print(index,name)
    for index, name in enumerate(li, 100):  # 起始位置默认是0，可更改
        print(index, name)

range：指定范围，生成指定数字。

*  start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
 *  stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是\[0, 1, 2, 3, 4\]没有5
 *  step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

for i in range(1,10):
        print(i)
    
    for i in range(1,10,2):  # 步长
        print(i)
    
    for i in range(10,1,-2): # 反向步长
        print(i)
    
    
    #range 和len()配合使用
    x = 'runoob' >>> for i in range(len(x)) : ... print(x[i]) ...

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

l1 = ['wusir', 'alex', '太白', '女神', 12, 666]
    for i in range(len(l1)):
        print(i)

利用len和range打印索引的切片

转载于:https://www.cnblogs.com/shangping/p/11234983.html

[IMAGE_7ZjVE7w.PNG]: http://crm.pythonav.com/media/uploads/2019/03/27/IMAGE_7ZjVE7w.PNG
[IMAGE_NubXAX6.PNG]: http://crm.pythonav.com/media/uploads/2019/03/27/IMAGE_NubXAX6.PNG
[9213b07eca8065388a8973be97dda144ad348238.jpg]: https://gss2.bdstatic.com/-fo3dSag_xI4khGkpoWK1HF6hhy/baike/s%3D250/sign=34a5a18b6d224f4a5399741639f69044/9213b07eca8065388a8973be97dda144ad348238.jpg
[9213b07eca8065388a8973be97dda144ad348238.jpg 1]: https://baike.baidu.com/pic/%E5%8D%81%E8%BF%9B%E5%88%B6%E8%BD%AC%E4%BA%8C%E8%BF%9B%E5%88%B6/393189/0/9213b07eca8065388a8973be97dda144ad348238?fr=lemma&ct=single
[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20211023/da5675a14eb94063aa387964148479e1.png
[988316-20190321161218486-291122921.png]: /images/20211023/65d12b95df5f453e811b854ac6b19cff.png
[1388404-20190723221056754-993610549.png]: /images/20211023/1c7fb0fb94be429e9532fc4b710c697d.png