python学习基础知识5

8月2号小结

目录

元组

集合

元组

和列表很相似

一、性质

1. 容器符号：()；数据类型：tuple
2. 有序的容器型数据类型。（有下标）
3. 不可变数据类型。（没有增删改）
4. 可以储存任意的数据类型。

二、元组的拼接、重复、比较大小(比较运算)、成员运算和列表一模一样

t1 = tuple()
t2 = (1, 2, 3, (1, 2))
print(t1 + t2)
print(t2 * 2)
# 定义一个三元组
t3 = (30, 10, 55)
# 定义一个四元组
t4 = ('骆昊', 40, True, '四川成都')
# 成员运算
print(100 in t3)    # False
print(40 in t4)     # True
# 拼接
t5 = t3 + t4
print(t5)           # (30, 10, 55, '骆昊', 40, True, '四川成都')

# 切片
print(t5[::3])      # (30, '骆昊', '四川成都')

# 比较运算
print(t3 == t5)    # False
print(t3 >= t5)    # False
print(t3 < (30, 11, 55))    # True

三、循环遍历和字符串一模一样

for i in t2:
    print(i)
for i in range(len(t2)):
    print(t2[i])

四、打包和解包操作

1. 打包操作：python一个变量允许同时被赋予多个值，实际上多个变量会变成元组这个容器赋给变量。

a = 10, 20, 30, 40
print(a)

2. 解包操作：可以将一个容器中的数据拆分给多个变量。

# a.变量数量和容器中数据的个数相同
x_1, x_2, x_3, x_4 = a
print(x_1, x_2, x_3, x_4)

print('*' * 20)
# b.变量数量少于容器中元素的个数;不定长参数
# 注意：一次解包操作只能有一个不定长参数
x, *y = a
print(x, y)
x, *y, z = a
print(x, y, z)

# c.变量的数量比容器中的元素个数多;不定长参数
# 注意：一次解包操作只能有一个不定长参数
*m, n, x = (10, 20)
print(m, n, x)
# *m, n, *x, y = (10, 20)
# print(m, n, x, y)

五、创建元组

# a.创建空元组
t1 = ()
t2 = tuple()
print(t1, t2, type(t1), type(t2))

# b.创建一元组
t3 = (3)
t4 = (3,)
print(t3, t4, type(t3), type(t4))

# c.创建多元组
t5 = (1, 2)
print(t5, type(t5))

六、python中多个变量值交换

a = 20
b = 30
c = 40
a, b = b, a
a, b, c = b, a, c
print(a, b, c)

七、sum、max、min、count、index、sorted和列表一模一样

t6 = (1, 2, 3, 5, 4)
print(sum(t6))
print(max(t6))
print(min(t6))
print(t6.count(1))
print(t6.index(2))
print(sorted(t6))    # [1, 2, 3, 4, 5]

集合

一、性质

1. 容器符号：{}；类型：set
2. 无序的数据类型（没有下标）
3. 可变的数据类型（只有增删，没有改）
4. 集合中只能存放不可变数据类型（数字、字符串、元组等不可变数据类型）

二、创建集合

# a.创建空集合
s1 = set()
print(s1, type(s1))
# b.创建集合
s2 = {10, 10.5, True, False, None, 'abcde', (1, 2, 3)}
print(s2)

三、集合的运算：交、并、差、对称差

a = {1, 3, 5, 7, 9}
b = {1, 2, 3, 4, 5}
# 交集：&
print(a & b)
# 并集：|
print(a | b)
# 差集：-
print(a - b)
print(b - a)
# 对称差：^
print(a ^ b)

四、由一个或多个元素组成的确定的集合。数学中集合的性质：确定性、互异性、无序性

• 确定性：一个元素，只有在或者不在两种可能。
• 互异性：一个集合中不可能出现重复元素。
• 无序性：集合中的元素没有固定位置。

五、列表去重（集合互异性的应用）

list1 = [1, 2, 3, 4, 3, 2, 1]
list2 = list(set(list1))
print(list2)
s3 = {1, 2, 3, 4, 3, 2, 1}
print(s3)
print(set('hello'))

六、对集合遍历

s3 = {1, 2, 3, 4, 3, 2, 1}
for i in s3:
    print(i)

七、成员运算

s3 = {1, 2, 3, 4, 3, 2, 1}
print(3 in s3)

八、集合的增删

增：

• add：向集合中添加元素
• update：从一个容器中将所有的元素添加到集合中

s1 = set()
s1.add(1)
s1.add('abc')
print(s1)
s1.update('hello')
print(s1)

删除：

• discard：删除某个指定的元素，重复删除不报错。
• remove：删除某个指定的元素，重复删除报错。
• pop：删除的集合中当前排第一的元素（但是不能确定到具体的元素）不常用。
• clear：清空集合

s1.discard(1)
s1.discard(1)
s1.remove('abc')
# s1.remove('abc')
print(s1)
print(s1.pop())
s1.clear()
print(s1)

补充：

集合推导式 —> 将列表推导式的[]换成{}

比较运算

两个集合可以用==和!=进行相等性判断，如果两个集合中的元素完全相同，那么==比较的结果就是True，否则就是False。

set1 = {1, 3, 5}
set2 = {1, 2, 3, 4, 5}
set3 = set2
# <运算符表示真子集，<=运算符表示子集
print(set1 < set2, set1 <= set2)    # True True
print(set2 < set3, set2 <= set3)    # False True
# 通过issubset方法也能进行子集判断
print(set1.issubset(set2))      # True

# 反过来可以用issuperset或>运算符进行超集判断
print(set2.issuperset(set1))    # True
print(set2 > set1)              # True

不可变集合

Python中还有一种不可变类型的集合，名字叫frozenset。set跟frozenset的区别就如同list跟tuple的区别，frozenset由于是不可变类型，能够计算出哈希码，因此它可以作为set中的元素。除了不能添加和删除元素，frozenset在其他方面跟set基本是一样的，下面的代码简单展示了frozenset的用法。

set1 = frozenset({1, 3, 5, 7})
set2 = frozenset(range(1, 6))
print(set1 & set2)    # frozenset({1, 3, 5})
print(set1 | set2)    # frozenset({1, 2, 3, 4, 5, 7})
print(set1 - set2)    # frozenset({7})
print(set1 < set2)    # False