元祖

元祖介绍

  • tuple 
1
2
('name1','sansan')
(1,2,3,4)
  • 元祖是一个不可变序列（一般当我们希望数据不改变时，我们使用元祖，其他情况下用列表）
  • 使用（）创建
  • 元祖不是空元祖，至少有一个逗号（，）当元祖不是空元祖时括号可以省略
1
2
3
4
5
6
7
a = 9
b = 9,
c = (9)
d = (9,)
print(type(a),type(b),type(c),type(d))

<class 'int'> <class 'tuple'> <class 'int'> <class 'tuple'>
  • 元祖解包是指将元祖当中的每一个元素都赋值给一个变量
1
2
3
4
a,b,*c=(1,2,3,4)
print(a,b,c)

1 2 [3, 4]

字典

字典基本介绍

  • 属于一种新的数据结构成为映射（mapping）
  • 作用与列表相似，都是储存对象的容器
  • 列表储存数据性能好，但是查询数据性能差，字典正好相反
  • 在字典中每一个value都有唯一的key，可以通过key找到value
  • 字典也称为键值对（key-value）结构
  • 每个字典都可以有多个键值对，每个键值我们称其为一项（item）
  • 创建一个有数据的字典语法key:value}
  • 字典的值可以使任意对象，字典的键可以使任意不可变对象
  • 字典的键不可重复，如果重复的后面的会代替前面
