Loading

Python基本数据类型及内置方法（二）

img

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 优先掌握的操作

img

# 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 需要掌握的操作

img

  1. 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方法

  2. pop()

    >>> dic2 = {'k1':'jason', 'k2':'Tony', 'k3':'JY'}
>>> v = dic2.pop('k2')  # 删除指定的key对应的键值对,并返回值
>>> dic2
{'k1': 'jason', 'k3': 'JY'}
>>> v
Tony

  3. popitem()

    >>> dic3 = {'k1':'jason', 'k2':'Tony', 'k3':'JY'}
>>> item = dic3.popitem()  # 删除最后一组键值对,并将删除的键值对放到元组内返回
>>> dic3
{'k1': 'jason', 'k2': 'Tony'}
>>> item
('k3', 'JY')

  4. update()

    # 用新字典更新旧字典，有则修改，无则添加
>>> dic4 = {'k1':'jason', 'k2':'Tony', 'k3':'JY'}
>>> dic4.update({'k1':'JN', 'k4':'xxx'})
>>> dic4
{'k1': 'JN', 'k2': 'Tony', 'k3': 'JY', 'k4': 'xxx'}

  5. fromkeys()

    >>> dic5 = dict.fromkeys(['k1','k2','k3'], [])  # fromkeys()会从中取出每个值当做key，然后与指定类型数据组成key:value放到字典中
>>> dic5
{'k1': [], 'k2': [], 'k3': []}

    关于该方法的有一个需要注意的地方,如下图所示:

    image

  6. 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 作用

元组与列表类似,也是可以存多个任意类型的元素,不同之处在于元组的元素不能修改(索引指向的元素的内存地址不能改变),即元组相当于不可变的列表,用于记录多个固定不允许修改的值,单纯用于取.

img

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 使用

img

>>> 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一样都可以存放多个值，但是集合主要用于：去重，关系运算

img

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 去重

img

集合去重有局限性:

  1. 只能针对不可变类型
  2. 集合本身是无序的,去重之后无法保留原来的顺序

示例如下:

>>> 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的好友们

两个集合的关系如下图所示

img

# 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 其他操作

img

# 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 练习

img

image

7.可变类型与不可变类型

可变数据类型：值发生改变时，内存地址不变，即id不变，证明在改变原值。

不可变数据类型：值发生改变时，内存地址发生改变，即id也变，证明是没有在改变原值，是产生了新值。

  • 数字类型

    >>> x = 10
>>> id(x)
1830448896 
>>> x = 20
>>> id(x)
1830448928
# 内存地址改变了，说明整型是不可变数据类型，浮点型同理也一样

    img

  • 字符串

    >>> x = "Jy"
>>> id(x)
938809263920 
>>> x = "Ricky"
>>> id(x)
938809264088
# 内存地址改变了，说明字符串是不可变数据类型

    img

  • 列表

    >>> list1 = ['tom', 'jack', 'egon']
>>> id(list1)
486316639176
>>> list1[2] = 'kevin'
>>> id(list1)
486316639176
>>> list1.append('lili')
>>> id(list1)
486316639176
# 对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型

    img

  • 元组

    >>> 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)
"""
我们可以发现，虽然元组数据发生改变，但是内存地址没有发生了改变，但是我们不可以以此来判定元组就是可变数据类型。我们回头仔细想想元组的定义就是不可变的。我们修改了元组中列表的值，但是因为列表是可变数据类型，所以虽然在列表中更改了值，但是列表的地址没有改变，列表在元组中的地址的值没有改变，所以也就意味着元组没有发生变化。我们就认为元组是不可变数据类型，因为元组是不可变的。
"""

    img

  • 字典

    >>> dic = {'name':'egon', 'sex':'male', 'age':18}
>>> 
>>> id(dic)
4327423112
>>> dic['age'] = 19
>>> dic
{'age': 19, 'sex': 'male', 'name': 'egon'}
>>> id(dic)
4327423112
# 对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型

    img

8.数据类型总结

img

img

​

posted @ 2021-11-09 17:09  JZEason  阅读(81)  评论(0)  编辑  收藏  举报