Python 列表與元組

時間  2019-11-19
標籤 python 列表 欄目 Python 简体版
原文   原文鏈接

 本節導航：

1、List 列表

　　列表（list）屬於一種有序的集合，能夠隨時添加和刪除其中的元素。列表是 Python 中內置的一種數據類型，也是最常用的 Python 數據類型。列表的命名規則就是一個方括號（[]），建立一個列表只要把逗號分隔的不一樣的數據項使用方括號括起來便可。列表中每一個元素都分配有一個數字（從0開始），這個數字即爲該元素的位置（或索引）也能夠認爲是該元素的下標，第一個索引是0，第二個索引是1，反過來最後一個索引是-1，依此類推。函數

　　在這裏咱們就簡單聲明一個班級名單列表 name 進行演示：atom

name = ["Madonna", "Cory", "Annie", "Nelly"]

注：列表中的數據項能夠爲任意數據類型。spa

 　　如今咱們已經弄清楚列表元素的具體位置了，也順便創建了一個簡單的列表，那下面就讓咱們詳細的瞭解下列表到底有哪些方法吧。rest

「增」：在單個列表添加元素時不能批量的插入元素，只能一個一個的來，具體的方法有 append() 和 insert() 兩種方法。append() 是直接在原列表的末尾追加（添加）元素，而 insert() 是在添加的索引前面插入（添加）元素；當在涉及兩個或兩個以上列表時，列表的內置方法中還提供了一種 extend() ，能夠把另外一個列表的因此元素追加到原列表（尾部追加）。演示實例以下：code

name = ["Madonna", "Cory", "Annie", "Nelly"]        #建立一個班級名單列表 name
 name.append("Eleanor")          #在name列表末尾追加 "Eleanor"
print(name)                     #['Madonna', 'Cory', 'Annie', 'Nelly', 'Eleanor']
 name.insert(1, "Baade")         #在原索引爲1的元素前面添加 "Baade"，即 "Baade" 佔據原爲索引爲1的位置
print(name)                     #['Madonna', 'Baade', 'Cory', 'Annie', 'Nelly', 'Eleanor']
 b = [1, 2, 3]                   #建立一個新的列表 b
name.extend(b)                  #把 b 列表整個追加到 name 列表後
print(name)                     #['Madonna', 'Baade', 'Cory', 'Annie', 'Nelly', 'Eleanor', 1, 2, 3]
    def append(self, p_object): # real signature unknown; restored from __doc__
        """ L.append(object) -> None -- append object to end """
        pass

    def insert(self, index, p_object): # real signature unknown; restored from __doc__
        """ L.insert(index, object) -- insert object before index """
        pass

    def extend(self, iterable): # real signature unknown; restored from __doc__
        """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """
        pass
append() insert() extend() 部分源代碼

「刪」：Python中提供了三種相關的內置方法和一種通用的刪除方法。remove() ：肯定要刪除的對象後，刪除第一次出現的值，若是值不存在，就會引起ValueError錯誤；pop() ：輸入下標後，刪除指定位置的元素，若是列表爲空或索引超出範圍，則會引起IndexError錯誤；clear() ：直接清空列表；del：能夠經過指定索引位置刪除列表中所對應的元素，也能夠直接刪除列表。對象

name = ["Madonna", "Cory", "Annie", "Nelly", "Cory"]        #建立一個班級名單列表 name
name.remove("Cory")             #移除從左邊數第一個 "Cory" 元素
print(name)                     #['Madonna', 'Annie', 'Nelly', 'Cory']
 name = ["Madonna", "Cory", "Annie", "Nelly", "Cory"] name.pop() #默認刪除列表的最後一位元素
print(name)                     #['Madonna', 'Cory', 'Annie', 'Nelly']
name.pop(0)                     #指定刪除列表中的第一個元素，至關於 del
print(name)                     #['Cory', 'Annie', 'Nelly']
 name = ["Madonna", "Cory", "Annie", "Nelly", "Cory"] del name[2]                     # 刪除列表中的第二個元素
