组合数据类型

一、本章目标

        1、了解序列和索引的相关概念

        2、了解序列的相关操作

        3、了解列表的相关操作

        4、了解元组的相关操作

        5、了解字典的相关操作

        6、了解集合的相关操作

二、序列与索引

       1、 序列是一个用于存储多个值的连续空间，每个值都对应一个整数的编号，称为索引

        例：使用索引检索字符串中的元素

# 正向递增
s='helloworld'
for i in range(0,len(s)):
    print(i,s[i],end='\t\t')
print('\n--------------------')

# 反向递减
for i in range(-10,0):
    print(i,s[i],end='\t\t')

        2、切片的语法结构

        例：序列的切片操作

s='HelloWorld'
# 切片操作
s1=s[0:5:2] # 索引从0开始，到5结束（不包含5），步长为2
print(s1)
print(s[:5:1]) # 省略了开始位置，start默认从0开始
print(s[:5:]) # 省略开始位置start，省略步长step
print(s[0::1]) # 省略结束位置，stop默认到序列的最后一个元素（包括最后一个元素）

print(s[5::])
print(s[5:]) # 与print(s[5::])功能相同，省略了结束，省略了步长

print(s[0:5:2]) # 索引从0开始，到5结束（不包含5），步长为2

print(s[::2]) # 省略开始位置，省略结束位置，只写步长，分别获取0,2,4,6,8索引位置上的元素

# 步长为负数
print(s[::-1]) # 可以使用哪句代码替换呢
print(s[-1:-11:-1]) # 与print(s[::-1])功能相同

        例：序列的相加和相乘操作

s='Hello'
s1='World'
print(s+s1) # 产生一个新的字符串序列

# 序列的相乘操作
print(s*5)
print('-'*40)

操作符/函数	描述说明
x in s	如果x是s的元素，结果为True，否则结果为False
x not in s	如果x不是s的元素，结果为True，否则结果为False
len(s)	序列s中元素的个数（即序列的长度)
max(s)	序列s中元素的最大值
min(s)	序列s中元素的最小值
s.index(x)	序列s中第一次出现元素x的位置
s.count(x)	序列s中出现x的总次数

        例：序列的相关操作符和函数的使用

s='helloworld'
print('e在helloworld中存在吗？',('e'in s)) # in的使用
print('v在helloworld中存在吗？',('v'in s))

# not in 的使用
print('e在helloworld中不存在吗？',('e'not in s)) # not in的使用
print('v在helloworld中不存在吗？',('v'not in s))

# 内置函数的使用
print('len():',len(s))
print('max():',max(s))
print('min():',min(s))

# 序列对象的方法，使用序列的名称，打点调用
print('s.index():',s.index('o')) # o在s中第一次出现的索引位置 4 
# print('s.index():',s.index('v')) # ValueError: substring not found ,报错的原因是v在字符串中根本不存在，不存在所以找不到
print('s.count():',s.count('o')) # 统计o在字符串s中出现的次数

三、列表

        是指一系列的按照特定顺序排列的元素组成

        是Python中内置的可变序列

        在Python中使用[]定义列表，元素与元素之间使用英文的逗号分隔

        列表中的元素可以是任意的数据类型

        1、列表的创建与删除定义

        例：列表的创建与删除

# 直接使用[]创建列表
lst=['hello','world',98,100.5]
print(lst)

# 可以使用内置的函数list创建列表
lst1=list('helloworld')
lst2=list(range(1,10,2)) # 从1开始到10结束，步长为2，不包含10
print(lst1)
print(lst2)

# 列表是序列中的一种，对序列的操作符，运算符，函数均可以使用
print(lst+lst1+lst2) # 序列中的相加操作
print(lst*3) # 序列的相乘操作
print(len(lst))
print(max(lst2))
print(min(lst2))

print(lst1.count('o')) # 统计o的个数
print(lst1.index('o')) # o在列表lst1中第一次出现的位置

# 列表的删除操作

lst3=[10,20,30]
print(lst3)
del lst3
print(lst3) # NameError: name 'lst3' is not defined. Did you mean: 'lst'?

        2、列表的遍历

        例：列表的遍历操作

lst=['hello','world','python','php']
# 使用遍历循环for遍历列表元素
for item in lst:
    print(item)

