列表

列表

列表使用方括号括起来的[],每个元素以逗号分隔；

可以储存不同的数据类型数据

数组

特点：

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

创建

• 创建空列表

li=[]

• 创建多元素列表

li=[1,2,3,“abc”,“city”,“college”,[“i”,“love”]]

(拼接)
li1=["i"]
li2=["love","python"]
print(li1+li2)
#['i', 'love', 'python']



# li=[1,2,3,"abc","city","college",["i","love"]]
# print((li,type(li)))
# sr="abcd"
# li=list(sr)
# print((li,type(li)))

(2)重复

print(li2*3)

(3)索引，切片

li=[1,2,3,"abc","city","college","zhejiang"]
print(len(li))
print((li[0],li[-7]))
print(li[:5])
print(li[::-1])
print(li[4][1])
print(li[7][1])
#7
#(1, 1)
#[1, 2, 3, 'abc', 'city']
#['zhejiang', 'college', 'city', 'abc', 3, 2, 1]
#i

(4)列表的常见操作

• 增删改查

1.增

• append()
• extend()
• insert(),按照索引和位置添加

li=["city","college"]
print(id(li))
li1=["a","b","c"]
li.append(li1)
print((li,id(li)))
#2109718996488
#(['city', 'college', ['a', 'b', 'c']], 2109718996488)
li=["city","college"]
li1=["a","b","c"]
li.extend(li1)
print(li)
li.insert(1,li1)
print(li)
li[5]="6666"
li[2:6]=["x","y","z"]
print(li)
#['city', 'college', 'a', 'b', 'c']
#['city', ['a', 'b', 'c'], 'college', 'a', 'b', 'c']
#['city', ['a', 'b', 'c'], 'x', 'y', 'z']

删除

• pop()，返回被删除的元素

  • 如果不指定索引，默认删除最后一个元素
  • 删除指定索引对应的元素

  li=["a","b","c","d","e"]
  print(li.pop())
  print(li)
  

• remove()，移除第一次遇到的指定元素

li=["a","b","c","d","e","city","e"]
print(li.remove("e"))
print(li)
#None
#['a', 'b', 'c', 'd', 'city', 'e']

• del

li=["a","b","c","d","e","city","e"]
del li[5]
print(li)
['a', 'b', 'c', 'd', 'e', 'e']

• clear()

li=["a","b","c","d","e","city","e"]
li.clear()
print(li)
#[]

查，索引，遍历

(1)元素遍历

li=["a","b","c"]
for i in li:
    print(i)
#a
#b
#c

(2)索引遍历

li=["a","b","c"]
for i in range(len(li)):
    print(li[i])
#a
#b
#c

(3)枚举遍历

• enumerate(),对于一个可迭代的可遍历的对象，将其组成一个索引序列，利用他，我们可以同时获得索引和值

li=["a","b","c"]
for i in enumerate(li,2):
    print(i)
li =["a","b","c"]
for index,value in enumerate(li,2):
    print(index,value)
#(2, 'a')
#(3, 'b')
#(4, 'c')
#2 a
#3 b
#4 c

堆和栈，用列表实现

• 计数，count(),查找元素出现的次数
• 反转，reverse()
• 排序，sort()

input()函数实现往空列表内添加元素，当输入“q”时，结束输入，并返回列表

a=[]
while True:
    x=input("请输入")
    if "q"in x:
        break
    else:
        a.append(x)
print(a)

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

import random
x=[]
y=[]
for i in range(1,31):
    a = random.randint(0, 10)
    x.append(a)
for b in range(0,11):
    c=x.count(b)
    z=[b,c]
    y.append(z)
print(y)

赋值与深浅拷贝

赋值

赋值是对对象的引用

la = [1,2,3,4,5,'a',['b1','b2']]
lb=la
print(la)
print(lb)
print(id(la),id(lb))
print(la is lb)
la[5]="aaa"
print(la)
print(lb)


