Python_面向对象_list

--列表相关操作

#列表拼接
#列表的重复
#列表的索引
#列表的修改
#列表的切片

"""
# 字符串跟元祖相似 只能获取,不能修改
strvar = "abcdef"
strvar[0] = "你好"
print(strvar)
"""
#列表拼接
list1 = [1,2,3]
list2 = [4,5,6]
res = list1+list2
print(res)

#列表的重复
list1 = ["脏煎饼","大西瓜"]
res = list1 * 3
print(res)

#列表的索引

# 0 1 2 3
listvar = ["黑山","白云","淑芬","皇后娘娘"]
# -4 -3 -2 -1

print(listvar[-1])

#列表的修改
listvar[-1] = "味之源"
print(listvar)

语法[::] 完整格式：[开始索引:结束索引:间隔值]
　　(1)[开始索引:] 从开始索引截取到列表的最后
　　(2)[:结束索引] 从开头截取到结束索引之前
　　(3)[开始索引:结束索引] 从开始索引截取到结束索引之前
　　(4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取列表值
　　(5)[:]或[::] 截取所有列表数据
#列表的删除

#列表的切片
listvar = ["李阳","曾线","陈家洛","牟梦坤","牟梦坤1","牟梦坤2"]
#(1)[开始索引:] 从开始索引截取到列表的最后
res = listvar[1:]
print(res)

#(2)[:结束索引] 从开头截取到结束索引之前
res = listvar[:-1]
print(res)

#(3)[开始索引:结束索引] 从开始索引截取到结束索引之前
res = listvar[-3:-1]
print(res)

#(4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取列表值
res = listvar[0:6:2]
print(res)

#(5)[:]或[::] 截取所有列表数据
# res = listvar[:]
res = listvar[::]
print(res)

#列表的删除 del 关键字
listvar = ["李阳","曾线","陈家洛","牟梦坤","牟梦坤1","牟梦坤2"]
#(1) 删除单个元素
# del listvar[-1]
# print(listvar)

#(2) 删除切片后的元素
del listvar[-2:]
print(listvar)

#(3) 删除所有列表
del listvar
# print(listvar)

--成员检测

"""
　　检测一个数据是否在列表中
　　格式：值 in 列表
　　结果：布尔值

　　检测一个数据是否不在列表中
　　格式：值 not in 列表
　　结果：布尔值
"""

listvar = ["张三","李四","王五","赵云","钱多多","孙悟空"]
res = "王五" in listvar
print(res)

res = "八哥" not in listvar
print(res)

--列表的相关函数

**append()**
```
　　功能：向列表的末尾添加新的元素
　　格式：列表.append(值)
　　返回值：None
　　注意：新添加的值在列表的末尾，该函数直接操作原有列表
```

**insert()**
```
　　功能：在指定索引之前插入元素
　　格式：列表.insert(索引,值)
　　返回值:None
　　注意：直接改变原有列表
```

**extend()**
```
　　功能：将一个列表继承给另一个列表
　　格式：列表.extend(序列)
　　返回值：None
　　注意：直接改变原有列表
```

**pop()**
```
　　功能：通过指定的索引在列表中移除一个元素
　　格式：列表.pop(索引)
　　返回值：删除的元素
　　注意：没有指定索引，默认移除最后一个元素
```

**remove()**
```
　　功能：通过给予的值来删除,如果多个相同元素,默认删除第一个
　　格式：列表.remove(值)
　　返回值：无
　　注意：如果有索引的情况推荐使用POP移除，效率高于remove,但remove可以用于无序容器类型
```

**index()**
```
　　功能：获取某个值在列表中的索引
　　格式：列表.index(值[,start][,end]) # [] 表达参数可选项
　　返回值：找到返回索引 找不到报错
　　注意：不存在抛出异常错误！
```

**count()**
```
　　功能：计算某个元素出现的次数
　　格式：列表.count(值)
　　返回值：次数
```

**sort()**
```
　　功能：列表排序
　　格式：列表.sort() 按照从小到大排序（数字）
　　格式：列表.sort(reverse=True) 按照从大到小排序（数字）
　　格式：列表.sort(key=函数) 把值通过函数处理之后在从小到大排序
　　格式：列表.sort(key=函数，reverse=True) 把值通过函数处理之后在从大到小排序

　　返回值：None
　　注意：直接更改原列表
　　与高阶函数sorted相比: sort更改原列表
　　sorted不更改原列表,返回新列表
```

**reverse()**
```
　　功能：列表反转操作
　　格式：列表.reverse()
　　返回值：None
　　注意：直接更改原列表
```

#**clear**
```
　　功能：清空列表
　　格式：列表.clear()
　　返回值：空列表
```

#import copy | copy模块中有 浅拷贝 和 深拷贝
"""
　　#浅拷贝: 浅拷贝只拷贝外层列表 内层列表跟随原列表进行改变
　　#深拷贝: 拷贝整个列表 内外列表都不跟随原列表进行改变
　　#**深拷贝copy.deepcopy(listvar)**
　　#**浅拷贝copy.copy(listvar) 或者 listvar.copy()**
　　注意:copy模块的copy方法 和 python内置的函数copy一样 都是浅拷贝
"""

#--列表的相关函数
#**append()**
listvar = [1,2,3]
res = listvar.append(4)
print(listvar) #[1, 2, 3, 4]
print(res)   # None

#**insert()**
listvar = [1,2,3,4,5]
res = listvar.insert(2,"我爱北京天安门")
print(listvar)
print(res)

#**extend()**
list1 = ["杨玉环","貂蝉"]
list2 = ["潘金莲"]

res = list2.extend(list1)
print(list2)
print(res)

#**pop()**
listvar = [7,2,1,9]
"""
res = listvar.pop(-2)
print(listvar) #[7, 2, 9]
print(res) #1
"""
res = listvar.pop()
print(listvar)
print(res)

#**remove()**
#(1)
listvar = [1,2,3,4]
res = listvar.remove(3)
print(listvar)
print(res)
#(2) 如果有多个相同的值, 默认删除第一个
listvar = [1,2,3,4,5,3,7,8,9]
res = listvar.remove(3)
print(listvar)
print(res)

#**index()**
listvar = ["张三","李四","王五","赵云","钱多多","孙悟空"]
# 如果不存在该值 则报错 ValueError
suoyinhao = listvar.index("李四4")
print(suoyinhao)

suoyinhao = listvar.index("李四",listvar.index("李四")+1)
# suoyinhao = listvar.index("李四",listvar.index("李四")+1,listvar.index("李四")+2)
print(suoyinhao)

#**count()**
listvar = [1,7,3,2,4,6,2,3,11,22,2]
res = listvar.count(2)
print(res)

#**sort()**
listvar = [7,3,8,1]
res = listvar.sort()
print(listvar)
print(res)

# 通过reverse=True 进行降序
res = listvar.sort(reverse=True)
print(res)
print(listvar)

print("<>")
listvar = [7,3,8,1]
res = sorted(listvar)
print(listvar)
print(res)

#练习 按照字母排序

listvar = [
{"name":"dalinzi","age":11},
{"name":"cerry","age":12},
{"name":"bobo","age":13},
{"name":"aniol","age":14}
]

listvar.sort(key=lambda x:x['name'])
print(listvar)

#**reverse()**
listvar = [78,34,11,55]
res = listvar.reverse()
print(listvar)
print(res)

#**clear**
listvar = [78,34,11,55]
res = listvar.clear()
print(listvar)
print(res)

 

"""
　　#浅拷贝: 浅拷贝只拷贝外层列表 内层列表跟随原列表进行改变
　　#深拷贝: 拷贝整个列表 内外列表都不跟随原列表进行改变
　　#**深拷贝copy.deepcopy(listvar)**
　　#**浅拷贝copy.copy(listvar) 或者 listvar.copy()**
　　注意:copy模块的copy方法 和 python内置的函数copy一样 都是浅拷贝
"""

# 深拷贝 和 浅拷贝
"""
# 这样的缘起 我们怎么办?
listvar = [1,2,3]
listvar2 = listvar
print(listvar2)
listvar.append(4)
print(listvar)
print(listvar2)
listvar2.append(5)
print(listvar)
print(listvar is listvar2)
"""
"""
a = 5
b = a
a +=1
print(b)
"""

# 案例2 copy
listvar = [1,2,3]
# listvar2 = []
listvar2 = listvar.copy()
print(listvar2)
listvar.append(4)
print(listvar)
print(listvar2)

# 案例3 copy
listvar = [1,2,3,[4,5]]
listvar2 = listvar.copy()
listvar.append(6)
print(listvar2) #[1, 2, 3, [4, 5]]
print(listvar) #[1, 2, 3, [4, 5], 6]
listvar[3].append(7)
print(listvar2)
print(listvar)

# 案例4 浅拷贝
"""
copy模块的copy方法
和
python内置的函数copy一样 都是浅拷贝
"""

import copy
#copy deepcopy
listvar = [1,2,3,[4,5]]
res = copy.copy(listvar)
print("<>")
print(res)
listvar[-1].append(8)
print(listvar)
print(res)

# 案例5 深拷贝
# 内层外层均拷贝出来 再也不受原列表影响了
#copy deepcopy
listvar = [1,2,3,[4,5]]
newlist = copy.deepcopy(listvar)
listvar[-1].append(9)
print(newlist)
print(listvar)
print(newlist is listvar)

--列表推导式
　　#普通列表推导式
　　#带有判断条件的列表推到式
　　#多循环列表推到式
　　#带有判断条件的多循环推到式

# 列表推导式
# 案例1
listvar = [1,2,3,4,5,6]
listvar2 = []
for i in listvar:
　　res = i ** 2
　　listvar2.append(res)
print(listvar2)

# 列表推导式里面只能是循环和判断 除此之外的任何语法都不行
res = [i ** 2 for i in listvar]
print(res)

# 带有判断条件的列表推到式
listvar = [1,2,3,4,5,6]
res = [i for i in listvar if i % 2 == 0]
print(res)

# 多循环列表推到式
list1 = ["火龙果","菠萝蜜","要钱树"]
list2 = ["栗子","鸡子","苹果"]
# list3 = []
"""
#原型:
for i in list1:
　　for j in list2:
　　　　if list1.index(i) == list2.index(j):
　　　　　　list3.append(i+"---"+j)
print(list3)
"""
res = [ i+"---"+j for i in list1 for j in list2 ]
print(res)
#['火龙果---栗子', '火龙果---鸡子', '火龙果---苹果', '菠萝蜜---栗子', '菠萝蜜---鸡子', '菠萝蜜---苹果', '要钱树---栗子', '要钱树---鸡子', '要钱树---苹果']
# 火龙果---栗子 菠萝蜜---鸡子 要钱树---苹果

#带有判断条件的多循环推到式
res = [ i+"---"+j for i in list1 for j in list2 if list1.index(i) == list2.index(j)]
print(res)

练习

#(1).{'x': 'A', 'y': 'B', 'z': 'C' } 把字典写成x=A,y=B,z=C的列表推导式
# [x=A,y=B,z=C]
dictvar = {'x': 'A', 'y': 'B', 'z': 'C' }
#方法一
res = [i[0]+"="+i[1] for i in dictvar.items()]
#方法二
res = [a+"="+b for a,b in dictvar.items()]
print(res)

# (2).把列表中所有字符变成小写
listvar = ["ADDD","dddDD","DDaa","sss"]
res = [ i.lower() for i in listvar]
print(res)

#(3)求(x,y)其中x是0-5之间的偶数，y是0-5之间的奇数组成的元祖列表 (不包含5)
# (0 2 4) (1 3) x , y
res = [(x,y) for x in range(0,5) if x % 2 == 0 for y in range(0,5) if y % 2 == 1]
print(res)

#(4).使用列表推导式 制作所有99乘法表中的运算
"""
for i in range(1,10):
for j in range(1,10):
if j<=i:
print("%d*%d =%2d "%(i,j,i*j),end="")
print()
"""
res = ["%d*%d =%2d "%(i,j,i*j) for i in range(1,10) for j in range(1,10) if j <= i ]
print(res)

#(5)#求M,N中矩阵和元素的乘积
# M = [ [1,2,3], 
#    [4,5,6], 
#    [7,8,9] ] 

# N = [ [2,2,2], 
#    [3,3,3], 
#    [4,4,4] ] 

"""
row 0 col 0
row 0 col 1
row 0 col 2

row 1 col 0
row 1 col 1
row 1 col 2

row 2 col 0
row 2 col 1
row 2 col 2
"""

M = [ [1,2,3],[4,5,6],[7,8,9]]
N = [ [2,2,2],[3,3,3],[4,4,4]]
res = [M[row][col] * N[row][col] for row in range(0,3) for col in range(0,3)]
#[2, 4, 6, 12, 15, 18, 28, 32, 36]
print(res)

#[[2, 4, 6], [12, 15, 18], [28, 32, 36]]
res = [ [ M[row][col] * N[row][col] for col in range(0,3) ] for row in range(0,3)]
print(res)