列表
列表是序列的一种,是Python语言中最常用的数据结构 序列中的每个元素都有一个相应的位置,或者说是索引,第一个索引是 0,第二个索引是 1,依此类推 所有序列都具有的操作有:索引,切片,加,乘,检查成员 容器数据类型
类型 描述 list 列表 tuple 元组 dict 字典 set 集合 str 字符串
1.列表的定义
列表是有序集合,没有固定大小,能够保存任意数量任意类型的Python对象,语法为[元素1, 元素2, ..., 元素n]
。 关键点是中括号[]
和逗号,
[]
把所有元素绑在一起,,
将每个元素分开
2.列表的创建
创建一个列表,只要把逗号,
分隔的不同的数据项使用方括号[]
括起来即可
x = [ 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' ]
print ( x, type ( x) )
x = [ 2 , 3 , 4 , 5 , 6 , 7 ]
print ( x, type ( x) )
x = list ( range ( 10 ) )
print ( x, type ( x) )
x = list ( range ( 1 , 11 , 2 ) )
print ( x, type ( x) )
x = [ 0 ] * 5
print ( x, type ( x) )
x = [ 0 for i in range ( 5 ) ]
print ( x, type ( x) )
x = [ i for i in range ( 10 ) ]
print ( x, type ( x) )
x = [ i for i in range ( 1 , 10 , 2 ) ]
print ( x, type ( x) )
x = [ i for i in range ( 10 , 1 , - 2 ) ]
print ( x, type ( x) )
x = [ i ** 2 for i in range ( 1 , 10 ) ]
print ( x, type ( x) )
x = [ i for i in range ( 100 ) if ( i % 2 ) != 0 and ( i % 3 ) == 0 ]
print ( x, type ( x) )
由于list
的元素可以是任何对象,因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3],也有3个指针和3个整数对象。 x = [a] * 4
操作中,只是创建4个指向list
的引用,所以一旦a改变,x中4个a也会随之改变。
x = [ [ 0 ] * 3 ] * 4
print ( x, type ( x) )
x[ 0 ] [ 0 ] = 1
print ( x, type ( x) )
a = [ 0 ] * 3
x = [ a] * 4
print ( x, type ( x) )
x[ 0 ] [ 0 ] = 1
print ( x, type ( x) )
mix = [ 1 , 'lsgo' , 3.14 , [ 1 , 2 , 3 ] ]
print ( mix, type ( mix) )
empty = [ ]
print ( empty, type ( empty) )
列表不像元组,列表内容可更改mutable
,因此附加append
, extend
、插入insert
、删除remove
,pop
这些操作都可以用在它身上。
3.向列表中添加元素
list.append(obj)
在列表末尾添加新的对象,只接受一个参数,参数可以是任何数据类型,被追加的元素在list
中保持着原结构类型。
x = [ 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' ]
x. append( 'Thursday' )
print ( x)
如果append
的元素是一个list
,那么这个list
将作为一个整体进行追加,注意append()
和extend()
的区别。
x = [ 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' ]
x. append( [ 'Thursday' , 'Sunday' ] )
print ( x)
list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
x = [ 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' ]
x. extend( [ 'Thursday' , 'Sunday' ] )
print ( x)
严格来说append
是追加,把一个object
整体添加在列表后,而extend
是扩展,把另一个序列中的所有元素添加在列表后。
list.insert(index, obj)
,在编号index
位置插入obj
x = [ 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' ]
x. insert( 2 , 'Sunday' )
print ( x)
4.删除列表中的元素
list.remove(obj)
移除列表中某个值的第一个匹配项
x = [ 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' ]
x. remove( 'Monday' )
print ( x)
list.pop([index = -1])
移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
x = [ 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' ]
y = x. pop( )
print ( y)
y = x. pop( 0 )
print ( y)
y = x. pop( - 2 )
print ( y)
print ( x)
x = [ 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' ]
del x[ 0 : 2 ]
print ( x)
如果你要从列表中删除一个元素,且不再以任何方式使用它,就使用del语句;如果你要在删除元素后还能继续使用它,就使用方法pop()
获取列表中的元素
通过元素的索引值,从列表获取单个元素,注意,列表索引值是从0
开始的 通过将索引指定为-1
,可让Python返回最后一个列表元素,索引-2
返回倒数第二个列表元素,以此类推
x = [ 'Monday' , 'Tuesday' , 'Wednesday' , [ 'Thursday' , 'Friday' ] ]
print ( x[ 0 ] , type ( x[ 0 ] ) )
print ( x[ - 1 ] , type ( x[ - 1 ] ) )
print ( x[ - 2 ] , type ( x[ - 2 ] ) )
切片的通用写法是start
:stop
:step
情况 1 - start:
,以step
为1
(默认) 从编号start
往列表尾部切片
x = [ 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' ]
print ( x[ 3 : ] )
print ( x[ - 3 : ] )
情况 2 - :stop
,以step
为1
(默认) 从列表头部往编号stop
切片,但不包含stop
week = [ 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' ]
print ( week[ : 3 ] )
print ( week[ : - 3 ] )
情况 3 - start:stop
,以step
为1
(默认) 从编号start
往编号stop
切片,但不包含stop
week = [ 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' ]
print ( week[ 1 : 3 ] )
print ( week[ - 3 : - 1 ] )
情况 4 - start:stop:step
,以step
步长,从编号start
往编号stop
切片,但不包含stop
。注意最后把step
设为-1
,相当于将列表反向排列。
week = [ 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' ]
print ( week[ 1 : 4 : 2 ] )
print ( week[ : 4 : 2 ] )
print ( week[ 1 : : 2 ] )
print ( week[ : : - 1 ] )
week = [ 'Monday' , 'Tuesday' , 'Wednesday' , 'Thursday' , 'Friday' ]
print ( week[ : ] )
list1 = [ 123 , 456 , 789 , 213 ]
list2 = list1
list3 = list1[ : ]
print ( list2)
print ( list3)
list1. sort( )
print ( list2)
print ( list3)
list1 = [ [ 123 , 456 ] , [ 789 , 213 ] ]
list2 = list1
list3 = list1[ : ]
print ( list2)
print ( list3)
list1[ 0 ] [ 0 ] = 111
print ( list2)
print ( list3)
6.列表的常用操作符
操作符 描述 == 等号操作符 + 连接操作符 * 重复操作符 in/not in 成员关系操作符
==
用户判断列表相等,只有成员、位置都相同时才返回True+
用于组合列表*
号用于重复列表
list1 = [ 123 , 456 ]
list2 = [ 456 , 123 ]
list3 = [ 123 , 456 ]
print ( list1 == list2)
print ( list1 == list3)
list4 = list1 + list2
print ( list4)
list5 = list3 * 3
print ( list5)
list3 *= 3
print ( list3)
print ( 123 in list3)
print ( 456 not in list3)
前面三种方法append
,extend
,insert
可对列表增加元素,它们没有返回值,是直接修改了原数据对象。 而将两个list
相加,需要创建新的list
对象,从而需要消耗额外的内存,特别是当list
较大时,尽量不要使用+
来添加list
。
7.列表的其它方法
list.count(obj)
统计obj
在列表
中出现的次数
list1 = [ 123 , 456 ] * 3
print ( list1)
num = list1. count( 123 )
print ( num)
list.index(x[, start[, end]])
从列表中找出某个值第一个匹配项的索引位置
list1 = [ 123 , 456 ] * 5
print ( list1. index( 123 ) )
print ( list1. index( 123 , 1 ) )
print ( list1. index( 123 , 3 , 7 ) )
x = [ 123 , 456 , 789 ]
x. reverse( )
print ( x)
list.sort(key=None, reverse=False)
对原列表进行排序key
主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序reverse
排序规则,reverse = True
降序,reverse = False
升序(默认)该方法没有返回值,但是会对列表的对象进行排序
x = [ 123 , 456 , 789 , 213 ]
x. sort( )
print ( x)
x. sort( reverse= True )
print ( x)
def takeSecond ( elem) :
return elem[ 1 ]
x = [ ( 2 , 2 ) , ( 3 , 4 ) , ( 4 , 1 ) , ( 1 , 3 ) ]
x. sort( key= takeSecond)
print ( x)
x. sort( key= lambda a: a[ 0 ] )
print ( x)
list.clear()
清空列表list.copy()
复制列表
元组
语法为(元素1, 元素2, ..., 元素n)
小括号()
把所有元素绑在一起,逗号,
将每个元素分开
1.创建和访问一个元组
元组与列表类似,不同之处在于tuple
被创建后就不能对其进行修改,类似字符串 元组使用小括号,列表使用方括号 元组与列表类似,也用整数来对它进行索引indexing
和切片slicing
t1 = ( 1 , 10.31 , 'python' )
t2 = 1 , 10.31 , 'python'
print ( t1, type ( t1) )
print ( t2, type ( t2) )
tuple1 = ( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 )
print ( tuple1[ 1 ] )
print ( tuple1[ 5 : ] )
print ( tuple1[ : 5 ] )
tuple2 = tuple1[ : ]
print ( tuple2)
创建元组可以用小括号()
,也可以什么都不用,为了可读性,建议还是用()
元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用
x = ( 1 )
print ( type ( x) )
x = 2 , 3 , 4 , 5
print ( type ( x) )
x = [ ]
print ( type ( x) )
x = ( )
print ( type ( x) )
x = ( 1 , )
print ( type ( x) )
print ( 8 * ( 8 ) )
print ( 8 * ( 8 , ) )
x = ( 1 , 10.31 , 'python' ) , ( 'data' , 11 )
print ( x)
print ( x[ 0 ] )
print ( x[ 0 ] [ 0 ] , x[ 0 ] [ 1 ] , x[ 0 ] [ 2 ] )
print ( x[ 0 ] [ 0 : 2 ] )
2.更新和删除一个元组
week = ( 'Monday' , 'Tuesday' , 'Thursday' , 'Friday' )
week = week[ : 2 ] + ( 'Wednesday' , ) + week[ 2 : ]
print ( week)
元组有不可更改immutable
的性质,因此不能直接给元组的元素赋值,但是只要元组中的元素可更改mutable
,那么我们可以直接更改其元素,注意这跟赋值其元素不同。
t1 = ( 1 , 2 , 3 , [ 4 , 5 , 6 ] )
print ( t1)
t1[ 3 ] [ 0 ] = 9
print ( t1)
3.元组相关的操作符
操作符 描述 == 等号操作符 + 连接操作符 * 重复操作符 in/not in 成员关系操作符
==
用户判断元组相等,只有成员、位置都相同时才返回True+
用于组合元组*
号用于重复元组
4.内置方法
元组大小和内容都不可更改,因此只有count
和index
两种方法
t = ( 1 , 10.31 , 'python' )
print ( t. count( 'python' ) )
print ( t. index( 10.31 ) )
count('python')
是记录在元组 t 中该元素出现几次,显然是 1 次index(10.31)
是找到该元素在元组 t 的索引,显然是 1
5.解压元组
t = ( 1 , 10.31 , 'python' )
( a, b, c) = t
print ( a, b, c)
t = ( 1 , 10.31 , ( 'OK' , 'python' ) )
( a, b, ( c, d) ) = t
print ( a, b, c, d)
如果你只想要元组其中几个元素,用通配符*
,英文叫wildcard
,在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了rest
变量
t = 1 , 2 , 3 , 4 , 5
a, b, * rest, c = t
print ( a, b, c)
print ( rest)
如果你根本不在乎rest
变量,那么就用通配符*
加上下划线_
t = 1 , 2 , 3 , 4 , 5
a, b, * _ = t
print ( a, b)