Python学习记录4-列表、元祖和集合
list列表
- 一组由有序数据组成的序列
- 数据有先后顺序
- 数据可以不是一类数据
- list的创建
- 直接创建，用中括号创建，内容直接用英文逗号隔开
- 使用list创建
- 列表包含单个字符串的时候是一个特例
# 直接赋值创建列表
>>> L1 = [1,2,3,4,5]
# list内的数据可以不是一个类型
>>> L2 = [1,2,3,"China","小明"]
# 创建列表的第二种方式
>>> L3 = list()
>>> print(L1)
>>> print(L2)
>>> print(L3) #L3是一个空的列表
>>> print(type(L3))#内置函数 type() 显示变量的类型b
输出：
[1, 2, 3, 4, 5]
[1, 2, 3, 'China', '小明']
[]
<class 'list'>
---------------------------------------------------------------------------------------------------
# list创建的特例
>>> s = "Ha ha"
#想创建就包含s一个字符串的列表
>>> L1 = list(s)
# 此种情况用 L1 = [s]
>>> print(L1)
>>> print(type(L1))
输出：
['H', 'a', ' ', 'h', 'a']
<class 'list'>
列表的常见操作
- 访问
- 使用下标操作，也叫索引
- 列表的元素索引是从0开始
- 切片操作
- 对列表进行任意一段的截取
- 截取之后，创建一个新的列表
>>> L1 = [22,23,45,65,342,545]
#使用下标访问
>>> print(L1[0])
#如果下标超标 会报错 list index out of range
输出：
22
---------------------------------------------------------------------------------------------------
# 切片操作需要注意取值范围，左包括右不包括
>>> L1 = [1,2,3,4,5,6,7,8,9,10]
>>> print(L1[1:7])
# 下面结果说明切片后生成的是一个全新的列表
# 通过内置函数id可以判断出切片是否生成了全新的列表
# id的作用是用来判断两个变量是否是一个变量
>>> L2 = L1[0:10] #把L1的值全部赋给 L2变量
>>> print(id(L1)) #通过id比较发现内存地址不同
>>> print(id(L2)) #这说明切片后是生成了全新的列表
# 切片下标可以为空
>>> print(L1[:4]) #从开头截取到下标3 因为右不包括 所以取不到下标4
>>> print(L1[2:]) #从下标2开始截取到结尾
>>> print(L1[:]) #从开头到结尾 即全部
输出：
[2, 3, 4, 5, 6, 7]
4543225360
4542443760
[1, 2, 3, 4]
[3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 分片可以控制增长幅度，默认增长幅度为1
>>> print(L1[::1]) # 等于print(L1[:])
>>> print(L1[::2])
输出：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 3, 5, 7, 9]
# 下标可以超出范围，超出后不再考虑多余下标内容
>>> print(L1[:100])
输出：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
---------------------------------------------------------------------------------------------------
# 下标值，增长幅度可以为负数
# 如果下标值为负数，表明顺序是从右往左
# 规定：数组最后一个数字的下标是-1
# 这样子输出的为空，这是因为默认是从左向右移动
>>> print(L1[-2:-5])
# 如果想利用负数下标打印7,8,9 则
>>> print(L1[-2:-5:-1]) #此时虽然打印出来了但是顺序是 9 8 7是反着的
# 调整打印的顺序
>>> print(L1[-5:-2:1]) #此时顺序虽然对了 但是下标不对了 这是由于左包括 右不包括
#最终调整
>>> print(L1[-4:-1:1])
输出：
[]
[9, 8, 7]
[6, 7, 8]
[7, 8, 9]
tuple（元祖）
- 可以理解成一个不允许更改的列表
# tuple的创建
# 1. 直接用小括号创建
>>> ta = ()
>>> print(type(ta))
# 特殊情况：当用小括号创建一个元素的tuple的时候
>>> tb = (100) # 这种情况下 只有一个元素 并不识别这是一个tuple 因为可能是数学中的小括号 所以不识别 这是特例 需要加逗号表示这是一个tuple
>>> print(type(tb))
>>> tc = (100,)
>>> print(type(tc))
# 2.直接用逗号
>>> ta = 100,
>>> print(type(ta))
>>> ta = 100, 200, 300, #多个元素时 后面可以跟 也可以不跟
>>> print(type(ta))
# 3.使用tuple定义
>>> ta = tuple()
>>> print(ta)
>>> li = [1,2,3,"hahah ha"]
>>> tb = tuple(li) # 这种创建方式必须要求tuple的参数是可迭代的 例如一个数字就不行
>>> print(tb)
>>> print(li)
输出：
<class 'tuple'>
<class 'int'>
<class 'tuple'>
<class 'tuple'>
<class 'tuple'>
()
(1, 2, 3, 'hahah ha')
[1, 2, 3, 'hahah ha']
tuple其余特征跟list基本一致
- 有序
- 可以访问不可以被修改
- 元素可以是任意类型
# tuple索引操作
>>> la = ["i","love","China"]
>>> print(la)
>>> ta = tuple(la)
>>> print(ta[2])
输出：
['i', 'love', 'China']
China
# tuple分片操作
>>> print(ta[:])
>>> print(ta[:2])
>>> print(ta[-1::-1])
输出：
('i', 'love', 'China')
('i', 'love')
('China', 'love', 'i')
---------------------------------------------------------------------------------------------------
# 元祖的相加
>>> ta = 100,200,300
>>> tb = ("I","love","China")
>>> tc = ta + tb
>>> print(tc)
输出：
(100, 200, 300, 'I', 'love', 'China')
# tuple 乘法
>>> tc = tb * 2
>>> print(tc)
输出：
('I', 'love', 'China', 'I', 'love', 'China')
---------------------------------------------------------------------------------------------------
# tuple 成员检测
print(tb)
>>> if "China" in tb:
print("在的")
>>> if "I" not in tb:
print("不在")
输出：
('I', 'love', 'China')
在的
# 元祖遍历
>>> for i in tb:
print(i)
输出：
I
love
China
---------------------------------------------------------------------------------------------------
ta = ((10,20,30),("i","love","China"),(100,200,300))
# 嵌套元祖的 访问
# 1. 双层循环访问 每个元素都是一个元祖 再遍历每一个元祖即可取出
>>> for i in ta:
print(i)
for j in i:
print(j)
>>> print("------分割线-------")
# 单层循环 此种方式 i,j,k要跟元祖的元素个数对应
>>> for i,j,k in ta:
print(i,j,k)
输出：
(10, 20, 30)
10
20
30
('i', 'love', 'China')
i
love
China
(100, 200, 300)
100
200
300
------分割线-------
10 20 30
i love China
100 200 300
---------------------------------------------------------------------------------------------------
# 常用元祖函数
>>> ta = (123,232,45,34)
# len：长度
>>> print(len(ta))
# max/min：最大值/ 最小值
>>> print(max(ta))
>>> tb = (1,2,3,"love") #会报错 int和str类型不能比较
>>> print(max(tb))
输出：
4
232
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-29-e86ab84987e6> in <module>
7
8 tb = (1,2,3,"love")
----> 9 print(max(tb))
TypeError: '>' not supported between instances of 'str' and 'int'
# count：对某一元素计数
>>> ta = (1,2,3,34,2,2,2,2)
>>> print(ta.count(2))
#index：某一元素所在的位置
>>> print(ta.index(1))
输出：
5
0
---------------------------------------------------------------------------------------------------
# tuple的特殊用法
>>> a = 100
>>> b = "I hahah"
# 要求对a,b值进行互换
# 此种用法是python的特殊用法 在其他语言中一般是借助一个中间变量
>>> print(a,b)
>>> a,b = b,a
>>> print(a,b)
输出：
100 I hahah
I hahah 100
集合
- 跟数学中集合的概念一致
- 内容无序 + 内容不重复
# 集合的定义
# 1.通过set关键字
>>> sa = set()
>>> print(sa)
>>> print(type(sa))
# 2. 使用list创建
>>> li = [1,2,3,4,45,54,34,1,2]
>>> sb = set(li)
>>> print(sb)
# 3. 使用大括号 注意是大括号 用小括号会报错
>>> sc = {1,2,3,4,45,54,34,1,2,4545,6757,345}
>>> print(sc)
输出：
set()
<class 'set'>
{1, 2, 3, 4, 34, 45, 54}
{1, 2, 3, 4, 34, 4545, 6757, 45, 54, 345}
---------------------------------------------------------------------------------------------------
# in 操作
>>> if 2 in sc:
print(22222)
>>> if 23 in sc:
print(1111)
>>> for i in sc: #通过循环可以看出 set确实是无序的
print(i)
输出：
22222
1
2
3
4
34
4545
6757
45
54
345
---------------------------------------------------------------------------------------------------
# 集合的另一种遍历
>>> sa = {(1,2,3),(4,5,6),("I","love","China")}
>>> for i,j,k in sa:
print(i,j,k)
输出：
I love China
4 5 6
1 2 3
# 集合的生成式
>>> sa = {1,2,3,4,5,6,7,8,9,10}
# 利用sa生成一个sb
>>> sb = {i for i in sa}
>>> print(sb)
>>> sc = {i for i in sa if i % 2 == 0}
>>> print(sc)
# 双重for循环
# 把sa中的每一个元素的平方生成一个新的集合
# 1. 用一个for
>>> sd = {i**2 for i in sa}
>>> print(sd)
# 2.使用 enumerate
>>> for index, every in enumerate(sa):
print (index , every)
# 3.使用 iter() 迭代器
>>> for every in iter(sa):
print (every)
输出：
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
{2, 4, 6, 8, 10}
{64, 1, 4, 36, 100, 9, 16, 49, 81, 25}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 24, 25, 27, 28, 30, 32, 35, 36, 40, 42, 45, 48, 49, 50, 54, 56, 60, 63, 64, 70, 72, 80, 81, 90, 100}
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
1
2
3
4
5
6
7
8
9
10
---------------------------------------------------------------------------------------------------
# 集合的内置函数
# len：长度
>>> print(len(se))
# max/min :最值
# add：向集合中添加元素
>>> sa = {1,2,3,4,5,6,7,3,2,1}
>>> print(sa)
#使用add添加元素打印的结果却是None
>>> print(sa.add(0))
>>> sb = sa
>>> print(sb)
>>> sb.update({8,9,10})
>>> print(sb)
# clear：清空
输出：
42
{1, 2, 3, 4, 5, 6, 7}
None
{0, 1, 2, 3, 4, 5, 6, 7}
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
---------------------------------------------------------------------------------------------------
# 删除操作
# remove 和 discard的区别
>>> sa = {1,2,3,4,5,6,7}
>>> print(sa)
>>> sa.remove(5)
>>> print(sa)
#使用discard和remove都可以删除set当中的元素，
#区别就是remove的元素在set当中没有的话会报错，而discard不会。
#像上面的sa 集合 如果我执行remove(5)两次就会报错 因为第一次已经删除了
#第二次sa集合中已经没有了 而用discard(5) 执行几次都不会报错
输出：
{1, 2, 3, 4, 5, 6, 7}
{1, 2, 3, 4, 6, 7}
# pop弹出集合的一个内容
# 删除的内容是随机的
# 删除的内容没什么规律 随机
>>> sa = {1,2,3,4,5,6,7}
>>> print(sa)
>>> sa.pop()
>>> print(sa)
>>> sa.pop()
>>> print(sa)
>>> sa.pop()
>>> print(sa)
输出：
{1, 2, 3, 4, 5, 6, 7}
{2, 3, 4, 5, 6, 7}
{3, 4, 5, 6, 7}
{4, 5, 6, 7}
---------------------------------------------------------------------------------------------------
# 集合的数学操作
# intersection：交集
>>> sa = {1,2,3,4,5,6}
>>> sb = {4,5,6,7,8,9}
#sa 和 sb的交集
>>> print(sa.intersection(sb))
#difference: 差集
>>> print(sa.difference(sb))
#差集的另一种表示
>>> print(sa - sb)
#union:并集 注意 并集是无法用+计算的
>>> print(sa.union(sb))
输出：
{4, 5, 6}
{1, 2, 3}
{1, 2, 3}
{1, 2, 3, 4, 5, 6, 7, 8, 9}
frozenset冰冻集合
- 不允许修改的集合
# 冰冻集合
>>> print(sa)
>>> sb= frozenset(sa)
>>> print(sb)
输出：
{1, 2, 3, 4, 5, 6}
frozenset({1, 2, 3, 4, 5, 6})
总结
数据结构是重点，以上只是总结了一部分，还需要多加练习和思考，彻底弄懂。
