Gausst松鼠会

这个屌丝很懒，什么也没留下！

热门标签

Python 期末复习-列表_列表[1:4:2]什么意思

作者：Gausst松鼠会 | 2024-05-05 17:49:51

踩

列表[1:4:2]什么意思

列表切片问题：列表切片时的开始，结束，和步长问题

不要将列表的开始与结束与步长一起看，将他们分为两组，开始与结束为一组他们决定切片区间，步长单独一组为方向与切片间隔数

比如说
我们定义一个列表l

l=[0,1,2,3,4,5,6,7,8]

实验一下l[1:4:2]

我们先将【1:4】讲一下

1为列表切片的开始，代表的是列表中从0开始数位置为1的那一个在我们所见的列表中l[1]就是1

4为列表的结束，++但在列表切片中我们是取不到最后一个的++，因此我们实际只取到了l[4-1]即l[3]
我们讲一下步长

步长为2，判断2是正数，所以我们从左向右取，间隔数为2-1=1（因为我们每个步长个长度中只取一个），如果间隔后没有可以取得了，那就不取了。

省略问题

L[:3:2]类问题：

：前没有给数字，这是省略了开始，即从头开始取
L[1::2]类问题：

中间没有加数字表明他是从给定的开始数字，此处时l[1]一直到最后
L[1:4]类问题：

此时没有了第二个：不要方，此时列表还在省略，省略的是步长，即1。
L[-4:-1]类问题：

这时候不要看前边区间都是负的就要从右往左去取，这时候他依然是从左往右的，我们写时或许会在这出错，但是题目大多是不会错的，大胆的分成两组去看

写列表切片时要注意区间与方向的问题

如果步长是正的，那么：前的位置要比冒号后边的位置要靠前。

如果步长是负的，那么：前的位置要比冒号后边的位置要靠后。

因为开始方向不同

首先定下区间，那个取不到

然后看方向和步长去取值

列表分片赋值

分片赋值等号前后都为列表形式

field[1:1]=list('bcd')
1

列表分片赋值:可以使用与原序列不等长的序列将分片替换

greeting=list("hi")
greeting[1:]=list("ello") 
print(greeting)
1
2
3

['h', 'e', 'l', 'l', 'o']
1

可以在不替换任何原有元素的情况下在任意位置插入新元素

field=list('ae')
field[1:1]=list('bcd')
print(field)
boil=list('女排夺冠了')
print(boil)
boil[2:2]=list('2016年奥运会')
print(boil)
1
2
3
4
5
6
7

['a', 'b', 'c', 'd', 'e']
['女', '排', '夺', '冠', '了']
['女', '排', '2', '0', '1', '6', '年', '奥', '运', '会', '夺', '冠', '了']
1
2
3

分片赋值实现删除功能

field=list('abcde')
print(field)
field[1:4]=[]
print(field)
boil=list('女排2016年奥运会夺冠了')
print(boil)
boil[2:10]=[]
print(boil)
1
2
3
4
5
6
7
8

['a', 'b', 'c', 'd', 'e']
['a', 'e']
['女', '排', '2', '0', '1', '6', '年', '奥', '运', '会', '夺', '冠', '了']
['女', '排', '夺', '冠', '了']
1
2
3
4

将切片出来的列表赋值成空列表

列表方法

插入类

1. append()
    ```
    L=[1,1.3,'2','china',['I','am','another','list']]
    L.append([5])
    print(L)
    L.append('a')
    print(L)
    L.append(12)
    print(L)
    ```
    ```
    [1, 1.3, '2', 'china', ['I', 'am', 'another', 'list'], [5]]
    [1, 1.3, '2', 'china', ['I', 'am', 'another', 'list'], [5], 'a']
    [1, 1.3, '2', 'china', ['I', 'am', 'another', 'list'], [5], 'a', 12]
    ```
     ==此函数中只能在末尾添加，可以加列表、字符串、数字==
2. extend()
    ```
    a=['hello','world']
    print(a)
    b=['python','is','funny']
    a.extend(b)
    print(a)
    a.extend([1,2,3])
    print(a)
    ```
    ```
    ['hello', 'world']
    ['hello', 'world', 'python', 'is', 'funny']
    ['hello', 'world', 'python', 'is', 'funny', 1, 2, 3]
    ```
    ==此函数只能在末尾加列表==
             
    **同效果**
    * 序列相加
    ```
    a=['hello','world']
    b=['python','is','funny']
    print(a+b)
    print(a)
    ```
    ```
    ['hello', 'world', 'python', 'is', 'funny']
    ['hello', 'world']
    ```
    * 切片赋值
    ```
    a=['hello','world']
    b=['python','is','funny']
    a[len(a):]=b
    print(a)
    ```
    ```
    ['hello', 'world', 'python', 'is', 'funny']
    ```
3. insert()

    **insert(位置，插入元素)**
    ```
    num=['a','b','c']
    print('插入之前的num:',num)
    num.insert(2,'hello word')
    print('插入之后的num：',num)
    num.insert(2,[3])
    print('插入之后的num：',num)
    num.insert(2,1234)
    print('插入之后的num：',num)
    ```
    ```
    插入之前的num: ['a', 'b', 'c']
    插入之后的num： ['a', 'b', 'hello word', 'c']
    插入之后的num： ['a', 'b', [3], 'hello word', 'c']
    插入之后的num： ['a', 'b', 1234, [3], 'hello word', 'c']
    ```
    ==将ℹ️位置的元素向后挪，把加的元素放在ℹ️位置==
    
    ==可以列表，字符串，数字==
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

