博客源为书写的载体,书写以对思维的缓存 正文

Python list和tuple的使用


序列是Python中最基本的数据结构,所谓序列,即成员有序排列、可通过下标访问。在Python中常见序列类型包括:字符串(普通字符串和unicode字符串)、列表和元组,以下仅讨论列表和元组。

一:list(列表)

list是一种有序的集合,可以随时添加、修改和删除其中的元素,包含的数据类型可以是:整数、浮点数、字符串、list、tuple、dict、set、bool、空值、常量等等。

1.创建、删除、清空列表

1.创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可,如:
>>> list1 = [1, 2.0, "三", [4], (5,), {6 : "陆"}, set([7]), True, None]
>>> list1 = []    # 空列表

2.删除列表
>>> del list1

3.清空列表
>>> list1.clear()

2.增加元素

1.增加元素到指定位置:insert(index, elem)
>>> list1 = []    # 空列表
>>> list1.insert(0, "添加第一个元素")
>>> list1
... ["添加第一个元素"]

2.增加元素到列表末尾:append(elem)
>>> list1 = ["添加一个元素"]
>>> list1.append("添加第二个元素")
>>> list1
... ["添加第一个元素", "添加第二个元素"]

3.删除元素

1.删除指定位置的元素:pop(index)
>>> list1 = [1, 2, 3]
>>> list1.pop(0)    # 删除索引为0的元素
>>> list1
... [2, 3]
或者:del list[index]
>>> list1 = [1, 2, 3]
>>> del list1[1]
>>> list1
... [1, 3]
或者:remove(elem)
>>> list1 = [1, 1, 2, 3]
>>> list1.remove(1)    # 删除列表中指定元素的第一个匹配项
>>> list1
... [1, 2, 3]


2.删除列表末尾的元素:pop()
>>> list1 = [1, 2, 3]
>>> list1.pop()    # 删除末尾
>>> list1
... [1, 2]

4.修改元素

# 通过索引修改
>>> list1 = [1, 2, 3]
>>> list1[1] = "一"
>>> list1
... ["一", 2, 3]

5.查询元素

# 通过索引查询
>>> list1 = [1, 2, 3]
>>> list1[0]
... 1
>>> list[2]
... 3

6.列表运算符

             表达式   
            结果   
            描述   
     [1, 2, 3] + [4, 5, 6]     [1, 2, 3, 4, 5, 6]            组合
     [1, 2, 3] += [4, 5, 6]     [1, 2, 3, 4, 5, 6]            组合
     ["hello"] * 2     ["hello", "hello"]            重复
     ["hello"] *= 2     ["hello", "hello"]            重复

7.列表切片

>>> list = ["one", "two", "three", "four"]

   表达式   
    结果   
   描述   
   list[2]   "three"   读取"索引为2"的元素
   list[-2]   "three"   从右侧开始读取倒数第二个元素
   list[1:]   ["two", "three", "four"]   从"索引为1"的元素开始往右的所有元素
   list[:-1]   ["one", "two", "three"]   输出从右侧倒数第一个元素开始往左的所有元素(不包括倒数第一个元素)
   list[1:3]   ["two", "three"]   从"索引为1"开始到"索引为3"元素之间的所有元素(不包括索引为3的元素)
   list[:]   ["one", "two", "three", "four"]   输出整个列表
   list[5:]   []   超出最大索引范围不报错,从"索引为5"开始往右的所有元素,返回空列表
   list[:-5]
   []   超出最大索引范围不报错,从"倒数第5"开始往左的所有元素,返回空列表

8.列表嵌套

使用嵌套列表即在列表里创建其它序列,例如:

>>> list1 = [1, 2, [3, 4], (5, 6)]
>>> list1[2]
... [3, 4]
>>> list[2][1]
... 4

9.列表函数

   序号   
    函数
   说明
     1    len(list)        返回列表元素个数
     2    max(list)   返回列表元素中的最大值
     3    min(list)   返回列表元素中的最小值
     4
    list(seq)   将序列类型(字符串、元祖)转换为列表

10.列表方法

   序号   
   方法
   说明
     1   list.count(elem)   统计某个元素在列表中出现的次数
     2   list.extend(seq)   在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
     3   list.index(elem)
   从列表中找出某个元素的第一个匹配项的索引位置
     4   list.reverse()   反向列表中元素
     5   list.sort()   在原列表上进行排序,会改变原列表,列表中的元素必须为同一类型。
     6   list.copy()   复制列表(浅复制)

