python基础--核心数据类型6

python 的核心数据类型：

• Number 数字（整数，浮点数，复数，布尔型数）
• String 字符串
• List 列表
• Tuple 元组
• Dictionary 字典
• Set 集合

1. 集合 set

集合是可变的容器
集合内的数据对象都是唯一的（不能重复多次）
集合是无序的存储结构，集合中的数据没有先后关系
集合内的元素必须是不可变对象
集合是可迭代对象,可以用for循环来遍历集合
集合是相当于只有键没有值的字典（键则是集合的数据）

• 创建空的集合

print(set(), type(set()))   # 创建一个空的集合对象必须使用 set函数

set() <class 'set'>

• 创建非空集合

set(iterable)   用可迭代对象创建一个新的集合对象

s = set()
print(s)
s = set(range(10))
print(s)
s = {5, 8, 10, 3}
print(s)
s = set("ABCDABCABA")
print(s)
s = set([5, 6, 7, 8])
print(s)
s = set({1:"One", 3:"Three"})
print(s)
s = {1, 2, (3.1, 3.2)}
print(s)

# 以下错误：
s = {1, 2, [3.1, 3.2]}   # 出错，因为列表/字典是可变对象
s = {1, 2, {1:"One"}}

set()
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
{8, 10, 3, 5}
{'C', 'A', 'B', 'D'}
{8, 5, 6, 7}
{1, 3}
{1, 2, (3.1, 3.2)}

2. 集合的运算：（不改变原集合的运算）

交集， 并集， 补集， 子集， 超集

• & 生成两个集合的交集

s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2
print(s3)

{2, 3}

• | 生成两个集合的并集

s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2
print(s3)

{1, 2, 3, 4}

• - 生成两个集合的补集

s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 - s2
print(s3)
# 补集是指，生成s1除去s1和s2的交集

{1}

• ^ 生成两个集合的对称补集

s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2
print(s3)

{1, 4}

• 超集

< 判断一个集合是另一个集合的超集
< 判断一个集合是另一个集合的子集
>=  <= 可以使用，判断子集或相同，超集或相同

s1 = {1, 2, 3}
s2 = {2, 3}
print(s1 > s2)
print(s1 < s2)

True
False

• == / != 判断集合相同或不同

s1 = {1, 2, 3}
s2 = {3, 2, 1}
print(s1 == s2)
print(s1 != s2)

True
False

• in / not in 运算符

等同于前面所学的in运算符，用于判断一个值是否在集合中

3. Python3 中集合常用的方法

S表示集合
S.add(e)      # 在集合中添加一个新元素e，如果元素已经存在，则不添加
S.remove(e)   # 从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError的错误
S.discard(e)  # 从集合中删除一个元素，但不会发生错误
S.clear()     # 清空集合
S.copy()      # 将集合进行一次浅拷贝
S.pop()       # 从集合S中删除一个随机元素，如果此集合为空，则引发KeyError错误
S.update(S2)  # 用S与S2得到的并集更新集合S

练习：任意输入一些英文单词，每次输入一个，当输入零结束，打印输入的单词的个数（去重），打印每个单词到终端，如：

输入:
ABC
abc
ABCD
abc

输出:
3
abc
ABC
ABCD

S = set()

while True:
    s = input("请输入:")
    if s == "0":
        break
    else:
        S.add(s)

print(len(S))
for x in S:
    print(x)

请输入:abc
请输入:ABC
请输入:abc
请输入:ABCD
请输入:0
3
abc
ABC
ABCD

4. 集合推导式：

作用：

用可迭代对象创建集合

语法：

{表达式 for x in 可迭代对象 [if 真值表达式]}
[] 部分可省略

s = {x**x for x in range(1, 10)}
print(s)
# 集合推导式不会生成重复的元素
s = {x for x in "ABCDAAABBBCCD"}
print(s)
# 等同于
s=set("ABCDAAABBBCCD")
print(s)

{256, 1, 46656, 16777216, 4, 387420489, 3125, 823543, 27}
{'B', 'C', 'A', 'D'}
{'B', 'C', 'A', 'D'}

5. 固定集合 frozenset

固定集合是不可变的，无序的，含有唯一元素的集合

可变         不可变
list -----> tuple
set  -----> frozenset

• 作用：

固定集合可以作为字典的键，还可以作为集合的值

• 创建空的固定集合：

frozenset()

frozenset()

• 创建非空的固定集合

frozenset(iterable)

frozenset([1, 3, 5, 7, 9])

frozenset({1, 3, 5, 7, 9})

• 运算：（等同于set中的用法）

&   |   -   ^
<   <=   >   >=   ==   !=
in   not in

• 固定集合的方法：

相当于集合的全部方法去掉修改集合的方法

6. 内置函数(6)

• 能用于字符串，列表，元组, 字典(针对所有的键), 集合, bytes，bytearray：

len(seq)         返回序列的长度
max(seq)         返回序列的最大值元素
min(seq)         返回序列的最小值元素
sum(seq)         返回序列中所有元素的和（元素必须是数值类型）
any(seq)         真值测试，如果序列中，其中一个值为真值则返回True，否则返回False
all(seq)         真值测试，如果序列中所有值为真值则返回Ture
str(obj)         字符串构造（创建）函数，将对象转换为字符串
list(iterable)   用可迭代对象生成一个列表
tuple(iterable)  用可迭代对象生成一个元组
set(iterable)    用可迭代对象生成一个集合
frozenset(iterable)  创建非空的固定集合
sorted(iterable, reverse = False)   排序可排序的对象，返回一个已排序的新列表

• 可用于序列的内建函数

reversed(seq)    返回反向顺序的迭代器对象

同名公众号： 庄AC