# python 系列# —1 列表与元组

发表于 | 分类于

概述

Python 包含6种内建序列，其中包括包括列表，元组，字符串， Unicode字符串， buffer对象和xrange对象。我们这篇文章来讲一下序列跟元组这两种基本序列。
其中列表和元组最大的区别是列表是可变的, 而元组是不可变的

序列的基本通用操作

基本操作包括索引，分片， 加，乘，长度，判断序列是否存在成员 等等

索引

我们用索引来访问序列单个元素

1
2
3
4
5
6
7
8
## 通用序列操作 -- 索引##
## 获取第一个元素 ##
value='helloWorld'
print(value[0])## ==> h
## 那么如何获取最后一个元素 ##
print(value[-1])## ==> d
## 当然也可以用直接字面值获取索引值 ##
print('helloWorld'[0])## ==> h

分片

我们用分片访问多个元素，用冒号隔开声明范围的两个索引。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
## 通用序列操作 -- 分片 ##
number=[1,2,3,4,5,6,7,8,9,10]
## 获取前五个元素 ##
print(number[0:5]) ## ==> [1, 2, 3, 4, 5]
## 如果我在不知道元素个数的情况下，要获取最后3个元素呢？ python的魔法来了##
print(number[-3:]) ## ==> [8, 9, 10]
## 还可以从元素后面开始获取元素 ##
print(number[-4:-1]) ## ==> [7, 8, 9]
## 那么你可能会想，可不可以这样呢 ##
print(number[-3:0]) ## ==> [] 抱歉结果不是你想的那样
## 如果你想复制一个序列，你可以这样 ##
newNumber = number[:]
print(newNumber) ## ==> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

## 分片还有步长的概念，通常步长是默认设置的，值为1 ##
print(number[0:10:2]) ## 步长设置为2 ==>[1, 3, 5, 7, 9]
print(number[0:3:3]) ## 步长设置为3 ==> [1]
## 当前也还是可以使用上面不设置分片开始和结束索引值 ##
print(number[::3]) ## 范围开始和结束值都不设置 ==> [1, 4, 7, 10]

序列相加

相同序列可以相加，不同类型的序列不可以相加.

1
2
3
4
5
6
7
8
9
10
## 通用序列操作 -- 加 ##
numberAdd=[1,2,3]
numberAdd2=[4,5,6]
print(numberAdd+numberAdd2) ##序列相同，可以相加 ==> [1, 2, 3, 4, 5, 6]
## 如果是字符串列表和数字列表相加呢呢 ##
numberStr=['4','5','6']
print(numberAdd + numberStr); ## ==> [1, 2, 3, '4', '5', '6']
## 那如果是字符串和数字列表相加呢 ##
helloStr = 'hello';
#print(numberAdd + helloStr) ## ==> error 会报错。不同序列之间不能相加

序列相乘

如果同一个字符串或者列表要复制多次怎么办，如果以前用java 可能需要for循环，然后每次append。
但是在python你不用这么做。他有乘法操作。

1
2
3
4
5
## 通用序列操作 -- 相乘##
print('hello'*5) ## ==> hellohellohellohellohello
## 如果想声明10个空元素的列表应该怎么做呢 ##
emptyList=[None]## 其中None为内建空值
print(emptyList*10)## ==>[None, None, None, None, None, None, None, None, None, None]

判断成员资格

如果需要判断一个成员是否存在于某个序列之中，成员资格判断是一种boolean操作。

1
2
3
4
5
6
7
## 通用序列操作 -- 成员资格判断 ##
print('w'in'www.python.org')# ==>True
print('w'in'WWW.PYTHON.ORG')# ==>False
numberSub=[1,2,3]
numberAll=[1,2,3,4]
print(numberSub in numberAll)# ==>False
print(1 in numberAll) # ==>true

长度，最大值，最小值

1
2
3
4
5
## 通用序列操作 -- 长度，最大值，最小值##
number=[1,2,3,4,5]
print(len(number))## 长度运算 ==>5
print(max(number))## 最大值运算 ==>5
print(min(number))## 最小值运算 ==>1

列表

上面我们讲了序列的一些通用操作，下面我们来讲讲我们这篇文章的主角之一，列表。
python的列表相当于java的List容器，而且相当灵活。列表的基础操作包括列表的赋值
，删除，增加，统计，排序等操作。

列表基础操作

