【Python3_基础系列_002】Python3-序列类型与通用方法

最新推荐文章于 2024-10-13 23:49:20 发布

weixin_30709929

最新推荐文章于 2024-10-13 23:49:20 发布

阅读量118

点赞数

文章标签： python 数据结构与算法 java

原文链接：http://www.cnblogs.com/forfreewill/articles/9279305.html

版权

一、序列类型

什么是序列：所谓序列,即成员有序排列,可通过索引访问.简单理解就是数据是按照先后顺序排列所以可以通过索引去定位具体信息的数据结构。

python3的序列类型：（简单介绍序列类型，后面会详细介绍每一种序列）

序列类型--string（字符串）：

单引号，双引号，三引号括起来的字符序列
>>> f = 'abc'
>>> f1 = "abc"
>>> f2 = '''abc'''
>>> f3 = """abc"""

注意定义的类型，单引号，双引号，三引号括起来的都是字符串类型

序列类型--list(列表)

用[]这些元素，就是列表里的元素元素之间用逗号分隔
>>> a = [1,2,3]
>>> a
[1, 2, 3]
>>> type(a)
<class 'list'>

注意：使用中括号‘【】’括起来并通过,分割的字符序列。可以类别java中的数组。

序列类型-tuple(元祖)

用（）括起来的字符序列，序列之间逗号分隔

>>> 1,2,3 #创建元祖的方法：直接通过都好分割序列就创建了一个元祖
(1, 2, 3)
>>> () #空元祖
()
>>> (1) #如果元祖的元素个数为1的时候，必须用逗号分割，否则是（）内基本的数据类型，而不是元祖。（1）代表的是整型1而不是1个元素的元祖。
1
>>> (1,) #1个元素的元祖
(1,)
>>> (a,b,c) #元祖包含其他变量
(1, -3.1415, (1+2j))

二、序列的通用操作

序列（string，list，tuple）由于其具有有序的特性，所以序列有一些通用的操作。

序列通用操作：索引，分片，+，*，in(成员资格)

2.1-索引-返回1个位置元素

序列中的元素都是有序的、第一个元素的索引是0,我们可以通过索引得到序列中对应的元素，索引也可以为负值,负数索引表示从右往左开始计数，最后一个元素索引为-1,倒数第二为-2,以此类推.

>>> s = 'abcdefg'
>>> s[0] #第1个元素
'a'
>>> s[1] #第2个元素
'b'
>>> s[-1] #最后1个元素
'g'
>>>
>>> l = [1,2,3,4,5,6,7]
>>> l[4] #第5个元素
5
>>> l[0]
1
>>> l[-1] #最后1个元素
7
>>>
>>> t = (1,2,3,4,5,6,7)
>>> t[0]
1
>>> t[-1]
7
>>> t[4]
5

2.2-切片-返回list

左闭右开原则：使用索引可以获取单个元素，使用分片可以获取序列中指定范围内的元素（返回值类型是list）.切片：obj[start_index:end_index] 表示获取从start_index开始到end_index（不包含右边界）结束所有索引对应的元素.

注意：obj[index1:index2],index1的索引位置一定要在index2索引位置的左边，否则返回结果是[]，空列表。

复制代码
>>> l
[1, 2, 3, 4, 5, 6, 7]
>>>
>>> l[0:5] #获取第1-5个元素（不包含右边界）
[1, 2, 3, 4, 5]
>>> l[4:6] #获取第5-6元素（不包含右边界）
[5, 6]
>>> l[2:2] #左索引与右索引相同但是无法取到右索引，所以返回空list
[]
>>> l[-3:-1]　#倒数第3,2个元素，不包含右边界，所以取不到最后的值　　　　　　
[5, 6]
>>> l[-1:-3] #左索引不是右索引的左边，返回空list
[]
>>> s
'abcdefg'
>>> s[1:2] #取第2个元素，不包括右边界
'b'

>>> l[:5] #取1-5元素，不包括右边界
[1, 2, 3, 4, 5]
>>> l[2:] #取3-最后，包含右边界
[3, 4, 5, 6, 7]
>>> l[-2:] #倒数第2,1个元素，包含右边界
[6, 7]
>>> l[:-3] #第1-倒数第4个元素，不包括右边界

[1, 2, 3, 4]
>>> l[:] #取全部元素
[1,2,3,4,5,6,7]

[start_index:end_index:step] (step>0)表示从start_index索引对应的元素开始每step个元素取出来一个，直到取到end_index对应的元素结束(step默认为1)

str[x:y:z]

x=开始索引

y=结束索引（不包含）

z=步长（默认为1，负值代表反向>>> ll[0:9:] #取1-9，默认步长1

[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> ll[0:9:1] #取1-9，指定步长1
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> ll[0:9:2] #取1-9，步长2
[1, 3, 5, 7, 9]
>>> ll[::4] #取全部，步长4
[1, 5, 9]
>>> s[::-2] #反向取全部，步长2
'geca'
>>>
[start_index:end_index:step] (step<0)表示从右到左反向提取元素,即从start_index索引对应的元素开始反向每step个元素取出来一个，直到取到end_index+1对应的元素结束.
此时start_index对应的元素要晚于end_index对应的元素出现,否则返回[]

>>> ll[0:6:-2]
[]
>>> ll[9:6:-2]
[10, 8]
>>> ll[6:9:-2]
[]
>>> ll[::-1]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> ll[:2:-3]
[10, 7, 4]
>>> ll[9:2:-1]
[10, 9, 8, 7, 6, 5, 4]

2.3-+加法-返回类型为同一序列

两种相同的序列才可以进行加法操作，不同序列加法时提示错误。

>>> l1=[1,2,4]
>>> l2=[4,5,6]
>>> l3=['9','10']
>>> l1+l2
[1, 2, 4, 4, 5, 6]
>>> l1+l3
[1, 2, 4, '9', '10']
>>> l1+'abcdefg'

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "str") to list

2.4-*乘法-返回类型为同一序列

序列类型可以使用*int返回重复的序列

>>> 'python'*2
'pythonpython'
>>> [1,2,3,4,5]*2
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
>>> ('a','b')*2
('a', 'b', 'a', 'b')

>>> '*'*5
'*****'

2.5-in(成员资格)-返回布尔

>>> s
'abcdefg'
>>> t
(1, 2, 3, 4, 5, 6, 7)
>>> l
[1, 2, 3, 4, 5, 6, 7]
>>>
>>>
>>> if 'ab' in s and 'c' in s:
... print 'yes'
... else:
... print 'no'
...
yes
>>> if 5 in l and 6 in t:
... print 'yes'
... else:
... print 'no'
...
yes
>>>
>>> if 10 in l:
... print 'yes'
... else:
... print 'no'
...
no