列表
"""
列表:使用一个变量，存储多个元素
列表：可变的、有序的序列
"""
name1="tom"
name2="jerry"
name3="kate"
一、列表的定义
names=["tom","jerry","kate"]
print(names)
print(type(names))
#列表的内存结构
names2=["tom","jerry","kate"]
# 列表元素的数据类型：可以是任何数据类型，包括列表
# 定义空列表：一般用来声明列表类型的变量
listnull=[]
print(listnull)
print(type(listnull))
# 列表的长度
print(len(names))
二、列表的操作
1.运算
# 支持+ * in not in is is not == < > （除了位运算符，//,%)
# + 合并列表 # 新创建的列表
a=[1,2,3]
b=["a","b"]
c=a+b
print(c)
print(a,b)
# * 重复
print(a*3)
# in not in ，返回布尔类型 True False
print(1 in a)
print(3 in names)
print(3 in names[6])
# is: 对象是否同一个
# == ： 内容是否同一个
a=[1,2,3]
b=[1,2,3]
c=b
print(a == b)
print(a is b)
print(c == b)
print(c is b)
# < > 按照元素依次比较
print(["a","b","c"]>["a","c","d"])
2. 索引 获取一个元素
# 列表[index]：index 正数（从左到右），负数（从右到左），0，第一个元素
li=["a","b","c",'d']
print(li[0])
print(li[len(li)-1])
print(li[-1])
# 索引不能越界，越界会报错
# [-len(o),len(o)-1]
# 列表的可变性
li[1]=[1,2,3]
print(li)
# 字符串不具备可变性
# s="abcd"
# s[1]="f"
# 使用索引修改元素的位置
1. 交换某两个元素的位置
# li=[1,2,3,4]
# temp=li[0]
# li[0]=li[1]
# li[1]=temp
li[0],li[1]=li[1],li[0]
print(li)
2. 可以将列表中的所有元素都修改成原来的 第一个元素
for index,i in enumerate(li):
li[index]=li[0]
print(li)
3. 切片：获取一个区域内多个元素
# 列表[start:end:step] 包含start ，不包含end
# start end step ,正数，负数，start和end可以是0，step不能是0
# start 省略，默认是0
# end省略，默认是len（o）
# step 省略，默认是1
li=[1,2,3,4,5,6]
print(li[0:4])
print(li[:4])
print(li[0:])
print(li[:])
print(li[1:4:-1])
print(li[4:1:-1])
print(li[-100:100])
# 列表的切片赋值
li[1:2]="a"
print(li)
# 向第二个元素后面插入一个元素 不能插入数值，可以插入字符串
li[2:2]="dddd"
print(li)
# 删除第二个元素
li[1:2]=[]
print(li)
三、列表的相关方法
1. 添加、追加、合并
append： 向列表尾部追加一个元素,一次只能追加一个元素，在原列表上追加
li=["A",'B','C','D']
li.append("E")
print(li)
# + : 新创建列表对象
print(li+["E"],li)
extend 合并，一次可以追加多个元素，向尾部追加，原地追加
b=[1,2,3]
li.extend(b)
print(li)
insert 可以向列表的指定位置插入元素，一次插入一个,原地操作
li.insert(2,"new")
print(li)
2. 删除清空类型
pop 删除指定位置index的元素，一次只能删一个：原地删除
# pop中不添加参数，删除最后一个元素
li.pop()
print(li)
li.pop(3)
print(li)
remove: 根据指定的内容删除元素，一次也只能删除一个:原地删除
li.remove("D")
print(li)
del 删除所有的对象（变量名，元素）,删除的是名字
del li[0]
print(li)
del li
print(li)
清空clear ,清空列表中的所有元素
li.clear()
print(li)
3.查找， 统计，反转
index ， 如果存在该元素，返回元素所在的位置，如果不存在，会报错
# 不指定start和end，会默认查找全部元素
print(li.index("E"))
print(li.index("Ee"))
print(li.index("E,0,3"))
count :统计某一个元素的个数
print(li.count("E"))
反转：就地反转
li.reverse()
print(li)
排序:就地排序
a=["aa","bb","gg","cc","dd"]
# 默认是升序 reverse=False
a.sort()
a.sort(reverse=False)
print(a)
# 降序
# 降序方式1
a.sort(reverse=True)
print(a)
# 降序方式2
a.sort()
a.reverse()
print(a)
4. 列表的复制
1. 赋值：其实不是复制，只是给原来的列表起个新名字
a=[1,2,3,[5,6]]
b=a
print(a is b)
a[0]="new"
a[3][0]="new2"
print(a,b)
2. 切片 浅拷贝:会拷贝到第一个列表对象（第一个可变类型）
# 对于可变类型来说，整切片会新创建对象。
c=a[:]
print(c is a)
a[0]="new"
a[3][0]="new2"
print(a,c)
函数id（o）能够看到内存地址
print(id(a),id(b),id(c))
print(id(a[3]),id(b[3]),id(c[3]))
3. copy方法：浅拷贝
a=[1,2,3,[5,6]]
d=a.copy()
print(a is d)
a[0]="new"
a[3][0]="news"
print(a,b)
print(id(a),id(d))
print(id(a[3]),id(d[3]))
深拷贝 :一直拷贝所有的可变类型，不拷贝不可变类型
import copy
a=[1,2,3,[5,6]]
e=copy.deepcopy(a)
print(a is e)
a[0]="new"
a[3][0]="new2"
print(a,e)
print(id(a),id(e))
print(id(a[3]),id(e[3]))
print(id(a[3][1]),id(e[3][1]))
# 练习
# sort 原地排序
# 定义一个列表，使用赋值、切片、深拷贝，
# 去复制列表，对原来的列表进行排序，输出原来的列表和复制后的列表
def coy():
li=[1,3,4,56,88,42]
li1=li
li2=li[:]
li3=copy.deepcopy(li)
print(li)
print(li1)
print(li2)
print(li3)
print()
li.sort()
print(li)
print(li1)
print(li2)
print(li3)
lix1=[[1],[3],[2]]
lix2=lix1
lix3=lix1[:]
lix4=copy.deepcopy(lix1)
print(lix1)
print(lix2)
print(lix3)
print(lix4)
lix1.sort()
print()
print(lix1)
print(lix2)
print(lix3)
print(lix4)
四、列表的遍历
li=[2,3,4,5,67,77]
for i in li:
print(i)
for index in range(len(li)):
print("index",index)
print("item",li[index])
for index,i in enumerate(li):
print(index)
print(i)
对于嵌套列表的遍历
# li=[[1,2,3],1,[3,5]] #练习：遍历列表中所有的元素（字符串、数值、列表）
li=[[1,2,3],[3,5]]
for i in li:
for j in i:
print(j)
五、列表推导式
# 作用：能够输出列表中所有的元素，而且对元素进行修改
# 格式：[输出的内容（表达式） for 每一个元素变量名 in 列表 [if 条件]]
li=[1,2,3]
b=[x*2 for x in li]
print(b)
c=[]
for x in li:
c.append(x*2)
print(c)