Python基础教程第3版:第2章 列表和元组

数据结构是以某种方式(如通过编号)组合起来的数据元素(如数、字符乃至其他数据结构)集合。在Python中,最基本的数据结构为序列(sequence)。

Python支持一种数据结构的基本概念,名为容器(container)。容器基本上就是可包含其他对象的对象。

Python中三类主要的容器:

  • 序列(列表,元组,字符串) , 映射(字典), 集合
  • 序列中的元素有0开始的编号; 映射中的元素有名字(键)
  • 集合既不是序列, 也不是映射

2.1 序列概述

Python内置了多种序列,本章重点讨论其中最常用的两种:列表和元组。另一种重要的序列是字符串.

列表和元组的主要不同在于,列表是可以修改的,而元组不可以。

在你自己编写程序时,几乎在所有情况下都可使用列表来代替元组。一种例外情况是将元组用作字典键. 字典键是不允许修改的。

2.2 通用的序列操作

有几种操作适用于所有序列,包括索引(indexing)、切片(slicing)、相加、相乘和成员资格检查。另外,Python还提供了一些内置函数,可用于确定序列的长度以及找出序列中最大和最小的元素。

有一个重要的操作这里没有介绍,它就是迭代(iteration)。对序列进行迭代意味着对其每个元素都执行特定的操作。

可使用加法运算符来拼接相同类型的序列,如列表, 一般情况下不能拼接不同类型的序列。

>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> 'Hello,' + 'world!'
'Hello,world!'
>>> [1, 2, 3] + 'world!'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "str") to list

将序列与数x相乘时,将重复这个序列x次来创建一个新序列:

>>> 'python' * 5
'pythonpythonpythonpythonpython'
>>> [1,2,3] * 5
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> [None] * 10
[None, None, None, None, None, None, None, None, None, None]

在Python中,None表示什么都没有

# -*- coding: utf-8 -*-
# 在位于屏幕中央且宽度合适的方框内打印指定的句子

sentence = input("要打印的句子: ")
screen_width = 80  # 一行代码的标准最大宽度80?
text_width = len(sentence)
box_width = text_width + 6  ## 句子前后有两个空格
left_margin = (screen_width - box_width) // 2
print()

print(' ' * left_margin + '+' + '-' * (box_width-2) + '+') # box第一行两个角为 +
print(' ' * left_margin + '|' + ' ' * (box_width-2) + '|')
print(' ' * left_margin + '|  ' + sentence + '  |')
print(' ' * left_margin + '|' + ' ' * (box_width-2) + '|')
print(' ' * left_margin + '+' + '-' * (box_width-2) + '+')
print()

'''输出示例(显示上中文比英文字母宽,用英文字母演示):
                               +----------------+
                               |                |
                               |  hello,world!  |
                               |                |
                               +----------------+
'''

2.3 列表:Python 的主力

方法是与对象(列表、数、字符串等)联系紧密的函数。方法调用与函数调用很像,只是在方法名前加上了对象和句点,通常,像下面这样调用方法:

object.method(arguments)

部分列表方法:

  • append :将一个对象附加到列表末尾
  • clear: 就地清空列表的内容。
  • count : 计算指定的元素在列表中出现了多少次。
  • copy: 方法copy 复制列表, 创建列表的副本 b = a.copy(), 这类似于使用a[:]list(a),它们也都复制a
  • extend: 方法extend让你能够同时将多个值附加到列表末尾,为此可将这些值组成的序列作为参数提供给方法extend。换而言之,你可使用一个列表来扩展另一个列表。
  • index: 找出某个值第一次出现的位置, 如果不存在会抛出异常, 所以可以和 count 结合使用, 或者用 in 替代 count
  • insert: 方法insert用于将一个对象插入列表。
  • pop : 从列表中删除一个元素(默认为列表的最后一个元素),并返回这一元素。pop是唯一既修改列表又返回一个非None值的列表方法。
  • remove: 删除第一个为指定值的元素(如果不存在会抛出异常), 不会返回值
  • reverse : 反向存放列表值, 改变了列表.
  • sort : 对列表在原位置排序, 会改变原列表. 如果不改变原列表, 可以使用:
    • 用分片操作 [:] , 或 y = x.copy() 先创建一个副本, 对副本进行排序
    • 使用 sorted() 函数
