Python基本数据类型及内置方法（二）
4.字典类型dict
4.1 定义
# 定义:在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，详见第7小节，通常key应该是str类型，因为str类型会对value有描述性的功能
info = {'name':'tony', 'age':18, 'sex':'male'} # 本质info = dict({....})
# 也可以这么定义字典:
info = dict(name='tony', age=18, sex='male') # info = {'age': 18, 'sex': 'male', 'name': 'tony'}
4.2 类型转换
# 转换1:
>>> info = dict([['name','tony'],('age',18)])
>>> info
{'age': 18, 'name': 'tony'}
# 转换2:fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
>>> {}.fromkeys(('name','age','sex'), None)
{'age': None, 'sex': None, 'name': None}
4.3 使用
4.3.1 优先掌握的操作
# 1、按key存取值：可存可取
# 1.1 取
>>> dic = {
... 'name': 'xxx',
... 'age': 18,
... 'hobbies': ['play game', 'basketball']
... }
>>> dic['name']
xxx
>>> dic['hobbies'][1]
basketball
# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value
>>> dic['gender'] = 'male'
>>> dic
{'name': 'xxx', 'age': 18, 'hobbies': ['play game', 'basketball'], 'gender':'male'}
# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
>>> dic['name'] = 'tony'
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}
# 2、长度len()
>>> len(dic)
3
# 3、成员运算 in 和 not in
>>> 'name' in dic # 判断某个值是否是字典的key
True
# 4、删除
>>> dic.pop('name') # 通过指定字典的key来删除字典的键值对,并返回value
>>> dic
{'age': 18, 'hobbies': ['play game', 'basketball']}
# 5、键keys(), 值values(), 键值对items(): 这三个方法都是迭代器
>>> dic = {'name': 'xxx', 'age': 18, 'hobbies': ['play game', 'basketball']}
# 获取字典所有的key
>>> dic.keys()
dict_keys(['name', 'age', 'hobbies'])
# 获取字典所有的value
>>> dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])
# 获取字典所有的键值对
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
# 6、循环
# 6.1 默认遍历的是字典的key
>>> for key in dic:
... print(key)
...
name
age
hobbies
# 6.2 只遍历key
>>> for key in dic.keys():
... print(key)
...
name
age
hobbies
# 6.3 只遍历value
>>> for key in dic.values():
... print(key)
...
xxx
18
['play game', 'basketball']
# 6.4 遍历key与value
>>> for key in dic.items():
... print(key)
...
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')
>>> for key, val in dic.items():
... print(key, val)
...
name xxx
age 18
hobbies ['play game', 'basketball']
4.3.2 需要掌握的操作
-
get()
>>> dic1 = {'k1':'jason', 'k2':'Tony', 'k3':'JY'} >>> dic1.get('k1') jason # key存在，则获取key对应的value值 >>> res = dic1.get('xxx') # key不存在，不会报错而是默认返回None >>> print(res) None >>> res = dic1.get('xxx',666) # key不存在时，可以设置默认返回的值 >>> print(res) 666 # ps:字典取值建议使用get方法 -
pop()
>>> dic2 = {'k1':'jason', 'k2':'Tony', 'k3':'JY'} >>> v = dic2.pop('k2') # 删除指定的key对应的键值对,并返回值 >>> dic2 {'k1': 'jason', 'k3': 'JY'} >>> v Tony -
popitem()
>>> dic3 = {'k1':'jason', 'k2':'Tony', 'k3':'JY'} >>> item = dic3.popitem() # 删除最后一组键值对,并将删除的键值对放到元组内返回 >>> dic3 {'k1': 'jason', 'k2': 'Tony'} >>> item ('k3', 'JY') -
update()
# 用新字典更新旧字典，有则修改，无则添加 >>> dic4 = {'k1':'jason', 'k2':'Tony', 'k3':'JY'} >>> dic4.update({'k1':'JN', 'k4':'xxx'}) >>> dic4 {'k1': 'JN', 'k2': 'Tony', 'k3': 'JY', 'k4': 'xxx'} -
fromkeys()
>>> dic5 = dict.fromkeys(['k1','k2','k3'], []) # fromkeys()会从中取出每个值当做key，然后与指定类型数据组成key:value放到字典中 >>> dic5 {'k1': [], 'k2': [], 'k3': []}关于该方法的有一个需要注意的地方,如下图所示:
-
setdefault()
# key不存在则新增键值对，并将新增的value返回 >>> dic6 = {'k1':111, 'k2':222} >>> res = dic6.setdefault('k3', 333) >>> res 333 >>> dic6 # 字典中新增了键值对 {'k1': 111, 'k2': 222, 'k3': 333} # key存在则不做任何修改，并返回已存在key对应的value值 >>> dic7 = {'k1':111, 'k2':222} >>> res = dic7.setdefault('k1', 666) >>> res 111 >>> dic7 # 字典不变 {'k1': 111, 'k2': 222}
5.元组类型tuple
5.1 作用
元组与列表类似,也是可以存多个任意类型的元素,不同之处在于元组的元素不能修改(索引指向的元素的内存地址不能改变),即元组相当于不可变的列表,用于记录多个固定不允许修改的值,单纯用于取.
5.2 定义方式
# 在()内用逗号分隔开多个任意类型的值
>>> countries = ("中国", "美国", "英国") # 本质:countries = tuple("中国", "美国", "英国")
# 强调:如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组
>>> countries = ("中国"，) # 本质:countries = tuple("中国")
5.3 类型转换
# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
>>> tuple('wdad') # 结果：('w', 'd', 'a', 'd')
>>> tuple([1, 2, 3]) # 结果：(1, 2, 3)
>>> tuple({"name":"jason", "age":18}) # 结果：('name', 'age')
>>> tuple((1, 2, 3)) # 结果：(1, 2, 3)
>>> tuple({1, 2, 3, 4}) # 结果：(1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中
5.4 使用
>>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)
# 1、按索引取值(正向取+反向取):只能取，不能改否则报错！
>>> tuple1[0]
1
>>> tuple1[-2]
22
>>> tuple1[0] = 'hehe' # 报错：TypeError:
# 2、切片(顾头不顾尾，步长)
>>> tuple1[0:6:2]
(1, 15000.0, 22)
# 3、长度
>>> len(tuple1)
6
# 4、成员运算 in 和 not in
>>> 'hhaha' in tuple1
True
>>> 'hhaha' not in tuple1
False
# 5、循环
>>> for line in tuple1:
... print(line)
1
hhaha
15000.0
11
22
33
"""
容器类型:内部可以存放多个值的数据类型都可以称之为容器类型
建议:所有的容器类型在存储数据的时候,如果内部只有一个元素,建议加上逗号(元组只有一个元素的情况)
"""
6.集合类型set
6.1 作用
集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重，关系运算
6.2 定义
"""
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序
"""
s = {1, 2, 3, 4} # 本质 s = set({1,2,3,4})
# 注意1:列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。
# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在如果想定义一个空字典和空集合，该如何准确去定义两者?
d = {} # 默认是空字典
s = set() # 这才是定义空集合
6.3 类型转换
# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
>>> s = set([1, 2, 3, 4])
>>> s1 = set((1, 2, 3, 4))
>>> s2 = set({'name':'jason',})
>>> s3 = set('egon')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}
6.4 使用
6.4.1 去重
集合去重有局限性:
- 只能针对不可变类型
- 集合本身是无序的,去重之后无法保留原来的顺序
示例如下:
>>> lis = ['a', 'b', 1, 'a', 'a']
>>> s = set(lis)
>>> s # 将列表转成了集合
{'b', 'a', 1}
>>> lis_new = list(s) # 再将集合转回列表
>>> lis_new
['b', 'a', 1] # 去除了重复，但是打乱了顺序
# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
lis2 = [
{'name':'lili', 'age':18, 'sex':'male'},
{'name':'jack', 'age':73, 'sex':'male'},
{'name':'tom', 'age':20, 'sex':'female'},
{'name':'lili', 'age':18, 'sex':'male'},
{'name':'lili', 'age':18, 'sex':'male'},
]
new_lis = []
for dic in lis2:
if dic not in new_lis:
new_lis.append(dic)
print(new_lis)
# 结果：既去除了重复，又保证了顺序，而且是针对可变类型的去重
[
{'age': 18, 'sex': 'male', 'name': 'lili'},
{'age': 73, 'sex': 'male', 'name': 'jack'},
{'age': 20, 'sex': 'female', 'name': 'tom'}
]
6.4.2 关系运算
我们定义两个集合friends1与friends2来分别存放两个人的好友名字,然后以这两个集合为例讲解集合的关系运算.
>>> friends1 = {"zero", "kevin", "jason", "egon"} # 用户1的好友们
>>> friends2 = {"Jy", "ricky", "jason", "egon"} # 用户2的好友们
两个集合的关系如下图所示
# 1.合集/并集(|):求两个用户所有的好友（重复好友只留一个）对应的集合内置方法:union()
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}
# 2.交集(&):求两个用户的共同好友 对应的集合内置方法:intersection()
>>> friends1 & friends2
{'jason', 'egon'}
# 3.差集(-)： 对应的集合内置方法:difference()
>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}
# 4.对称差集(^):求两个用户独有的好友们（即去掉共有的好友）对应的集合内置方法: symmetric_difference()
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}
# 5.值是否相等(==)
>>> friends1 == friends2
False
# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1, 2, 3} > {1, 2}
True
>>> {1, 2, 3} >= {1, 2}
True
# 6.2 不存在包含关系，则返回False
>>> {1, 2, 3} > {1, 3, 4, 5}
False
>>> {1, 2, 3} >= {1, 3, 4, 5}
False
# 7.子集
>>> {1, 2} < {1, 2, 3}
True
>>> {1, 2} <= {1, 2, 3}
True
6.4.3 其他操作
# 1.长度
>>> s = {'a', 'b', 'c'}
>>> len(s)
3
# 2.成员运算
>>> 'c' in s
True
# 3.循环
>>> for item in s:
... print(item)
...
c
a
b
6.5 练习
7.可变类型与不可变类型
可变数据类型：值发生改变时，内存地址不变，即id不变，证明在改变原值。
不可变数据类型：值发生改变时，内存地址发生改变，即id也变，证明是没有在改变原值，是产生了新值。
-
数字类型
>>> x = 10 >>> id(x) 1830448896 >>> x = 20 >>> id(x) 1830448928 # 内存地址改变了，说明整型是不可变数据类型，浮点型同理也一样
-
字符串
>>> x = "Jy" >>> id(x) 938809263920 >>> x = "Ricky" >>> id(x) 938809264088 # 内存地址改变了，说明字符串是不可变数据类型
-
列表
>>> list1 = ['tom', 'jack', 'egon'] >>> id(list1) 486316639176 >>> list1[2] = 'kevin' >>> id(list1) 486316639176 >>> list1.append('lili') >>> id(list1) 486316639176 # 对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型
-
元组
>>> t1 = ("tom", "jack", [1,2]) >>> t1[0] = 'TOM' # 报错：TypeError >>> t1.append('lili') # 报错：TypeError # 元组内的元素无法修改，指的是元组内索引指向的内存地址不能被修改 >>> id(t1[0]),id(t1[1]),id(t1[2]) (4327403152, 4327403072, 4327422472) >>> t1[2][0]=111 # 如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变 >>> t1 ('tom', 'jack', [111, 2]) >>> id(t1[0]),id(t1[1]),id(t1[2]) # 查看id仍然不变 (4327403152, 4327403072, 4327422472) """ 我们可以发现，虽然元组数据发生改变，但是内存地址没有发生了改变，但是我们不可以以此来判定元组就是可变数据类型。我们回头仔细想想元组的定义就是不可变的。我们修改了元组中列表的值，但是因为列表是可变数据类型，所以虽然在列表中更改了值，但是列表的地址没有改变，列表在元组中的地址的值没有改变，所以也就意味着元组没有发生变化。我们就认为元组是不可变数据类型，因为元组是不可变的。 """
-
字典
>>> dic = {'name':'egon', 'sex':'male', 'age':18} >>> >>> id(dic) 4327423112 >>> dic['age'] = 19 >>> dic {'age': 19, 'sex': 'male', 'name': 'egon'} >>> id(dic) 4327423112 # 对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型
8.数据类型总结
浙公网安备 33010602011771号