python 定义字典 换行_Python 列表

本文详细介绍了Python中的列表,包括如何创建、修改和遍历列表,以及各种操作如加法、乘法、切片、方法(如append、extend、sort等)。还探讨了列表与字符串的区别,以及在函数传递中列表的引用特性,强调了避免别名和理解列表方法返回值的重要性。
摘要由CSDN通过智能技术生成

Python 列表、字典、元组

列表

相当于java中的list集合,列表 是由多个值组成的序列。在字符串中,每个值都是字符; 在列表中,值可以是任何数据类型。列表中的值称为 元素(element) ,有时也被称为 项(item) 。

列表的创建

最简单的方法是用方括号( [ 和 ] )将元素包括起来:

[10, 20, 30, 40]

['crunchy frog', 'ram bladder', 'lark vomit']

下面的列表包含一个字符串、一个浮点数、一个整数和另一个列表:

['spam', 2.0, 5, [10, 20]]

一个不包含元素的列表被称为空列表;你可以用空的方括号 [] 创建一个空列表。

>>> cheeses = ['Cheddar', 'Edam', 'Gouda']

>>> numbers = [42, 123]

>>> empty = []

>>> print(cheeses, numbers, empty)

['Cheddar', 'Edam', 'Gouda'] [42, 123] []

列表是可变的

和字符串不同的是,列表是可变的。当括号运算符出现在赋值语句的左边时,它就指向了列表中将被赋值的元素。

>>> numbers = [42, 123]

>>> numbers[1] = 5

>>> numbers

[42, 5]

in运算符在列表中同样可以使用。

>>> cheeses = ['Cheddar', 'Edam', 'Gouda']

>>> 'Edam' in cheeses

True

>>> 'Brie' in cheeses

False

遍历列表

最常用的遍历列表的方式是使用for循环。语法和字符串遍历类似:

for cheese in cheeses:

print(cheese)

然而,如果你想要写入或者更新列表中的元素,你需要通过下标访问。一种常用的方法是结合内置函数 range 和 len :

for i in range(len(numbers)):

numbers[i] = numbers[i] * 2

对一个空列表执行for循环时,将不会执行循环的主体:

for x in []:

print('This never happens.')

列表操作

+运算符拼接多个列表:

>>> a = [1, 2, 3]

>>> b = [4, 5, 6]

>>> c = a + b

>>> c

[1, 2, 3, 4, 5, 6]

运算符 * 以给定次数的重复一个列表:

>>> [0] * 4

[0, 0, 0, 0]

>>> [1, 2, 3] * 3

[1, 2, 3, 1, 2, 3, 1, 2, 3]

列表切片

>>> t = ['a', 'b', 'c', 'd', 'e', 'f']

>>> t[1:3]

['b', 'c']

>>> t[:4]

['a', 'b', 'c', 'd']

>>> t[3:]

['d', 'e', 'f']

如果你省略第一个索引,切片将从列表头开始。如果你省略第二个索引,切片将会到列表尾结束。 所以如果你两者都省略,切片就是整个列表的一个拷贝。

由于列表是可变的,通常在修改列表之前,对列表进行拷贝是很有用的。

切片运算符放在赋值语句的左边时,可以一次更新多个元素:

>>> t = ['a', 'b', 'c', 'd', 'e', 'f']

>>> t[1:3] = ['x', 'y']

>>> t

['a', 'x', 'y', 'd', 'e', 'f']

列表方法

Python为列表提供了一些方法. 例如, append 添加一个新元素到列表的末端:

>>> t = ['a', 'b', 'c']

>>> t.append('d')

>>> t

['a', 'b', 'c', 'd']

extend将接受一个列表作为参数,并将其其中的所有元素添加至目标列表中:

>>> t1 = ['a', 'b', 'c']

>>> t2 = ['d', 'e']

>>> t1.extend(t2)

>>> t1

['a', 'b', 'c', 'd', 'e']

sort将列表中的元素从小到大进行排序

>>> t = ['d', 'c', 'e', 'b', 'a']

>>> t.sort()

>>> t

['a', 'b', 'c', 'd', 'e']

映射、筛选和归并

你可以这样使用循环,对列表中所有元素求和:

def add_all(t):

total = 0

for x in t:

total += x

return total

把一个列表中的元素加起来是一个很常用的操作, 所以Python将其设置为一个内建内置函数 sum :

>>> t = [1, 2, 3]

>>> sum(t)

6

一个像这样的将一系列的元素合并成一个单一值的操作有时称为 归并(reduce) 。

有时,你在构建一个列表时还需要遍历另一个列表。 例如,下面的函数接受一个字符串列表作为参数,返回包含大写字符的新列表:

def capitalize_all(t):

res = []

for s in t:

res.append(s.capitalize())

return res

删除元素

使用 pop

>>> t = ['a', 'b', 'c']

>>> x = t.pop(1)

>>> t

['a', 'c']

>>> x

'b'

使用 del 运算符

>>> t = ['a', 'b', 'c']

>>> del t[1]

>>> t

['a', 'c']

如果你知道要删除的值(但是不知道其下标),你可以使用 remove

>>> t = ['a', 'b', 'c']

>>> t.remove('b')

>>> t

['a', 'c']

要移除多个元素,你可以结合切片索引使用 del :

>>> t = ['a', 'b', 'c', 'd', 'e', 'f']

>>> del t[1:5]

>>> t

['a', 'f']

列表和字符串

