Python 列表（list） 详解

列表的常见操作

列表(list)特点: 是有序的，可重复的序列，可变类型

创建一个空列表

list1 = []

创建一个有多个值的列表

#list列表是用来存放多个元素, 每个元素之间用 , 逗号隔开

list1 = [20,18,22,34,23]

     #注意: python的一个列表可以存放不同类型的元素

list1 = [20,18,"周杰伦",22,34,"林俊杰","方文山"]
print(list1)
print(type(list1))


>>>求平均年龄

ages = [12,23,34,16,17,18,19]

i=0

sum=0

while i<len(ages):

     sum=sum+ages[i]

     i+=1

print(sum/len(ages))

ages1 = [12,23,34,16,17,18,19]

ages2 = [34,45]

#拼接的方式

age3 = ages1 + ages2

print(age3)

#乘法操作

age4 = ages2*3

print(age4)


>>>判断一个元素是否在一个列表中

if 17 in ages1:

     print("True")


#截取列表的一部分

#列表截出来的一定是列表
ages1 = [12,23,34,16,17,18,19]

     print(ages1[:2])

     print(ages1[::])

     print(ages1[::-1])


#二维列表

data1 = [[1,2,3],[4,5,6],[7,8,9]]

     #取出二维列表的某个值

res=data1[0][1]


# 三维列表
data2 = [[[1,2,3],[4,5],[6,7]], ,]

>>>将列表中的一个元素大写:
lst = ["alex", "gay","wusir",["范冰冰","李冰冰",[1, "火锅", "ritian", "凤爪"],"王冰冰"]]
#print(lst[3][2][1]) # 火锅
lst[3][2][2] = lst[3][2][2].upper() #前面的是位置，后面的是改变后的值
#注意找到的是一个字符串，字符串不可变类型，所以要让它改变，需要重新放回去
print(lst)

lst[3][2][0] = lst[3][2][0] + 99
print(lst)
#叫降维操作

>>>将list=["渡我被身子","丽日御茶子","绿谷出久"] 变成 "渡我被身子_丽日御茶子_绿谷出久":

s = '' 
for i in li:
     s = s + i + '_' 
print(s[:-1]) #打印时，最后一个不要打印
#print(sum.strip("_"))

遍历list的方式

方式1:列表是可迭代对象，可以直接用for
for i in names:
	print(i)

方式2:
# i 表示的索引
for i in range(len(names)):
	name = names[i]
	print(name)

方式3:enumerate（枚举）
# index 表示索引,
# i 表示元素值
for index,i in enumerate(names):
	print("names[%d] = %s"%(index,i))
#输出结果：
names[0]=马蓉
names[1]=白百合
names[2]=芙蓉姐姐
names[3]=凤姐
names[4]=金三胖胖

>>>题目：取出二维列表data= [[1,2,3],[4,5,6],[7,8,9]] 中所有的值

data= [[1,2,3],[4,5,6],[7,8,9]]

line_num=0
while line_num<len(data):
	colum_num = 0
	while colum_num<len(data[line_num]):
		print(data[line_num][colum_num])
		colum_num+=1
	line_num+=1

#用for循环解决
for i in data:
	for j in i :
		print(j,end="")

#列表for可以用 el  element“元素”


枚举 （enumerate）

lst = ["纯妃","娴妃","令妃","韩妃","各种妃"]

for index, el in enumerate(lst,1):
     print(index)
     print(el)
#第二个参数，表示从几开始，省略表示从0开始！

#字典遍历的 dic.items() 和 enumerate 是一样的

#列表值相加

sum(list) 列表的值相加 

list=[]
for i in range(1,1001):
     list.append(i)
     total=sum(list)
print（total）

#求列表最大、最小值
#最大值
maxNumber = max(list1)
print(maxNumber)
#最小值
minNumber = min(list1)
print(minNumber)

列表的增删改（查）

增（添加）

dataList = [0,1,2,3,4,5]

