字典的常用操作及is和==的比较

字典的常用操作

字典由key和value组成
```
dict = {}
dict = {'name': "李明"}
```

key必须是可哈希的(不可变）

dict = {}
dict['name'] = 'xiaoxiao'
dict[(1, 'JackMa')] = 'Alibaba'
dict["['houhou']"] = "houhou"
print(dict)
{"['houhou']": 'houhou', (1, 'JackMa'): 'Alibaba', 'name': 'xiaoxiao'}
# 第一个元素的key是一个列表组成的字符串，也是不可变的元素

字典的增删改查

'''增加元素'''
dict  = {}
# 方式一
dict['name'] = "liming"
# 方式二
dict.setdefault('age', 18)
# setdefault(key, value)添加元素
dict.setdefault('age', 19)
# 如果字典中key已经存在，setdefault再设定value将不再继续保存
print(dict)
dict.setdefault('age')
print(dict)
{'age': None}
# 当setdefault方法只给key的时候，value默认为None
--------------------
'''删除元素'''
# 方式一：pop
dict = {'gender': 'male', 'age': 19, 'name': '李明'}
dict.pop()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pop expected at least 1 arguments, got 0
dict.pop('name')
'李明'
print(dict)
{'gender': 'male', 'age': 19}
# pop方式删除和列表中的pop有一个很大的区别，字典中必须把指定的key传入pop中才能找到并删除，否则会报上边的错误。

# 方式二：del
del dict['age']
print(dict)
{'gender': 'male'}

# 方式三：popitem
dict = {'gender': 'male', 'age': 18, 'name': 'lizhen'}
print(dict.popitem())
返回值：('gender', 'male')
# popitem()不传递任何参数，随机删除

# 方式四：clear
dict.clear()
print(dict)
{}
# 清空字典

--------------------
'''修改字典'''
# 方式一：update
dict = {'age': 100, 'name': 'xiaoxiao'}
dict1 = {'gender': 'male', 'age': 150}
print(dict1)
{'gender': 'male', 'age': 150}
dict.update(dict1)
print(dict)
{'gender': 'male', 'age': 150, 'name': 'xiaoxiao'}
dict.update({'level': 'five'})
print(dict)
{'gender': 'male', 'age': 150, 'name': 'xiaoxiao', 'level': 'five'}
# 这种方式是以另外一个字典中的元素来替换掉已有的元素，括号内必须是字典，新字典中不包括的元素，愿字典不做更改，依旧保留，原字典中没有的元素将被添加
# 方式二
dict['age'] = 101
print(dict)
{'gender': 'male', 'age': 101, 'name': 'xiaoxiao', 'level': 'five'}
# 这种方式既可以添加也可以修改某个key的值，setdefault只能添加不存在的key，并不能修改已存在的key的值。

--------------------
'''查询方式'''
# 方式一：方括号
dict['age']
101
# 方式二：get
dict.get('age')
dict.get('course', '')
101
''
# 注意get方式查询的话可以设定两个参数，第一个是key，第二个自定义，如果有值返回值，如果没有返回为第二个参数

# 方式三：setdefault
dict.setdefault('age')
dict.setdefault('age', 1000)
101
101
# 注意： setdefault如果只输入已有的key或者输入key和任意的value，那么将返回对应的value值
# setdefault首先查看是否存在key，如果不存在，添加元素，如果存在返回对应key的value值

字典的其他操作

查询所有的key值，返回的是伪列表, 可以进行迭代循环，注意：在python3中是伪列表不是真正的列表，在python2解释器中是列表类型。

dict.keys()
['gender', 'age', 'name', 'level']
dict = {'k1': 100, 'k2': 1001, 'k3': 200}
print(type(dict.keys()))
print(type(dict.values()))

结果是：

<class 'dict_keys'>
<class 'dict_values'>
for i in keys:
print(dict[i])
male
101
xiaoxiao
five

查询所有的values, 返回的也是伪列表，可以进行迭代循环

values = dict.values()
values
['male', 101, 'xiaoxiao', 'five']

查询key、value值,组成列表, 也可以迭代循环，相当于上边两个的功能的合并

list1 = dict.items()
list1
[('gender', 'male'), ('age', 101), ('name', 'xiaoxiao'), ('level', 'five')]
for key, value in list1:
print(key, value)
('gender', 'male')
('age', 101)
('name', 'xiaoxiao')
('level', 'five')

for i in list1:
key, value = i
print(key, value)
('gender', 'male')
('age', 101)
('name', 'xiaoxiao')
('level', 'five')

items()返回的是由key和value对应的元组组成的列表。注意遍历循环两个方式，方式一直接是遍历key和value，第二种方式是把元组作为一个变量，在把元组中的内容赋值给两个对应的变量，进行输出。key, value = (1, 2)这种方式在python中被称为解构或者解包，即把一个完整的对象中的值分解并赋值给多个变量，解构需要注意的是变量个数必须和元组中的value元组个数一致。列表也可以解构，用法一样，但是字典的解构需要注意的是解构出来的值是字典中的每一个key，并不包含value


* 字典的嵌套

```python
dict = {
	'name': 'xiaoxiao', 
	'gender': 'female', 
	'age': 19,
	'record': {
		'语文': 100,
		'数学': 80
	},
	'hobby': [
		{
			'name': 'fitness',
			'year': 3
		},
		{
			'name': 'football',
			'year': 1		
		}
	]
}
print(dict)
# 结果是：
{'name': 'xiaoxiao', 'gender': 'female', 'age': 19, 'record': {'语文': 100, '数学': 80}, 'hobby': [{'name': 'fitness', 'year': 3}, {'name': 'football', 'year': 1}]}
# 字典中可以嵌套字典、列表，可以进行多层嵌套
print(dict['hobby'][0].get('name'))
# 结果是:fitness

is和==的比较

数字和字符串

'''数字的比较'''
n1 = 1
n2 = 1
id(n1)
140419597884856
id(n2)
140419597884856
print(n1==n2)
print(n1 is n2)
# 结果是： True, True

a = -6
b = -6
id(a)
140419599119512
id(b)
140419599999240
print(a==b)
True
print(a is b)
False
# 值相等，但是内存地址不同
------------------
'''字符串的比较'''
a= 'alexx'
id(a)
4316628048
b = 'alexx'
id(a)
4316628048
print(a=b)
print(a is b)
# 结果是： True, True

str1 = '!12'
str2 = '!12'
id(str1)
4316659304
id(str2)
4316656944
print(str1==str2)
True
print(str1 is str2)
False
# 值相等，但是内存地址不同

str1 = 'sdd'* 21
str1
'sddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsdd'
str2 = 'sdd' * 21
str2
'sddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsddsdd'
id(str1) == id(str2)
False
# 值相等，但是内存不同

列表的比较

list = [1,2,3]
list1 = [1,2,3]
id(list)
4316616680
id(list1)
4316614736
print(list ==list1)
True
print(list is list1)
False
# 值相等，但是不共用一个内存空间

元组的比较

tu1 = (1,2,3)
tu2 = (1,2,3)
id(tu1)
4316412096
id(tu2)
4316277888
print(tu1==tu2)
True
print(tu1 is tu2)
False
# 值相等，但是不共用一个内存空间

字典的比较

dict = {'name': "xiaoxiao"}
dict1 = {'name': 'xiaoxiao'}
id(dict)
4316618832
id(dict1)
4316609064
print(dict==dict1)
True
print(dict is dict1)
False
# 值相等，但是不共用一个内存空间

Note

小数据池：

小数据池是python中专门为字符串和数字设置的存储

数字的小数据池的规则：当数字是-5～256之间的时候，只要值相等时变量共用一个内存地址

字符串的小数据池的规则：如果有特殊字符，那么即使值相等，对应的内存地址也是不一样的, 空格也是特殊字符

字符串单个 * 20以内的字符串值相等内存相同，超过20则内存不同

如果字符串和数字符合上述的规则，那么值和内存地址都是一样的

==是比较变量的值是否相等，is比较的是变量对应的内存地址是否相同

集合的操作

集合是python的基本数据类型，一般不常用，set中的元素是不重复的、无序的，并且必须是可哈希的(int, str, tuple, bool)，可以这样来记：set就是dict类型的数据，但是不保存value，只保存key， set也用{}表示。需要注意的是：set中的元素必须是可哈希的，但是set本身是不可哈希的，即可变的。

set集合具有元素不可重复放入特性，可以用于数据的去重操作

lst = ['liuyang', 'liuyang', 'lili']
print(lst)
['liuyang', 'liuyang', 'lili']
s = set(lst)
print(s)
set(['lili', 'liuyang'])
# 转变成set集合，去掉重复的元素
lst1 = list(s)
print(lst1)
['lili', 'liuyang']
# 再把集合变量转换成列表，即完成去重工作

集合的增删改查

'''添加元素'''
s.add('楷书')
'''迭代更新元素'''
s = {'lil', 'wwf', 'sdfd'}
s.update('麻花腾')
# 结果是:
{'麻', '花', '腾', 'lil', 'wwf', 'sdfd'}
# 即更新的元素被迭代输入，并不影响原来的集合中的元素
'''删除元素'''
s.remove('麻')
# 没有则会报错
'''需改元素'''
s.remove('刘嘉玲')
s.add('赵本山')
# set集合没有索引，也没有key，所以无法通过这些找到元素，如果要修改，必须先删除，在添加
'''查询元素'''
for s in s:
	print(s)
# 结果是： 
s
m
saf
dfsd
# set集合是可迭代对象，所以通过遍历来获取元素

其他操作

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))
# 结果是：
{'李明', '张毅', '张胜', '李爽', '李镇'}
{'李明', '张毅', '张胜', '李爽', '李镇'}
'''子集操作'''
print(s1<s2)
print(s1.issubset(s2))
# 结果是：
False
False
'''超集操作'''
print(s1>s2)
print(s1.issuperset(s2))
# 结果是：
False
False

set本身是不可哈希的，是可以改变的，我们可以通过frozenset()来冻结数据，frozenset()后的数据是可哈希的，可以把新的到的数据作为元素传递给新的set

s = {'name', 'dsfd', 'qr3'}
# 结合中的每一个元素都是可哈希的
s = frozenset(s)
print(s)
frozenset(['dsfd', 'qr3', 'name'])
s1 = {1, s}
print(s)
frozenset(['dsfd', 'qr3', 'name'])
print(s1)
set([1, frozenset(['dsfd', 'qr3', 'name'])])
# frozenset既可以去重，也可以不可哈希的数据/对象变成可哈希的数据/对象

posted @ 2020-01-09 12:28 大道至诚阅读(351) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

大道至诚

字典的常用操作及is和==的比较