1
a = {"name":"123","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}} #是一个字典
1
2
3
4
a = {'b':'c','d':'e','b':'f'}
print(a)

{'b': 'f', 'd': 'e'}

字典的使用

  • 可以使用dict函数来创建字典，dict函数可以将一个双值子序列转换为字典
  • 双值序列：序列中有两个值[1,2] (‘a’,’b’) ‘ab’
  • 子序列：序列中的元素也是序列 我们称这个元素为子序列[(1,2)]
  • 双值子序列：[(‘a’,’b’),(‘name’,’guojing’)]
1
2
3
4
5
6
z = dict([('a','三三'),('b','不')])
print(z)
print(len(z))

{'a': '三三', 'b': '不'}
2
  • 可以用in 或 not in 判断key是否存在
1
2
3
4
z = dict([('a','三三'),('b','不')])
print('a' in z)

True
  • 可以用dictp[]来取value
1
2
3
4
z = dict([('a','三三'),('b','不')])
print(z['a'])

三三
  • 可以用dict.get(key,default）如果没有这个key返回None不会报错，也可以设定默认值，获取不到key返回默认值
1
2
3
4
5
6
7
8
9
z = dict([('a','三三'),('b','不')])
print(z.get('b'))
print(z.get('hello','没有这个值'))
s = z.get('hello','没有这个值')
print(s)

不
没有这个值
没有这个值

  • 修改以及添加

    • dict[‘key’] = value 可以修改字典，如果没有这个值，则将键值对添加至字典

    1
    2
    3
    4
    5
    z = dict([('a','三三'),('b','不')])
    z['b'] = '不得'
    print[z]

    {'a': '三三', 'b': '不得'}
    1
    2
    3
    4
    5
    z = dict([('a','三三'),('b','不')])
    z['c'] = '得'
    print[z]

    {'a': '三三', 'b': '不', 'c': '得'}

  • dict.setdefault[key,default] 也可以添加键值对，但如果key已经存在，则会返回value

    1
    2
    3
    4
    5
    z = dict([('a','三三'),('b','不'),('c','得')])
    z.setdefault('d','酒')
    print(z)

    {'a': '三三', 'b': '不', 'c': '得', 'd': '酒'}
    1
    2
    3
    4
    5
    6
    7
    8
    z = dict([('a','三三'),('b','不'),('c','得')])
    z.setdefault('d','酒')
    print(z)
    s = z.setdefault('d','酒啊')
    print(s)

    {'a': '三三', 'b': '不', 'c': '得', 'd': '酒'}
    酒
  • dict.update() 可以将其他字典添加至dict
1
2
3
4
5
6
z = dict([('a','三三'),('b','不'),('c','得'),('d','酒')])
x = {'e':'啊'}
z.update(x)
print(z)

{'a': '三三', 'b': '不', 'c': '得', 'd': '酒', 'e': '啊'}

  • 删除

    • del 删除字典中key对应的键值对
    1
    2
    3
    4
    5
    z = dict([('a','三三'),('b','不'),('c','得'),('d','酒'),('e','啊')])
    del z['e']
    print(z)

    {'a': '三三', 'b': '不', 'c': '得', 'd': '酒'}

  • 随机删除 dict.popitem() 一般会删除最后一项

    1
    2
    3
    4
    5
    z = dict([('a','三三'),('b','不'),('c','得'),('d','酒')])
    z.popitem()
    print(z)

    {'a': '三三', 'b': '不', 'c': '得'}

  • 指定删除dict.pop(key,default) 删除key的键值对，若无key则返回default

    1
    2
    3
    4
    5
    6
    7
    z = dict([('a','三三'),('b','不'),('c','得')])
    f = z .pop('f','18')
    print(z)
    print(f)

    {'a': '三三', 'b': '不', 'c': '得'}
    18

    深拷贝与浅拷贝

    浅拷贝

  • 赋值相当于一个引用

    1
    2
    3
    4
    5
    a = {'a':'三三','b':'不'}
    b = a
    print(id(b),id(a))

    2211443731192 2211443731192

  • 浅拷贝以后的对象和原对象相互独立，不影响另一个对象

    1
    2
    3
    4
    5
    a = {'a':'三三','b':'不'}
    b = a.copy()
    print(id(b),id(a))

    1788152343360 1788152343288
    1
    2
    3
    4
    5
    6
    import copy   #使用模块
    a = {'a':'三三','b':'不'}
    b = copy.copy(a)
    print(id(b),id(a))

    2201703181120 2201703181048

  • 深拷贝也会改变地址，拷贝就会改变地址

    1
    2
    3
    4
    5
    6
    import copy
    a = {'a':'三三','b':'不','c':{'d':'酒','e':'啊'}}
    b = copy.deepcopy(a)
    print(id(b),id(a))

    2778718918552 2778718038848
    1
    2
    3
    4
    5
    6
    7
    8
    import copy
    a = {'a':'三三','b':'不','c':{'d':'得','e':'酒'}}
    b = copy.deepcopy(a)
    print(a)
    print(b)

    {'a': '三三', 'b': '不', 'c': {'d': '得', 'e': '酒'}}
    {'a': '三三', 'b': '不', 'c': {'d': '得', 'e': '酒'}}

    改变value做深拷贝，内部id也进行拷贝

    1
    2
    3
    4
    5
    6
    7
    8
    9
    import copy
    a = {'a':'三三','b':'不','c':{'d':'得','e':'酒'}}
    b = copy.deepcopy(a)
    a['c']['e'] = '酒啊'
    print(a)
    print(b)

    {'a': '三三', 'b': '不', 'c': {'d': '得', 'e': '酒啊'}}
    {'a': '三三', 'b': '不', 'c': {'d': '得', 'e': '酒'}}

    改变value做浅拷贝,浅拷贝只能拷贝最外层地址，内层id无法拷贝,相当于赋值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    import copy
    a = {'a':'三三','b':'不','c':{'d':'得','e':'酒'}}
    b = copy.copy(a)
    a['c']['e'] = '酒啊'
    print(a)
    print(b)

    {'a': '三三', 'b': '不', 'c': {'d': '得', 'e': '酒啊'}}
    {'a': '三三', 'b': '不', 'c': {'d': '得', 'e': '酒啊'}}

​

遍历字典

  • keys（）该方法返回字典所有key
1
2
3
4
5
z = dict([('a','三三'),('b','不'),('c','得'),('d','酒'),('e','啊')])
a = z.keys()
print(a)

dict_keys(['a', 'b', 'c', 'd', 'e'])
  • values() 该方法返回一个序列
1
2
3
4
5
z = dict([('a','三三'),('b','不'),('c','得'),('d','酒'),('e','啊')])
b = z.values()
print(b)

dict_values(['三三', '不', '得', '酒', '啊'])
  • items() 返回所有项，它返回一个序列 包括双值子序列
1
2
3
4
5
z = dict([('a','三三'),('b','不'),('c','得'),('d','酒'),('e','啊')])
c = z.items()
print(c)

dict_items([('a', '三三'), ('b', '不'), ('c', '得'), ('d', '酒'), ('e', '啊')])

集合

集合简介

  • 表现形式set集合和列表相似
  • 不同点
    • 集合只能储存不可变对象
    • 集合中储存的对象是无序的
    • 集合不能出现重复元素
  • 使用{}创建集合
  • 可以通过set（）将序列转换成集合
1
2
3
4
5
a = [1,2,3,4]
b =set(a)
print(b)

{1, 2, 3, 4}
  • len()获取元素数量
  • add()添加元素
  • update()将一个集合添加到另一个集合当中
  • pop()随机删除集合中的一个元素 一般为最后一个元素
  • remove() 删除指定元素
  • clear() 清空集合
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
a = {1,2,3,4}
b = {3,4,5,6}
print(len(a))
a.add(5)
print(a)
a.update(b)
print(a)
a.pop()
print(a)
a.remove(2)
print(a)
a.clear()
print(a)

4
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5, 6}
{2, 3, 4, 5, 6}
{3, 4, 5, 6}
set()

集合运算

  • &交集运算
  • |并集运算
  • -差集运算
  • ^异或运算
1
2
3
4
5
6
7
8
9
10
11
a = {1,2,3,4}
b = {3,4,5,6}
print(a&b)
print(a|b)
print(a-b)
print(a^b)

{3, 4}
{1, 2, 3, 4, 5, 6}
{1, 2}
{1, 2, 5, 6}

  • <= 检查一个集合是否是另一个集合的子集

  • < 检查真子集

  • >= 超集

  • >真超集

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    a = {1,2,3,4}
    c = {1,2,3,4}
    d = {1,2,3}
    print(c <= a)
    print(d < a )
    print(c < a )

    True
    True
    False