append表示向列表的末尾添加一个数据,不能添加多个元素
# dataList.append(6)
# dataList.append(7)


extend向列表的末尾添加多个元素
#迭代添加
# dataList.extend([6,7,8])  #注意添加元素时要带上[]

#迭代添加（必须是可迭代对象）
lst = ["王志⽂", "张一⼭", "苦海无涯"]
lst.extend(["麻花藤", "麻花不疼"])
print(lst)


insert（参数1，参数2）向列表的某个位置插入一个值

# 参数1:表示插入的位置(索引)

# 参数2: 表示要插入元素

# 注意: 当元素插入位置x后,x及其x以后的所有元素会往后移

dataList.insert(2,8)
print(dataList)


lst = ["麻花藤", "林林俊杰", "周润发", "周芷若"]
print(lst)
lst.append("wusir")
print(lst)

lst = []
while True:
     content = input("请输⼊入你要录⼊的员工信息, 输⼊Q退出:")
     if content.upper() == 'Q':
         break
     lst.append(content)
print(lst)

lst = ["麻花藤", "张德忠", "孔德福"]
lst.insert(1, "刘德华") # 在1的位置插⼊入刘德华. 原来的元素向后移动⼀一位
print(lst)

删

dataList2 = [0,1,"2",3,4,5]

pop表示从列表中删除一个元素,默认(不传递参数)删除末尾的元素

# pop的参数用来指定要删除元素的索引

# pop会返回被删除的元素的值

# dataList2.pop() 

# res = dataList2.pop(2) 参数表示删除几号元素

#print(dataList2)

#print(res)      #结果为2


remove 表示从列表中根据元素的值删除一个元素

dataList2 = [0,1,"2",3,"2"4,5]

# res = dataList2.remove("2") #看列表里有两个“2”，执行一次，默认会移除靠前的一个相同的元素

# print(res)

# print(dataList2) #输出结果为：dataList2 = [0,1,3,"2"4,5]


lst = ["麻花藤", "王剑林林", "李李嘉诚", "王富贵"]
print(lst)
deleted = lst.pop() # 删除最后⼀一个
print("被删除的", deleted)
print(lst)
el = lst.pop(2) # 删除2号元素
print(el)
print(lst)

lst.remove("麻花藤") # 删除指定元素
print(lst)
#lst.remove("哈哈") # 删除不不存在的元素会报错
#print(lst)

lst.clear() #清空list
print(lst) #返回一个空列表 []

#切⽚删除
del lst[1:3]
print(lst)

#注意：如何用remove来删除列表所有元素
st = ["紫云", "大云", "玉溪", "紫钻","a","b"]
for el in st:#有一个变量来记录当前循环的位置
     st.remove(el)
print(st) #错误写法，结果为['大云', '紫钻', 'b']
#for 会计数，它有一个变量来记录当前循环位置

#改进：
lst = ["紫云", "大云", "玉溪", "紫钻","a","b"]
new_lst = [] #准备一个新列表，存放要删除的信息
for el in lst: 
    new_lst.append(el) #将你要删除的内容添加进去

#循环新列表, 删除老列表
for el in new_lst:
    lst.remove(el) #是老列表在删除，新列表不动，所以索引不发生变化

#删除的时候, 发现. 剩余了一下内容. 原因是内部的索引在改变.
#需要把要删除的内容记录下来. 然后循环这个记录. 删除原来的列表

print(lst)
print(new_lst)

lst = ["张国荣", '张铁林', '张国立', "张曼玉", "汪峰"]
# 删掉姓张的
# 记录姓张的.
zhangs = []
for el in lst:
     if el.startswith("张"):
          zhangs.append(el)
for el in zhangs:
     lst.remove(el)
print(lst)
print(zhangs)


#删除list所有相同的元素

获取元素在列表中的个数：list.count()

list1 = [78,23,45,12,78,-90]
#remove会删除找到的第一个元素
#list1.remove(78)

