一.什么是数据类型
什么是数据类型？
我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种，如下：
整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).
- int：数字：主要用于运算。1 ，2,3...
- bool：判断真假：True, False.
- str：简单少量的储存数据，并进行相应的操作。name = 'alex',
- tuple：只读，不能更改。(1,'yhh')
- list：大量有序数据，[1,'ses',True,[1,2,3],{'name':'huihuang'}]
- dict：大量数据，且是关联性比较强的数据 {'name':'yhh','age':28,'name_list':['严'，'辉煌']}
二.基础数据类型
2.1数字int
int，就是咱们常见的数据类型，主要是用于各种运算，加减乘数等
2.1.1 十进制二进制转换
十进制整数转换为二进制整数采用"除2取余，逆序排列"法。具体做法是：用2整除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为小于1时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来
十进制小数转换成二进制小数采用"乘2取整，顺序排列"法。具体做法是：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，此时0或1为二进制的最后一位。或者达到所要求的精度为止
2.1.2二进制转化成十进制
把二进制数首先写成加权系数展开式，然后按十进制加法规则求和。这种做法称为"按权相加"法
二进制数100011转成十进制数可以看作这样：
数字中共有三个1 即第一位一个，第五位一个，第六位一个，然后对应十进制数即2的0次方+2的1次方+2的5次方， 即
100011=32+0+0+0+2+1=35
2.1.3 int操作方法
因为数字主要是用于计算，所以针对于数字可以使用的方法除了那些运算之外，没有什么经常会用的方法，python给咱们提供了一种方法：bit_length()就是帮助你快速的计算整数在内存中占用的二进制码的长度.
num = 10 print(num.bit_length()) # 当十进制用二进制表示时，最少使用的位数 # 运行结果: 4
2.2布尔值bool
布尔值就两种：True，False。就是反应条件的正确与否
真 1 True。
假 0 False。
这里补充一下int str bool 三者数据类型之间的转换
1 # int ---> bool 2 i = 100 3 print(bool(i)) # True # 非零即True 4 i1 = 0 5 print(bool(i1)) # False 零即False 6 7 # bool ---> int 8 t = True 9 print(int(t)) # 1 True --> 1 10 t = False 11 print(int(t)) # 0 False --> 0 12 13 # int ---> str 14 i1 = 100 15 print(str(i1)) # '100' 16 17 # str ---> int # 全部由数字组成的字符串才可以转化成数字 18 s1 = '90' 19 print(int(s1)) # 90 20 21 # str ---> bool 22 s1 = '辉煌' 23 s2 = '' 24 print(bool(s1)) # True 非空即True 25 print(bool(s2)) # False 26 # bool ---> str 27 t1 = True 28 print(str(True)) # 'True'
2.3字符串str
Python中凡是用引号引起来的数据可以称为字符串类型，组成字符串的每个元素称之为字符，将这些字符一个一个连接起来，然后在用引号起来就是字符串
s1 = '辉煌好帅good‘ 它由四个字符组成：辉，煌，好，帅，g,o,o,d
2.3.1、字符串的索引与切片
索引即下标，就是字符串组成的元素从第一个开始，初始索引为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、字符串常用方法
字符串除了可以用切片（步长）之外，还有一些其他的操作方法
#数字符串中的元素出现的个数。 # ret3 = a1.count("a",0,4) # 可切片 # print(ret3) a4 = "abcdefg12345" #startswith 判断是否以...开头 #endswith 判断是否以...结尾 # ret4 = a4.endswith('bcd',3,6) # 顾头不顾腚 # print(ret4) # 返回的是布尔值 # ret5 = a4.startswith("abc",0,2) # print(ret5) #split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。 # ret9 = 'title,Tilte,atre,'.split('t') # print(ret9) # ret91 = 'title,Tilte,atre,'.rsplit('t',1) # print(ret91) #format的三种玩法 格式化输出 res='{} {} {}'.format('yhh',28,'male') res='{1} {0} {1}'.format('yhh',28,'male') res='{name} {age} {sex}'.format(sex='male',name='yhh',age=28) #strip name='*yanhuihuang**' print(name.strip('*')) print(name.lstrip('*')) print(name.rstrip('*')) #replace name='yhh say :i have one tesla,my name is yhh' print(name.replace('yhh','NB',1)) #####is系列 name='taibai123' print(name.isalnum()) #字符串由字母或数字组成 print(name.isalpha()) #字符串只由字母组成 print(name.isdecimal()) #字符串只由十进制组成 #寻找字符串中的元素是否存在 # ret6 = a4.find("bcde",1,6) # print(ret6) # 返回的找到的元素的索引，如果找不到返回-1 # ret61 = a4.index("bcde",4,6) # print(ret61) # 返回的找到的元素的索引，找不到报错。 #captalize,swapcase,title print(name.capitalize()) #首字母大写 print(name.swapcase()) #大小写翻转 msg='yanhuihuang say hellow' print(msg.title()) #每个单词的首字母大写 # 内同居中，总长度，空白处填充 ret2 = a1.center(20,"*") print(ret2)
2.4列表list
列表是python的基础数据类型之一
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 列表的索引切片
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']
1 li = [1, 3, 2, "a", 4, "b", 5,"c"] 2 通过对li列表的切片形成新的列表l1,l1 = [1,3,2] 3 通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"] 4 通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"] 5 通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]
2.4.3. 增
1 # append 追加，给列表的最后面追加一个元素 2 l = [1, 2, 'a'] 3 l.append(666) 4 print(l) # [1, 2, 'a', 666] 5 6 # insert 插入在列表的任意位置插入元素 7 l = [1, 2, 'a'] 8 l.insert(1,'辉煌') 9 print(l) # [1, '辉煌', 2, 'a'] 10 11 # extend 迭代着追加，在列表的最后面迭代着追加一组数据 12 l = [1, 2, 'a'] 13 l.extend('辉煌a') 14 print(l)
2.4.4. 删
pop 通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素 l = ['辉煌', 'yan', 'Yhh', '田心女亭'] ret = l.pop(1) print(ret,l) # yan ['辉煌', 'Yhh', '田心女亭'] # remove 通过元素删除列表中该元素 l = ['辉煌', 'yan', 'Yhh', '田心女亭'] l.remove('yan') print(l) # ['辉煌', 'Yhh', '田心女亭'] # clear 清空列表 l = ['辉煌', 'yan', 'Yhh', '田心女亭'] l.clear() print(l) # [] # del #按照索引删除该元素 l = ['辉煌', 'yan', 'Yhh', '田心女亭'] del l[2] print(l) # ['辉煌', 'yan', '田心女亭'] # 切片删除该元素 l = ['辉煌', 'yan', 'Yhh', '田心女亭'] del l[1:] print(l) # ['辉煌'] # 切片(步长)删除该元素 l = ['辉煌', 'yan', 'Yhh', '田心女亭'] del l[::2] print(l) # ['yan', '田心女亭']
2.4.5. 改
# 按照索引改值 l = ['辉煌', 'yan', 'Yhh', '田心女亭'] l[0] = '男神' print(l) # ['男神', 'yan', 'Yhh', '田心女亭'] # 按照切片改值(迭代着增加) l = ['辉煌', 'yan', 'Yhh', '田心女亭'] l[1:3] = 'abcdefg' print(l) # ['辉煌', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '田心女亭'] # 按照切片(步长)改值(必须一一对应) l = ['辉煌', 'yan', 'Yhh', '田心女亭'] l[::2] = '对应' print(l) # ['对', 'yan', '应', '田心女亭']
2.4.6. 查
利用索引按照切片或者循环去查看
2.4.7.内置函数操作
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)
列表也可以相加与整数相乘
列表也可以相加(与int相乘)相应练习题
li = ["one", "tow", "three", "four", "five"] 计算列表的长度并输出 列表中追加元素"six",并输出添加后的列表 请在列表的第1个位置插入元素"seven",并输出添加后的列表 请修改列表第2个位置的元素为"eigth",并输出修改后的列表 请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现，不允许循环添加。 请将字符串s = "yanhuihuang"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。 请删除列表中的元素"sie",并输出添加后的列表 请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表 请删除列表中的第2至4个元素，并输出删除元素后的列表lian
2.4.6 列表的嵌套
l1 = [1, 2, 'huihuang', [1, 'Yan', 3,]] 1, 将l1中的'huihuang'变成大写并放回原处。 2，给小列表[1,'yanhuihuang',3,]追加一个元素,'我爱你'。 3，将列表中的'yanhuihuang'通过字符串拼接的方式在列表中变成'yanhuihuanglove'
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"] 将列表lis中的"tt"变成大写（用两种方式）。 将列表中的数字3变成字符串"100"（用两种方式）。 将列表中的字符串"1"变成数字101（用两种方式）。
Where:(这个知识点用在什么地方)：
你需要存储大量的数据，且需要这些数据有序的时候。
制定一些特殊的数据群体：按顺序，按规则，自定制设计数据。
2.5元组tuple
元组:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改.
2.5.1 元组的索引切片
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 元组其他操作方法
因为元组的特性，直接从属于元组的元素不能更改，所以元组只能查看。
# 可以利用for循环查询 tu1 = ('a', 'b', '辉煌', 3, 666) for i in tu1: print(i)
index：通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错
tu = ('辉煌', [1, 2, 3, ], 'yan', 'huihuang') print(tu.index('辉煌')) # 0
count: 获取某元素在列表中出现的次数
tu = ('辉煌', '辉煌', 'Yan', 'Y严辉煌') 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
Where:
1，就是将一些非常重要的不可让人改动的数据放在元组中，只供查看。
2，常用于元组的拆包（数据类型补充的时候会给大家讲到）
2.6字典dict
数据类型可以按照多种角度进行分类，就跟咱们人一样，人按照地域可以划分分为亚洲人，欧洲人，美洲人等，但是按照肤色又可以分为白种人，黄种人，黑种人，等等，数据类型可以按照不同的角度进行分类，先给大家按照可变与不可变的数据类型的分类：
不可变（可哈希）的数据类型：int，str，bool，tuple。
可变（不可哈希）的数据类型：list，dict，set。
字典是Python语言中的映射类型，他是以{}括起来，里面的内容是以键值对的形式储存的：
Key: 不可变（可哈希）的数据类型.并且键是唯一的，不重复的。
Value:任意数据(int，str，bool，tuple，list，dict，set)，包括后面要学的实例对象等。
在Python3.5版本（包括此版本）之前，字典是无序的。
在Python3.6版本之后，字典会按照初建字典时的顺序排列(即第一次插入数据的顺序排序)。
当然，字典也有缺点：他的缺点就是内存消耗巨大。
# 此段解释来源于《流畅的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 的工作原理能让我们知道它的所长和所短，以及从它衍生而来的数据类型
由于字典使用了散列表，而散列表又必须是稀疏的，这导致它在空间上的效率低下。举例而言，如果你需要存放数量巨大的记录，那么放在由元组或是具名元组构成的列表中会是比较好的选择；最好不要根据 JSON 的风格，用由字典组成的列表来存放这些记录。用元组取代字典就能节省空间的原因有两个：其一是避免了散列表所耗费的空间，其二是无需把记录中字段的名字在每个元素里都存一遍。记住我们现在讨论的是空间优化。如果你手头有几百万个对象，而你的机器有几个GB 的内存，那么空间的优化工作可以等到真正需要的时候再开始计划，因为优化往往是可维护性的对立面。
2.6.2 创建字典的几种方式：
# 创建字典的几种方式： # 方式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 验证字典的合法性
# 合法 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 dic = {{1, 2, 3}: '呵呵呵'} # set是可变的, 不能作为key
2.6.4 字典的常用操作方法
增
# 通过键值对直接增加 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) # 辉煌
删
# 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
改
# 通过键值对直接改 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":"yan","weight":75} dic1.update(dic2) print(dic1) # {'name': 'yan', 'age': 18, 'sex': 'male', 'weight': 75} print(dic2) # {'name': 'yan', 'weight': 75}
查
# 通过键查询 # 直接dic[key](没有此键会报错) dic = {'name': 'yan', 'age': 18} print(dic['name']) # yan # get dic = {'name': 'yan', 'age': 18} v = dic.get('name') print(v) # 'yan' v = dic.get('name1') print(v) # None v = dic.get('name2','没有此键') print(v) # 没有此键 keys() dic = {'name': 'yan', 'age': 18} print(dic.keys()) # dict_keys(['name', 'age']) values() dic = {'name': 'yan', 'age': 18} print(dic.values()) # dict_values(['yan', 18]) items() dic = {'name': 'yan', 'age': 18} print(dic.items()) # dict_items([('name', 'yan'), ('age', 18)])
相关练习题fromkeys
dic = dict.fromkeys('abcd','yan') print(dic) # {'a': 'yan', 'b': 'yan', 'c': 'yan', 'd': 'yan'} dic = dict.fromkeys([1, 2, 3],'yan') print(dic) # {1: 'yan', 2: 'yan', 3: 'yan'}
其他操作
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) 结果： ('剑圣', '易') ('哈啥给', '剑豪') ('大宝剑', '盖伦')
分别赋值，也叫拆包
a,b = 1,2 print(a,b) 结果: 1 2 a,b = ('你好','世界') # 这个用专业名词就叫做元组的拆包 print(a,b) 结果: 你好 世界 a,b = ['你好','大飞哥'] print(a,b) 结果: 你好 世界 a,b = {'汪峰':'北京北京','王菲':'天后'} print(a,b) 结果: 汪峰 王菲
循环字典时获取字典的键
for k,v in dic.items(): print('这是键',k) print('这是值',v) 结果: 这是键 剑圣 这是值 易 这是键 哈啥给 这是值 剑豪 这是键 大宝剑 这是值 盖伦
4.1.5字典的嵌套
字典的嵌套是非常重要的知识点，这个必须要建立在熟练使用字典的增删改查的基础上，而且字典的嵌套才是咱们在工作中经常会遇到的字典，工作中遇到的字典不是简简单单一层，而就像是葱头一样，一层接一层，但一般都是很有规律的嵌套，那么接下来我们就学习一下字典的嵌套：
现在有如下字典，完成一下需求：
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就可以获取到汪峰这个值。
name = dic['name'] print(name)
2. 获取这个字典{'name':'国际章','age':38}: 想要获取这个字典，先要看字典从属于谁？这个字典从属于一个列表，而这个列表是字典wife对应的键，所以咱们应该先通过wife获取到对应的这个列表，然后通过这个列表按照所以取值取到对应的这个字典。
l1 = dic['wife'] # 先获取到这个列表 di = l1[0] # 列表按照索引取值，这个字典是列表的第一个元素，所以通过索引获取到这个字典 print(di) # 当然上面是分布获取的，我们还可以合并去写： di = dic['wife'][0] print(di)
3. 获取汪峰的妻子名字: 还是按照上一题的思路：想要获取汪峰妻子的名字：国际章，那么他是一个字典的键对应的值，所以我们通过'name'这个键就可以获取到对应的值，这个题的难点是获取到这个小字典，而上一个题我们已经获取了这个小字典，所以在上面的基础上再执行就可以了。
di = dic['wife'][0] # 这个是上一次题获取的小字典的代码 wife_name= di['name'] # 通过小字典然后再通过键就能获取到对应的值 print(wife_name) # 当然咱们可以简化： wife_name = dic['wife'][0]['name] print(wife_name)
4. 获取汪峰的第三个孩子名字: 汪峰的孩子们是在一个字典中的，你要想获取汪峰的第三个孩子，你应该先获取到它从属于的这个字典，然后再通过这个字典获取第三个孩子的名字
dic2 = dic['children'] # 先获取这个字典 name = dic2['girl_three'] # 在通过这个字典获取第三个孩子的名字 print(name) # 当然你可以简化： name = dic['children']['girl_three'] print(name)
2.7集合set （不重要）
集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
去重，把一个列表变成集合，就自动去重了。
关系测试，测试两组数据之前的交集、差集、并集等关系。
1，集合的创建。
set1 = set({1,2,'yan'}) set2 = {1,2,'yan'} print(set1,set2) # {1, 2, 'yan'} {1, 2, 'yan'}
2，集合的增
set1 = {'one','tow','three','efour','five}
set1.add('six')
print(set1)
#update：迭代着增加
set1.update('A')
print(set1)
set1.update('辉煌')
print(set1)
set1.update([1,2,3])
print(set1)
3，集合的删
set1 = {'one','tow','three','efour','five}
set1.remove('one') # 删除一个元素
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('yan') print(s,type(s)) # frozenset({'y', 'a', 'n'}) <class 'frozenset'>
三 其他（for，enumerate，range）
for循环：用户按照顺序循环可迭代对象的内容
msg = '我是yanhuihuang，今年28岁，' for item in msg: print(item) li = ['小明','小红','小黄','张三','李四'] 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 = ['小明','小红','小黄','张三','李四'] 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：指定范围，生成指定数字
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)
li = ['小明','小红','小黄','张三','李四'] for i in range(len(li)): print(i)