【Python基础】列表和元组

阳光穿透心脏的1/2处 2023-10-17 08:11 1阅读 0赞

## 列表的定义 ##

Python中使用\[\]来包含列表成员。

空列表直接使用\[\]来表示。

列表中的成员的类型可以不同。

列表中还可以包含列表。

if __name__ == "__main__":
        emptyList = []          # Empty list.
        aList = ["John", 18]    # Ordinary list.
        listInList = [aList, 1] # List with list in.
        
        print emptyList         # []
        print aList             # ['John', 18]
        print listInList        # [['John', 18], 1]

## 列表索引 ##

Python中的列表的索引有很多的方式，下面是一些例子：

if __name__ == "__main__":
        aList = [1, 2, 3, 4, 5, 6]
        print aList[0]      # 1, Positive index, from left to right, start from 0.
        print aList[-1]     # 6, Negative index, from right to left, start form -1.
        print aList[0:4]    # [1, 2, 3, 4], index [0, 4), index 4 not contained.
        print aList[-3:-1]  # [4, 5], index [-3, -1), index -1 not contained.
        print aList[0:-1]   # [1, 2, 3, 4, 5], index -1 not contained.
        print aList[:]      # [1, 2, 3, 4, 5, 6], print all.
        print aList[:2]     # [1, 2], index [0, 2).
        print aList[-2:]    # [5, 6], index [-2, -2).
        print aList[-3:0]   # [], wrong order!!
        print aList[0:6:2]  # [1, 3, 5], the third one is step.
        print aList[-3:0:-1]# [4, 3, 2], the third one is step, could be negative.

Python中的索引可以从左开始也可以从右开始。

可以分片，但是分片需要注意的是第一个索引必须是表示从左边开始的，第二个索引必须是从右边开始的，这也是为什么aList\[-3:0\]返回的结果是空。

## 列表操作 ##

Python中的列表可以相加，甚至可以相乘：

if __name__ == "__main__":
        aList = [1, 2, 3]
        bList = [4, 5, 6]
        print aList + bList # [1, 2, 3, 4, 5, 6]
        print aList * 3     # [1, 2, 3, 1, 2, 3, 1, 2, 3]

**in**操作符可以用在List的if和for语句中：

if __name__ == "__main__":
        aList = [-1, 0, 1, 2, 3]
        for e in aList:
            print e
        if 0 in aList:
            print "yes"

del可以用在列表中用于删除元素：

if __name__ == "__main__":
        aList = [-1, 0, 1, 2, 3]
        del aList[0]    # del -1.
        del aList[0]    # del 0.
        print aList     # [1, 2, 3].

列表中的长度，最大值，最小值都有函数来判断：

if __name__ == "__main__":
        aList = [1, 2, 3, 4]
        print len(aList)    # 4
        print max(aList)    # 4
        print min(aList)    # 1

Python中提供了工厂方法list()来构建列表：

if __name__ == "__main__":
        aStr = "hello world"
        print list(aStr)         # ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

## 列表的方法 ##

下面是列表的方法举例：

#coding=utf-8
    #
    # This file talks about list and tuple in Python.
    #
    
    if __name__ == "__main__":
        aList = [1, 2, 3, 4]
        aList.append(5)         # 添加元素.
        print aList             # [1, 2, 3, 4, 5].
        aList.append([5, 6])    # 添加元素，“一个”元素.
        print aList             # [1, 2, 3, 4, 5, [5, 6]].
        aList.extend([5, 6])    # 一次性追加序列中的多个元素, 不同于列表相加，这里直接改变了列表本身，而相加不会改变列表本身.
        print aList             # [1, 2, 3, 4, 5, [5, 6], 5, 6].
        print aList.count(5)    # 1 # 统计一个元素出现的次数，不会递归统计，所以结果是2，而不是3.
        print aList.index(5)    # 4 # 找到第一个匹配项的下标.
        aList.insert(2, "two")  # 指定位置插入元素.
        print aList             # [1, 2, 'two', 3, 4, 5, [5, 6], 5, 6].
        print aList.pop()       # 6 # 删除最后一个元素，并返回它.
        print aList.pop(0)      # 1 # 删除第一个元素，并返回它.
        print aList             # [2, 'two', 3, 4, 5, [5, 6], 5] # 通过pop()防范，元素已删除.
        aList.remove(5)         # 删除第一个匹配的元素.
        print aList             # [2, 'two', 3, 4, [5, 6], 5].
        aList.reverse()         # 列表反向存放.
        print aList             # [5, [5, 6], 4, 3, 'two', 2].
        aList.sort()            # 原地排序，所以会改变列表本身.
        print aList             # [2, 3, 4, 5, [5, 6], 'two'].

## 元祖的定义 ##

元组跟列表类似。

Python中使用()来包含成员。

空的元组就是一对()。

元组中必须多于一个成员。

下面是一些例子：

if __name__ == "__main__":
        emptyTuple = ()             # Empty tuple.
        print emptyTuple            # ()
        aTuple = (1, 2)             # Ordinary tuple.
        print aTuple                # (1, 2)
        singleTuple = (1)           # This is not a tuple.
        print type(singleTuple)     # <type 'int'>.
        print singleTuple           # 1
        singleTuple_modify = (1,)   # This is a tumple.
        print singleTuple_modify    # (1,).

Python提供了tuple构造函数：

if __name__ == "__main__":
        print tuple([1, 2, 3])      # (1, 2, 3), list to tuple.
        print tuple("hello")        # ('h', 'e', 'l', 'l', 'o'), string to tuple.
        print tuple((1, 2, 3))      # (1, 2, 3), tuple to tuple.

## 元组的访问同列表，其他操作基本没有，因为它不可变 ##

元组可以当作映射中的“键”来使用。

元组常用作函数或者方法的返回值（如果这个函数或者方法需要返回多个值的话）。