【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