【Python数据类型】有序序列:列表,元组,字符串

1. 什么是有序序列?

        有顺序的,可以通过索引取值,可以遍历。

2.有序序列通用的特性?
  • + 拼接
    • # 1.列表拼接
      list1 = [1, 2, 3, 4, 5, 6]
      
      list2 = [7, 8, 9]
      
      list3 = list1 + list2
      
      print(list3)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]
      
      
      # 2.元组拼接
      
      tup1 = (1, 2, 3, 4)
      
      tup2 = (5, 6, 7)
      
      tup3 = tup1 + tup2
      
      print(tup3)   # (1, 2, 3, 4, 5, 6, 7) 
      
      
      # 3.字符串拼接
      
      str1 = "Hello,"
      
      str2 = "World"
      
      str3 = str1 + str2
      
      print(str3)  # Hello,World
  • *,重复
  • list1 = [1, 2, 3]
    
    tup1 = (1, 2, 3)
    
    str1 = 'abc'
    
    print(list1*2)  # [1, 2, 3, 1, 2, 3]
    
    print(tup1*2)  # (1, 2, 3, 1, 2, 3)
    
    print(str1*2)  # abcabc
    
    实现进度条功能
    import time
    for i in range(30,100):
        time.sleep(0.05)
        print(f"\r当前电量是{'❤️'*i} {i}", end='')

  • 切片
    • 从序列中复制出部分元素的操作,返回的是一个新序列
    • 语法格式: 变量名[start:end:step]     左开右闭[start,end),step可以为负数
      • 参数start,省略时表示起始索引;如果填写超出索引范围不报错
      • 参数end,省略时表示终止索引;如果填写超出索引范围不报错
      • 参数step,数值表示取值的步长,从当前索引开始向后取step。省略时表示步长=1;正负表示取值方向
        • 为正时,从左到右; 不填写该参数默认为正
        • 为负时,从右到左
      • # 以列表切片为例:
        list1 = [1, 2, 3, 4, 5, 6]
        
        print(id(list1))
        
        # 场景1: 正序取片,仅有起始索引,则从该索引开始取到最后且step为1
        
        list2 = list1[2:] 
        
        print(list2)  # [3,4,5,6]
        
        # 场景2: 正序取片,仅有结束索引,则从0开始索引开始取到该索引且step为1
        
        list3 = list1[:2] 
        
        print(list3)  # [1,2,3]
        
        # 场景3: 正序取片,3个参数从左向右取
        list4 = list1[1:4:2] 
        
        print(list4)  # [2, 4]
        
         
        # 场景4: 正序取片,无参数(默认从左向右取值,0开始索引到末尾索引,步长为1)
        
        list5 = list1[::]
        
        print(list5)  # [1,2,3,4,5]
        
        # 逆序取片,3个参数从右向左取
        list6 = list1[3:1:-1]
        
        print(list6)  # [4,3]
        
        # 逆序取片,仅有起始索引,则从该索引开始取到最后且step为-1
        
        list7 = list1[3::-1]
        
        print(list7)  # [4,3,2,1]
        
        # 逆序取片,仅有结束索引,则从起始索引到该索引且step为-1
        
        list8 = list1[:2:-1]
        
        print(list8)  # [6,5,4]
        
        # 逆序取片,仅有step且为-1
        
        list9 = list1[::-1]
        
        print(list9)  # [6,5,4,3,2,1]
        
        
        
    • ❗️注意点1:修改切片的值,值需要是可迭代的,否则报错:TypeError: can only assign an iterable
    • 切片赋值
      lst = [1,2,3,4]
      
      lst[2:] = 0
      
      print(lst)  # TypeError: can only assign an iterable
      
      
      
      
    •  ❗️注意点2: 起始索引要早于结束索引,否则取不到值但也不会抛异常
      • str = '112113112114'
        
        print(str[3:1])  # 正向切片取不到值,因为从左到右取值起始索引晚于结束索引
        
        print(str[3:-1:-1]) # 逆向切片取不到值,因为从右到左取值起始索引晚于结束索引
        
  • 索引(访问序列对象的主要方式)
    • 索引一般为整数,放在[]中。返回的是一个元素
    • 语法格式:变量[索引值]
      • # 1.列表拼接
        list1 = [1, 2, 3, 4, 5, 6]
        
        
        # 取索引为0的第1个元素
        print(list1[0])   # 1
        
        # 取反索引的值即~索引=-(索引值+1)
        print(list1[~2])    # 4
        
        
        # 2.元组拼接
        
        tup1 = (1, 2, 3, 4)
        
        print(tup1[3])   # 4
        
        
        # 3.字符串拼接
        
        str1 = "Hello,"
        
        print(str1[2])   # l
  • 查询首次子串的位置  index(substring,start_index,end_index)
    • 查询不到报异常
    • 场景1: 默认参数
      
      list_data = [1,2,3,4,2]
      print(list_data.index(2)) # 1
      
      场景2: 指定开始索引
      
      list_data = [1,2,3,4,2]
      print(list_data.index(2,3)) # 4
      
  • 成员验证
    • 使用成员运算符in去判断是否存在在序列里,返回的是bool值
    • 语法: 元素 in 序列
  • 逆序
    • 使用reversed()内置函数,返回的是可迭代对象
  • count()函数
    • 计算元素的个数
    • 语法: seq.count(element)
  • str1 = "hello world"
    
    print(str1.count('l')  # 3
    
    
    list1 = [1,2,3,4,3,2,1]
    
    print(list1.count(3))  # 2
    
    
    tuple1 = (1,2,3,4,3,2,1)
    
    print(tuple1.count(3))  # 2
    
    题目一: 计算字符串中第一个不重复的字符
    
    str = "Hi,Hello,World,hei"
    
    def fuc(str):
    
        for j in str:
    
            if str.count(j) == 1:
    
                return j
    
        return False
    
    print(fuc(str))

    3.列表与元组的区别

  • 区别列表元组
    表示符号[]()
    序列可变序列不可变序列
    访问和处理速度动态数组,慢静态数组,快
    是否可作为字典的键

总结:

         1. 有序序列逆序

方法一: 使用切片

lst = [1, 2, 3, 4]
str1 = "Hello"
tup1 = (1, 2, 3, 4)

print(lst[::-1])
print(str1[::-1])
print(tup1[::-1])

方法二: 使用reversed()内置函数

lst = [1, 2, 3, 4]
str1 = "Hello"
tup1 = (1, 2, 3, 4)
print(list(reversed(lst)))
print("".join(list((reversed(str1)))))
print(tuple(reversed(tup1)))


方法三: for和range()

lst = [1, 2, 3, 4]
str1 = "Hello"
tup1 = (1, 2, 3, 4)
lst1 = [lst[i] for i in range(len(lst)-1, -1, -1)]
print(lst1)
str2 = [str1[i] for i in range(len(str1)-1, -1, -1)]
print("".join(str2))
tup2 = [tup1[i] for i in range(len(tup1)-1, -1, -1)]
print(tuple(tup2))


方法四: while

lst = [1, 2, 3, 4]
str1 = "Hello"
tup1 = (1, 2, 3, 4)
i = len(lst)-1
while i >= 0:
    print(lst[i])
    i -= 1




  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值