print(name)                     #['Madonna', 'Cory', 'Nelly', 'Cory']
 name.clear() #清空列表
print(name)                     #[]

del name                        #刪除列表
print(name)                     #NameError: name 'name' is not defined

注：pop() 方法不加索引位置時默認刪除列表的最後一位，輸入下標（索引位置）後，刪除指定位置的元素。blog

    def remove(self, value): # real signature unknown; restored from __doc__
        """ L.remove(value) -> None -- remove first occurrence of value. Raises ValueError if the value is not present. """
        pass

    def pop(self, index=None): # real signature unknown; restored from __doc__
        """ L.pop([index]) -> item -- remove and return item at index (default last). Raises IndexError if list is empty or index is out of range. """
        pass

    def clear(self): # real signature unknown; restored from __doc__
        """ L.clear() -> None -- remove all items from L """
        pass
remove() pop() clear() 部分源代碼

「查」：能夠分爲兩種狀況，一種狀況是想中知道單個索引或一個索引到另外一個索引所對應的元素，這時候直接用列表名加方括號的方式獲取，咱們能夠把這種狀況說成是列表的切片，即獲取列表中對應索引的元素（通俗來說就是把列表中的部份內容取出來）；另一種狀況是知道列表中的某個元素，想要查詢該元素所在的索引位置，在這種狀況下咱們就須要利用內置的 index() 來實現了。演示實例以下：排序

name = ["Madonna", "Cory", "Annie", "Nelly"]        #建立一個班級名單列表 name

print(name[0])          #Madonna　　　　　　取列表的第一個元素
print(name[3])          #Nelly　　　　　　　取列表的第四個元素
print(name[-1])         #Nelly　　　　　　　取列表的最後一個元素
print(name[0:2])　　　　　　　　　  #['Madonna', 'Cory']　　　　　　　 取列表第一個到第二個元素
print(name[:2])　　　　　　　　　   #['Madonna', 'Cory']　　　　　　　 取列表第一個到第二個元素
print(name[0:-1])　　　　    #['Madonna', 'Cory', 'Annie'] 取列表第一個到三個元素
print(name[1:]) 　　　　     #['Cory', 'Annie', 'Nelly'] 取列表第二個到最後一個元素
print(name[-3:-1])          #['Cory', 'Annie'] 取列表第二個到第三個元素
print(name[:])              #['Madonna', 'Cory', 'Annie', 'Nelly'] 取列表第一個到最後一個元素

print(name.index("Cory"))   #1 查詢 Cory 元素所在的索引位置
print(name.index("Nelly"))  #3 查詢 Nelly 元素所在的索引位置

　注：

  • 一、方括號的切片原則是「顧頭不顧尾」，當查找單個索引所對應的元素時直接方括號內加索引位置便可；當查找一個索引到另外一個索引所對應的元素時，在方括號內寫入索引位置中間用冒號（:）隔開；
  • 二、當輸入的索引位置爲 0 或 -1 時，能夠省略，尤爲是省略 -1時包含 -1 所對應的最後一個元素，不省略的話不包括最後一個元素；
  • 三、切片是從左往右取，若是是 name[-1:-3] 則取不到值，爲空，正確寫法爲 name[-3:-1] 。
    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
        """ L.index(value, [start, [stop]]) -> integer -- return first index of value. Raises ValueError if the value is not present. """
        return 0
index() 部分源代碼

「改」：是最簡單的也是最直接的，直接經過賦值修改對應索引位置的元素便可。演示實例以下：

name = ["Madonna", "Cory", "Annie", "Nelly"]        #建立一個班級名單列表 name
 name[0] = "Ayris"           #把 "Ayris" 元素賦值給name列表中的 0 索引位置，即把0索引位置的元素改成 "Ayris"
print(name)                 #['Ayris', 'Cory', 'Annie', 'Nelly']
print(name[0])              #Ayris

