文章目录
- 2.1 序列概述(列表和元组)
- 2.2 通用的序列操作
- 2.3 列表:Python 的主力
- 2.3.1 函数list
- 2.3.2 基本的列表操作
- 2.3.3 列表方法
- 1.append(X) 用于将一个对象附加到列表末尾。
- 2.clear() 就地清空列表的内容
- 3.copy() 复制列表
- 4.count(X) 计算指定的元素在列表中出现了多少次。
- 5.extend(X) 同时将多个值附加到列表末尾
- 6.index(X.n) 在列表中查找指定值X第n次出现的索引
- 7.insert(n,X) 将一个对象插入列表。
- 8.pop(n) 从列表删除一个元素(默认最后一个元素),并返回这一元素
- 9.remove(X) 删除第一个为指定值的元素
- 10.reverse() 按相反的顺序排列列表中的元素
- 11.sort() 对列表就地排序 修改列表而不返回任何值
- 12.高级排序 sort的参数key(排序依据) 和reverse(是否倒序)
- 2.4 元组:不可修改的序列
数据结构:数据结构是以某种方式(如通过编号)组合起来的数据元素(如数、字符乃至其他数据结构)集合。
序列:基本数据结构,序列中的每个元素都有编号,即位置或索引,第一个元素的索引为0。
- 序列–列表和元组
- 映射-- 字典(详见第四章)
- 集合-- set(详见第十章)
2.1 序列概述(列表和元组)
不同在于,列表是可以修改的,而元组不可以。
序列 列表名=[元素1,元素2… …] 元组名=(元素1,元素2… …)
>>> edward = ['Edward Gumby', 42]
>>> type(a)
<class ‘list’>
序列还可包含其他序列
>>> john = ['John Smith', 50]
>>> database = [edward, john]
>>> database
[['Edward Gumby', 42], ['John Smith', 50]]
2.2 通用的序列操作
2.2.1 索引 序列名[索引号] 访问单个元素
字符串就是由字符组成的序列。序列中的所有元素都有编号——从0开始递增。
>>> greeting = 'Hello'
>>> greeting[0]
'H'
-1是最后一个元素的位置
>>> greeting[-1]
'o'
对于字符串字面量(以及其他序列字面量),可直接对其执行索引操作,无需先将其赋变量。
>>> 'Hello'[1]
'e'
>>> fourth = input('Year: ')[3]
Year: 2005
>>> fourth
'5'
列表相加+相乘*(见下文)
>>>Fruits=['apple','peach']+5*['pear']+['orange']
>>>Fruits
['apple','peach','pear','pear','pear', 'pear','pear','orange']
CASE:输出英文格式的日期
2.2.2 切片——列表名[起始位置含:结束位置不含]
访问特定范围内的元素
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[3:6]
[4, 5, 6]
索引负数-n代表倒着数第n位数
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[3:-4]
[4, 5, 6]
1、绝妙的简写
从起始位置到最尾——列表名[起始位置含:]
>>> numbers[7:]
[8, 9, 10]
倒着数方法
>>> numbers[-3:]
[8, 9, 10]
从头到截止位置——列表名[:结束位置不含]
>>> numbers[:3]
[1, 2, 3]
复制整个序列
>>> numbers[:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
CASE:截取字段
2、 更大的步长——列表名[起始位置含:结束位置不含:步长]
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[0:10:2]
[1, 3, 5, 7, 9]
>>> numbers[::4]
[1, 5, 9]
步长是负数,表示从右往左提取
>>> numbers[::-2]
[10, 8, 6, 4, 2]
2.2.3 序列相加
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> 'Hello,' + 'world!'
'Hello,world!'
>>> [1, 2, 3] +[‘world’]
[1, 2, 3, ‘world’]
但是,不同的类型序列不能拼接
>>> [1, 2, 3] + 'world!' #报错
>>> [1, 2, 3] + (1,2,3) # 报错
2.2.4 乘法
>>> 'python' * 5
'pythonpythonpythonpythonpython'
>>> [42] * 10
[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]
None、空列表和初始化
>>> sequence = [None] * 10
>>> sequence
[None, None, None, None, None, None, None, None, None, None]
CASE:打印方框
2.2.5 成员资格
要检查特定的值是否包含在序列中,可使用运算符in。布尔运算符,返回布尔值。
>>> permissions = 'rw'
>>> 'w' in permissions
True
>>> 'x' in permissions
False
>>> users = ['mlh', 'foo', 'bar']
>>> input('Enter your user name: ') in users
Enter your user name: mlh
True
>>>A=[['as',12],['d',14]]
>>>s=['as',12]
>>>s in A
True
现在可使用运算符in来检查指定的字符串是否为另一个字符串的子串。
>>> subject = '$$$ Get rich now!!! $$$'
>>> '$$$' in subject
True
CASE:输入验证
长度len、最小值min和最大值max
>>> numbers = [100, 34, 678]
>>> len(numbers)
3
>>> max(numbers)
678
>>> min(numbers)
34
>>> min([100, 34, 678])
34
以下调用max和min时指定的实参并不是序列,而直接将数作为实参。
>>> max(2, 3)
3
>>> min(9, 3, 2, 5)
2
2.3 列表:Python 的主力
2.3.1 函数list
使用字符串来创建列表(也可以将元组转化成列表)
>>> list('Hello')
['H', 'e', 'l', 'l', 'o']
>>> ‘’.join(['H', 'e', 'l', 'l', 'o'])
'Hello'
2.3.2 基本的列表操作
1.修改列表 给元素赋值 =
>>> x = [1, 1, 1]
>>> x[1] = 2
>>> x
[1, 2, 1]
2.删除元素 del 列表名【索引号】
>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
>>> del names[2]
>>> names
['Alice', 'Beth', 'Dee-Dee', 'Earl']
3.给切片赋值(替换,插入、删除)
>>> X=[1,2,3,4,5,6]
>>> X[:2]=[11,22]
>>> X
[11,22,3,4,5,6]
>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:] = list('ar')
>>> name
['P', 'e', 'a', 'r']
通过使用切片赋值,可将切片替换为长度与其不同的序列
>>> name = list('Perl')
>>> name[1:] = list('ython')
>>> name
['P', 'y', 't', 'h', 'o', 'n']
使用切片赋值还可在不替换原有元素的情况下插入新元素——用空切片器替换
这里的空切片器是numbers[1:1],numbers[4:0]也是
>>> numbers = [1, 5]
>>> numbers[1:1] = [2, 3, 4]
>>> numbers
[1, 2, 3, 4, 5]
取相反的措施来删除切片——替换成空切片
>>> numbers
[1, 2, 3, 4, 5]
>>> numbers[1:4] = []
>>> numbers
[1, 5]
2.3.3 列表方法
方法是与对象(列表、数、字符串等)联系紧密的函数。像下面这样调用方法:
object.method(arguments)
1.append(X) 用于将一个对象附加到列表末尾。
>>> lst = [1, 2, 3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]
Notice:每次只能追加一个元素或者序列,如果添加的是序列,原序列也是多一个子序列,注意与extend()的区别
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.append(b)
>>> a
[1, 2, 3, [4, 5, 6]]
2.clear() 就地清空列表的内容
>>> lst = [1, 2, 3]
>>> lst.clear()
>>> lst
[ ]
这类似于切片赋值语句lst[:] = []
3.copy() 复制列表
如果是以赋值的方式"复制",新旧列表其实质是指向同一个列表,其中一个修改,另一个也变,并未建立副本
>>> a = [1, 2, 3]
>>> b = a # b=a[:] b=list(a) 才是复制,见下文
>>> b[1] = 4
>>> a
[1, 4, 3]
用copy函数才能建立一个副本,指向两个不同的列表
>>> a = [1, 2, 3]
>>> b = a.copy()
>>> b[1] = 4
>>> a
[1, 2, 3]
这类似于使用a[:]或list(a),它们也都复制a
>>> a = [1, 2, 3]
>>> c = list(a)
>>> c[1] = 4
>>> a
[1, 2, 3]
>>> a = [1, 2, 3]
>>> d = a[:]
>>> d[1] = 4
>>> a
[1, 2, 3]
4.count(X) 计算指定的元素在列表中出现了多少次。
>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to')
2
>>> x = [[1, 2], 1, 1, [2, 1, [1, 2]]]
>>> x.count(1)
2
>>> x.count([1, 2])
1
延伸:如果要快速统计列表中每个元素出现次数
from collections import Counter
ls=['to', 'be', 'or', 'not', 'to', 'be']
c=Counter(ls)
c
>>>Counter({'to': 2, 'be': 2, 'or': 1, 'not': 1})
c.most_common(2)
>>>[('to', 2), ('be', 2)]
5.extend(X) 同时将多个值附加到列表末尾
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]
Notice:注意与append()的区别
与拼接不同,拼接会返回一个新序列,并不是在原序列的基础上修改
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a + b //extend效果:a=a+b 或者列表赋值给空切片 a[len(a):]=b
[1, 2, 3, 4, 5, 6] ///////////////////////////////////////////////////////////
>>> a
[1, 2, 3] //[1, 2, 3, 1, 2, 3]
extend()等效方法:a=a+b 或者 列表赋值给空切片 a[len(a):]=b
6.index(X.n) 在列表中查找指定值X第n次出现的索引
>>> knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni']
>>> knights.index('who')
4
查找第2次的位置
>>> happy= ['h', 'a', 'p', 'p', 'y']
>>> happy.index('p',2)
3
7.insert(n,X) 将一个对象插入列表。
方法insert(n,X) 用于将一个对象X插入列表n位置
>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers.insert(3, 'four')
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]
也可使用切片赋值来插入,但插入的元素一定是列表形式
>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers[3:3] = ['four']
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]
8.pop(n) 从列表删除一个元素(默认最后一个元素),并返回这一元素
>>> x = [1, 2, 3]
>>> x.pop()
3
>>> x
[1, 2]
>>> x.pop(0)
1
>>> x
[2]
Notice: pop是唯一既修改列表又返回一个非None值的列表方法
栈(stack)后进先出 ,push(append)和pop是两种昂栈操作, 方法pop和append的效果相反
>>> x = [1, 2, 3]
>>> x.append(x.pop())
>>> x
[1, 2, 3]
创建先进先出队列: Insert(0,…) pop(0)
9.remove(X) 删除第一个为指定值的元素
>>> x = ['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']
10.reverse() 按相反的顺序排列列表中的元素
>>> x = [1, 2, 3]
>>> x.reverse()
>>> x
[3, 2, 1]
reversed不返回列表,而是返回一个迭代器
>>> x = [1, 2, 3]
>>> list(reversed(x))
[3, 2, 1]
11.sort() 对列表就地排序 修改列表而不返回任何值
>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort()
>>> x
[1, 2, 4, 6, 7, 9]
修改列表而不返回任何值 所以y是NONE
>>> x = [4, 6, 2, 1, 7, 9]
>>> y = x.sort() # Don't do this!
>>> print(y)
None
sorted函数可用于任何序列,但总是返回一个列表
>>> x = [4, 6, 2, 1, 7, 9]
>>> y = sorted(x)
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]
实际上sorted函数还可以对集合set,字典视图dict_keys排序,最终都会返回列表
12.高级排序 sort的参数key(排序依据) 和reverse(是否倒序)
>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
>>> x.sort(key=len)
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']
Notice:排序关键字也要根据列表元素类型,如果里面是数字,没有len属性
>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort(reverse=True)
>>> x
[9, 7, 6, 4, 2, 1]
>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
>>> x.sort(key=len,reverse=True)
>>> x
['aardvark', 'abalone', 'aerate', 'acme', 'add']
函数sorted也接受参数key和reverse
2.4 元组:不可修改的序列
用逗号分隔还可用圆括号括起,
>>> 1, 2, 3
(1, 2, 3)
>>> (1, 2, 3)
(1, 2, 3)
空元组用两个不包含任何内容的圆括号表示
>>> ()
()
只有一个值,也必须在它后面加上逗号.
>>> 42
42
>>> 42,
(42,)
>>> (42,)
(42,)
逗号至关重要,仅将值用圆括号括起不管用
>>> 3 * (40 + 2)
126
>>> 3 * (40 + 2,)
(42, 42, 42)
Tuple()类似list(),可以将一个序列作为参数转化成元组
>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple((1, 2, 3))
(1, 2, 3)
Notice:list()也可以将元组转化成列表
>>> list((1, 2, 3))
[1, 2, 3]
元组的主要操作是创建和访问其元素,且方式与其他序列相同
>>> x = 1, 2, 3
>>> x[1]
2
>>> x[0:2]
(1, 2)
Notice:元组访问元素后面还是中括号
元组的必要性:
它们用作映射中的键(以及集合的成员),而列表不行
有些内置函数和方法返回元组,这意味着必须跟它们打交道。