python学习笔记——组合数据类型

 

组合数据类型¶

 

集合类型 (set)¶

特点¶

• 集合是多个元素的无序组合
• 每个元素唯一，不存在相同元素
• 集合元素不可更改，不能是可变数据类型（如列表类型）

 

生成集合¶

1. 直接使用 '{}' （大括号）定义，不同元素之间用 ',' 隔开
2. 使用 set 函数

In [61]:

# 使用大括号定义集合
a = {'python',('miku','lily')}
# 该集合由一个字符串 和 一个元组组成
print(a)

# 使用set函数定义集合
b = set('miikuu 520')
print(b)

 

{'python', ('miku', 'lily')}
{'k', 'm', ' ', '2', '0', 'u', 'i', '5'}

 

集合操作符¶

• |（并运算）：S|T 集合S和集合T中所有元素
• -（减运算）：S-T 包含集合S中存在但没有T中的元素
• &（交运算）：S&T 在集合S和集合T中均存在的元素
• ^（补运算）：S^T 集合S和集合T中的非相同元素

关系操作符：

• S <= T 或 S < T：返回True/False，判断S和T子集关系
• S >= T 或 S > T：同上

In [62]:

a = {'m','i','k','u','1','2','3'}
b = set('miku520')
#并运算
print(a|b)
#减运算
print(a-b)
#交运算
print(a&b)
#补运算
print(a^b)
#关系操作符
print(a<b)

 

{'k', 'm', '2', '0', 'u', '1', 'i', '3', '5'}
{'1', '3'}
{'k', 'm', '2', 'u', 'i'}
{'0', '1', '5', '3'}
False

 

集合处理方法¶

• S.add(x)：如果x不在集合S中，加入x
• S.discard(x)：移除S中元素x，如果x不在集合中，不报错
• S.remove(x)：移除S中元素x，如果x不在集合中，产生KeyError异常
• S.clear()：清除S中所有元素
• S.pop()：随机删除S的一个元素，并返回该元素，为空产生KeyError异常
• S.copy()：返回集合S的一个副本

 

集合应用场景¶

1. 包含关系比较
2. 数据去重

 

---

 

序列类型¶

特点¶

• 具有先后关系的一组元素
• 元素类型可以不行
• 元素间由序号引导，通过下标访问序列的特定元素
  • 包含 正向递增序号 和 反向递减序号

衍生¶

• 字符串类型
• 元组类型
• 列表类型

 

序列类型通用操作符¶

• in：同字符串
• not in：同字符串
• +：同字符串
• *：同字符串
• s[i]：索引，返回s的第i个元素
• s[i:j:k]：切片，第i个元素到第j个元素以k为步长的元素子序列

In [63]:

# 通过切片使s反向
s1 = [1,2,3,4,5]
print(s1[::-1])

 

[5, 4, 3, 2, 1]

 

序列类型通用函数和方法¶

• len(s)：返回序列的长度
• min(s)：返回序列元素中最小的元素，要求序列元素可比较
• max(s)：返回序列元素中最大的元素，要求序列元素可比较
• s.index(x[,i,j])：表示 元素x 在s中 第i位到第j位 第一次出现的位置下标
• s.count(x)：s中 元素x 的个数

In [64]:

s = [1,2,3,4,5,1,2,3,4,5,0]
# 求序列的长度
print(len(s))
# 求序列中最小的元素
print(min(s))
# 求序列中最大的元素
print(max(s))
# 求 3 第一次出现的下标
print(s.index(3))
# 求 2 在 s 中的个数
print(s.count(2))

 

11
0
5
2
2

 

---

 

元组类型 (tuple)¶

是序列类型的衍生类型，即序列类型的操作符和函数和方法均可使用

特点¶

• 一旦创建就不能被修改

 

创建元组¶

1. 直接使用 '()' （小括号）创建，元素之间用 ','（逗号）隔开
2. 也可不用小括号之间创建，元素之间用 ',' 隔开
3. 使用 tuple() 函数创建

In [65]:

# 使用小括号创建元组
t1 = ('miku', 'lily', 1)
print(t1)
# 不使用小括号直接创建
t2 = 'p','y','1'
print(t2)
# 使用 tuple() 函数创建
t3 = tuple('miku')
print(t3)

 

('miku', 'lily', 1)
('p', 'y', '1')
('m', 'i', 'k', 'u')

 

---

 

列表类型 (list)¶

是序列类型的衍生类型，即序列类型的操作符和函数和方法均可使用

特点¶

• 创建后可以随意修改

 

创建列表¶

1. 直接使用 '[]' （方括号）创建，元素之间用 ',' （逗号）隔开
2. 使用 list() 函数创建

注意¶

当使用 一个列表 = 已有的列表时，指向的是同一个指针

In [66]:

# 使用方括号创建列表
l1 = ['miku','lily',1]
print(l1)
# 使用 list() 函数创建
l2 = list('miku')
print(l2)
# 注意
l3 = list('python')
l4 = l3
l4[0] = '1'
print(l3)
# 可以看到改变 l4 时， l3 也改变了

 