# 使用for循环，range()函数，len()函数，根据索引进行遍历
for i in range(0,len(lst)):
    print(i,'-->',lst[i])

# 第三种遍历方式enumerate()函数
for index,item in enumerate(lst):
    print(index,item) #index是序号，不是索引

# 手动修改序号的起始值
for index,item in enumerate(lst,start=1):
    print(index,item)

for index,item in enumerate(lst,1): #省略start不写，直接写起始值
    print(index,item)

        3、列表的相关操作方法 ​​

        例：列表的相关操作

lst=['hello','world','python']
print('原列表：',lst,id(lst))
# 增加元素的操作
lst.append('sql')
print('增加元素之后：',lst,id(lst))

# 使用insert(index,x)在指定的index位置上插入元素x
lst.insert(1,100)
print(lst)

# 列表元素的删除操作
lst.remove('world')
print('删除元素之后的列表：',lst,id(lst))

# 使用pop(index)根据索引将元素取出，然后再删除
print(lst.pop(1))
print(lst)

# 清除列表中所有的元素clear()
# lst.clear()
# print(lst)

# 列表的反向
lst.reverse() # 不会产生新的列表，在原列表的基础上进行的
print(lst)

# 列表元素的修改操作
# 根据索引进行修改元素
lst[1]='mysql'
print(lst)

        4、列表有两种排序方式

        例：列表的排序-sort

lst=[4,56,3,78,40,56,89]
print('原列表：',lst)

# 排序，默认是排序
lst.sort() # 排序是在原列表的基础上进行的，不会产生新的列表对象
print('升序:',lst)

# 排序，降序
lst.sort(reverse=True)
print('降序:',lst)

print('---------------------------')
lst2=['banana','apple','Cat','Orange']
print('原列表:',lst2)
# 升序排列，先排大写，再排小写
lst2.sort()
print('升序:',lst2)

# 降序，先排小写，后排大写
lst2.sort(reverse=True)
print('降序:',lst2)

# 忽略大小写进行比较
lst2.sort(key=str.lower)
print(lst2)

        例：列表的排序-sorted

lst=[4,56,3,78,40,56,89]
print('原列表：',lst)
# 排序
asc_lst=sorted(lst)
print('升序:',asc_lst)
print('原列表:',lst)

# 降序
desc_lst=sorted(lst,reverse=True)
print('降序:',desc_lst)
print('原序列：',lst)

lst2=['banana','apple','Cat','Orange']
print('原序列:',lst2)

# 忽略大小写进行排序
new_lst2=sorted(lst2,key=str.lower)
print('原序列:',lst2)
print('排序后的列表：',new_lst2)

        5、列表生成式

        例：列表生产式的使用

import random
lst=[item for item in range(1,11)]
print(lst)

lst=[item*item for item in range(1,11)]
print(lst)

lst=[random.randint(1,100) for item in range(10)]
print(lst)

# 从列表中选择符合条件的元素组成新的列表
lst=[i for i in range(10) if i%2==0]
print(lst)

        6、二维列表

        例：二维列表的遍历与列表生产式

# 创建二维列表
lst=[
    ['城市','环比','同比'],
    ['北京',102,103],
    ['上海',104,504],
    ['深圳',100,39]
]
print(lst)

# 遍历二维列表使用双层for循环
for row in lst: # 行
    for item in row: # 列
        print(item,end='\t')
    print() # 换行


# 列表生成式生成一个4行5列的二维列表
lst2=[ [j for j in range(5)] for i in range(1,5)]
print(lst2)

四、元组

        是Pyton中内置的不可变序列

        在Python中使用（）定义元组，元素与元素之间使用英文逗号分隔

        元组中只有一个元素的时候，逗号也不能省略

1、元组的创建与删除

        (1)使用（）直接创建

        语法结构如下：

        元组名=（element1,element2,......,elementN)

        (2)使用内置函数tuple()创建元组

        语法结构如下：

        元组名=tuple(序列)

       (3)删除元组

        语法结构如下：

        del  元组名

        例：元组的创建与删除

# 使用小括号创建元组
t=('hello',[10,20,30],'python','world')
print(t)

# 使用内置函数tuple创建元组
t=tuple('helloworld')
print(t)

t=tuple([10,20,30])
print(t)

