一.什么是数据类型？
什么是数据类型？
我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种，如下：
整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).
- int。数字：主要用于运算。1 ，2,3…
- bool。判断真假：True, False.
- str。简单少量的储存数据，并进行相应的操作。name = ‘alex’,
- tuple。只读，不能更改。(1,‘alex’)
- 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时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。
十进制小数转换成二进制小数采用"乘2取整，顺序排列"法。具体做法是：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，此时0或1为二进制的最后一位。或者达到所要求的精度为止。
二进制转化成十进制:
要从右到左用二进制的每个数去乘以2的相应次方,小数点后则是从左往右
例如：二进制数1101.01转化成十进制
1101.01（2）=120+021+122+123 +02-1+12-2=1+0+4+8+0+0.25=13.25（10）
所以总结起来通用公式为：
abcd.efg(2)=d20+c21+b22+a23+e2-1+f2-2+g*2-3（10）
或者是：
把二进制数首先写成加权系数展开式，然后按十进制加法规则求和。这种做法称为"按权相加"法。
此时，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()就是帮助你快速的计算整数在内存中占用的二进制码的长度.
1
2
3
|
num = 10
print(num.bit_length()) # 当十进制用二进制表示时，最少使用的位数
# 运行结果: 4
|
2.2布尔值bool。
布尔值就两种：True，False。就是反应条件的正确与否。
真 1 True。
假 0 False。
这里补充一下int str bool 三者数据类型之间的转换。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
# 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….
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。
a = 'ABCDEFGHIJK'
print(a[0])
print(a[3])
print(a[5])
print(a[7])
切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。
1
2
3
4
5
6
|
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、字符串常用方法。
字符串除了可以用切片（步长）之外，还有一些其他的操作方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
#数字符串中的元素出现的个数。
# 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 alex’ 像这样的字符串，我如果通过切片或者其他方法将1 True alex 取出来，他也只能是字符串，但是我想要得到数字的1，布尔值的True，必须还要转化，是不是很麻烦。
所以python给咱们也提供了一类数据类型，他能承载多种数据类型，这类数据类型被称作容器类数据类型可以存储大量的数据。列表就属于容器类的数据类型。
**What:**这个数据类型就是list列表。
列表是python的基础数据类型之一 ,其他编程语言也有类似的数据类型.比如JS中的数 组, java中的数组等等. 它是以[ ]括起来, 每个元素用’ , ‘隔开而且可以存放各种数据类型: 列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类
型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
How：那么这个列表如何使用呢？咱们从这几方面去深入研究这个列表。
2.4.1 列表的创建
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
# 创建一个列表有三种方式：
# 方式一：（常用）
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 列表的索引切片
1
2
3
4
5
6
7
|
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
2
3
4
5
|
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. 增
列表的增
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
# 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. 删
列表的删
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
# 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. 改
列表的改
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
# 按照索引改值
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
2
|
1 a = ["q","w","q","r","t","y"]
2 print(a.count("q"))
|
index（方法用于从列表中找出某个值第一个匹配项的索引位置）
1
2
|
1 a = ["q","w","r","t","y"]
2 print(a.index("r"))
|
sort （方法用于在原位置对列表进行排序）。
reverse （方法将列表中的元素反向存放）。
1
2
3
4
5
|
1 a = [2,1,3,4,5]
2 a.sort()# 他没有返回值，所以只能打印a
3 print(a)
4 a.reverse()#他也没有返回值，所以只能打印a
5 print(a)
|
列表也可以相加与整数相乘
1
2
3
4
|
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]
|
相应练习题
1
2
3
4
5
6
7
8
9
10
|
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 列表的嵌套
1
2
3
4
|
l1 = [1, 2, 'taibai', [1, 'WuSir', 3,]]
1, 将l1中的'taibai'变成大写并放回原处。
2，给小列表[1,'alex',3,]追加一个元素,'老男孩教育'。
3，将列表中的'alex'通过字符串拼接的方式在列表中变成'alexsb'
|
相应练习题
1
2
3
4
|
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
将列表lis中的"tt"变成大写（用两种方式）。
将列表中的数字3变成字符串"100"（用两种方式）。
将列表中的字符串"1"变成数字101（用两种方式）。
|
2.5元组tuple。
Why:对于容器型数据类型list，无论谁都可以对其增删改查，那么有一些重要的数据放在list中是不安全的，所以需要一种容器类的数据类型存放重要的数据，创建之初只能查看而不能增删改，这种数据类型就是元组。
what:这个容器型数据类型就是元组。
元组:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改.
2.5.1 元组的索引切片
1
2
3
4
5
6
7
|
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 元组其他操作方法
因为元组的特性，直接从属于元组的元素不能更改，所以元组只能查看。
1
2
3
4
5
|
# 可以利用for循环查询
tu1 = ('a', 'b', '太白', 3, 666)
for i in tu1:
print(i)
|
index：通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错。
1
2
|
tu = ('太白', [1, 2, 3, ], 'WuSir', '女神')
print(tu.index('太白')) # 0
|
count: 获取某元素在列表中出现的次数
1
2
|
tu = ('太白', '太白', 'WuSir', '吴超')
print(tu.count('太白')) # 2
|
2.5.3 len
1
2
3
4
5
|
tu1 = (1,2,3,4,84,5,2,8,2,11,88,2)
print(len(tu1))
结果:
12
|
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版本之后，字典会按照初建字典时的顺序排列(即第一次插入数据的顺序排序)。
当然，字典也有缺点：他的缺点就是内存消耗巨大。
2.6.2 创建字典的几种方式：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
# 创建字典的几种方式：
# 方式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 验证字典的合法性
1
2
3
4
5
6
7
8
9
10
11
12
13
|
# 合法
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 字典的常用操作方法
增
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
# 通过键值对直接增加
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) # 太白
|
删
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
# 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
|
改
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# 通过键值对直接改
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}
|
查
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
# 通过键查询
# 直接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)])
|
相关练习题
1
2
3
4
5
|
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
请在k3对应的值中追加一个元素 44，输出修改后的字典
请在k3对应的值的第 1 个位置插入个元素 18，输出修改后的字典
|
fromkeys 数据类型
dic = dict.fromkeys('abcd','太白')
print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}
dic = dict.fromkeys([1, 2, 3],'太白')
print(dic) # {1: '太白', 2: '太白', 3: '太白'}
其他操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
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)
结果：
('剑圣', '易')
('哈啥给', '剑豪')
('大宝剑', '盖伦')
|
分别赋值，也叫拆包。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
a,b = 1,2
print(a,b)
结果:
1 2
a,b = ('你好','世界') # 这个用专业名词就叫做元组的拆包
print(a,b)
结果:
你好 世界
a,b = ['你好','大飞哥']
print(a,b)
结果:
你好 大飞哥
a,b = {'汪峰':'北京北京','王菲':'天后'}
print(a,b)
结果:
汪峰 王菲
|
所以利用上面刚学的拆包的概念，我们循环字典时还可以这样获取字典的键，以及值：
4.1.5字典的嵌套
字典的嵌套是非常重要的知识点，这个必须要建立在熟练使用字典的增删改查的基础上，而且字典的嵌套才是咱们在工作中经常会遇到的字典，工作中遇到的字典不是简简单单一层，而就像是葱头一样，一层接一层，但一般都是很有规律的嵌套，那么接下来我们就学习一下字典的嵌套：
现在有如下字典，完成一下需求：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
dic = {
'name':'汪峰',
'age':48,
'wife':[{'name':'国际章','age':38}],
'children':{'girl_first':'小苹果','girl_second':'小怡','girl_three':'顶顶'}
}
1. 获取汪峰的名字。
2.获取这个字典：{'name':'国际章','age':38}。
3. 获取汪峰妻子的名字。
4. 获取汪峰的第三个孩子名字。
|
相关练习题
1
2
3
4
5
6
7
8
9
|
dic1 = {
'name':['alex',2,3,5],
'job':'teacher',
'oldboy':{'alex':['python1','python2',100]}
}
1，将name对应的列表追加⼀个元素’wusir’。
2，将name对应的列表中的alex⾸字⺟⼤写。
3，oldboy对应的字典加⼀个键值对’⽼男孩’,’linux’。
4，将oldboy对应的字典中的alex对应的列表中的python2删除
|
2.7集合set (了解)
集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
去重，把一个列表变成集合，就自动去重了。
关系测试，测试两组数据之前的交集、差集、并集等关系。
1，集合的创建。
1
2
3
|
set1 = set({1,2,'barry'})
set2 = {1,2,'barry'}
print(set1,set2) # {1, 2, 'barry'} {1, 2, 'barry'}
|
2，集合的增。
1
2
3
4
5
6
7
8
9
10
11
|
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，集合的删。
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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）
1
2
3
4
|
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）
1
2
3
|
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）
1
2
3
4
|
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）
1
2
3
4
|
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子集与超集
1
2
3
4
5
6
7
8
|
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不可变集合，让集合变成不可变类型。
1
2
|
s = frozenset('barry')
print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>
|
三.其他（for，enumerate，range）。
for循环：用户按照顺序循环可迭代对象的内容。
1
2
3
4
5
6
7
8
9
10
11
|
msg = '老男孩python是全国范围内最好的python培训机构'
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将其组成一个索引序列，利用它可以同时获得索引和值。
1
2
3
4
5
6
7
|
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：指定范围，生成指定数字。
1
2
3
4
5
6
7
8
|
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)
|