其餘：count()  ：在列表中統計某個元素出現的次數；reverse()  ：反轉列表元素；sort()  ：把列表元素按ASCII碼排序；

name = ["Madonna", "Cory", "Annie", "Nelly", "Cory"]        #建立一個班級名單列表 name

print(name.count("Cory"))           #2 在列表中統計 "Cory" 元素出現的次數
 name.reverse() #反轉列表
print(name)                         #['Cory', 'Nelly', 'Annie', 'Cory', 'Madonna']
 name.sort() #按ASCII碼排序
print(name)                         #['Annie', 'Cory', 'Cory', 'Madonna', 'Nelly']
    def count(self, value): # real signature unknown; restored from __doc__
        """ L.count(value) -> integer -- return number of occurrences of value """
        return 0

   def reverse(self): # real signature unknown; restored from __doc__
        """ L.reverse() -- reverse *IN PLACE* """
        pass

    def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
        """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
        pass
count() reverse() sort() 部分源代碼

　　「淺copy」與「深copy」的探究：copy () 又稱淺copy，在列表複製中只固定列表的第一層，若是原列表內鑲嵌多層時，若是修改原列表的深層（大於一層）時，copy的新列表的深層也會跟着發生變換，第二個列表的內容（每個元素）只是第一個列表內容的引用；copy.deepcopy() 咱們稱之爲深copy，即所有複製原列表，複製好後的列表和新列表變成兩個徹底獨立的列表，互不干擾。

import copy         #導入 copy 模塊
 name = ["Madonna", "Cory", ["Annie", "Nelly"], "Cory"]        #建立一個班級名單列表 name
 b = name.copy()                 #淺copy，複製成新的列表 b
c = copy.deepcopy(name)         #深copy，複製成新的列表 c
print(b)                        #['Madonna', 'Cory', ['Annie', 'Nelly'], 'Cory']
print(c)                        #['Madonna', 'Cory', ['Annie', 'Nelly'], 'Cory']

del name[1]                     #刪除原列表中的第二個元素
print(name)                     #['Madonna', ['Annie', 'Nelly'], 'Cory']
print(b)                        #['Madonna', 'Cory', ['Annie', 'Nelly'], 'Cory']
print(c)                        #['Madonna', 'Cory', ['Annie', 'Nelly'], 'Cory']

del name[1][1]                  #刪除第二個元素後，在新列表中刪除第一個二個元素（列表元素）中的第一個元素
print(name)                     #['Madonna', ['Annie'], 'Cory']
print(b)                        #['Madonna', 'Cory', ['Annie'], 'Cory']
print(c)                        #['Madonna', 'Cory', ['Annie', 'Nelly'], 'Cory']
     def copy(self): # real signature unknown; restored from __doc__
        """ L.copy() -> list -- a shallow copy of L """
        return []

def deepcopy(x, memo=None, _nil=[]):
    """Deep copy operation on arbitrary Python objects.

    See the module's __doc__ string for more info.
    """

    if memo is None:
        memo = {}

    d = id(x)
    y = memo.get(d, _nil)
    if y is not _nil:
        return y

    cls = type(x)

    copier = _deepcopy_dispatch.get(cls)
    if copier:
        y = copier(x, memo)
    else:
        try:
            issc = issubclass(cls, type)
        except TypeError: # cls is not a class (old Boost; see SF #502085)
            issc = 0
        if issc:
            y = _deepcopy_atomic(x, memo)
        else:
            copier = getattr(x, "__deepcopy__", None)
            if copier:
                y = copier(memo)
            else:
                reductor = dispatch_table.get(cls)
                if reductor:
                    rv = reductor(x)
                else:
                    reductor = getattr(x, "__reduce_ex__", None)
                    if reductor:
                        rv = reductor(4)
                    else:
                        reductor = getattr(x, "__reduce__", None)
                        if reductor:
                            rv = reductor()
                        else:
                            raise Error(
                                "un(deep)copyable object of type %s" % cls)
                if isinstance(rv, str):
                    y = x
                else:
                    y = _reconstruct(x, memo, *rv)

    # If is its own copy, don't memoize.
    if y is not x:
        memo[d] = y
        _keep_alive(x, memo) # Make sure x lives at least as long as d
    return y
copy() copy.deepcopy() 部分源代碼

　　列表的循環：咱們實現列表的循環可使用兩種方法，第一種直接使用循環語句實現每一個元素的打印效果，打印的結果不是列表了而是一個一個單獨的元素；第二種仿照簡單的 for 循環結構進行打印，能夠實現跳躍打印，打印的結果仍是一個列表。（循環語句咱們會在之後的話題中談到）

name = ["Madonna", "Cory", ["Annie", "Nelly"], "Cory"]        #建立一個班級名單列表 name

for i in name:          #for 循環打印列表的元素
    print(i)            #Madonna Cory ['Annie', 'Nelly'] Cory

print(name[::])         #['Madonna', 'Cory', ['Annie', 'Nelly'], 'Cory']
print(name[0:3:1])      #['Madonna', 'Cory', ['Annie', 'Nelly']]
print(name[::2])        #['Madonna', ['Annie', 'Nelly']]

　　經過 len() 函數獲取列表元素的個數。

name = ["Madonna", "Cory", ["Annie", "Nelly"], "Cory"]        #建立一個班級名單列表 name

print(len(name))            #4

2、Tuple 元組

　　元組和列表差很少，咱們能夠把元組當作是簡單的只讀列表，與「強大」的列表不一樣的是，元組建立後其中的元素就不能被修改了，它只有兩個內置的方法：index() 和 count() ,能夠像列表那樣進行「查」（即進行切片）和count() 統計，不支持複雜的「增」、「刪」、「改」等功能。元組建立很簡單，只須要在小括號中添加元素，並使用逗號隔開便可。具體的操做請查看上文列表，這裏就不進行詳細的說明，簡單演示實例以下：

name = ["Madonna", "Cory", ["Annie", "Nelly"], "Cory"]        #建立一個班級名單列表 name
 name_1 = ("Madonna", "Cory", ["Annie", "Nelly"], "Cory")      #建立一個班級名單元組 name_1
print(name_1)               #('Madonna', 'Cory', ['Annie', 'Nelly'], 'Cory')

print(name_1[1:3])                  #('Cory', ['Annie', 'Nelly'])
print(name_1.index("Madonna"))      #0

print(len(name_1))                  #4

注：單個括號 ()  便可表示元組，又能夠表示數學公式中的小括號，打印時會產生歧義，因此當定義單個單獨的元素時，元素後必需要加一個逗號（,）隔開。

a = ("name") print(a)                #name
print(type(a))          #<class 'str'>
b = (1) print(b)                #1
print(type(b))          #<class 'int'>
c = ("name",) print(c)                #('name',)
print(type(c))          #<class 'tuple'>
d = (1,) print(d)                #(1,)
print(type(d))          #<class 'tuple'>

補充：當更深層次的涉獵元組時咱們就會發現，當元組的內部定義一個列表元素時，咱們能夠改變這個列表元素中的元素，這樣一來元組的內容就發生了改變，這不就與咱們上文中所說起的「元組不變」相矛盾嗎？

　　其實並非這樣的，元組中所謂的「不變」是指元素的指向不發生改變，即指向一個列表後就不能指向其餘對象了，在元組中的整個列表合起來屬於一個元組元素，元組指向這個列表後就不會指向其餘對象了。在列表內容中咱們就已經知道列表是可變的，當定義在元組內部時其可變的性質是不會隨之發生改變的，因此這個發生改變的是元組內部的列表。

a = (1, 2, 3, ["one", "two"])       #建立一個元組 a
 a[3][0] = "first"       #把列表中的第一個元素改成 first
a[3][1] = "second"      #把列表中的第二個元素改成 second

print(a)                #(1, 2, 3, ['first', 'second'])
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程