一个字符串是多个字符组成的序列,一个列表是多个值组成的序列。但是一个由字符组成的列表不同于字符串。可以使用 list 将一个字符串转换为字符的列表:

>>> s = 'spam'

>>> t = list(s)

>>> t

['s', 'p', 'a', 'm']

list函数将字符串分割成单独的字符。如果你想将一个字符串分割成一些单词,你可以使用 split 方法:

>>> s = 'pining for the fjords'

>>> t = s.split()

>>> t

['pining', 'for', 'the', 'fjords']

可以提高一个叫做 分隔符(delimiter) 的可选参数,指定什么字符作为单词之间的分界线。下面的例子使用连字符作为分隔符:

>>> s = 'spam-spam-spam'

>>> delimiter = '-'

>>> t = s.split(delimiter)

>>> t

['spam', 'spam', 'spam']

join的功能和 split 相反。它将一个字符串列表的元素拼接起来。join 是一个字符串方法,所以你需要在一个分隔符上调用它,并传入一个列表作为参数:

>>> t = ['pining', 'for', 'the', 'fjords']

>>> delimiter = ' '

>>> s = delimiter.join(t)

>>> s

'pining for the fjords'

在这个例子中,分隔符是一个空格,所以 join 在单词之间添加一个空格。如果不使用空格拼接字符串,你可以使用空字符串 '' 作为分隔符。

创建字符串的时候,如果字符串的内容是一样的,生成一个字符串对象,然后同时指向它。

但是当你创建两个列表时,你得到的是两个对象:

>>> a = [1, 2, 3]

>>> b = [1, 2, 3]

>>> a is b

False

在这个例子中,我们称这两个列表是 相等(equivalent) 的,因为它们有相同的元素。但它们并不 相同(identical) ,因为他们不是同一个对象。如果两个对象 相同 ,它们也是相等的,但是如果它们是相等的,它们不一定是相同的。

别名

如果 a 指向一个对象,然后你赋值 b = a ,那么两个变量指向同一个对象:

>>> a = [1, 2, 3]

>>> b = a

>>> b is a

True

变量和对象之间的关联称为 引用(reference) 在这个例子中,有两个对同一个对象的引用。

如果一个对象有多于一个引用,那它也会有多个名称, 我们称这个对象是 有别名的(aliased) 。

如果一个有别名的对象是可变的,对其中一个别名(alias)的改变对影响到其它的别名:

>>> b[0] = 42

>>> a

[42, 2, 3]

个人理解:在这里指向的都是一样的,即所有的改变都会同步过去。

尽管这个行为很有用,但是容易导致出现错误。 通常,避免对于可变对象使用别名相对更安全

a和 b 是否指向同一个字符串基本上没有什么影响。

列表参数

当你将一个列表作为参数传给一个函数,函数将得到这个列表的一个引用。如果函数对这个列表进行了修改,会在调用者中有所体现。例如, delete_head 删除列表的第一个元素:

def delete_head(t):

del t[0]

>>> letters = ['a', 'b', 'c']

>>> delete_head(letters)

>>> letters

['b', 'c']

需要注意的是修改列表操作和创建列表操作间的区别。 例如,append 方法是修改一个列表,而 + 运算符是创建一个新的列表

>>> t1 = [1, 2]

>>> t2 = t1.append(3)

>>> t1

[1, 2, 3]

>>> t2

None

append修改列表并返回None。

>>> t3 = t1 + [4]

>>> t1

[1, 2, 3]

>>> t3

[1, 2, 3, 4]

>>> t1

运算符 + 创建了一个新列表,而不改变原始的列表。

调试

粗心地使用列表(以及其他可变对象)会导致长时间的调试。 下面列举一些常见的陷阱以及避免它们的方法:

大多数的列表方法会对参数进行修改,然后返回 None 。这和字符串方法相反,后者保留原始的字符串并返回一个新的字符串。

如果你习惯这样写字符串代码:

word = word.strip()

那么你很可能会写出下面的列表代码:

t = t.sort() # 错误!

因为 sort 返回 None ,所以你的下一个对 t 执行的操作很可能会失败。

在使用 list 方法和操作符之前,你应该仔细阅读文档,然后在交互模式下测试。

选择一种写法,坚持下去。

列表的一个问题就是有太多方法可以做同样的事情。 例如,要删除列表中的一个元素,你可以使用 pop 、remove 、del 甚至是切片赋值。

要添加一个元素,你可以使用 append 方法或者 + 运算符。假设 t 是一个列表,x 是一个列表元素,以下这些写法都是正确的:

t.append(x)

t = t + [x]

t += [x]

而这些是错误的:

t.append([x]) # 应该是正确的! 备注:实验下这个方法,笔者测试可以,结果会将[x]值直接存进去

t = t.append(x) # 错误!

t + [x] # 错误!

t = t + x # 错误!

在交互模式下尝试每一个例子,保证你明白它们做了什么。 注意只有最后一个会导致运行时错误;其他的都是合乎规范的的,但结果却是错的。

通过创建拷贝来避免别名.

如果你要使用类似 sort 这样的方法来修改参数, 但同时有要保留原列表,你可以创建一个拷贝。

>>> t = [3, 1, 2]

>>> t2 = t[:] # 创建备份

>>> t2.sort()

>>> t

[3, 1, 2]

>>> t2

[1, 2, 3]

在这个例子中,你还可以使用内置函数 sorted ,它将返回一个新的已排序的列表,原列表将保持不变。

>>> t2 = sorted(t)

>>> t

[3, 1, 2]

>>> t2

[1, 2, 3]

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值