Python基础Day4

一、字典

字典也是一种数据的集合，由键值对组成的数据集合，字典中的键不能重复

字典中的键必须是不可变的数据类型，常用的键主要是：字符串，整型。。。

1.字典的定义和创建

• 字典可以通过将以逗号分隔的 键: 值 对列表包含于花括号之内来创建字典
• 也可以通过 dict 构造器来创建

{'jack': 4098, 'sjoerd': 4127} 或 {4098: 'jack', 4127: 'sjoerd'}

（1）创建可以通过{}、dict(key=value,key=value) 来创建字典对象。

>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> b = dict(name='gaoqi',age=18,job='programmer') 
>>> a = dict([("name","gaoqi"),("age",18)]) >
>>> c = {} #空的字典对象 
>>> d=  dict() #空的字典对象

（2）通过 zip()创建字典对象

>>> k = ['name','age','job'] 
>>> v = ['gaoqi',18,'techer'] 
>>> d = dict(zip(k,v)) 
>>> d {'name': 'gaoqi', 'age': 18, 'job': 'techer'}

（3）据类型的转换 dict(二级容器类型) 列表或元组，并且是二级容易才可以转换

vardict = dict([['a',1],['b',2],['c',3]])  # {'a': 1, 'b': 2, 'c': 3}

（4）zip压缩函数，dict转类型

var1 = [1,2,3,4]
var2 = ['a','b','c','d']

** 转换的原理和上面的第三种 是一个原理**
vardict = dict(zip(var1,var2))  # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
print(vardict)

（5）通过 fromkeys 创建值为空的字典

>>> a = dict.fromkeys(['name','age','job']) 
>>> a {'name': None, 'age': None, 'job': None}

2.字典的操作

var1 = {'a': 1, 'b': 2, 'c': 3}
var2 = {1: 'a', 2: 'b', 3: 'c', 4: 'd'}

# res = var1 +  var2 # XXXX  TypeError
# res = var1 * 3 # xxxx TypeError

(1)获取元素–[键] 获得“值”；get()方法获得“值”

>>> a.get('name') 
'gaoqi' 
>>> a.get('sex') 
>>> a.get('sex','一个男人') 
'一个男人'

(2)修改元素

 var1['a'] = 111

(3)删除元素

del var1['a']

(4)添加元素

var1['aa'] = 'AA'

**如果字典中的key重复了，会被覆盖**
# var1['aa'] = 'aa'

3.成员检测和获取

（1）成员检测和获取 ,只能检测key，不能检测value

res = 'AA' in var1
res = 'AA' not in var1

（2）获取当前字典的长度 只能检测当前又多少个键值对-len

res = len(var1)

（3） 获取当前字典中的所有 key 键

res = var1.keys()

（4）获取字典中所有的 value 值

res = var1.values()

（5）获取当前字典中所有 键值对

res = var1.items()

4.字典的遍历

（1）在遍历当前的字典时，只能获取当前的key

for i in var1:
    print(i) # 只能获取 key
    print(var1[i]) # 通过字典的key获取对应value

（2）遍历字典时，使用 items() 函数，可以在遍历中获取key和value

for k,v in var1.items():
    print(k)  # 遍历时的 key
    print(v)  # 遍历时的 value

print('===='*20)
# (3) 遍历字典的所有key
for k in var1.keys():
    print(k)

print('===='*20)
# (4) 遍历字典的所有 value
for v in var1.values():
    print(v)

5.字典的相关函数

（1）len(字典) #获取字典的键值对个数

（2）dict.keys() 获取当前字典的所有key 键，组成的列表

（3）dict.values() # 获取当前字典的所有 value 值，组成的列表

（4）dict.items() # 返回由字典项 ((键, 值) 对) 组成的一个新视图

（5）iter(d) 返回以字典的键为元素的迭代器。

vardict = {'a':1,'b':2,'c':3}

（6）dict.pop(key) # 通过 key 从当前字典中弹出键值对删除

res = vardict.pop('a')

（7）dict.popitem() LIFO: Last in, First out.后进先出

res = vardict.popitem() # 把最后加入到字典中的键值对删除并返回一个元组

（8）使用key获取字典中不存在元素，会报错

print(vardict['aa'])

（9）可以使用get获取一个元素，存在则返回，不存在默认返回None

res = vardict.get('aa')
res = vardict.get('aa','abc')

（10）dict.update(),更新字典,如果key存在，则更新，对应的key不存在则添加

vardict.update(a=11,b=22)
vardict.update({'c':33,'d':44})
dict.setdefault(key[,default])

（11）如果字典存在键 key ，返回它的值。

如果不存在，插入值为 default 的键 key ，并返回 default 。
default 默认为 None。

res = vardict.setdefault('aa','123')
print(res)
print(vardict)

6.字典推导式

# 把字典中的键值对位置进行交换 {'a':1,'b':2,'c':3}
vardict = {'a':1,'b':2,'c':3}

# 普通方法实现 字典中的键值交换  {1: 'a', 2: 'b', 3: 'c'}
newdict = {}
for k,v in vardict.items():
    newdict[v] = k
# print(newdict)

# 使用字典推导式完成  {1: 'a', 2: 'b', 3: 'c'}
newdict = {v:k for k,v in vardict.items()}
# print(newdict)

# 注意：以下推导式，返回的结果是一个集合，集合推导式
# newdict = {v for k,v in vardict.items()}
# print(newdict,type(newdict))


# 把以下字典中的是偶数的值，保留下来，并且交换键值对的位置
vardict = {'a':1,'b':2,'c':3,'d':4}

# 普通方式完成  {2: 'b', 4: 'd'}
# newdict = {}
# for k,v in vardict.items():
#     if v % 2 == 0:
#         newdict[v] = k
# print(newdict)

# 字典推导式完成  {2: 'b', 4: 'd'}
newdict = {v:k for k,v in vardict.items() if v % 2 == 0}
# print(newdict)

二、集合

1.定义

集合是无序可变，元素不能重复。
实际上，集合底层是字典实现，集合的所有元素都是字典 中的“键对象”，因此是不能重复的且唯一的。

2.创建和删除

（1）使用{}创建，并用add（）添加

>>> a = {3,5,7}
>>> a {3, 5, 7} 
>>> a.add(9) 
>>> a {9, 3, 5, 7}

（2）使用 set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保 留一个。

>>> a = ['a','b','c','b'] 
>>> b = set(a) 
>>> b {'b', 'a', 'c'}

（3）remove()删除指定元素；clear()清空整个集合

>>> a = {10,20,30,40,50}
 >>> a.remove(20) 
 >>> a {10, 50, 30}

3.集合相关操作

（1）并集

（2）交集

（3）差集

>>> a = {1,3,'sxt'} 
>>> b = {'he','it','sxt'} 
>>> a|b #并集 {1, 3, 'sxt', 'he', 'it'} 
>>> a&b #交集 {'sxt'} 
>>> a-b #差集 {1, 3} 
>>> a.union(b) #并集 {1, 3, 'sxt', 'he', 'it'} 
>>> a.intersection(b) #交集 {'sxt'} 
>>> a.difference(b) #差集 {1, 3}