列表与元组

列表

◆基本概念

➢列表是有序的元素集合，所有元素放在一对中括号中，用逗号隔开,没有长度限制;
➢列表索引值以0为开始值，-1为从末尾的开始位置。
➢列表可以使用+操作符进行拼接,使用*表示重复。
➢当列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有缝隙;

◆列表元素可以通过索引访问单个元素

a=[4,2,3,6,6,9,5, 8, 1] 
a[3]= 6
a[0]=4
a[9] =?     //报错

◆列表

➢列表可以完成大多数集合类的数据结构实现。
➢列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表(所谓嵌套)。
➢元组、集合、列表都可以作为列表

◆列表元素修改

➢列表大小没有限制，可以随时修改
➢列表元素变可随时修改

>>> a=[4,2,3,6,6,9,5,8,1]
>>> a.insert(0, 1)   //在0的位置插入1
>>> a 
[1,4,2,3,6,6,9,5,8,1]
>>> a[0]= 10    //将0位置上更改为10
>>> a
[10, 4,2,3, 6,6,9,5, 8, 1]

◆列表的基本操作

◆列表的相关方法

◆创建列表

  >>> list((3， 5, 7, 9, 11))  #将元组转换为列表
  [3，5, 7, 9, 11]

  >>> list(range(1, 10, 2))  #将range对象转换为列表
  [1, 3，5，7, 9]

  >>> list('hello world')   # 将字符串转换为列表，每个字符转换为列中的一个元素
  ['h', 'e', 'l', 'l', '0',’, 'w",o', r l', 'd]

  >>> list({3, 7, 5})   #将集合转换为列表，集合中的元素是无序的
  [3，5, 7]

  >>> x = list()   #创建空列表
  >>> x= [1, 2, 3]
  >>> del x  #删除列表对象
  >>> x  #对象删除后无法再访问，抛出异常
  NameError: name 'x' is not defined

range函数默认有三个参数range(start,end,step)

◆利用索引访问列表

  data = list(range(10))

  print(data)
  print(data[0])     # 第一个元素的下标为
  print(data[1])     # 第二个元素的下标为1
  print(data[-1])    # -1表示最后一个元素的下标
  print(data[15])    # 15不是有效下标，代码抛出异常


  [0，1,2,3,4,5,6,7,8,9]
  0
  1
  9

  IndexError  Traceback (most recent call last)<ipython- input -8-6f56fa97754d> in <module>

      4 print(data[1])  #第二个元素的下标为1
      5 print(data[-1])  # -1表示最后一个元素的下标
----> 6 print(data[15])  # 15不是有效下标，代码抛出异常

IndexError: list index out of range

◆列表常用方法

➢append(). insert(). extend()

  lst=[1,2,3,4]
  print(lst)

  lst.append(5)
  print(lst)

  lst.insert(0, 0)
  print(lst)

  lst.insert(2,1.5)
  print(lst)

  1st.extend([6, 7])
  print(lst)


  [1,2,3,4]
  [1,2,3,4,5]
  [0,1,2,3,4,5]
  [0,1,1.5,2,3,4,5]
  [0,1,1.5,2,3,4,5,6,7] 

◆列表常用方法
➢pop(), remove()

  lst = [1,2,3,4,5,6]

  print(lst.pop())  #删除并返回最后一个元素
  print(lst)

  print(lst. pор(0))   #删除并返回下标为0的元素，后面的元素向前移动
  print(lst)

  print(lst. pop(2))   #除并返回下标为2的元素，后面的元素向前移动
  print(lst)

  lst=[1,2,3,2,4,2]
  lst .remove(2)  #删除第一个2，该方法没有返回值
  print(lst)       


  6
  [1,2,3,4,5]
  1
  [2,3,4,5]
  4
  [2,3,5]
  [1,3,2,4,2]

◆列表常用方法

➢sort()、 reverse()

 from random import sample

  #在range(10000)中任选10个不重复的随机数
  data = sample(range(10000)，10)
  print(data)

  data.reverse()  #翻转，首尾交换，该方法没有返回值
  print(data)
  data.sort()  #按元素大小进行排序，该方法没有返回值
  print(data)
  data. sort(key=str)  #按所有元素转换为字符串后的大小进行排序
  print(data)


  [7506, 6063，1651, 660,2468， 8727,6301, 2448，2911,3074]
  [3074，2911, 2448, 6301, 8727, 2468,660, 1651, 6063,7506]
  [660，1651, 2448，2468，2911，3074，6063，6301，7506,8727]
  [1651, 2448，2468，2911,3074，6063，6301，660，7506, 8727]