删除类

clear()

整个清空

field=['study','python','is','happy']
field.clear()
print('field调用clear方法后的结果：',field)
1
2
3

field调用clear方法后的结果： []
1

pop()

l.pop(位置)

弹出列表中ℹ️号元素并返回其值，若为pop()则弹出最后一个

field=['hello','world','python','is','funny']
print(field.pop())
print('移除元素后的field：',field)

print(field.pop(3))
print('移除元素之后的field：',field)

print(field.pop(0))
print('移除元素之后的field：',field)
1
2
3
4
5
6
7
8
9

funny
移除元素后的field： ['hello', 'world', 'python', 'is']
is
移除元素之后的field： ['hello', 'world', 'python']
hello
移除元素之后的field： ['world', 'python']
1
2
3
4
5
6

remove()

l.remove(i)

删除列表s中第一个值为ℹ️的元素

field=['女排','精神','中国','精神','学习','精神']
print('移除前列表field：',field)
field.remove('精神')
print('移除后列表field：',field)
1
2
3
4

移除前列表field： ['女排', '精神', '中国', '精神', '学习', '精神']
移除后列表field： ['女排', '中国', '精神', '学习', '精神']
1
2

del

** del i**

删除ℹ️

 string=['a','b','c','d','e']
 del string[1]
 print("请删除列表中第二个元素:",string)
1
2
3

请删除列表中第二个元素: ['a', 'c', 'd', 'e']
1

其他类

copy()

field=['study','python','is','happy']
copyfield=field.copy()
copyfield2=field[:]
print('复制操作的结果：',copyfield)
print('使用列表分片实现复制的效果',copyfield2)
field.append(999)
print(field)
print(copyfield)
print(copyfield2)
L=[1,2,3,4,5]
LL=[7,8,9]
LL=L
print(L)
print(LL)
L.clear();
print(L)
print(LL)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

复制操作的结果： ['study', 'python', 'is', 'happy']
使用列表分片实现复制的效果 ['study', 'python', 'is', 'happy']
['study', 'python', 'is', 'happy', 999]
['study', 'python', 'is', 'happy']
['study', 'python', 'is', 'happy']
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[]
[]
1
2
3
4
5
6
7
8
9

这里清空后LL也没有了的原因是深浅拷贝

变量名所指的是一片空间，此时的L和LL都指向一片空间，所以用任何一个变量名都可以指到这片空间并对其改变，改变后变量名还是只想这片空间，但是空间里的数据变了。
解决办法是为复制的单独在开辟一片空间，切片法或者copy函数法

L=[1,2,3,4,5,6]
LL=L
L1=L[::]
L2=L.copy()
L[2]="huan"
print(L)
print(LL)
print(L1)
print(L2)
1
2
3
4
5
6
7
8
9

[1, 2, 'huan', 4, 5, 6]
[1, 2, 'huan', 4, 5, 6]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]
1
2
3
4

count()

list.count(obj)

field=['h','e','l','l','o','w','o','r','l','d']
print(field)
#统计列表中的字符个数
print('列表field中，字母o的个数：',field.count('o'))
print('列表field中，字母l的个数：',field.count('l'))
print('列表field中，字母a的个数：',field.count('a'))
listobj=[123,'hello','world',123]
listobj=[26,'hello','world',26]
print('数字26的个数：',listobj.count(26))
print('hello的个数：',listobj.count('hello'))
print(['a','c','a','f','a'].count('a'))
mix=[[1,3],5,6,[1,3],2]
print('嵌套列表mix中列表[1,3]的个数为：',mix.count([1,3]))
1
2
3
4
5
6
7
8
9
10
11
12
13

['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']
列表field中，字母o的个数： 2
列表field中，字母l的个数： 3
列表field中，字母a的个数： 0
数字26的个数： 2
hello的个数： 1
3
嵌套列表mix中列表[1,3]的个数为： 2
1
2
3
4
5
6
7
8

sort()

sorted 不改变原列表

L=[123,1,312,42,32]
print(sorted(L))
print(L)
1
2
3

[1, 32, 42, 123, 312]
[123, 1, 312, 42, 32]
1
2

sort 反向排序

L=[123,1,312,42,32]
L.sort(reverse=True)
print(L)
1
2
3

[312, 123, 42, 32, 1]
1

按要求排序法

LL=['12','1','123','2','4']
LL.sort(key=len)
print(LL)
1
2
3

['1', '2', '4', '12', '123']
1

排序实质
字符串按首位排序相同排下一位,按ASCII码排序。

L=[123,1,312,42,32]
LL=['123','1','312','42','32']
L.sort()
LL.sort()
print(L)
print(LL)
1
2
3
4
5
6

[1, 32, 42, 123, 312]
['1', '123', '312', '32', '42']
1
2

index()
语法：list.index(obj)

field=['hello','world','python','is','funny']
print('hello的索引位置为：',field.index('hello'))
print('python的索引位置为：',field.index('python'))
1
2
3

hello的索引位置为： 0
python的索引位置为： 2
1
2

reverse()

num=[1,2,3]
print('列表反转前num：',num)
num.reverse()
print('列表反转后：',num)
print('使用reversed函数翻转结果：',list(reversed(num)))
1
2
3
4
5

列表反转前num： [1, 2, 3]
列表反转后： [3, 2, 1]
使用reversed函数翻转结果： [3, 2, 1]
1
2
3

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/540126