print('10在元组中是否存在：',(10 in t))
print('10在元组是不存在：',(10 not in t))
print('最大值：',max(t))
print('最小值：',min(t))
print('len:',len(t))
print('t.index:',t.index(10))
print('t.count:',t.count(10))

# 如果元组中只有一个元素 10 <class 'int'>
y=(10)
print(y,type(y))

# 如果元组中只有一个元素，逗号不能省略 (10,) <class 'tuple'>
z=(10,)
print(z,type(z))

# 元组的删除
del z
# print(z)

          2、元组生成式

        元组生成式的结果是一个生成器对象，需要转换成元组或列表才能查看到元素的内容

        生成器对象中的元素可以使用__next__()方法进行获取

        例：元组生成式

t=(i for i in range(1,4))
print(t) # <generator object <genexpr> at 0x7fa8383f2c10>
# t=tuple(t)
# print(t)

# 遍历 
# for item in t:
#    print(item)

print(t.__next__())
print(t.__next__())
print(t.__next__())

t=tuple(t)
print(t) # ()

五、元组和列表的区别

六、字典

        字典是根据一个信息查找另一个信息的方式构成了“键值对”，它表示索引用的键和对应的值构成的成对关系

        1、字典类型的创建方式

        (1)使用{}直接创建字典

        d={key1:value1,key2:value2,key3:value3......}

        (2)使用内置函数dict()创建字典

                通过映射函数zip()创建字典：zip(lst1,lst2)

        

        dict(key1=value1,key2=value2,key3=value3......)

        例：字典的创建与删除

# (1)创建字典
d={10:'cat',20:'dog',30:'pet',20:'zoo'}
print(d) # {10: 'cat', 20: 'zoo', 30: 'pet'}  key相同时，value值进行了覆盖

# (2)zip函数
lst1=[10,20,30,40]
lst2=['cat','dog','pet','zoo','car']
zipobj=zip(lst1,lst2)
# print(zipobj)  # <zip object at 0x7fa55956dfc0>
# print(list(zipobj)) # [(10, 'cat'), (20, 'dog'), (30, 'pet'), (40, 'zoo')]
d=dict(zipobj)
print(d) # {10: 'cat', 20: 'dog', 30: 'pet', 40: 'zoo'}

# 使用参数创建字典
d=dict(cat=10,dog=20) # 左侧cat是key,右侧的是value
print(d)

t=(10,20,30)
print({t:10}) # t是key,10是value，元组是可以作为字典中的key

# lst=[10,20,30]
# print({lst,10})  # TypeError: unhashable type: 'list'

# 字典属于序列
print('max:',max(d))
print('min:',min(d))
print('len:',len(d))

# 字典的删除
del d
# print(d) NameError: name 'd' is not defined

        注意事项：字典中的key是无序的，Python3.5及其之前的版本字典的key在输出时无序，但是从Python3.6版本之后Python解释器进行了处理，所以才会看到输出的顺序与添加的顺序“一致”

        2、字典元素的访问与遍历方式

(1)字典元素的取值：d[key]或d.get(key)

(2)字典元素的遍历：遍历出key与value的元组

        for  element in d.items():

                pass

      分别遍历出key和value

        for key,value in d.items():

                pass

        例：字典元素的访问与遍历方式

d={'hello':10,'world':20,'python':30,10:40}
# 访问字典中的元素
# (1)使用d[key]
print(d['hello'])
print(d[10])

#(2)d.get(key)
print(d.get('hello'))
print(d.get(10))

# 二者之间是有区别的，如果key不存在，d[key]会报错，d.get(key)可以指定默认值
# print(d['java']) # KeyError: 'java'
print(d.get('java')) # None
print(d.get('java','不存在'))

# 字典的遍历
for item in d.items():
    print(item,end='\t') # ('hello', 10) ('world', 20) ('python', 30) (10, 40)  key与value组成一个元素

for key,value in d.items():
    print(key,'------>',value)

         3、字典的相关操作方法

d={1002:'黄牛',1002:'铁瓜',1003:'老王',1004:'王二麻子'}
print(d)

# 向字典中添加元素
d[1005]='张雪莉' # 直接使用赋值运算符向字典中添加元素
print(d)

# 获取字典中的所有的key
keys=d.keys()
print(keys) # dict_keys([1001, 1002, 1003, 1004])
print(list(keys))
print(tuple(keys))