#获取元素在列表中的个数
count1 = list1.count(78)
#print(count1)
for i in  range(count1):
    list1.remove(78)
print(list1)


clear删除所有元素

dataList2.clear()
print(dataList2)

改

dataList3 = [0,1,"2",3,4,5]
dataList3[2] = 2
print(dataList3)

lst = ["太⽩白", "太⿊黑", "五⾊色", "银王", "⽇日天"]
lst[1] = "太污" # 把1号元素修改成太污
print(lst)

#切片添加是迭代效果，需要加[]

lst[1:4] = ["渡我被身子赛高"] # 如果切片没有步⻓或者⻓长是1. 则不⽤关心个数
print(lst)

lst[1:4:3] = ["麻花藤", "哇靠"] # 切⽚修改也OK. 如果步⻓不是1, 要注意. 元素的个数
print(lst)

lst[1:] =["丽日御茶子","绿谷出久","渡我被身子"] #注意下从某个位置取到最后，
会将后面的全部当成一个位置，会全部替换后面的元素


# 查
dataList4 = [0,1,"2",3,4,5]
# 根据索引来查数据
res = dataList4[2] #如果角标越界也会报错
print(res)  #无论怎样强制变换，输出时都会把原列表的字符串的值变成数值类型！

 
index 根据值 来获取该值在列表中的位置
dataList5 = [0,1,"2",3,"2"4,5]
# 根据值获取该值在列表中的位置，如果该值不存在会报错
res = dataList4.index(5)  #结果：6
res = dataList4.index("2") #结果：2  列表中有两个相同元素只会找出靠前的一个位置
print(res)

列表的排序

列表的排序：一种是调用函数；一种是直接使用，然后接收

升序:
list1=[1,2,3,4,-5]
list2=sorted(list1)
print(list2) #结果：[-5, 1, 2, 3, 4]

sorted会生成一个新的排序后的列表
     list2 = sorted(list1) #要接收


list1=[1,2,3,4,-5]
list1.sort() #这个不能接收，即不能list2=list1.sort()
print(list1)

.sort()将原列表进行排序(默认是升序)
     list1.sort()
     print(list1)

降序:
list1=[1,2,3,4,-5]
list1.sort(reverse=True)
print(list1) #结果：[4, 3, 2, 1, -5]


list1=[1,2,3,4,-5]
list2=sorted(list1,reverse=True)
print(list2) #结果：[4, 3, 2, 1, -5]


将列表翻转：
#直接使用.reverse()是将列表翻转（对称位置数字对换）
list1=[1,2,3,4,-5]
list1.reverse()
print(list1) #结果：[-5, 4, 3, 2, 1]

深浅拷贝问题

#列表状态下
list1 = [0,1,2,3,4,5]
list2 = list1
list2[0] = 100 # 这是重新赋值，会把list1中的第一个元素覆盖
print(list1)
print(list2) # 输出结果，两个列表值相同
# 这个是两个不同变量同时指向相同的内存地址

list1 = [0,1,2,3,4,5]
list2 = list1.copy()
list2[0] = 100
print(list1)
print(list2) # 结果：[0, 1, 2, 3, 4, 5] [100, 1, 2, 3, 4, 5]
# 如果是不可变类型，copy后，重新赋值只有赋值的序列会变化
# 浅拷贝了一份内存地址


list1 = [[7,8,9],1,2,3,4,5]
list2 = list1.copy()
list2[0][0] = 100
print(list1)
print(list2) # 结果：[[100, 8, 9], 1, 2, 3, 4, 5] [[100, 8, 9], 1, 2, 3, 4, 5]
# 如果是可变类型，copy后，重新赋值则所有都会变化
# 浅拷贝后，但是内部的没拷贝到，只能共用，所以会发生变化