['miku', 'lily', 1]
['m', 'i', 'k', 'u']
['1', 'y', 't', 'h', 'o', 'n']

 

列表类型的函数或方法¶

• del ls[i]：删除ls的第i个元素
• ls.append(x)：在列表ls末尾增加一个元素 x
• ls.clear()：在列表ls中删除所有元素
• ls.copy()：生成一个新列表，赋值ls中的所有元素
• ls.insert(i,x)：在列表ls的第i位增加元素 x
• ls.pop(i)：删除列表ls的第i位元素，并返回该元素的值，默认位末位元素
• ls.remove(x)：将列表ls中出现的第一个元素x删除
• ls.reverse()：将ls中的元素反转

In [67]:

ls1 = list('miku1')
print(ls1)
# 删除 ls1 的最后一个元素
del ls1[len(ls1)-1]
print(ls1)
# 删除 偶位 元素
del ls1[1:len(ls1):2]
print(ls1)
# 在 ls1 的末尾增加一个元素 2
ls1.append('2')
print(ls1)
# 复制 ls1 到 ls2
ls2 = ls1.copy()
print(ls1, ls2)
# 清除 ls2
ls2.clear()
print(ls1, ls2)
# pop
print(ls1.pop(1), ls1)

 

['m', 'i', 'k', 'u', '1']
['m', 'i', 'k', 'u']
['m', 'k']
['m', 'k', '2']
['m', 'k', '2'] ['m', 'k', '2']
['m', 'k', '2'] []
k ['m', '2']

 

列表的排序方法 list.sort()¶

list.sort(cmp=None, key=None, reverse=False)

• cmp：可选参数，如果指定了该参数会是使用该参数的方法进行排序
• key：函数名称，为列表的元素标记权值
• reverse：排序规则，True为从大到小排序，False为从小到大排序

注意¶

• sort() 只改变该表原表的顺序，返回none
• 由于 key 代表函数名称，所以经常结合 lambda 函数使用

In [68]:

ls3 = ["Beijing", "Shanghai", "Xian", "NanJing"]
# 不加参数
ls3.sort()
print(ls3)
# 以 字符串长度排序 (len)
ls3.sort(key=len)
print(ls3)
# 以字符串最后一个字母排序
ls3.sort(key=lambda x:x[-1], reverse=True)
print(ls3)

 

['Beijing', 'NanJing', 'Shanghai', 'Xian']
['Xian', 'Beijing', 'NanJing', 'Shanghai']
['Xian', 'Shanghai', 'Beijing', 'NanJing']

 

---

 

字典数据类型 (dict)¶

key -- value 的对应

字典是 键值对的集合，键值对之间无序

 

创建字典¶

1. 采用'{}' （大括号）创建，键值对之间用':' （冒号）表示
2. 采用 dict() 函数创建，键值对之间用 '=' （等号）表示

In [69]:

# 大括号直接创建字典
dic1 = {'name':'miku', 'age':16}
print(dic1)
# 使用 dict() 函数创建字典
dic2 = dict(name='xiao', age=21)
print(dic2)

# 字典中 value 的获取
print('{}是{}岁'.format(dic1['name'], dic1['age']))

 

{'name': 'miku', 'age': 16}
{'name': 'xiao', 'age': 21}
miku是16岁

 

字典类型的函数和方法¶

• del d[k]：删除字典中 键值k 对应的数据值
• len(d)：字典中键值对的总个数
• d.keys()：返回 d 中所有键的信息
  • 返回 dict_keys 类型，可以 for in 遍历，但无法当作列表操作
• d.values()：返回 d 中所有值的信息
  • 返回 dict_values 类型，可以 for in 遍历，但无法当作列表操作
• d.items()：返回 d 中所有键值对的信息
  • 返回 dict_items 类型，可以 for in 遍历，但无法当作列表操作
• d.get(k,\)：返回 键为 k 的值，若k不存在，则返回 default (未设置即为None)
• d.pop(k,\)：删除 键为 k 的值，并返回该值，若k不存在，则返回 default
• d.popitem()：从字典中随机获取一个键值对
• d.clear()：清空字典

In [70]:

# 新建字典
d = {'name':'miku', 'age':16, 'lover':'me'}
print(d)
# 删除字典中 lover 键
del d['lover']
print(d)
# 输出字典长度
print(len(d))

 

{'name': 'miku', 'age': 16, 'lover': 'me'}
{'name': 'miku', 'age': 16}
2

In [71]:

# 字典中所有键
print(d.keys())
# 字典中所有值
print(d.values())
# 字典中所有键值对 并 遍历
print(d.items())
for i in d.items():
    print(i)

 

dict_keys(['name', 'age'])
dict_values(['miku', 16])
dict_items([('name', 'miku'), ('age', 16)])
('name', 'miku')
('age', 16)

In [72]:

d = {'name':'miku', 'age':16}
# d.get()
print(d.get('name'))
print(d.get('i'))
print(d.get(i,'default'))
# d.pop()
print(d)
print(d.pop('age', '1'), d)

 

miku
None
default
{'name': 'miku', 'age': 16}
16 {'name': 'miku'}