#
[1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
[1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
2352199011016 2352199011016
True
[1, 2, 3, 4, 5, 'aaa', ['b1', 'b2']]
[1, 2, 3, 4, 5, 'aaa', ['b1', 'b2']]

深浅拷贝

浅拷贝会创建新对象，内容是原对象的引用

浅拷贝相当于我们只拷贝了一层，修改外层元素，就会修改引用，让他们指向另一个位置；修改嵌套列表的元素，列表地址没有发生变化，指向的还是同一个位置。

三种实现方法：

• 切片操作[:]
• 工厂函数list(li)
• copy模块内的copy函数

la = [1,2,3,4,5,'a',['b1','b2']]
lb=la
lb2= la[:]
print(id(la),id(lb2))
import copy
lb_copy=copy.copy(la)
print(id(la),id(lb_copy))
la.append('test')# 添加原子类型，不会影响lb_copy
print(la)
print(lb_copy)

深拷贝

深拷贝拷贝对象的所有元素，包括多层嵌套的元素。因此，是开辟了一个新的内存，和数据源没有关系了

import copy
la = [1,2,3,4,5,'a',['b1','b2']]
lb_deepcopy= copy.deepcopy(la)
print(la,id(la))
print(lb_deepcopy,id(lb_deepcopy))
la[6][1]="aaa"
print(la)
print(lb_deepcopy)
#
[1, 2, 3, 4, 5, 'a', ['b1', 'b2']] 2612515599880
[1, 2, 3, 4, 5, 'a', ['b1', 'b2']] 2612515601160
[1, 2, 3, 4, 5, 'a', ['b1', 'aaa']]
[1, 2, 3, 4, 5, 'a', ['b1', 'b2']]

格式：

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

实现原理：

• 迭代[可迭代对象]中的每一个元素

• 每迭代一次的结果赋值给对应的迭代元素，在通过表达式运算得到一个新的值

• 最后所有通过表达式计算的值以一个列表的形式返回

• sr= "城市学院"
  print([ord(x)for x in sr])
  #
  [22478, 24066, 23398, 38498]
  y=10
  x=y+1 if y>10 else y-1
  print (x)
  #9
  
  

带过滤功能格式

[exp for iter_val in if if_condtion]
li = []
for iter_val in iter:
    if if_condtion:
        li.append(iter_val)
print(li)

name = ["tom","jack","lucy"]
subject=["python","java","c","c++"]
li=[]
for i in name:
    for j in subject:
        li.append([i,j])
        print(li)
print([[i,j] for i in name for j in subject])
#
[['tom', 'python']]
[['tom', 'python'], ['tom', 'java']]
[['tom', 'python'], ['tom', 'java'], ['tom', 'c']]
[['tom', 'python'], ['tom', 'java'], ['tom', 'c'], ['tom', 'c++']]
[['tom', 'python'], ['tom', 'java'], ['tom', 'c'], ['tom', 'c++'], ['jack', 'python']]
[['tom', 'python'], ['tom', 'java'], ['tom', 'c'], ['tom', 'c++'], ['jack', 'python'], ['jack', 'java']]
[['tom', 'python'], ['tom', 'java'], ['tom', 'c'], ['tom', 'c++'], ['jack', 'python'], ['jack', 'java'], ['jack', 'c']]
[['tom', 'python'], ['tom', 'java'], ['tom', 'c'], ['tom', 'c++'], ['jack', 'python'], ['jack', 'java'], ['jack', 'c'], ['jack', 'c++']]
[['tom', 'python'], ['tom', 'java'], ['tom', 'c'], ['tom', 'c++'], ['jack', 'python'], ['jack', 'java'], ['jack', 'c'], ['jack', 'c++'], ['lucy', 'python']]
[['tom', 'python'], ['tom', 'java'], ['tom', 'c'], ['tom', 'c++'], ['jack', 'python'], ['jack', 'java'], ['jack', 'c'], ['jack', 'c++'], ['lucy', 'python'], ['lucy', 'java']]
[['tom', 'python'], ['tom', 'java'], ['tom', 'c'], ['tom', 'c++'], ['jack', 'python'], ['jack', 'java'], ['jack', 'c'], ['jack', 'c++'], ['lucy', 'python'], ['lucy', 'java'], ['lucy', 'c']]
[['tom', 'python'], ['tom', 'java'], ['tom', 'c'], ['tom', 'c++'], ['jack', 'python'], ['jack', 'java'], ['jack', 'c'], ['jack', 'c++'], ['lucy', 'python'], ['lucy', 'java'], ['lucy', 'c'], ['lucy', 'c++']]
[['tom', 'python'], ['tom', 'java'], ['tom', 'c'], ['tom', 'c++'], ['jack', 'python'], ['jack', 'java'], ['jack', 'c'], ['jack', 'c++'], ['lucy', 'python'], ['lucy', 'java'], ['lucy', 'c'], ['lucy', 'c++']]

‘python’], [‘jack’, ‘java’], [‘jack’, ‘c’], [‘jack’, ‘c++’], [‘lucy’, ‘python’], [‘lucy’, ‘java’], [‘lucy’, ‘c’], [‘lucy’, ‘c++’]]
[[‘tom’, ‘python’], [‘tom’, ‘java’], [‘tom’, ‘c’], [‘tom’, ‘c++’], [‘jack’, ‘python’], [‘jack’, ‘java’], [‘jack’, ‘c’], [‘jack’, ‘c++’], [‘lucy’, ‘python’], [‘lucy’, ‘java’], [‘lucy’, ‘c’], [‘lucy’, ‘c++’]]