第三章 数据类型
第三章 数据类型
3.1 整型（int）
3.1.1 整型的长度
py2中有：int/long
py3中有：int（int/long）
3.1.2 整除
py2和py3中整除是不一样的。
3.2 布尔（bool）
布尔值就是用于表示真假。True和False
其他类型转换成布尔值：
- str
- ....
对于：None / ‘’ / 0 .....>false
3.3 字符串（str）
字符串是写代码中最常见的，python内存中的字符串是按照：unicode 编码存储，对于字符串是不可变的。
字符串自己有很多方法，如：
1.大写
v = 'ALEX'
v1 = v.upper()
print(v1)
v2 = v.isupper() # 判断是否全部是大写
print(v2)
2.小写
v = 'ALEX'
v1 = v.lower()
print(v1)
v2 = v.islower() # 判断是否全部是大写
print(v2)
3.判断是否是数字
v = '1'
# v = '二'
# v = '②'
v1 = v.isdigit() # '1'->True; '二' -> False '②'-> True
v2 = v.isdecimal() # '1'->True; '二' -> False '②'-> False
v3 = v.isnumeric() # '1'->True; '二' -> True '②'-> True 能识别的字符最全
print(v1,v2,v3)
##############应用############
v = ['alex','eric','tony']
for i in v:
print(i)
num = input('请输入序号：')
if num.isdecimal():
num = int(num)
print(v[num])
else:
print('你输入的不是字符串')
4.去两侧的空白 \t \n 字符
v1 = ' alex '
print(v1.strip())
v2 = 'alex \t'
print(v2.strip())
v3 = 'alex \n'
print(v3.strip())
v4 = ' aalexa'
print(v4.strip('a'))
5 .替换 replace
6.开头/结尾
7.编码，把字符串转换成二进制
8.format / format_map
v = '我是{0}，谢谢{1}'.format('alex',19)
print(v)
v = '我是{x1}，谢谢{x2}'.format_map({'x1':'alex','x2':19})
print(v)
9.join 连字符
10.split 切割
3.4 列表
3.5 元组
3.6 集合
集合在python中也是一个数据类型,我们只用它自带的特性,其余的操作很少使用
集合在Pyhton中的关键字是set,也是以{}的形式展示 只不过集合是一个没有值得字典,为什么这么说呢??
因为集合中的元素要求是不可变的并且还是唯一的,我们就利用它是唯一来做去重
lst = [1,3,4,112,23,1,3,1,41,12,3,1]
print(set(lst)) # 这样就没有重复的元素出现了,我们在将集合抓换成列表
list(set(lst)) # 这样就把没有重复的集合转成列表了
print(list(set(lst)))
集合是无序,可变的数据类型,说到可变我们就知道集合是能够增加和删除等操作的,我们来看看怎么操作
set集合增删改查
增加
s = {"刘嘉玲", '关之琳', "王祖贤"}
s.add("郑裕玲")
print(s)
s.add("郑裕玲") # 重复的内容不会被添加到set集合中
print(s)
s = {"刘嘉玲", '关之琳', "王祖贤"}
s.update("麻花藤") # 迭代更新
print(s)
s.update(["张曼⽟", "李若彤","李若彤"])
print(s)
删除
s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
item = s.pop() # 随机弹出⼀个.
print(s)
print(item)
s.remove("关之琳") # 直接删除元素
# s.remove("⻢⻁疼") # 不存在这个元素. 删除会报错
print(s)
s.clear() # 清空set集合.需要注意的是set集合如果是空的. 打印出来是set() 因为要和
dict区分的.
print(s) # set()
修改
# set集合中的数据没有索引. 也没有办法去定位⼀个元素. 所以没有办法进⾏直接修改.
# 我们可以采⽤先删除后添加的⽅式来完成修改操作
s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
# 把刘嘉玲改成赵本⼭
s.remove("刘嘉玲")
s.add("赵本⼭")
print(s)
查询
# set是⼀个可迭代对象. 所以可以进⾏for循环
for el in s:
print(el)
常⽤操作
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
# 交集
# 两个集合中的共有元素
print(s1 & s2) # {'⽪⻓⼭'}
print(s1.intersection(s2)) # {'⽪⻓⼭'}
# 并集
print(s1 | s2) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}
print(s1.union(s2)) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}
# 差集
print(s1 - s2) # {'赵四', '刘能'} 得到第⼀个中单独存在的
print(s1.difference(s2)) # {'赵四', '刘能'}
# 反交集
print(s1 ^ s2) # 两个集合中单独存在的数据 {'冯乡⻓', '刘能', '刘科⻓', '赵四'}
print(s1.symmetric_difference(s2)) # {'冯乡⻓', '刘能', '刘科⻓', '赵四'}
s1 = {"刘能", "赵四"}
s2 = {"刘能", "赵四", "⽪⻓⼭"}
# ⼦集
print(s1 < s2) # set1是set2的⼦集吗? True
print(s1.issubset(s2))
# 超集
print(s1 > s2) # set1是set2的超集吗? False
print(s1.issuperset(s2))
set集合本⾝是可以发⽣改变的. 是不可hash的. 我们可以使⽤frozenset来保存数据. frozenset是不可变的. 也就是⼀个可哈希的数据类型
s = frozenset(["赵本⼭", "刘能", "⽪⻓⼭", "长桂"])
dic = {s:'123'} # 可以正常使⽤了
print(dic)
这个不是很常⽤. 了解⼀下就可以了
3.7 字典
列表可以存储大量的数据类型，但是只能按照顺序存储，数据与数据之间关联性不强。
所以咱们需要引入一种容器型的数据类型，解决上面的问题，这就需要dict字典。
字典(dict)是python中唯⼀的⼀个映射类型.他是以{ }括起来的键值对组成.
在dict中key是 唯⼀的.在保存的时候, 根据key来计算出⼀个内存地址. 然后将key-value保存在这个地址中.
这种算法被称为hash算法, 所以, 切记, 在dict中存储的key-value中的key必须是可hash的
可以改变的都是不可哈希的, 那么可哈希就意味着不可变. 这个是为了能准确的计算内存地址⽽规定的.
已知的可哈希(不可变)的数据类型: int, str, tuple, bool 不可哈希(可变)的数据类型: list, dict, set
语法:{'key1':1,'key2':2}
注意: key必须是不可变(可哈希)的. value没有要求.可以保存任意类型的数据
# 合法
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
注意:dict保存的数据不是按照我们添加进去的顺序保存的. 是按照hash表的顺序保存的. ⽽hash表 不是连续的. 所以不能进⾏切片⼯作. 它只能通过key来获取dict中的数据
1.1 字典增删改查
1.1.1 增
dic = {}
dic['name'] = '汪峰'
dic['age'] = 18
print(dic)
结果:
{'name': '汪峰', 'age': 18}
# 如果dict中没有出现这个key,就会将key-value组合添加到这个字典中
# 如果dict中没有出现过这个key-value. 可以通过setdefault设置默认值
s1 = dic.setdefault('王菲')
print(s1)
print(dic)
结果:
None
# 返回的是添加进去的值
{'王菲': None}
# 我们使用setdefault这个方法 里边放的这个内容是我们字典的健,这样我们添加出来的结果
就是值是一个None
dic.setdefault('王菲',歌手)
# 这样就是不会进行添加操作了,因为王菲在dic这个字典中存在
# 总结: 当setdefault中第一个参数存在这个字典中就就不进行添加操作,否则就添加
dic1 = {}
s2 = dic1.setdefault('王菲','歌手')
print(s2)
print(dic1)
结果:
歌手
{'王菲': '歌手'}
1.1.2删
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
s = dic.pop('哈啥给') # pop删除有返回值,返回的是被删的值
print(s)
print(dic) # 打印删除后的字典
dic.popitem() # 随机删除 python3.6是删除最后一个
print(dic)
dic.clear() # 清空
1.1.3改
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
dic['哈啥给'] = '剑姬' # 当哈哈给是字典中的健这样写就是修改对应的值,如果不存在就是添加
print(dic)
dic.update({'key':'v','哈啥给':'剑姬'})
# 当update中的字典里没有dic中键值对就添加到dic字典中,如果有就修改里边的对应的值
print(dic)
1.1.4 查
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
s = dic['大宝剑'] #通过健来查看,如果这个健不在这个字典中.就会报错
print(s)
s1 = dic.get('剑圣') #通过健来查看,如果这个健不在这个字典中.就会返回None
print(s1)
s2 = dic.get('剑姬','没有还查你是不是傻') # 我们可以在get查找的时候自己定义返回的结果
print(s2)
练习
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
请在k3对应的值中追加一个元素 44，输出修改后的字典
请在k3对应的值的第 1 个位置插入个元素 18，输出修改后的字典
1.2 字典其他操作
1.2.1 获取字典所有的键
key_list = dic.keys()
print(key_list)
结果:
dict_keys(['剑圣', '哈啥给', '大宝剑'])
# 一个高仿列表,存放的都是字典中的key
1.2.2 获取字典所有的值
value_list = dic.values()
print(value_list)
结果:
dict_values(['易', '剑豪', '盖伦'])
#一个高仿列表,存放都是字典中的value
1.2.3 获取字典的键值对
key_value_list = dic.items()
print(key_value_list)
结果:
dict_items([('剑圣', '易'), ('哈啥给', '剑豪'), ('大宝剑', '盖伦')])
# 一个高仿列表,存放是多个元祖,元祖中第一个是字典中的键,第二个是字典中的值
练习
循环打印字典的值
循环打印字典的键
循环打印元祖形式的键值对
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
for i in dic:
print(i)
for i in dic.keys():
print(i)
循环打印字典中的键
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
for i in dic:
print(dic[i])
for i in dic.values():
print(i)
循环打印字典中的值和值
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
for i in dic.items():
print(i)
循环打印元祖形式的键值对
1.3 解构
a,b = 1,2
print(a,b)
结果:
1 2
a,b = ('你好','世界')
print(a,b)
结果:
你好 世界
a,b = ['你好','大飞哥']
print(a,b)
结果:
你好 世界
a,b = {'汪峰':'北京北京','王菲':'天后'}
print(a,b)
结果:
汪峰 王菲
解构可以将内容分别赋值到变量当中,我们使用解构就能够快速的将值使用
1.3.1 循环字典获取键和值
for k,v in dic.items():
print('这是键',k)
print('这是值',v)
结果:
这是键 剑圣
这是值 易
这是键 哈啥给
这是值 剑豪
这是键 大宝剑
这是值 盖伦
1.4 字典的嵌套
dic = {
'name':'汪峰',
'age':48,
'wife':[{'name':'国际章','age':38}],
'children':['第一个熊孩子','第二个熊孩子']
}
获取汪峰的妻子名字
d1 = dic['wife'][0]['name']
print(d1)
获取汪峰的孩子们
d2 = dic['children']
print(d2)
获取汪峰的第一个孩子
d3 = dic['children'][0]
print(d3)
练习
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删除
深浅拷贝
往往到了深浅拷贝的时候,就是大家最容易蒙的地方,这个比较重要为什么这么说呢,因为面试的时候必问
都认真听,争取一遍就过,一般面试的时候都结合着赋值一起问
我们先说赋值,赋值就是一个容器有多个标签
lst = [1,2,3,[6,7,8]]
我们在程序这样写,当成程序执行完这两行的时候,内容空间发生的变化就是下图:
一个列表用两个标签,通过标签lst 找到的和标签lst1找到的是同一个,图中的那些一长串数字就是内存地址,Python中是通过内存地址来查看值
lst1 = lst
lst[-1].append(9)
我们通过lst这个标签找到这个列表然后添加一个9,再通过lst1找到这个列表也就多了一个9 因为lst和lst1都是贴在一个地方
我们再来说说浅拷贝,浅拷贝就是只拷贝第一层的元素
看例子:
lst = [1,2,3,[6,7,8]]
# lst2 = lst[:] # 浅拷贝
lst2 = lst.copy()
图中橙色的是新开辟的空间,浅蓝色的是数字类型,红色的列表类型
这样就是浅拷贝,浅拷贝只把原列表中记录的内存地址拿到一个新开辟的列表中
lst = [1,2,3,[6,7,8]]
lst2 = lst[:]
lst.append(9)
为什么lst1中没有添加,是因为咱们先进行的浅拷贝,浅拷贝把原列表中有的内存地址复制了一份放到新开辟的空间中,后期对原列表添加的内容新列表是不会有的,再看看下边的例子
lst = [1,2,3,[6,7,8]]
lst2 = lst.copy()
lst[1] = "22"
我们修改成字符串"22" 就是在列表中将以前的内存地址更换成新开辟的空间地址
lst = [1,2,3,[6,7,8]]
lst1 = lst.copy()
lst[-1].append(9)
因为我们对里边的列表进行修改,列表本身就是可变的数据类型,我们通过原列表修改最里层的小列表,小列表进行变化,新开辟的列表里存放就是小列表中的内存地址.在去查看的时候就有变动
我们接下来,来看看深拷贝是怎样的操作
import copy
lst = [1,2,3,[6,7,8,9]]
lst2 = copy.deepcopy(lst)
我们通过上图可以发现浅拷贝和深拷贝在最后列表的位置内存地址不一样,深拷贝是自己单独开辟了一个新的空间,我们现在修改原列表和新开辟的列表没有任何影响.
通过上面的各种测试,总结以下规律:
- 赋值:
- 两个或多个变量名指向同一个内存地址,有一个操作内存地址的值进行改变,其余的变量名在查看的时候都进行更改
- 浅拷贝:
- 只拷贝列表中第一层的内存地址,原列表修改了不可变数据类型,新开辟的列表不进行变动,因为只是在原列表中将内存地址进行修改了,新开辟的列表中的内存地址还是用的之前的内存地址
- 原列表对可变数据类型进行了添加,新开辟的列表中存放就是可变数据类型的地址,在去查看的时候就发现进行更改了
- 深拷贝:
- 不管你修改原数据的不可变类型还是可变类型,新开辟的空间中都不会进行改变,因为可变数据类型新开辟了一个空间
3.8 公共功能
- 求长度 len()
- 索引 [number]
- 切片 [number,nuimber]
- 步长 [number,nuimber,number]
- for循环
浙公网安备 33010602011771号