容器类型：列表和元组

数据收纳盒

• 用来收纳数据对象的数据类型
• 以一种规则的下标索引方式（收纳盒名字+ 数字序号）访问到每个数据
• 这种收纳盒是一种序列
• 列表可以删除、添加、替换、重排序列中的元素（可变类型）
• 元组是不能再更新（不可变）序列
  • 元组在保留列表大多数功能的同时，去掉了一些灵活性以换取更高的处理性能
  • 不可变意味着不支持增删改查
  • 有序的意味着支持下标操作

列表和元组的创建

创建列表

• 方括号法 []，指明类型法 list()
• 所有的容器型数据类型的数据都可以转换成列表
• 将容器中的元素全部转换成列表中的元素

创建元组

• 圆括号法()，指明类型法tuple()

列表或元组中保存的各个数据称作 元素(element)，类型没有限制

# 元组中表示为空
tuple1= () # () <class 'tuple'>
print(tuple1,type(tuple1))

# 元组中的单个元素表示
tuple3 = (10) #10 <class 'int'>
print(tuple3,type(tuple3))
tuple3 = (10,) #(10,) <class 'tuple'>
pritn(tuple3,type(tuple3))

#多个元素的元组表示
tuple4 = (100,200,300) #
tuple5 = 10,23,34,45   # 变量 = item1，item....item
print(tuple5,type(tuple5) # (10, 23, 34, 45) <class 'tuple'>

score = [60,67,78,56,78,90]
list1 = [90,'abc',True,[1,2,3]]

列表和元组的操作

列表的操作：增长/缩减

增长列表

• append操作/insert操作/extend操作

  list1.extend(list2) # 在原列表上改变
  list1.extend('abc') # 字符串也是容器类型

缩减列表

• pop操作/remove操作/clear操作

列表是一种可变容器，可以随意增减

但并不是所有的数据容器都能像列表 这样可以继续添加新元素

列表的操作：重新组织

reverse / sort 操作

• reverse：把列表中的数据元素头尾反转重新排列
• sort：把列表中的数据元素按照大小顺序重新排列

reversed / sorted 操作

• reversed(alist) / sorted(alist) 得到重新排列的列表，而不影响原来的列表

• sorted(列表，reverse=True) 将列表中的元素从大到小排列产生一个新的列表

  nums = [12,32,34,54]
  new_nums = reversed(nums)
  print(nuw_nums) # <list_reverseiterator object at 0x000001D171453D30>

列表的操作：大小比较

• 能比较的前提是，比较的数据是相同类型

能比较的前提是比较的数据是相同类型

• 从第一个元素顺序开始比较，如果相等，则继续。返回第一个不相等元素比较的结果。

• 如果所有元素比较均相等，则长的列表大，一样长则两列表相等

  list1 = ['abc', 100, 200, 50]
  list2 = ['100',50, 100]
  print(list1>list2) #TypeError: '>' not supported between instances of 'str' and 'int'

列表方法

见表格

方法名称 使用例子 说明
append(追加) alist.append(item) 列表末尾添加元素
insert(插入) alist.insert(i,item) 列表中i位置添加元素
del del alist(i) 删除列表中第i个元素(下标要存在)
remove alist.remove(item) 将item首次出现删除；如果元素不存在,会报错
pop alist.pop() 删除列表中的最后一个元素并返回其值
pop alist.pop(i) 删除列表中的第i个元素，并返回其值
sort alist.sort() 将表中元素排序
reverse alist.reverse() 将表中元素反向排序
index alist.index() 找到item的首次出现位置
count alist.count() 返回item在列表中出现的次数
clear alist.clear() 清空列表里的数据
copy alist.copy() 复制列表中所有元素，产生一个新列表

alist = [10,20,30,40,50,40]

alist.append(100)
alist.insert(1,100)
del alist(i)
alist.remove(40)

列表推导式

[ 表达式 for 变量 in 序列 ]

• 让变量去序列中取值，每取一个值就创建列表中的一个元素，元素的值就是表达式的值

  alist= [1 for x in range(4)]
  print(alist)
  list = [2*x for x in range(4)]
  print(alist)

[ 表达式 for 变量 in 序列 if 条件语句 ]

• 让变量去序列中取值，每取一个值就判断一次条件语句是否为true，为True就创建列表中的一个元素，元素的值就是表达式的值

  list6 = [x for x in range(6) if x & 1 == 0]
  list7 = [x**2 for x in range(10) if x % 2] # x%2 返回的是布尔值 只要表达式有值就可以判断
  print(list)

[表达式 for 变量1 in 序列1 for 变量2 in 序列2 ]

for 变量1 in 序列1:
    for 变量2 in 序列2:
        产生元素

[表达式 for 变量1 in 序列1 for 变量2 in 序列2 if 条件语句 ]

列表与元组的操作

合并

• 加法运算+：连接两个列表／元组 ，然后产生一个新列表，这一点与extend不同
• 乘法运算*：复制n次，生成新列表／元组 (这里的n是正整数)

列表/元组大小

• len()：列表／元组中元素的个数

列表与元组的操作：索引/切片

索引(下标)

alist[n] 或 atuple[n]

• 利用下标修改元素的值
  • 可以用赋值语句给列表中的任何一个位置重新赋值
  • 但元组属于不可变类型，索引只能 获取 对应位置中的数据值，不可重新赋值
• 利用下标获取列表值

  • 是用来表示有序序列中元素的位置(顺序)。

  • 列表中的每个元素都有固定的下标来表示这个元素在列表中的位置

  • python列表中的每个元素有两种下标值，一种是正的下标值(从0开始),另一种是负的下标值(从-1开始，以此减少，-1表示是最后一个元素)

  • 下标不能超出列表下标的范围

    names = ['小孩', '老虎', '枪']
    print(names[0],names[-1])
    print(names[10]) # IndexError: List index out of range

    names = '老友记','权利的游戏','杀死伊芙','兄弟连','维京传奇','亿万','傲骨传奇'

    用变量获取

    tuple6 = (10,78,45)
    a,b,c = tuple6 # 获取，变量与元素数量相等
    print(a,b,c)

    获取，变量与元素数量不相等时

    person = '施瓦辛格','男',100,101,102
    name, gender,*num = person
    print(name, gender,num)

    * 的作用 打包和解包·

    print(num)
    print(*num)

    列表相关操作全部适用于元素

切片

alist[start : end : step]

atuple[start : end : step]

• start，end指的是下标值(这个数值表示列表元素位置，与数轴上的数字位置不同）,整数，

• step是整数,正值是从左往右取，负值是从右往左取

  names = ['小孩', '老虎', '枪','胡萝卜','大棒']
  print(names[1:3:1]) # ['老虎','枪']
  print(names[-4:3:1]) # ['老虎','枪']
  print(names[1:-1:2])
  print(names[-1,1,1]) # []

  取出末尾三位

  print(names[2:5:1]) #这里下标越界是可以的

  省略写法

  print(names[1:4]) #省略步长
  print(names[:1:4]) # 省略开始下标
  print(names[:-1]) #省略开始下标和步长
  print(names[:2,-1]) # 步长为负，从最后一个元素从后往前
  print([names[:0:-2]])
  print([names[-3:]]) # 省略结束下标和步长，结束下标会去到最后一位
  print(names[-1::2]) # ['大棒']
  print(names[::-1]) #列表倒叙的简单写法
  print(names[:]) # 列表的copy

• 切片的省略写法

  • 省略步长

• 省略开始下标

  • 步长为正，从第一个元素从前往后取
  • 步长为负，从最后一个元素从后往前

• 省略开始下标和步长

  • 省略结束下标(相当于越界)
    • 步长为正，从开始下标取到最后一个下标位置的元素
    • 步长为负，从最后一个位置起到开始下标位置的元素

• 遍历列表

  • 方法一：直接法
    names = ['小孩', '老虎', '枪','胡萝卜','大棒']
    for i in names:
    循环体
  • 方法二：利用下标获取

• 将列表1中开始下标到结束下标选中的所有元素替换成列表2中所有的元素
  nums = [10,20,30,40,50]
  nums[1:3] = [100,200,300]
  print(nums)

列表与元组的操作：查找和计算

查找

• in / not in操作：判断某个元素是否存在于列表/元组中
• index操作：指定的数据在列表/元组的哪个位置

  • 如果元素不错在会报错

  • 如果元素有多个，只返回最前面的哪一个的标准

  • 列表.index(元素，开始下标，结束下标) 在范围内查找元素下标

    alist.index(12,2,5)
    alist.index(12,2) # 取到最后一个元素

• count操作：指定的数据在列表/元组中出现过几次

计算

• sum函数：将列表中所有的数值元素累加
  nums = [10,20,30,40,50]
  sum(nums)

• min/max函数：返回列表中最小/最大的数据元素