Python基础学习Day6

1.字典

Python中的字典是一种可变的容器模型，它可以存储任意类型对象，如字符串、数字等。字典的每个键值对用冒号 : 分割，每对之间用逗号 , 分割，整个字典用花括号 {} 包含。

格式为my_dict={key1：value1，key2:value2,key3:value3}

1.1创建字典

dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

y='money'
x={'name':'karen','age':20,y:200}
print(x)#输出{'name': 'karen', 'age': 20, 'money': 200}

x2=dict({'name':'jack','age':29})
print(x2)#输出{'name':'jack','age':29}

x3={}
print(x3,type(x3))#输出{} <class 'dict'>

x5={(10,20):100}#键值对的键名，可以是任何不可变的数据类型，键值可以是任何类型
print(x5)

x6={(10,20):200,(10,20):90,(10):200,(20):660}#键名会相同会被后面一个覆盖
print(x6)#输出{(10, 20): 90, 10: 200, 20: 660}

1.2字典的访问

把相应的键放入到方括号中re=my_dict[kay*]，如果用字典里没有的键访问数据，会输出错误 。字典的建无论是不是有顺序的数字，都不能切片，只能通过键名取值。

x7={'name':'jack','age':28,'name':'jacke2','money':28}
y=x7['age']#列表填的是下标，字典填的是键名
print(y)

x8={0:100,1:200,2:300,3:400}
print(x8[1])#键名是什么类型就写什么类型，不能字典内键名是数字，访问时填成字符串

1.3修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对。

能删单一的元素也能清空字典，清空只需一项操作

显式删除一个字典用del命令

x9={'x':100,'y':200}
x9['y']=999
print(x9)#输出{'x': 100, 'y': 999}
# re=x9['z']#
# print(re)
x9['z']=1111#字典是存储空间，当没有对应的建值对时，不可以取，但可以新增一对键值对进去
print(x9)#输出{'x': 100, 'y': 999, 'z': 1111}
del x9['x']#把键名为x的键值对删除
print(x9)#输出{'y': 999, 'z': 1111}

x9.clear()#清空字典，留下空字典
print(x9)#输出{}

#x={[10,20]:100}错误，列表不能用于键名
x={100:[10,20]}
print(x)#输出{100: [10, 20]}

1.4常用API

操作字典的函数

序号	函数	描述
1	len(dict)	计算字典元素个数，即键的总数。
2	str(dict)	输出字典，可以打印的字符串表示。
3	type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型。

字典的方法

序号	函数及描述
1	dict.clear()删除字典内所有元素
2	dict.copy()返回一个字典的浅复制
3	dict.fromkeys(seq)创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict如果键在字典dict里返回true，否则返回false
6	dict.items()以列表返回一个视图对象
7	dict.keys()返回一个视图对象
8	dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2)把字典dict2的键/值对更新到dict里
10	dict.values()返回一个视图对象
11	pop(key,default)删除字典 key（键）所对应的值，返回被删除的值。
12	popitem()返回并删除字典中的最后一对键和值。

x={1:20,9:232,'name':'jack',True:123,'vip':False,'books':['book1','book2']}#Turn覆盖了键名为1的键值对
print(x)
print(len(x))
print(type(str(x)),str(x))#未来网络传输时有用
#JSON是一种字符串

x={1:20,9:232,'name':'jack',True:123,'vip':False,'books':['book1','book2']}
x2=x.copy()
x2[1]=9999
print(x)
print(x2)
x2['books'][0]=0
print(x)
print(x2)
x2['books']=[11,22,33]
print(x)
print(x2)

keys={10,20,30}
x=dict.fromkeys(keys)
print(x)

keys=range(10)
x=dict.fromkeys(keys)
print(x)
x[0]=10
print(x)


x={0: 10, 1: None, 2: None, 3: None, 4: None, 5: None, 6: None, 7: None, 8: None, 9: None}
#age=x['age']
age=x.get(0,100)
print(age)
x.setdefault('name','jack')
print(x)
x.setdefault(1,'jack')
print(x)


x={1:200,2:300}
y={3:400,4:500}
z=x.update(y)#有相同键名的话会更新键值上去，没有就直接添加
print(z)
print(x)
#字典没法直接相加
# z=x+y
# print(z,'11111')

x={1:100,2:200,3:300}
k=1
k2=200
re=k in x
re2=k2 in x
print(re,re2)#in语法看的是建在不在字典中，不是看值

x={'name':'karen','age':28,'vip':False}
print(x)
obj=x.keys()
print(obj)
for el in obj:
    print(el)
    print(x[el],'11')#[]内加''代表x内叫el键名的值，不带表示取出所有键值（el取出的）