import copy # 引入copy函数，copy后，重新赋值只有赋值的序列会变化
list1 = [[7,8,9],1,2,3,4,5]
list2 = copy.deepcopy(list1)
list2[0][0] = 100
print(list1)
print(list2) # 结果：[[7, 8, 9], 1, 2, 3, 4, 5] [[100, 8, 9], 1, 2, 3, 4, 5]


import copy # 引入copy模块

lst1 = ["金毛狮王", "紫衫龙王", "青翼蝠王", "白眉鹰王",["张无忌","赵敏","周芷若"]]
lst2 = lst1[:] # 浅拷贝;切片会产生新列表
lst2 = lst1.copy() # 浅拷贝
lst2 = copy.deepcopy(lst1)

#lst1[4].append("小昭")

print(lst1)
print(lst2)

print(id(lst1[4]))
print(id(lst2[4]))

# 1. 赋值操作，没有创建新对象
# 2. 浅拷贝：只拷贝第一层内容，如 [:]  copy()
# 3. 深拷贝：把这个对象内部的内容全部拷贝一份，如 引入copy模块.deepcopy()

练习题

>>>将敏感内容替换为“*”号
li = ["苍老师", "东京热", "武藤兰", "波多野结衣"]
user_input=input("please enter content:").strip()
li2=[]
for re in li:
     if re in user_input: #判断多个时，必须要用 in 
          user_input=user_input.replace(re,"*"*len(re))
          #要替换的是user_input
li2.append(user_input)
print(li2)

>>>将多层列表里的内容全部打印出来，有大写变小写，保留双引号

li = [1, 3, 4, "alex", [3, 7, 8, "TaiBai"], 5, "RiTiAn"]

for i in li :
     if type(i)==list:
          for el in i:
               if type(el)==str: #只有字符串才能用
                    print(f'"{el.lower()}"',end=" ")
          else:
               print(el,end=" ")
     elif type(i)==str:
          print(f'"{i.lower()}"',end=" ")
     else:
          print(i,end=" ")

#格式化输出 
格式：f"{输入内容}"
f'"{输出内容}"' ，外层的单双引号可以按需求互换

>>>用户输入：姓名_成绩，求出所有的成绩的平均成绩
li=[]
while True:
     user_input = input("please enter content like 'min_100'and enter 'Q'quit:")
     if user_input=="Q".lower():
          print("enter over")
          break
     else:
          res=user_input.split("_")
          li.append(res[1]) #循环添加切割出来的第二元素（成绩）
sum=0
for el in li:
     sum+=int(el)
print(sum/len(li))

>>>敲7游戏，遇到7或者7的倍数则用“哐”代替
li=[]
n=int(input("please enter a num:").strip())
for i in range(n+1):
     if i!=0 and i % 7 ==0:
          li.append("哐")
          continue
     li.append(i)
print(li)

>>>给出一个纯数字列表. 请对列表进行排序(升级题).
思路:
1. 完成a和b的数据交换. 例如, a = 10, b = 24 交换之后, a = 24, b = 10
2. 循环列表. 判断a[i]和a[i+1]之间的大小关系, 如果a[i]比a[i+1]大. 则进行互换. 
     循环结束的时候. 当前列表中最大的数据就会被移动到最右端.
3. 想一想, 如果再次执行一次上面的操作. 最终第二大的数据就移动到了右端. 以此类推. 
     如果反复的进行执行相应的操作. 那这个列表就变成了一个有序列表.

#这个算法可以进行优化.
#冒泡排序,
lst = [5,1,7,2,6,4,5,6]
count = 0
while count < len(lst): # 控制次数
     i = 0
     while i < len(lst) - 1:
          if lst[i] > lst[i + 1]:
               lst[i], lst[i + 1] = lst[i + 1], lst[i]
          i = i + 1
     count = count + 1
print(lst)


#for来做：
for j in range(len(li)):
     for i in range(len(li)-1):
          if li[i]>li[i+1]:
               li[i], li[i + 1] = li[i + 1], li[i]
print(li)