python基础——04数据类型（元组，集合，字典）

一、元组(tuple)

1.1 什么是元组

元组和列表相似 ，但元组的元素放在 () 里面。

t = (1,2,3,4,5)
print(type(t))#<class 'tuple'>

t1 = ('hello') #<class 'str'> 这不是元组
t2 = ('hello',)# <class 'tuple'>
print(type(t1),type(t2))

1.2 访问元组

元组的访问，和列表一样可以直接遍历元素，也可以通过索引/下标遍历。

1.2.1 遍历元组

t = (1,2,3,'python',[4,5,6])
for i in t:
    print(i,end = ' ') #1 2 3 python [4, 5, 6]

for i in range(len(t)):
    print(t[i],end = ' ') #1 2 3 python [4, 5, 6]

 1.2.2 元组截取/切片

t = (1,2,3,'python',[4,5,6])
print(t[::-1]) #([4, 5, 6], 'python', 3, 2, 1)
print(t[1:5:2]) #(2, 'python')

1.3 修改元组——元组不支持修改

元组可以包含可变对象——列表，对列表项进行修改。

1.4 删除元组——元组不支持删除对应元素

不可以删除元组元素，可以删除整个元素

1.5 元组的运算

t1 = (11, 2, 13, 4)
t2 = (6, 12, 88, 10)
print(t1+t2)
print(t1*2)
print(len(t1), len(t2))
print(max(t1), min(t2))
print(sum(t1), sum(t2))
print(t1.index(13))
print(t2.count(10))

1.6 关于元组是不可变的——可读不可写

二、集合(set) 

2.1 集合是什么？

集合是一个无序的[没有下标索引的] 不重复的[去重] 序列，所有元素放在 {} 里面，中间以逗号隔开。

有序序列：有下标索引，字符串、列表、元组

无序序列：集合、字典

s = set() #空集合
print(type(s))#<class 'set'>

集合支持集合推导式(Set comprehension)：

eg:

1. 使用推导式，创建一个包含100以内能被3和5整除的数的集合
2. 使用推导式，创建一个集合，元素在'welcome to hqyj'中但不在'hello'中

s = {i for i in range(100) if i%5==0 and i%3==0}
print(s) #{0, 75, 45, 15, 90, 60, 30} 

s2 = {i for i in 'welcom to hqyj' if i not in 'hello'}
print(s2) #{'m', 'q', 'w', 'y', 't', 'j', ' ', 'c'}

1.2 添加元素

1. 将元素 x 添加到集合 set 中，如果元素已存在，则不进行任何操作，语法格式如下：set.add(x)
2. 还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：set.update(x) x 可以有多个，用逗号分开。

s = {1,2,3,4,5}
s.add(6)
print(s) #{1, 2, 3, 4, 5, 6}
s.update((77,88,99))
print(s)#{1, 2, 3, 4, 5, 6, 77, 88, 99}
s.update('hello')
print(s)#{1, 2, 3, 4, 5, 6, 'h', 77, 'o', 88, 99, 'e', 'l'}

1.3 移除元素

1. 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误，语法格式如下：set.remove(x)
2. 移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：set.discard(x)      set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面边第一个元素进行删除。
3. 我们也可以设置随机删除集合中的一个元素，语法格式如下：set.pop() 
4. 我们也可以使用clear()清空集合元素

s = {1,2,3,4,5}
s.remove(1)
print(s)#{2, 3, 4, 5}

s = {1,2,3,4,5}
s.discard(6)
print(s) #{1, 2, 3, 4, 5}找不到也不会报错

s = {1,2,3,4,5}
s.pop()
print(s)#{2, 3, 4, 5}

s = {1,2,3,4,5}
s.clear()
print(s) #set()

1.4 集合的数学运算

a = {1,2,3,4,5,6}
b = {6,7,8,9,0,4}

print("a与b的交集",a & b) #a与b的交集 {4, 6}
print("a与b的并集",a | b) #a与b的并集 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
print("a与b的异或集",a^b) #a与b的异或集 {0, 1, 2, 3, 5, 7, 8, 9}
print("a与b的差集",a-b,b-a) #a与b的差集 {1, 2, 3, 5} {0, 8, 9, 7}

