# day3 列表和元组

列表

列表使用方括号，每个元素以逗号分隔开

可以使用不同数据类型的数据

特点：

• 是一个有序的
• 可以重复的
• 可变的

1.创建

li=[1,2,2,65,'asd','agh',[1,2,7,'asd']]
print(li)

#[1, 2, 2, 65, 'asd', 'agh', [1, 2, 7, 'asd']]

• 字符串转换列表：

a="asdg231"
li=list(a)
print(li)

#['a', 's', 'd', 'g', '2', '3', '1']

2.拼接

li=[1,2,3]
li2=[4,5,6]
print(li+li2)

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

3.索引和切片

li=[1,2,3,'asd','4rg']
print(li[2])
print(li[1:3])

#3
#[2, 3]

4.列表的常见操作

增删改查

• 增

  • append()(将参数整体作为一个参数插入)

li=[1,2,3,4]
li.append([5,6])
print(li)

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

- extend()(将参数内的元素取出分别加入)

```python
li=[1,2,3,4]li.extend([2,'a'])
print(li)


#[1, 2, 3, 4, 2, 'a']

• insert()(按照索引值添加但是也是吧参数作为整体插入)

li=[1,2,3,4]
li.insert(2,[5,6])
print(li)

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

• 改

  • 直接赋值(索引或者切片)

  li=[1,2,3,4]
  li[0]=5
  li[1:]=[6,7,8]
  print(li)
  
  #[5, 6, 7, 8]
  

• 删

  • pop() 删除索引对应的元素,会返回被删除的元素(如果不指定索引默认删除最后一个元素)

  li=[1,2,3,4]
  print(li.pop(2))
  print(li)
  
  #3
  #[1, 2, 4]
  

  • remove() 删除参数值对应的参数(仅删除第一个遍历到的指定元素)

  li=[1,2,3,4,2,2]
  li.remove(2)
  print(li)
  
  #[1, 3, 4, 2, 2]
  

  • del 删除索引值对应的元素(如果不指定索引值将会直接删除整个列表)

  li=[1,2,3,4,2,]
  li2=[1,3,5,6,7]
  del li[3]
  del li2
  print(li)
  print(li2)
  
  #[1, 2, 3, 2]
  #NameError: name 'li2' is not defined
  

  • clear() 直接清空列表

  li=[1,2,3,4,2,]
  li.clear()
  print(li)
  
  #[]
  

• 查

  • 索引查
  • 切片查
  • 元素遍历

  li=[1,2,3,4,2,]
  for i in li:
      print(i , end=" ")
      
  #1 2 3 4 2 
  

  • 枚举遍历 enumerate()(对于一个可迭代的/可遍历的对象(例如：list，string)将其组成一个索引苏烈，利用它我们可以同时获得索引值和值)

  li=['a','b','c','d','e','f']
  for i in enumerate(li):
      print(i,end=" ")
      
  #(0, 'a') (1, 'b') (2, 'c') (3, 'd') (4, 'e') (5, 'f') 
  

• 计数 count()

li=['a','b','c','a','a','f']
print(li.count('a'))

#3

• 反转 reverse()

li=['a','b','c']
li.reverse()
print(li)
for i in enumerate(li):
    print(i)
    
#['c', 'b', 'a']
#(0, 'c')
#(1, 'b')
#(2, 'a')

• 排序 按照ASCII码排序(必须是同一种数据类型)

li=['g','f','sd','a','b','c']
li.sort()
print(li)

#['a', 'b', 'c', 'f', 'g', 'sd']

5.运用：

• 求列表的交集：

li=['a','b','c','d']
li2=['b','c','d','e']
li3=[]
for i in li:
    if i in li2:
        li3.append(i)
print(li3)

#['b', 'c', 'd']

• input()函数实现往空列表中添加元素，当输入"q"的时候，结束输入，并返回列表。

li=[]
a=''
while a!='q':
    a=input("请输入新元素:")
    li.append(a)
li.pop()
print(li)


#请输入新元素:1
#请输入新元素:2
#请输入新元素:3
#请输入新元素:q
#['1', '2', '3']

• 随机生成30个0-10的随机整数，并统计每个数出现的次数，返回的结果形式为[[0, 3], [1, 4], … , [10, 5]]

import random
li=[]
li2=[]
for i in range(10):
    li.append(int(random.uniform(0,11)))
for j in range(11):
    li2.append([j,li.count(j)])
print(li2)


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

6.深浅拷贝

• 浅三种实现

  • 切片操作[:]

  li=[1,2,3]
  li2=li[1:]
  print(id(li),id(li2))
  
  #1213327639432 1213327543432
  

  • 工厂函数list(li)

  li=[1,2,3]
  li2=list(li)
  print(id(li),id(li2))
  
  #2270299783880 2270299704328
  

  • copy模块内的copy函数

  import copy
  li=[1,2,3]
  li2=copy.copy(li)
  print(li2)
  print(id(li),id(li2))
  
  #[1, 2, 3]
  #2224624001608 2224624001672
  

• 深拷贝(会连列表地址块中的元素地址也拷贝)

import copy
li=[1,2,3,[1,2]]
li2=copy.deepcopy(li)
print(id(li),id(li2))
print(id(li[2]),id(li2[2]))

#2563960737032 2563960957000
#140708840133728 140708840133728

7.列表生成式

• 原理：迭代[可迭代对象]中的每一个元素，每迭代一次的结果赋值给对应的迭代元素，再通过表达式运算得到一个新的值，最后所有通过表达式计算的值以一个列表的形式返回。

• 格式：

[表达式 for 迭代元素 in 可迭代对象]

print([x for x in range(10) if x%2==0])

#[0, 2, 4, 6, 8]

三目运算：

y=10
x= y+1 if y>10 else y-1
print(x)

#9

元组

符号的使用()

元组元素不可修改

1.创建

• 空元组的创建(不能添加元素)

tu=()
print(tu)

#()

• 单元素元组的创建(需要在单元素后面添加逗号)

tu=(1,)
print(tu)

#(1,)

• 多元素元组的创建，包含多种数据类型

tu=(1,2,'2','3',['a',1],(3,4))
print(tu)

#(1, 2, '2', '3', ['a', 1], (3, 4))

2.拼接

tu=(1,2,3)
tu2=(2,3,4)
print(tu+tu2)

#(1, 2, 3, 2, 3, 4)

3.重复

tu2=(2,3,4)
print(tu2*3)

#(2, 3, 4, 2, 3, 4, 2, 3, 4)

4.索引和切片

tu=(1,2,3,4,5,6,7)
print(tu[2])
print(tu[3:])

#3
#(4, 5, 6, 7)

元组不可以修改元素，但是对于可变数据类型元素可以更改其内部元素(即元组元素的内存地址不改变)：

tu=(1,2,3,4,5,6,[1,3,6,'asd'])
print(tu)
tu[6][2]='sda'
print(tu)


#(1, 2, 3, 4, 5, 6, [1, 3, 6, 'asd'])
#(1, 2, 3, 4, 5, 6, [1, 3, 'sda', 'asd'])

5.元组常见操作

查询：

• 索引查
• 切片查
• index() 查询元组中以遍历到的与关键字相同的元素(不能查询元素内部的元素)

tu=(1,2,3,4,'a',6,[1,3,6,'asd'])
print(tu.index('a'))

#4

删除：

• del (只能整个删除元组不能删除部分)

tu=(1,2,3,4,'a',6,[1,3,6,'asd'])
print(tu)
del tu
print(tu)

#(1, 2, 3, 4, 'a', 6, [1, 3, 6, 'asd'])
#NameError: name 'tu' is not defined

最大值最小值(全部元素要统一类型)

tu=(1,2,3,4,5,6,7,8,9)
print(max(tu),min(tu))


#9 1

遍历：

• 元素遍历

tu=(1,2,3,4,5,6,7,8,9)
for i in tu:
    print(i ,end=" ")
    
    
#1 2 3 4 5 6 7 8 9 

• 索引遍历

tu=(1,2,3,4,5,6,7,8,9)
for i in range(len(tu)):
    print(tu[i] ,end=" ")
  

#1 2 3 4 5 6 7 8 9 

• 枚举遍历 enumerate

tu=('a','b','c','d','e')
for i in enumerate(tu):
    print(i,end=" ")
    
    
#(0, 'a') (1, 'b') (2, 'c') (3, 'd') (4, 'e')