零基础学Python4

列表

创建列表

Alt+p 重复上一段代码

 序列：字符串 列表

访问列表中的某一个元素：下标索引

序列最后一个元素索引值可以是 -1

[1,2,3,4,5]
[1, 2, 3, 4, 5]
[1,2,3,4,5,"上山大老鼠"]
[1, 2, 3, 4, 5, '上山大老鼠']
name=[1,2,3,4,5,"上山大老鼠"]
print(name)
[1, 2, 3, 4, 5, '上山大老鼠']
for each in name:
    print(each)

    
1
2
3
4
5
上山大老鼠
name[0]
1
name[5]
'上山大老鼠'
length=len(name)
name[length-1]
'上山大老鼠'
name[-1]
'上山大老鼠'

列表切片：一次性获取多个元素

name=[1,2,3,4,5,"上山大老鼠"]
name[0:3]
[1, 2, 3]
name[3:6]
[4, 5, '上山大老鼠']
name[:3]   
[1, 2, 3]
name[3:]
[4, 5, '上山大老鼠']
name[:]
[1, 2, 3, 4, 5, '上山大老鼠']
name[0:6:2]       #正序步长为2跳着输出
[1, 3, 5]
name[::2]    
[1, 3, 5]
name[::-2]   #倒序步长为2
['上山大老鼠', 4, 2]
name[::-1]       #倒序输出
['上山大老鼠', 5, 4, 3, 2, 1]

列表的诸多方法：增删改查

1.增：向列表添加元素

append( ):在列表末尾添加一个指定元素但每次只能添加一个元素。

heros=["绿巨人","钢铁侠"]
heros.append("黑寡妇")
heros
['绿巨人', '钢铁侠', '黑寡妇']

extend(): 可直接添加一个可迭代对象，它的参数必须是一个可迭代对象，新的内容是追加到原列表最后一个元素的后面。

heros.extend(["鹰眼","灭霸","雷神"])
heros
['绿巨人', '钢铁侠', '黑寡妇', '鹰眼', '灭霸', '雷神']

切片方法

s=[1,2,3,4,5]
s[len(s):]=[6]
s
[1, 2, 3, 4, 5, 6]
s[len(s):]=[6,7,8]
s
[1, 2, 3, 4, 5, 6, 6, 7, 8]

insert():在列表任意位置添加  （第一个参数：待插入位置 ，第二个参数：待插入元素）

s=[1,3,4]
s.insert(1,2)
s
[1, 2, 3, 4]
s.insert(0,0) #在开头添加
s
[0, 1, 2, 3, 4]
s.insert(len(s),5) #在末尾添加
s
[0, 1, 2, 3, 4, 5]

 2.删

remove():如果列表中存在多个匹配的元素，那么它只会删除第一个；如果指定的元素不存在，那么程序就会报错。

heros=["钢铁侠","灭霸","黑寡妇"]
heros.remove("灭霸")
heros
['钢铁侠', '黑寡妇']

 pop():删除某个位置上的元素；参数是元素的下标索引值

heros.pop(1)
'黑寡妇'
heros
['钢铁侠']

clear():全部清空

heros.clear()
heros
[]

3.改  （列表是可变的，而字符串是不可变的）

heros=["黑寡妇","蜘蛛侠","绿巨人","灭霸"]

heros[3]="钢铁侠"
heros
['黑寡妇', '蜘蛛侠', '绿巨人', '钢铁侠']

heros[2:]=["林冲","武松"]     #切片的方法
heros
['黑寡妇', '蜘蛛侠', '林冲', '武松']

这是分两步完成的 ：i.将赋值号（=）左边指定的内容删除

                                  ii.将包含在赋值号（=）右边的可迭代对象中的片段插入左边被删除的位置。

对序列进行排序：sort（） 、 reverse（）

nums=[3,1,6]

nums.sort()  #从小到大排序
nums
[1, 3, 6]

nums.reverse()  #从大到小排序
nums
[6, 3, 1]

nums=[3,1,6]
nums.sort(reverse=True)   #与先调用sort再调用reverse结果是一样的。
nums
[6, 3, 1]

heros.reverse()
heros
['武松', '林冲', '蜘蛛侠', '黑寡妇']

4.查

count()：查找某个元素出现的次数

nums=[1,1,1,4]
nums.count(1)
3

index()：查找某个元素的索引值 (当不知道某个元素的索引值并且想替换它时)  有多个相同元素时index返回第一个找的元素的下标值。

heros=["黑寡妇","李逵","林冲"]
heros.index("李逵")
1
heros[heros.index("李逵")]="神奇女侠"
heros
['黑寡妇', '神奇女侠', '林冲']

nums=[1,1,1,4]
nums.index(1)
0
nums.index(1,1,3)  #查找 1 从1号元素开始找到3号元素结束
1

5.浅拷贝

copy() :拷贝一个列表

nums_copy1=nums.copy()
nums_copy1
[1, 1, 1, 4]

用切片拷贝

nums_copy2=nums[:]
nums_copy2
[1, 1, 1, 4]

列表的加法和乘法

