python-序列类型

所谓序列类型就是系列中的每一个元素都是有编号的，其中第一个元素的编号（即索引）为0，第二个元素的编号为1，以此类推（相反最后一个元素的变化为-1，倒数第二个元素的编号为-2）。python中的序列有：列表（list），字符串（str），元组（tuple）。最大值，最小值，长度，索引，切片，相加，相乘和序列元素检查这些操作都适用于序列类型，python还提供一些内置函数，对于操作序列非常方便。

　　　1.序列的通用操作

　　　　1）最大值和最小值

　　　　　　python提供的内置函数max,min非常有用，min和max分别返回系列中最小的元素和最大的元素。

 

1 >>> nums = [23, 34, 12, 56]
2 >>> max(nums)
3 56
4 >>> min(nums)
5 12

 

　　　　2）长度

　　　　　　python提供内置函数len可以返回序列中元素的个数。

1 >>> len(nums)
2 4

　　　　3）索引

　　　　　　序列中所有的元素都有一个编号（即从0开始，依次递增），例如，我们创建一个字符串’hello_python‘，字符串中索引1指向的元素是’2‘。

 View Code

 

　　　　　　python 还可以使用负数索引，从左往右（即从最后一个元素开始），-1指向最后一个元素

 View Code

　　　　4）切片

　　　　　　在python我们可以使用切片的方式来访问序列中特定范围内的元素。

 View Code

　　　　　　前面的切片我们取到的是索引区间中的所有元素，因为我们忽略了另一个参数（即步长）。默认情况下，步长的值为1，如果我们吧步长设置为2或3呢。

 View Code

 　　　　5）序列乘法

　　　　　　python中只要将序列乘以一个数n，就是创建一个重复原先序列n次的新序列。

 View Code

　　　　6）序列加法

　　　　　　python中我们可以使用加法运算符（+）来拼接序列。但是不同的序列间的加法python不支持。

 View Code

　　　　7）序列元素检查

　　　　　　python提供运算符in,来检查序列中是否包含某个特定元素，如果包含元素则返回True,反之返回False。

 View Code

　　2.列表

　　　　1）修改列表元素的值

　　　　　　python可以直接通过索引获取列表的元素，并且直接用‘=’赋予新的值

1 >>> l = [1,2,3,4,5]
2 >>> l[3] = 9
3 >>> l
4 [1, 2, 3, 9, 5]

 

　　　　2）删除元素

　　　　　　使用del 语句就可以将列表中的元素轻松删除

1 >>> l = [1,2,3,4,5]
2 >>> del l[2]
3 >>> l
4 [1, 2, 4, 5]

　　　　3）给切片赋值

复制代码
1 >>> l = [1,2,3,4,5]
2 >>> l[1:3] = [0,0]
3 >>> l
4 [1, 0, 0, 4, 5]
5 #给切片赋值，列表长度更长了
6 >>> l = [1,2,3,4,5]
7 >>> l[1:3] = [9,9,9]
8 >>> l
9 [1, 9, 9, 9, 4, 5]
复制代码

　　　　4）列表方法

复制代码
 1 class list(object):
 2     """
 3     list() -> new empty list
 4     list(iterable) -> new list initialized from iterable's items
 5     """
 6     def append(self, p_object): 
 7     # real signature unknown; restored from __doc__
 8         """ L.append(object) -> None -- append object to end """
 9         pass