二:tuple(元祖)

元组与列表类似,不同之处在于元组的元素不能修改(不可变类型);元组使用小括号,列表使用方括号。

1.创建、删除元祖

1.元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。如:
>>> tuple1 = (1, 2.0, "三", [4], (5,), {6 : "陆"}, set([7]), True, None)

2.当元祖只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用:
>>> tuple1 = ("一")
>>> type(tuple1)    # 不加逗号,类型为字符串
... <class 'str'>
>>> tuple1 = ("一",)
>>> type(tuple1)    # 加了逗号,类型为元祖
... <class 'tuple'>

2.删除元组
>>> del tuple1

1.增加、删除、修改元素

因为元祖是不可变类型,所以元组中的元素是不允许增加和删除,元素的指向不能修改。

2.查询元素

元组可以使用下标索引来访问元组中的值

# 通过索引查询
>>> tuple1= (1, 2, 3)
>>> tuple1[0]
... 1
>>> tuple1[2]
... 3

3.元祖运算符

             表达式   
            结果   
            描述   
     (1, 2, 3) + (4, 5, 6)     (1, 2, 3, 4, 5, 6)            组合
     (1, 2, 3) += (4, 5, 6)     (1, 2, 3, 4, 5, 6)            组合
     ("hello",) * 2     ("hello", "hello")            重复
     ("hello",) *= 2     ("hello", "hello")            重复

4.元祖切片

>>> tuple= ("one", "two", "three", "four")

   表达式   
    结果   
   描述   
   tuple[2]   "three"   读取"索引为2"的元素
   tuple[-2]   "three"   从右侧开始读取倒数第二个元素
   tuple[1:]   ("two", "three", "four")   从"索引为1"的元素开始往右的所有元素
   tuple[:-1]   ("one", "two", "three")   输出从右侧倒数第一个元素开始往左的所有元素(不包括倒数第一个元素)
   tuple[1:3]   ("two", "three")   从"索引为1"开始到"索引为3"元素之间的所有元素(不包括索引为3的元素)
   tuple[:]   ("one", "two", "three", "four")   输出整个元祖
   tuple[5:]   ()   超出最大索引范围不报错,从"索引为5"开始往右的所有元素,返回空元祖
   tuple[:-5]
   ()   超出最大索引范围不报错,从"倒数第5"开始往左的所有元素,返回空元祖

5.元祖嵌套

使用嵌套元祖即在元祖里创建其它序列,例如:

>>> tuple1 = (1, 2, [3, 4], (5, 6))
>>> tuple1[2]
... [3, 4]
>>> tuple1[2][1]
... 4

6.元祖函数

   序号   
    函数
   说明
     1    len(tuple)        返回元祖元素个数
     2    max(tuple)   返回元祖元素中的最大值
     3    min(tuple)   返回元祖元素中的最小值
     4
    tuple(seq)   将序列类型(字符串、列表)转换为元祖

7.元祖方法

   序号   
   方法
   说明
     1   tuple.count(elem)   统计某个元素在元祖中出现的次数
     2   tuple.index(elem)   从元祖中找出某个元素的第一个匹配项的索引位置

8.拆包

拆包就是将元组中的元素拆分为多个单独变量中,列表也同理,事实上可迭代对象都具有拆包特性。

>>> tuple1 = ("张三", "男", 23)
>>> name, sex, age = tuple1
>>> name
... "张三"
>>> sex
... "男"
>>> age
... 23
# 变量数量必须要和元组中的元素数量一致,否则会报错:ValueError: too many values to unpack。

# 用星号"*"来表示多个值,解决上述问题

>>> tuple1 = ("张三", "男", 23)
>>> name, *other = tuple1
>>> name
... "张三"
>>> other
... ["男", 23]

9.元祖相对于列表的优势

1.性能好:不可变(immutable)的tuple会作为常量在编译时确定,因此操作时速度快。
2.线程安全。
3.可以作为字典(dict)的key:dict的key必须为不可变对象是因为immutable object的可哈希性(hashable),只有可哈希对象才能作为dict的key,可哈希对象是对象拥有__hash__(self)内置函数的对象。

关于字典(dict)和集合(set)的详细介绍可参考我的:Python dict和set的使用

四:最后

timg.gif