字典与集合

字典与集合

1. 字典

1.1 字典的定义

定义空字典：

1
members = {}
  • 字典对象定义用 花括号{} ，字典里的每个元素之间用 逗号 ， 隔开；
  • 每个元素都是一个 键值对 ，键和值之间用 冒号 : 隔开；
1
2
3
4
members = {
    'account1'  : 13 ,
    'account2'  : 12
}
  1. 字典的 键 必须是可以进行 哈希值计算 的对象，通常是 数字 或者 字符串 ；
  2. 字典的 值 可以是 任何类型 的对象， 包括 数字、 字符串、 列表、字典、自定义类型 等等。
1
2
3
4
members = {
    'account1'  : {'account':'account1', 'level': 13, 'point':3000} ,
    'account2'  : {'account':'account2', 'level': 12, 'point':36000}
}
  • 字典对象： 根据 键 去查找 值 非常的方便高效
    1
    2
    3
    4
    5
    members = {
        'account1'  : 13 ,
        'account2'  : 12
    }
    print(members['account1'])    # 13
  • 字典对象的 键是唯一的 ，如果出现两个相同的键，后面的元素会替换前面的元素。
    1
    2
    3
    4
    5
    members = {
        'account1'  : 13 ,
        'account1'  : 12
    }
    print(members)		# {'account1': 12}
  • 如果查找的 键 在字典中不存在，则会报错
    1
    2
    3
    4
    5
    members = {
        'account1'  : 13 ,
        'account2'  : 12
    }
    print(members['account99'])		# KeyError: 'account99'

1.2 添加、 修改、 删除

1
var[key] = something

括号里面的 key：

  • 如果在字典中 不存在，就是 添加元素 的的操作，
  • 如果已经 存在 ，就是 重新赋值 操作。 因为字典不允许有相同的 key

1.2.1 添加

1
2
3
4
5
6
7
members = {}

members['account1'] = 13
members['account2'] = 12

结果为：
{'account1': 13 ,'account2': 12}

1.2.2 修改

1
2
3
4
5
6
7
8
9
{
    'account1'  : 13 ,
    'account2'  : 12
}

members['account2'] = 88

结果为：
{'account1': 13 ,'account2'  : 88}

1.2.3 删除

  • pop ：可以返回删除 key 对应的 value 对象

    1
    2
    3
    4
    5
    6
    7
    8
    members = {
        'account1'  : 13 ,
        'account2'  : 12
    }

    val = members.pop('account1')
    print(members)
    print(val)		# 13

  • del

    1
    2
    3
    4
    5
    6
    members = {
        'account1'  : 13 ,
        'account2'  : 12
    }

    del members['account1']

1.3 判断字典是否存在某个 key

  • a in var # 检查 a 是否在 var 中存在，存在返回 True，否则返回 False

  • a not in var # 检查 a 是否不在 var 中，存在返回 False，否则返回 True

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    members = {
        'account1'  : 13 ,
        'account2'  : 12
    }

    if 'account1' in members:
        print('account1 在字典中存在')	# True

    if 'account88' not in members:
        print('account88 不在字典中')	# True

1.4 访问字典的所有元素

items（） 方法：可以返回一个列表对象，每个元素就是键值组成的元组。

1
[('account1', 13), ('account2', 12), ('account3', 15)]

访问所有元素：

1
2
3
4
5
6
7
8
members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

for account, level in members.items():
    print (f'account:{account}, level:{level}')

1.5 得到所有的 key 和 value 对象

1.5.1 keys（） 方法

1
2
3
4
5
6
7
members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

members.keys()		# ['account1', 'account2', 'account3']

1.5.2 values（） 方法

1
2
3
4
5
6
7
members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

members.values()		# [13, 12, 15]

1.6 清空字典

1.6.1 clear（） 方法

1
2
3
4
5
6
7
8
9
members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

members.clear()

print(members)

1.6.2 重新赋值

1
2
3
4
5
6
7
8
9
members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

members = {}

print(members)
  1. clear 方法指向的是 原字典
  2. 重新赋值 指向的是 新字典

1.7 字典合并

update（） 方法：可以合并两个字典得到一个新的字典

当有相同的键时，主字典中的 值 会被替换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

another =  {
    'account4'  : 13 ,
    'account3'  : 12 ,
}

members.update(another)

print(members)		# {'account1': 13, 'account2': 12, 'account3': 12, 'account4': 13}

1.8 得到字典元素的个数

len（） 方法

1
2
3
4
5
6
7
8
members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}


print(len(members)) 	# 3

1.9 字典 与 json 之间转换

1.9.1 字段转换为 json(dumps()方法)

1
2
3
4
import json

data1 = {"aac003": "tom", "tel": "13959687639", }
print(json.dumps(data1))

1.9.2 json 转换为字典(loads()方法)

1
2
3
4
import json

data1 = '{"aac003": "tom", "tel": "13959687639"}'
print(json.loads(data1))

1.9.3 关于 json 中文编码

json.dumps 序列化时对中文默认使用的 ascii 编码

想输出真正的中文需要指定ensure_ascii=False

indent=4 : 表示缩进

1
2
3
4
5
6
>>> import json
>>> print json.dumps('中国')
"\u4e2d\u56fd"
>>> print json.dumps('中国',ensure_ascii=False)
"中国"
>>>

2. 集合

  • python 的 set 和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素

2.1 创建集合

1
2
3
4
set1 = set([123,456,789])
print(set1)

结果: {123, 456, 789}
  • tuple (元组) 使用小括号，list (列表) 使用方括号, dict (字典) 使用的是大括号，
    • dict 也是无序的，只不过 dict 保存的是 key-value 键值对值，
    • 而 set 可以理解为只保存 key 值

2.2 添加元素 add(key)

通过 add(key) 方法可以添加元素到 set 中，可以重复添加，但不会有效果

1
2
3
4
5
6
set1 = set([123,456,789])
print(set1)     # {123, 456, 789}
set1.add(100)
print(set1)     # {123, 456, 789, 100}
set1.add(999)
print(set1)     # {123, 456, 789, 100, 999}

2.3 删除元素 remove(key)

通过 remove(key) 方法可以删除 set 中的元素，如果删除的元素不存在，就会报错

1
2
3
4
set1 = set([123,456,789])
print(set1)     # {123, 456, 789}
set1.remove(123)
print(set1)     # {456, 789}

2.4 set 的运用

set 是一个无序不重复元素集，因此，两个 set 可以做数学意义上的 union(并集), intersection(交集), difference(差集) 等操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
set1=set('hello')
set2=set(['p','y','y','h','o','n'])
print(set1)     # {'h', 'e', 'l', 'o'}
print(set2)     # {'h', 'y', 'n', 'p', 'o'}

# 交集 (求两个 set 集合中相同的元素)
set3=set1 & set2
print(f'\n交集 set3: {set3}')   # {'h', 'o'}

# 并集 （合并两个 set 集合的元素并去除重复的值）
set4=set1 | set2
print(f'\n并集 set4: {set4}')   # {'h', 'e', 'l', 'o', 'y', 'n', 'p'}

# 差集
set5=set1 - set2
set6=set2 - set1
print(f'\n差集 set5: {set5}')   # {'e', 'l'}
print(f'\n差集 set6: {set6}')   # {'y', 'n', 'p'}

# 去除海量列表里重复元素，用 hash 来解决也行，只不过感觉在性能上不是很高，用 set 解决还是很不错的
list1 = [111,222,333,444,111,222,333,444,555,666]
set7=set(list1)
print(f'\n去除列表里重复元素 set7: {set7}')     # {111, 222, 333, 444, 555, 666}