10 
11     def clear(self): 
12     # real signature unknown; restored from __doc__
13         """ L.clear() -> None -- remove all items from L """
14         pass
15 
16     def copy(self): 
17     # real signature unknown; restored from __doc__
18         """ L.copy() -> list -- a shallow copy of L """
19         return []
20 
21     def count(self, value): 
22     # real signature unknown; restored from __doc__
23         """ L.count(value) -> integer -- return number of occurrences of value """
24         return 0
25 
26     def extend(self, iterable): 
27     # real signature unknown; restored from __doc__
28         """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """
29         pass
30 
31     def index(self, value, start=None, stop=None): 
32     # real signature unknown; restored from __doc__
33         """
34         L.index(value, [start, [stop]]) -> integer -- return first index of value.
35         Raises ValueError if the value is not present.
36         """
37         return 0
38 
39     def insert(self, index, p_object): 
40     # real signature unknown; restored from __doc__
41         """ L.insert(index, object) -- insert object before index """
42         pass
43 
44     def pop(self, index=None):
45      # real signature unknown; restored from __doc__
46         """
47         L.pop([index]) -> item -- remove and return item at index (default last).
48         Raises IndexError if list is empty or index is out of range.
49         """
50         pass
51 
52     def remove(self, value): 
53     # real signature unknown; restored from __doc__
54         """
55         L.remove(value) -> None -- remove first occurrence of value.
56         Raises ValueError if the value is not present.
57         """
58         pass
59 
60     def reverse(self):
61      # real signature unknown; restored from __doc__
62         """ L.reverse() -- reverse *IN PLACE* """
63         pass
64 
65     def sort(self, key=None, reverse=False): 
66     # real signature unknown; restored from __doc__
67         """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
68         pass
复制代码

 　　　　1.append(self, p_object)

　　　　append方法用于将一个对象附加到列表的末尾（直接修改列表，而不是创建一个新的列表）。

#append方法需要我们传入一个对象作为参数（def append(self, p_object)）
>>> l = ['python', 'c', 'c++']
>>> l.append('java')
>>> l
['python', 'c', 'c++', 'java']

　　　　2.clear(self)

　　　　clear方法的作用就是清空列表

1 #直接调用clear方法就可以情况列表，无需传入参数
2 >>> l = ['python', 'c', 'c++']
3 >>> l.clear()
4 >>> l
5 []

　　　　3.copy(self)

　　　　copy方法就是复制列表，这里的复制浅复制。与赋值跟深复制存在区别。copy方法的效果与前面讲的通用方法中的切片list[:]的效果类似

复制代码
1 >>> l = ['python', 'c', 'c++', [1,2,3]]
2 >>> lst = l.copy()
3 >>> lst
4 ['python', 'c', 'c++', [1, 2, 3]]
5 >>> lst = l[:]
6 >>> lst
7 ['python', 'c', 'c++', [1, 2, 3]]
复制代码

　　　　4.count(self, value)

　　　　count方法的作用是计算列表中特定元素在列表中出现的次数

复制代码
1 #count需要我们传入一个value作为参数，最后将返回value在列表中出现的次数（def count(self, value)）
2 >>> l = ['python', 'c', 'c++', 'python', 'java', 'java', 'python', 'c']
3 >>> l.count('python')
4 3
5 >>> l.count('c')
6 2
复制代码

　　　　5.extend(self, iterable)

　　　　用于扩展列表，前面的append方法只能添加一个元素到列表的末尾，而extend方法只需传入一个可迭代对象便可以添加多个元素到列表末尾（可以用一个列表扩展当前列表，也可以用元组，字符串，字典等）

复制代码
 1 #extend方法需要我们传入一个可迭代对象作为参数，extend会依次迭代出对象的元素添加到列表的末尾（def extend(self, iterable)）。
 2 >>> l = ['python', 'c', 'c++']
 3 >>> l.extend(['java', 'php'])
 4 >>> l
 5 ['python', 'c', 'c++', 'java', 'php']
 6 >>> l.extend('china')
 7 >>> l
 8 ['python', 'c', 'c++', 'java', 'php', 'c', 'h', 'i', 'n', 'a']
 9 #注意：当传入的是字典时，添加到列表的是字典的值
10 >>> l.extend({'name': 'lin', 'age': 18})
11 >>> l
12 ['python', 'c', 'c++', 'java', 'php', 'c', 'h', 'i', 'n', 'a', 'name', 'age']
复制代码

　　　　6.index(self, value, start=None, stop=None)

　　　　index方法可以在列表中找到指定元素在列表中第一次出现的索引。

复制代码
 1 #index方法需要我们传入一个value作为参数，当参数存在时，返回第一次出现的索引
 2 >>> l = ['python', 'c', 'c++', 'java', 'c', 'python', 'c']
 3 >>> l.index('c')
 4 1
 5 >>> l.index('python')
 6 0
 7 #注意：当value不在列表中的时，程序将报错
 8 >>> l.index('php')
 9 Traceback (most recent call last):
10   File "<stdin>", line 1, in <module>
11 ValueError: 'php' is not in list
12 
13 #index方法我们还可以传入第二个参数（开始查找的索引），第三个参数（查找结束的索引）（def index(self, value, start=None, stop=None)）
14 >>> l = ['python', 'c', 'c++', 'java', 'c', 'python', 'c']
15 >>> l.index('c', 2, 5)
16 4
复制代码

 

　　　　7.insert(self, index, p_object)

　　　　　insert方法可以将一个随想插入列表，与append方法不同的是，insert可以在列表中的任何位置插入一个对象。

复制代码
#insert需要我们传入两个参数，第一个参数为要插入索引位置，第二个参数是要插入的对象（def insert(self, index, p_object)）
>>> l = ['python', 'c', 'c++']
>>> l.insert(2, 'java')
>>> l
['python', 'c', 'java', 'c++']
#插入的是一个元素，并没有迭代
>>> l.insert(2, ['go', 'java'])
>>> l
['java', 'python', ['go', 'java'], 'c', 'java', 'c++']
复制代码

　　　　8.pop(self, index=None)

　　　　pop方法将删除列表中最后一个元素，并返回这个元素。如果传入一个索引值，将删除所以位该值的元素而不是最后一个原素。

复制代码
 1 >>> l = ['python', 'c', 'c++', 'java']
 2 >>> l.pop()
 3 'java'
 4 #pop方法我们还可以传入一个数，可指定删除索引为该数的元素，并返回这个元素，如果这个数大于等于列表的长度，将会报错（def pop(self, index=None)）
 5 >>> l = ['python', 'c', 'c++', 'java']
 6 >>> l.pop(2)
 7 'c++'
 8 >>> l.pop(8)
 9 Traceback (most recent call last):
10   File "<stdin>", line 1, in <module>
11 IndexError: pop index out of range
复制代码

 

　　　　9.remove(self, value)

　　　　remove方法可以根据特定元素的值来删除列表中一个该元素

复制代码
 1 #传入'c',只删除列表中第一个'c'元素（def remove(self, value)）
 2 >>> l = ['python', 'c', 'c++', 'java', 'c', 'python', 'c']
 3 >>> l.remove('c')
 4 >>> l
 5 ['python', 'c++', 'java', 'c', 'python', 'c']
 6 #当该值不在列表中时，程序报错
 7 >>> l.remove('go')
 8 Traceback (most recent call last):
 9   File "<stdin>", line 1, in <module>
10 ValueError: list.remove(x): x not in list
复制代码

　　　　10.reverse(self)

　　　　reverse方法将返回相反顺序的列表，直接修改原列表

1 >>> l = ['python', 'c', 'c++', 'java']
2 >>> l.reverse()
3 >>> l
4 ['java', 'c++', 'c', 'python']

 　　　　11.sort(self, key=None, reverse=False)

　　　　sort方法会对列表进行排序，直接修改原列表

复制代码
 1 #def sort(self, key=None, reverse=False)
 2 >>> l = ['python', 'c', 'c++', 'java']
 3 >>> l.sort()
 4 >>> l
 5 ['c', 'c++', 'java', 'python']
 6 #我们可以传入可选参数reverse，当为True的时候，以相反的顺序排列
 7 >>> l.sort(reverse = True)
 8 >>> l
 9 ['python', 'java', 'c++', 'c']
10 #我看可以传入可选参数key（key可以可以设置为内置函数），这里我们设置为len函数，列表便按照元素的长度来排列
11 >>> l.sort(key = len, reverse = True)
12 >>> l
13 ['python', 'java', 'c++', 'c']
复制代码

 　　3.字符串

　　　　1.center(self, width, fillchar=None)

 

　　　　center方法可以设置字符串长度，添加的字符默认是空格，让字符串居中。返回的是居中后的副本，并不改变原字符串

复制代码
 1 #center方法需要我们传入一个参数
 2 >>> s = 'python'
 3 >>> s.center(15)
 4 '     python    '
 5 #我们还可以穿日第二个参数'*', 添加部分就用center填充
 6 >>> s.center(15, '*')
 7 '*****python****'
 8 #原字符串没有发生改变
 9 >>> s
10 'python'
复制代码

　　　　2.count(self, sub, start=None, end=None)

　　　　count方法返回字符串中某一特定子串出现的次数。

1 >>> s = 'pythonpython'
2 >>> s.count('o')
3 2

 

　　　　3.endswith(self, suffix, start=None, end=None) 和 startswith(self, prefix, start=None, end=None)

　　　　endswith和startswith分别返回字符串是否是以某子串结束和开始。

复制代码
1 >>> s = 'python'
2 >>> s.startswith('py')
3 True
4 >>> s.startswith('y')
5 False
6 >>> s.endswith('on')
7 True
8 >>> s.endswith('o')
9 False
复制代码

　　　　3.find(self, sub, start=None, end=None)

　　　　find方法可以在在字符串中查找字串，类似于序列的index方法，返回子串在子串中第一次出现的索引，如果不存在就返回-1。

复制代码
 1 >>> s = 'python' * 3
 2 >>> s
 3 'pythonpythonpython'
 4 #这里我们传入'th'，find方法返回'th'在字符串中第一次出现的索引
 5 >>> s.find('th')
 6 2
 7 #当传入的字符串不是s的子串的时候，返回-1
 8 >>> s.find('pth')
 9 -1
10 #我们还可以传入第二个参数开始查找的索引位置，第三个参数结束查找的位置
11 >>> s.find('on', 5, 15)
12 10
复制代码

 

　　　　4.join(self, iterable)与 split(self, chars=None)

　　　　join和split方法子字符串方法中非常重要的两个，join可以合并序列的元素，split的作用与join相反，拆分字符串。

复制代码
 1 >>> l = [1, 2, 3, 4]
 2 >>> s = '+'
 3 #合并的序列必须是字符串，不然程序就会报如下的错误
 4 >>> s.join(l)
 5 Traceback (most recent call last):
 6   File "<stdin>", line 1, in <module>
 7 TypeError: sequence item 0: expected str instance, int found
 8 >>> l = ['p', 'y', 't', 'h', 'o', 'n']
 9 >>> ''.join(l)
10 'python'
11 >>> '+'.join(l)
12 'p+y+t+h+o+n'
13 #字符串s根据空格分裂成一个列表
14 >>> s = 'hello python world'
15 >>> s.split(' ')
16 ['hello', 'python', 'world']
复制代码

　　　　5.lowe(self)， upper(self) 和 title(self) 

　　　　lower方法返回字符串的小写版本，upper方法返回字符串的大写版本， title返回字符串的标题形式。原字符穿没有被重新赋值

复制代码
 1 >>> s = 'Python'
 2 #字符串字母全为小写
 3 >>> s.lower()
 4 'python'
 5 #字符串字母全为大写
 6 >>> s.upper()
 7 'PYTHON'
 8 #原字符串没有发生改变
 9 >>> s
10 'Python'
11 >>> s = 'pYthon'
12 #字符串变为标题形式（首字母大写，其他小写）
13 >>> s.title()
14 'Python'
15 #原字符串不变
16 >>> s
17 'pYthon'
复制代码

　　　　6.replace(self, old, new, count=None)

　　　　replace方法将制定子串替换为另一个字符串，并且返回替换后的结果

复制代码
 1 #def replace(self, old, new, count=None)，这边我们必须传入第一个参数旧的子串，第二个参数新的字符串。第三个参数为可选参数（默认为旧的子串出现的次数）
 2 >>> s = 'hello python  python python world'
 3 >>> s.replace('python', 'java')
 4 'hello java  java java world'
 5 #传入第三个参数为2时，replace就修改前两个Python
 6 >>> s.replace('python', 'java', 2)
 7 'hello java  java python world'
 8 #传入第三个参数为2时，replace就修改第一个Python
 9 >>> s.replace('python', 'java', 1)
10 'hello java  python python world'
复制代码

　　　　7,.strip(self, chars=None)，lstrip(self, chars=None)，rstrip(self, chars=None)

　　　　strip方法将可以将字符串开头和结尾的空白处删除（不包括字符串中的字符串），返回删除后的结果。

　　　　lstrip则是删除字符串左边的空白处，rstrip是删除字符串右边的空白处。

复制代码
1 >>> s = '    hello python world   '
2 >>> s.strip()
3 'hello python world'
4 >>> s.lstrip()
5 'hello python world   '
6 >>> s.rstrip()
7 '    hello python world'
复制代码

　　　　8.translate(self, table)

　　　　translate方法与replace方法类似，都是替换字符串的一部分，但是replace只能替换字符串中某一特定子串，translace方法能同事替换多个子串

　　　　不过在替换之前我们需使用maketrans方法创建一个转换表（translate接收两个长度相同参数）

1 >>> table = str.maketrans('on', '**')
2 >>> s = 'hello python  python python world'
3 #这里只有是o,n都被替换成*
4 >>> s.translate(table)
5 'hell* pyth**  pyth** pyth** w*rld'

　　　　9.字符串的其他方法

字符串方法

说明

capitalize(self)

返回字符串的副本，但将第一个字符大写

 
casefold(self)

返回经过标准化后的字符串，类似于转换为小写

 
encode(self, encoding='utf-8', errors='strict')

返回使用编码的编码解码器对S进行编码。缺省编码是UTF-8。可以设置错误来设置不同的错误。

 
expandtabs(self, tabsize=8)

返回一个字符串的副本，其中所有的制表符都是使用空格展开的。如果没有给定Tabsize，则默认为8。

 
format(self, *args, **kwargs)

返回一个格式化版本的字符串

 
format_map(self, mapping)

使用映射替换来返回字符串的格式化版本

 
isalnum(self)

如果字符串中的所有字符都是字母或数字，则返回true。在字符串中至少有一个字符，否则为false

 
isalpha(self)

如果S中的所有字符都是字母，则返回true，在S中至少有一个字符，否则为false。

 
isdecimal(self)

如果S中只有十进制字符，则返回true，

否则为假。

 
isdigit(self)

如果S中的所有字符都是数字，则返回true

在S中至少有一个字符，否则为false

 
isidentifier(self)

如果S是有效标识符，则返回true

 
islower(self)

如果S中的所有字符都是小写的，则返回true

 
isnumeric(self)

如果S中只有数字字符，则返回true

 
isprintable(self)

如果S中的所有字符都是可打印的，则返回true

 
isspace(self)

如果S中的所有字符都是空白，则返回true

 
istitle(self)

检查字符串中位于非字母后面的字母是不是都是大写，且其他字母都是小写

 
isupper(self)

检查字符串所有字母是否都是大写

 
ljust(self, width, fillchar=None)

返回一个长度为max(len(string), width)的字符串，其开头是当前字符串的副本，末尾用fillchar指定的值填充

 
partition(self, sep)

在字符串中搜索sep，并返回元组（sep前面的部分，sep，sep后面的部分）

 
rfind(self, sub, start=None, end=None)

返回找到最后一个子串的索引，如果没有则引发异常

 
rindex(self, sub, start=None, end=None)

返回找到最后一个子串sub的索引，如果没有则引发异常

 
rjust(self, width, fillchar=None)

返回一个长度为max(len(string), width)的字符串，其开头是当前字符串的copy，末尾用fillchar指定的值填充

 
rpartition(self, sep)

在字符串中搜索sep，并返回元组

 
rsplit(self, sep=None, maxsplit=-1)

与split相同。但指定了maxsplit,将计算次数

 
splitlines(self, keepends=None)

返回一个列表，其中包括字符串中所有行，如果keepends为True，将包含换行符

 
swapcase(self)

将字符串中所有的字母的大小写反转，并返回结果

 
zfill(self, width)

在字符串左边填充0，长度为with
 

 　　　　4.元组

 　　　　元组与列表类似，列表使用[ ]，而元组则是使用（）。还有一个差别是元组是不可修改的

复制代码
 1 #元组的元素间需要有一个逗号隔开，如下的代码，2后面没加逗号就是数字2，当我们加上逗号就变成了元组
 2 >>> 2
 3 2
 4 >>> 2,
 5 (2,)
 6 #元组支持count(self, value)方法，计算元组中指定元素的个数
 7 >>> tu = (1,2,3,4,5,3,4,5,2,2)
 8 >>> tu.count(2)
 9 3
10 #元组也支持index(self, value, start=None, stop=None)方法，返回指定元素在元组中第一次出现的索引
11 >>> tu.index(2)
12 1
13 当元素不在元组里是，报错
14 >>> tu.index(9)
15 Traceback (most recent call last):
16   File "<stdin>", line 1, in <module>
17 ValueError: tuple.index(x): x not in tuple
复制代码
posted @ 2018-12-19 14:35  天上掉下来的林~~  阅读(558)  评论(0)    收藏  举报