加法就是拼接 所以要求加号两边也是列表

乘法就是重复若干次

s=[1,2,3]
t=[4,5,6]
s+t
[1, 2, 3, 4, 5, 6]
s*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

嵌套列表 二维列表

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

 访问嵌套列表元素：利用循环实现

for i in matrix:
        for each in i:
                print(each)

        
1
2
3
4
5
6
7
8
9
for i in matrix:
        for each in i:
                print(each,end=' ')
        print()

        
1 2 3 
4 5 6 
7 8 9 

用下标访问列表

matrix[0]      
[1, 2, 3]

matrix[0][0]        
1

循环语句创建并初始化二维

A=[0]*3      
A       
[0, 0, 0]

for i in range(3):
        A[i]=[0]*3     
A     
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

A[1][1]=1     
A     
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]

B=[[0]*3]*3   #错误写法        
B
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

B[1][1]=1  #因为
B
[[0, 1, 0], [0, 1, 0], [0, 1, 0]]

is 运算符称为同一性运算符：检验两个变量是否指向同一个对象

x="F"     
y="F"     
x is y       
True

x=[1,2,3]     
y=[1,2,3]      
x is y     #字符串可以指向一个 但列表不是 
False

A[0] is A[1]   
False    #这是正确列表

B[0] is B[1]
True     #这是错误的列表

变量是一个名字标签 通过变量找到数据  变量不是一个盒子

引用

x=[1,2,3]

x=y   #将一个变量赋值给另一个变量，就是将一个变量的引用传递给另一个变量。

x=[1,2,3]
y=x
x[1]=1
x
[1, 1, 3]
y
[1, 1, 3]    #y的内容也会跟着改变

 如果想得到两个独立的列表 要用拷贝

浅拷贝（copy、切片）&深拷贝

copy方法拷贝的是整个列表对象，不仅仅是变量的引用

x=[1,2,3]
y=x.copy()
x[1]=1
x
[1, 1, 3]
y
[1, 2, 3]   #使用拷贝方法y内容就不会改变

切片方法

x=[1,2,3]
y=x[:]
x[1]=1
x
[1, 1, 3]
y
[1, 2, 3]   #y的内容不会改变

一维列表要用浅拷贝 

嵌套列表要用深拷贝（copy模块   ）

import copy
x=[[1,2,3],[4,5,6],[7,8,9]]
y=copy.copy(x) #浅拷贝
x[1][1]=0
x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
y
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]

x=[[1,2,3],[4,5,6],[7,8,9]]
y=copy.deepcopy(x) #深拷贝
x[1][1]=0
x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
y
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

 列表推导式

将列表中的每一个元素的值都变成原来的2倍   

oho=[1,2,3,4,5]
for i in range(len(oho)):
    oho[i]=oho[i]*2
oho
[2, 4, 6, 8, 10]

oho=[1,2,3,4,5]
oho=[i*2 for i in oho]  #列表推导式
oho
[2, 4, 6, 8, 10]

列表推导式结构：

列表推导式的结果是一个列表，所以用 [  ]  ;expression 决定列表结果

x=[i for i in range(10)]
x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
x=[i+1 for i in range(10)]   #列表推导式
x
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

x=[]
for i in range(10):     #利用循环来写
    x.append(i+1) 
x
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

y=[c*2 for c in "love"]
y
['ll', 'oo', 'vv', 'ee']

coed=[ord(c) for c in "love"]   ##将每一个字符都转换成对应的Unicode编码并保存为列表
coed
[108, 111, 118, 101]

获取列表每一行第二个元素

matrix=[[1,2,3],
        [4,5,6],
        [7,8,9]]       
co12=[row[1] for row in matrix] #获取每一行第二个元素
co12        
[2, 5, 8]

diag=[matrix[i][i] for i in range(len(matrix))]   #获取主对角线上的值
diag        
[1, 5, 9]

diag=[matrix[i][-i-1] for i in range(len(matrix))]   #获取副对角线上的值  
diag        
[3, 5, 7]

 循环是通过迭代来逐个修改原列表中的元素

列表推导式是创建一个新的列表然后再赋值为原先的这个变量名

s=[[0]*3 for i in range(3)]  #列表推导创建列表
s
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

 列表推导式可以添加一个用于筛选的if分句  先执行for语句再执行if语句 再执行最左侧表达式

words=["gr","fish","kk"]
a=[i for i in words if i[0]=="f"]
a
['fish']

列表推导式的嵌套

 二维列表降级为一维列表

matrix=[[1,2,3],[4,5,6],[7,8,9]]
flatten=[col for row in matrix for col in row] #列表推导嵌套
flatten
[1, 2, 3, 4, 5, 6, 7, 8, 9]

flatten=[]           #循环理解
for row in matrix:
    for col in row:
        flatten.append(col)       
flatten
[1, 2, 3, 4, 5, 6, 7, 8, 9]

某个变量如果是临时的或者无关紧要的： 用下划线表示  _ 

程序设计原则 KISS：简洁胜于复杂

列表推到的终极语法：每个for后面都可以追加一个if 进行筛选