obj2=x.values()
print(obj2)
for el in obj2:
    print(el)

obj3=x.items()#items（）取出建和值，组成元组
print(obj3)
for el in obj3:
    print(el)
for el in obj3:
    k,v=el
    print(k,v,'ok')
for k,v in obj3:
    print(k,v,'sry')

obj4=x.pop('age')
#obj4=x.pop('age2')#不能删除不存在的键名
print(obj4)
print(x)
obj5=x.popitem()#没有键值对的时候是不能删除的，会报错。
print(x)

2.集合

在数学中，集合是一组没有重复元素的对象的组合。而在Python中，集合（set）也是一种内置的数据结构，它具有以下特点：

1. 无序性：集合中的元素没有顺序。
2. 唯一性：集合内的元素都是唯一的，不允许重复。
3. 可变性：可以添加或删除集合中的元素，但是不能修改单个元素本身（因为元素必须是不可变类型）。

2.1创建集合

可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。**注意：**创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

s1={10,20,30,40}
print(s1)#输出{40, 10, 20, 30}
s2={'hello',2.14,(10,20,30)}#集合中可以保存不可变数据
print(s2)#输出{2.14, 'hello', (10, 20, 30)}
s3={10,20,10}#可以写入多个相同的数值，但只保留最后一个
print(s3)#输出{10, 20}

s4=set({10,20,30})#集合
print(s4)

s5=set([10,20,30])#列表
print(s5)

s6=set((10,20,30))#元组
print(s6)

s7=set([100,200,300,100])#可去除重复数据
print(s7)

2.2修改集合

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

s.add( x ) 添加元素到集合

s.update( x ) 添加元素到集合，且参数可以是列表，元组，字典等 ,x 可以有多个，用逗号分开。

s.remove( x ):将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

s.discard( x ):将元素 x 从集合 s 中移除，如果元素不存在，不会发生错误。

s.pop():对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

len(s):计算集合元素个数。

s.clear():清空集合。

x in s 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

s10={10,20,30}
x=40
# x=[10,20,30]#add不能将列表添加到集合里
s10.add(x)
s10.add('x')
s10.add(40)
print(s10)#{40, 10, 'x', 20, 30}

s11={10,20,30}
s11.update([10,20,30,40])
s11.update(('xi','hello'))
s11.update([400,666],[999])
s11.update([111,22],(0,33))
#s11.update(([123,321],[456,645])) 会把元组里面的元素（列表）添加到集合里，会报错
s11.update((['mmn']))
s11.update({'name':'karem','age':888})#只会添加key，后面的value不添加
print(s11)#输出{0, 33, 'hello', 999, 40, 'mmn', 10, 'age', 111, 400, 'name', 20, 22, 666, 'xi', 30}


s12={1,2,3,4,5}
#s12.remove(7)#不能移除集合中不存在的元素
s12.remove(5)
s12.discard(4)
s12.discard(10)#可以移除不存在的元素，不会报错
print(s12)#输出{1, 2, 3}

s13={11,22,33,44,55,66}
x=s13.pop()
print(x)
print(s13)



s13={11,22,33,44,55,66}
x=s13.pop()
print(x)
print(s13)


s14={1,2,3,4,5,6,7}
print(len(s14))#7
s14.clear()
print(s14)#set()
x=10
re=x in s14
print(re)False

2.3集合API

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素
len()	计算集合元素个数

s14={1,2,3,4,5,6,7}
s15=s14.copy()
print(s15)#深拷贝

s16={1,2,3,4,5}
s17={3,4,5,6,7}
s18={2,3,9,10}
re=s16.difference(s17)
re1=s16.difference(s17,s18)
print(re)
print(re1)
print(s16)

s16.difference_update(s17)
print(s16)#改变原集合，与differenc不同的点在于，后者不改变原集合


s16={1,2,3,4,5}
s17={3,4,5,6,7}
s18={2,3,9,10}
re=s16.intersection(s17)
print(re)

s16={1,2,3,4,5}
s17={3,4,5,6,7}
s18={2,3,9,10}
re1=s16.intersection_update(s17)
print(re1)
print(s16)

s16={1,2,3,4,5}
s17={3,4,5,6,7}
s18={2,3,9,10}
re=s15.union(s17)
print(re)

s16={1,2,3,4,5}
s17={3,4,5,6,7}
re=s16.isdisjoint(s17)
print(re)#两集合不相交返回True，相交返回False

s20={1,2,3,4}
s21={1,2,3,4,5,6}
re=s20.issubset(s21)
print(re)

s22={1,2,3}
s23={2,3,4}
re=s22.symmetric_difference(s23)#两集合并集减去交集
print(re)
re=s22.symmetric_difference_update(s23)#直接修改原集合
print(s22)