python入门（二）——列表与元组

发表于 更新于 分类于 阅读次数：

本章介绍python的一些数据结构

  • 列表

  • 元组

列表

python里面摒弃了数组啊之类的概念，用列表来代替，其实效果和使用方法做了一个扩展，变得更6了～

直接上代码

1
2
3
list_int = [1, 2, 5, 3]
list2_string = ['Bella', 'Laura', 'Kinsey', 'Lydia']
list3_mix = [1, 4, 5.0, 'Bella', [1, 3, 5]]

也就是说，列表是一个乱七八糟的数组。一个数组里的元素是一样的类型，但是list可以是各种成分的杂糅体。

那么在选取的时候也跟array一样啦

1
2
3
4
name1 = list2_string[0]

>name1
>Bella

只要注意它从0开始就行了，没什么难的

添加element

有四种方法

1. append

直接加在末尾，加一个新的元素

1
2
3
4
list2_name.append('Iris')

>list2_name
>['Bella', 'Laura', 'Kinsey', 'Lydia','Iris']

2. extend

也是加在末尾，但是相当于两个list的合并，也就是说，不能直接把元素加进去，而要加一个list

1
list2_name.expend(['Iris'])

效果和append是一样的

3. insert

insert(插入的位置，插入的内容)

1
2
3
4
list2_name.insert(2, 'Iris')

>list2_name
>['Bella', 'Laura','Iris', 'Kinsey', 'Lydia']

4. 加号

最简单的啦，直接用➕号连接起来。注意连接的左右两边要是同样的类型，也就是list

1
2
3
4
list4 = list1 + [5,6,7]

>list4
>[1, 2, 5, 3, 5, 6, 7]

删除元素

三种方法

1. remove

remove + 元素名 

1
2
3
4
list2_name.remove('Bella')

>list2_name
>['Laura', 'Kinsey', 'Lydia','Iris']

2. del

del是一个系统函数，所以直接用，不用list点什么

1
2
3
4
del list2_name[1]

>list2_name
>['Laura',  'Lydia','Iris']

3. pop

pop是会弹出，也就是说不仅移除，而且会返回值

1
2
3
4
5
6
7
8
9
10
11
12
# pop()不带参数，默认弹出最后一个，像一个栈
list2_name.pop()

>list2_name
>['Laura',  'Lydia']

# pop（）也可以带参数，带index
list2_name.pop(1)

>list2_name
>['Laura']

好了，讲了基础的，下面是神奇的部分～

切片slice

我们发现，当我们想更偷懒一点，想要一次操作一片，怎么做呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
＃生成一个list
>list5 = list(range(10))

>list5
>[0,1,2,3,4,5,6,7,8,9]

# 截取前面的直到3，开区间，也就是0到2个
>pre = list5[:3]
>pre
>[0,1,2]

# 截取从index＝5（也就是第六个）后面的所有
>back = list5[5:]
>back
>[5,6,7,8,9]

# 截取中间的，范围从index的3到5
>mid = list[3,5]
>mid
>[3,4]

list比较

list们进行比较的时候，只比较第一个值的大小。比如

1
2
3
4
5
list_a = [1, 50]
list_B = [2, 0]

>list_a > list_b
>False

list和重复符号

1
2
3
4
list_repeat = list_a * 3

>list_repeat
>[1, 50, 1, 50, 1, 50]

list 和成员符号

1
2
3
4
5
6
7
8
>list_1
>[1, 50]

>2 in list_1
>False

>1 in list_1
>True

list的反转

1
list_1.reverse()

注意reverse没有返回值，会在原list上直接作修改。相当于原地翻转

list的排序

1
2
3
4
5
6
7
8
9
10
11
>list = [2,1,8,3]

# 默认从小到大
>list.sort()
>list
>[1,2,3,8]

# 如果要从大到小，这样做
>list.sort(reverse = True)
>list
>[8,3,2,1]

求元素的索引

list的元素下标索引是一个很鬼畜的功能，如果这个列表中有很多个你想查询的元素，则它只会返回范围内的第一个

1
2
3
4
5
6
7
8
9
10
11
l1 = [1,2,3] * 3
>l1
>[1,2,3,1,2,3,1,2,3]

# 不指定范围，则默认所有
>l1.index(1)
>0

# 指定范围之后 index(要找的元素，起点下标，终点下标)
>l1.index(1, 2, 5)
>3

计算某个元素出现的个数

这个很简单，直接用

1
2
3
4
5
6
l1 = list(range(3))*3
>l1
>[0,1,2,0,1,2,0,1,2]

>l1.count(1)
>3

当做函数

list还可以当做一个函数，后边括号里接需要迭代的内容，可以将后边的内容变成一个个list的元素

1
2
3
>>> s = "Bella is a good learner"
>>> list(s)
['b', 'e', 'l', 'l', 'a', ' ', 'i', 's', ' ', 'a', ' ', 'g', 'o', 'o', 'd', ' ', 'l', 'e', 'a', 'r', 'n', 'e', 'r']

好了，到这里，list的常用功能都介绍完了～
更多的功能，直接

1
dir(list)

就可以看到：

1
2
>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

就不一一介绍啦～相信大家都会举一反三的～

元组

元组tuple是跟list 很像的一个存在，只是加了枷锁的列表，一旦定义，不能进行修改。

元组的定义很神奇，不是像列表一样用［］方括号括起来就表示这种结构，而是由，进行来定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>tuple1 = 1, 2, 3
>tuple2 = (1,2,3)

# 两种表达形式都可以
>tuple1 
>(1,2,3)

>tuple2
>(1,2,3)

＃如果只有一个元素的元组，则记得加逗号
>tuple3 = 1,
>tuple3
>(1,)

元组可以进行切片

1
2
3
4
tuple3 = tuple1[:2]

>>>tuple3
>>>(1,2)

元组的插入

实际上就是先把元组切开，然后加上某些元素，再拼上去。很tricky

1
2
3
4
>>> temp = (1,2,3,4,5)
>>> temp = temp[:2]+(7,8)+temp[2:]
>>> temp
(1, 2, 7, 8, 3, 4, 5)

元组的就先讲到这里～想起来什么新的再说吧～