列表作为序列之中的一种内建类型，它的元素是可以被改变的。我们先来介绍列表作为序列所
支持的一些基础操作。其中包括元素赋值，分片赋值，永久删除元素

  • 元素赋值

    1
    2
    3
    4
    ## 列表通用操作 -- 元素赋值##
    number=[0,0,0]
    number[2]=1;
    print(number) ## ==> [0, 0, 1]

  • 分片赋值

    1
    2
    3
    4
    5
    6
    7
    ## 列表通用操作 -- 分片赋值##
    name=list('python');##list函数可以将一个字符串序列初始化成一个列表
    print(name) ## ==> ['p', 'y', 't', 'h', 'o', 'n']
    name[2:]=['p','y']
    print(name) ## ==> ['p', 'y', 'p', 'y'],
    name[2:2]=['1','1']
    print(name)##还可达到插入的效果 ==> ['p', 'y', '1', '1', 'p', 'y']

  • 删除元素

    1
    2
    3
    4
    ## 列表通用操作 -- 删除元素##
    name=[1,2,3,4]
    del name[1];
    print(name); ##==> [1, 3, 4]

列表函数:append

append可以在列表后面追加新的一个元素

1
2
3
4
## 列表函数 -- append ##
number=[1,2,3,4,5]
number.append(6)
print(number)### ==>[1, 2, 3, 4, 5, 6]

列表函数:extend

跟append不同，extend可以在原有的列表的后面追加多个值。

1
2
3
4
## 列表函数 -- extend ##
numberExtend=[6,7,8]
number.extend(numberExtend)
print(number)## ==>[1, 2, 3, 4, 5, 6, 6, 7, 8]

列表函数:count

count 函数可以统计某个元素在列表中出现的次数

1
2
3
## 列表函数 -- count 
number=[1,2,1,3,1]
print(number.count(1))##==>3

列表函数:index

index 函数可以找出元素匹配第一个值得索引值

1
2
3
## 列表函数 -- index ##
number=[1,2,3,4,5,3,3]
print(number.index(3))## ==> 2

列表函数:insert

insert 函数可以插入元素

1
2
3
4
## 列表函数 -- insert ##
number=[1,2,3,5]
number.insert(3,4)
print(number)## ==>[1, 2, 3, 4, 5]

列表函数:pop

pop函数可以使一个尾部元素出栈

1
2
3
4
## 列表函数 --pop##
number=[1,2,3]
number.pop();
print(number)##==>[1,2]

列表函数:remove

remove函数可以删除第一个与之匹配的元素

1
2
3
4
##列表函数 -- remove##
number=[1,2,3,4,1]
number.remove(1)
print(number)# ==>[2, 3, 4, 1]

列表函数:reverse

reverse可以使一个列表自身反转，但是这个函数不返回任何东西

1
2
3
4
5
6
## 列表函数 -- reverse ##
number=[1,2,3]
number.reverse()
print(number) #==>[3, 2, 1]
print(list(reversed(number)))#返回一个全新的list ==>[1, 2, 3]
print(number)##==>[3,2,1]

列表函数:sort

sort函数可以是一个列表自身进行排序，这个函数不返回任何东西

1
2
3
4
5
6
7
8
## 列表函数 -- sort ##
number=[1,2,3,8,34,3,11,23]
number.sort();
print(number)## ==>[1, 2, 3, 3, 8, 11, 23, 34]
##注意 sort和reverse 都是在原有的列表上操作，不返回任何副本列表
print(number.sort())## ==>None
##如果想要返回一个新的列表，可以使用sorted函数或者先复制一个副本再排序
print(sorted(number))#==> [1, 2, 3, 3, 8, 11, 23, 34]

元组

前面已经讲到元组跟列表最大的区别就是他的不可变性。
那么元组存在的意义是什么呢？不可变性究竟有什么作用
-元组可以做键值对的key，而列表不可以。
-元组作为很多内建函数的返回值。
而很多时候list比元组更加常用。

元组的函数tuple

其实元组的操作函数少之又少，以为它是不可修改的，当然不像列表那样具有很多操作函数。
tuple函数主要是将序列转化为元组。

1
2
3
4
5
6
### 元组函数 -- tuple ##
array=1,2,3 ##如果多个元素用逗号隔开就是默认创建了一个元组
print(array)
number=[1,2,3,4]
array=tuple(number)
print(array)

总结

这一篇文章我们学习了序列的一些基本操作，和两种较为常见的序列:列表以及元组，后面我们将使用另外一种序列:字符串

如果看的爽，不如请我吃根辣条？