◆列表常用方法

➢count(). index()

  lst=[1,2,2,3,3,3,4,4,4,4]

  print(lst.count(2))   # 输出2
  print(lst)

  print(lst.index(4))  # 4第一出现的索引值    输出6
  print(lst)

  print(lst.index(5))  # 代码抛出异常，提示5 is not in list


  2
  [1,2,2,3,3,3,4,4,4,4]
  6
  [1,2,2,3,3,3,4,4,4,4]

  ValueError                     Traceback (most recent call last)
  <ipython- input-6- 66d4beeb8c0d> in <module>

        4 print(lst.index(4))  # 输出6 
        5 print(lst）
  ----> 6 print(lst. index(5))  #代码抛出异常，提示5 is not in list

 ValueError: 5 is not in list  25:6  y

◆列表推导式

元组

◆基本概念

➢元组(tuple) 是包含多个元素的类型，元素之间用逗号分割
➢如:t1 =(123,456, "hello" )
➢可以通过把若干元素放在一 对圆括号中创建元组，如果只有一 个元素的话则需要多加一个逗号，例如(3,)。
➢也可以使用tuple()函数把列表、字典、集合、字符串以及range对象、map对象、zip
对象或其他类似对象转换为元组。
➢元组可以是空的，t2=()
➢一个元组也可以作为另一个元组的元素,此时,作为元素的元组需要增加括号，从而避
免歧义，如: t3= (123,456, ("hello","world"))

➢元组中各元素存在先后关系，可以通过索引访问元组中元素。

➢例如: t3[0]
➢元组定义后不能更改，也不能删除
➢t3[0]=78
➢与字符串类型类似，可以通过索引区来访问元组中的部分元素。
➢例如: t3[1:]
➢与字符串-样,元组之间可以用+号和*号进行运算

◆元组与列表的区别
➢元组是不可变的，不能直接修改元组中元素的值,也不能为元组增加或删除元素。因此,
元组没有提供append(、extend(和insert()等方法， 也没有remove()和pop()方法。
➢元组的访问速度比列表更快，开销更小。如果定义了一系列常量值，主要用途只是对它
们进行遍历或其他类似操作，那么一般建议使用元组而不用列表。
➢元组可以使得代码更加安全。例如，调用函数时使用元组传递参数可以防止在函数中修
改元组，而使用列表则无法保证这一点。
➢元组可用作字典的键,也可以作为集合的元素，但列表不可以，包含列表的元组也不可
以。

◆生成器表达式

gen = (2**i for i 1n range(8))   #创建生成器对象
print(gen)

print(list(gen))   #转换为列表用完生成器对象中的所有元素
#使用之后生成器中的对象为空，生成器中的元素只能使用一次，一次之后就失效
print(tuple(gen))   #转换为元组，得到空元组

gen = (2**i for i in range(8))  #重新创建生成器对象
print(next(gen))   #使用next()函数访问下一个元素
print(next(gen))
for item in gen:   #使用for循环访问剩余的所有元素
  print(item, end=' ')


<generator object <genexpr> at 0x00001FD12BFC5E8>
[1, 2, 4, 8, 16, 32, 64, 128]
()
1
2 4 8 16 32 64 128

切片操作

➢适用于列表和元组
➢切片是用来获取列表、元组、字符串等有序序列中部分元素的-种语法。在形式上，切
片使用2个冒号分隔的3个数字来完成。
➢[start🔚step]
➢其中第一-个数字start表示切片开始位置,默认为0;第二个数字end表示切片截止(但
不包含)位置(默认为列表长度) ;第三个数字step表示切片的步长(默认为1)，省略步长时还可以同时省略最后一个冒号。
➢当step为负整数时,表示反向切片，这时start应该在end的右侧。

适用于列表和元组

data = list(range(20))   
print(data[:])      #获取所有元素副本
print(data[:3])     #前三个个元素
print(data[3:])     #下标3之后的所有元素
print(data[::3])    #每3个元素选取1个，步长为3
print(data[-3:])    #最后3个元素
print(data[:-5])    #除最后5个元素之外的所有元素


[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]
[0,1,2]
[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]
[0, 3, 6, 9, 12, 15, 18]
[17, 18, 19]
[е,1,2,3,4,5,6,7,8,9,10,11,12,13,14]