>>> s = 'hello world'
>>> aList = list(s)
>>> aList
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
>>> aList.count('o')
2
>>> aList.count('z')
0
>>> aList.append([1,2])
>>> aList
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', [1, 2]]
>>> aList.count([1,2])
1
>>> aList.index('e')
1
>>> aList.index('z')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'z' is not in list
>>> aList.reverse()
>>> aList
[[1, 2], 'd', 'l', 'r', 'o', 'w', ' ', 'o', 'l', 'l', 'e', 'h']
>>> aList.reverse()
>>> aList
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', [1, 2]]       
>>> aList.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'list' and 'str'
>>> aList.pop()
[1, 2]
>>> aList.sort()
>>> aList
[' ', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
>>> aList.sort(reverse=True)
>>> aList
['w', 'r', 'o', 'o', 'l', 'l', 'l', 'h', 'e', 'd', ' ']                                          

如果要按相反的顺序迭代序列,可使用函数reversed。这个函数不返回列表,而是返回一个迭代器(迭代器将在第9章详细介绍)。你可使用list将返回的对象转换为列表。

>>> x = [1,3,5,2]
>>> list(reversed(x))
[2, 5, 3, 1]
>>> x
[1, 3, 5, 2]
>>> x.reverse()
>>> x
[2, 5, 3, 1]

sort 支持更复杂的排序, 如使用 key 参数指定排序函数.方法sort接受两个可选参数:key和reverse。这两个参数通常是按名称指定的,称为关键字参数,将在第6章详细讨论。参数key类似于参数cmp:你将其设置为一个用于排序的函数。然而,不会直接使用这个函数来判断一个元素是否比另一个元素小,而是使用它来为每个元素创建一个键,再根据这些键对元素进行排序。因此,要根据长度对元素进行排序,可将参数key设置为函数len。对于另一个关键字参数reverse,只需将其指定为一个真值(True或False),以指出是否要按相反的顺序对列表进行排序。函数sorted也接受参数key和reverse。在很多情况下,将参数key设置为一个自定义函数很有用。更多排序内容可参考: Sorting Mini-HOW TO

>>> aList = ['this','is','a','test']
>>> aList.sort(key=len)
>>> aList
['a', 'is', 'this', 'test']

del语句:删除列表元素

>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
>>> del names[0]
>>> names
['Beth', 'Cecil', 'Dee-Dee', 'Earl']

切片赋值:

  • 通过使用切片赋值,可将切片替换为长度与其不同的序列
  • 通过使用切片赋值“替换”了一个空切片,相当于插入了一个序列;可采取相反的措施来删除 切片。
>>> s = list('hello')
>>> s
['h', 'e', 'l', 'l', 'o']
>>> s[2:]='world'
>>> s
['h', 'e', 'w', 'o', 'r', 'l', 'd']
>>> s[1:1]='xxx'
>>> s
['h', 'x', 'x', 'x', 'e', 'w', 'o', 'r', 'l', 'd']
>>> s[1:4]=[]
>>> s
['h', 'e', 'w', 'o', 'r', 'l', 'd']

2.4 元组:不可修改的序列

与列表一样,元组也是序列,唯一的差别在于元组是不能修改的.

元组可以用作:

  • 字典的键
  • 函数或方法的返回值

元组的语法:

  • 元组语法很简单,只要将一些值用逗号分隔,就能自动创建一个元组。元组还可用圆括号括起(这也是通常采用的做法)。
  • 空元组用两个不包含任何内容的圆括号表示。
  • 如何表示只包含一个值的元组呢?这有点特殊:虽然只有一个值,也必须在它后面加上逗号。逗号至关重要,仅将值用圆括号括起不管用:(42)42完全等效。但仅仅加上一个逗号,就能完全改变表达式的值。
  • 使用函数 tuple:函数tuple的工作原理与list很像:它将一个序列作为参数,并将其转换为元组。如果参数已经是元组,就原封不动地返回它。
  • 元组的切片也是元组,就像列表的切片也是列表一样
>>> 1,2,3
(1, 2, 3)
>>> (1,2,3)
(1, 2, 3)
>>> 1
1
>>> 1,
(1,)
>>> ()
()
>>> 10*(1+2)
30
>>> 10*(1+2,)
(3, 3, 3, 3, 3, 3, 3, 3, 3, 3)
>>> tuple('hello')
('h', 'e', 'l', 'l', 'o')
>>> tuple((1,2,3))
(1, 2, 3)
>>> tuple([1,2,3])
(1, 2, 3)
>>> tuple([1,2,3])[2:]
(3,)
© Licensed under CC BY-NC-SA 4.0

我每天都自问: ‘如果今天是我生命的最后一天, 我还会做今天打算做的事情吗?’——史蒂夫.乔布斯

发表我的评论
取消评论
表情

Hi,您需要填写昵称和邮箱!