print("a是b的子集吗",a<=b) #a是b的子集吗 False
print("a是b的真子集吗",a<b) #a是b的真子集吗 False

1.5 集合内置方法

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

二、字典(dict)

2.1 字典是什么

数据元素是键值对【键和值用冒号相连】，多个键值对元素放在 {} 里面，中间以 逗号 隔开。

 

注意:

1. 键是唯一的，若有多个，只保留最后一次赋值的结果。
2. 键还必须是不可变数据类型——字符串、数值、元组。

 

2.2 创建字典

my_dict = {"王力宏":99,"周杰伦":88,"林俊杰":77}
#字典里面的key 不能重复 如果重复则前面的值会被后面的覆盖掉

d = dict(zhangshang = 18,lishi = 20,wangwu = 19)
print(d)

d2 = dict([('zhangsan',18),('lisi',19),('wangwu',20)])
print(d2)

name = ['张三','李四','王五']
d4 = dict.fromkeys(name,18)
print(d4)

2.3 访问、遍历字典

字典是无序序列，没有下标索引。但是可以把相应的键放入到方括号中，通过键去访问值，就像我们查字典是一样的，键就是那个‘人字旁’， 通过'人字旁'的索引查到所有的值。

print(my_dict)#{'王力宏': 99, '周杰伦': 88, '林俊杰': 77}
print(my_dict["周杰伦"])#88
print(my_dict["林俊杰"])#77

遍历字典的键、值、键值对

sorce = {
"王力宏":{"语文":77,"数学":66,"英语":33},
"周杰伦":{"语文":88,"数学":86,"英语":55},
"林俊杰":{"语文":99,"数学":96,"英语":66}
}

for i in sorce:
    print(i,end=' ') #王力宏 周杰伦 林俊杰

for i in sorce:
    print(sorce[i])#{'语文': 77, '数学': 66, '英语': 33} {'语文': 88, '数学': 86, '英语': 55} {'语文': 99, '数学': 96, '英语': 66}
print()
for i in sorce.keys():
    print(i,end = ' ')#王力宏 周杰伦 林俊杰

for i in sorce.values():
    print(i) #{'语文': 99, '数学': 96, '英语': 66}

for i in sorce.items():
    print(i,end=' ')#('王力宏', {'语文': 77, '数学': 66, '英语': 33}) ('周杰伦', {'语文': 88, '数学': 86, '英语': 55}) ('林俊杰', {'语文': 99, '数学': 96, '英语': 66})

2.4 修改字典——键存在，就修改；键不存在，就添加在末尾。

通过键的索引，赋值修改值即可。键存在，就修改；键不存在，就添加在末尾。

sorce = {"语文":77,"数学":66,"英语":33}

sorce['语文'] = 88
print(sorce) #{'语文': 88, '数学': 66, '英语': 33}

sorce['python'] = 22
print(sorce) #{'语文': 88, '数学': 66, '英语': 33, 'python': 22}

2.5 删除字典元素

1. pop() 以键做参数
2. popitem() 无参
3. clear() 清空
4. del 删除

sorce = {'python':22,"语文":77,"数学":66,"英语":33}

sorce.pop('python')
print(sorce) #{'语文': 77, '数学': 66, '英语': 33}

sorce = {'python':22,"语文":77,"数学":66,"英语":33}
sorce.popitem()
print(sorce)#{'python': 22, '语文': 77, '数学': 66}

sorce = {'python':22,"语文":77,"数学":66,"英语":33}
sorce.clear()
print(sorce) #{}

sorce = {'python':22,"语文":77,"数学":66,"英语":33}
del sorce
print(sorce)#error

2.6 字典键的特性

1. 不可变
2. 唯一

sorce = {'python':22,"语文":77,"数学":66,"英语":33}

for i in sorce.keys():
    i = 'xxx'
print(sorce)#不会发生改变

sorce = {'python':80,"语文":77,"数学":66,"英语":33,'python':22}
print(sorce) #{'python': 22, '语文': 77, '数学': 66, '英语': 33}

2.7 字典内置函数&方法

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

未完待续……