# 获取字典中所有的value
values=d.values()
print(values) # dict_values(['李梅', '王华', '张峰', '张丽丽'])
print(list(values))
print(tuple(values))

# 将字典中的数据转成key-value的形式，以元组的方式进行展现
lst=list(d.items())
print(lst) # [(1002, '铁瓜'), (1003, '老王'), (1004, '王二麻子'), (1005, '张雪莉')]

d=dict(lst)
print(d) # {1002: '铁瓜', 1003: '老王', 1004: '王二麻子'}

# 使用pop函数
print(d.pop(1002))
print(d)

print(d.pop(1008,'不存在'))

# 随机删除
print(d.popitem())
print(d)

# 清空字典中所有的元素
d.clear()
print(d) # {}

# Python中一切皆对象，每个对象都有一个布尔值
print(bool(d)) # 空字典的布尔值为False

        4、字典生成式 

        d={key:value for item in range}

        d={key:value for key,value in zip(lst1,lst2)}

        例：字典生成式

import random
d={item:random.randint(1,100) for item in range(5)}
print(d)

# 创建两个列表
lst1=[1,2,3,4]
lst2=['王二','张三','李四','徐丽']
d={key:value for key,value in zip(lst1,lst2)}
print(d)

七、集合

        Python中的集合与数学中集合的概念一致

        Python中的集合是一个无序的不重复元素序列

        集合中只能存储不可变数据类型

        在Python中集合使用{}定义

        与列表、字典一样，都是Python中的可变数据类型

        1、集合的创建与删除方式

        (1)使用{}直接创建

        s={element1,element2,elment3,......elementN}

        (2)使用内置函数set()创建集合

        s=set(可迭代对象)

        (3)集合的删除

        del  集合名

        例：集合的创建与删除

# {}直接创建集合
s={10,20,30,'python'}
print(s)

# 集合中只能存储不可变数据类型
# s={[10,20],[30,40]} # TypeError: unhashable type: 'list'
# print(s)

# 使用set()创建集合
s=set() # 创建了一个空集合，空集合的布尔值是False
print(s)

s={} # 创建的是集合还是字典呢
print(s,type(s)) #dict

s=set('helloword')
print(s) # {'r', 'l', 'e', 'h', 'w', 'd', 'o'} 集合是一个无序的，不重复元素序列

s2=set([10,20,30])
print(s2)

s3=set(range(1,10))
print(s3)

# 集合属于序列中的一种
print('max:',max(s3))
print('min:',min(s3))
print('len:',len(s3))

print('9在集合中存在吗？',(9 in s3))
print('9在集合中不存在吗？',(9 not in s3))

# 集合的删除操作
del s3
# print(s3) # NameError: name 's3' is not defined

          2、集合类型的操作符

  

        例:集合的操作符

A={10,20,30,40,50}
B={30,50,88,76,20}
# 交集操作
print(A&B)
# 并集操作
print(A|B)
# 差集操作
print(A-B)
# 补集操作
print(A^B)

          3、集合的相关操作方法

        例：集合的相关操作

s={10,20,30}
# 向集合中添加元素
s.add(100)
print(s)

# 删除元素
s.remove(20)
print(s)

# 清空集合的所有元素
# s.clear()
# print(s)

# 集合的遍历操作
for item in s:
    print(item)

# 使用enumerate()函数
for index,item in enumerate(s):
    print(index,'------>',item)

# 集合的生成式
s={i for i in range(1,10)}
print(s)

s={i for i in range(1,10) if i%2==1}
print(s)

         八、列表、元组、字典、集合的区别

        九、Python 3.11新特性 

        1、结构模型匹配

data=eval(input('请输入要匹配的数据：'))
match data:
    case {'name':'ysj','age':20}
        print('字典')
    case [10,20,30]:
        print('列表')
    case (10,20,40):
        print('元组')
    case _:
        print('相当于多重if中的else')

        2、合并字典运算符

d1={'a':10,'b':20}
d2={'c':30,'d':40,'e':50}
merged_dict=d1|d2
print(merged_dict)

        3、同步迭代

fruits=['apple','orange','pear','grape']
counts=[10,3,4,5]
for f,c in zip(fruits,counts):
    match f,c:
        case 'apple',10:
            print('10个苹果')
        case 'orange',3:
            print('3个桔子')
        case 'pear',4:
            print('4个梨')
        case 'grape',5:
            print('5串葡萄')