一、列表
需要安利一下：列表和字串數是不一樣的.進行操作時列表可以發生改變，而字串不可以，所以直接在原來的物件上操作。
1.列表的增加
def append(self, p_object): # real signature unknown; restored from doc
“”” L.append(object) -> None – append object to end “””
pass

    用法:在列表的最後追加一個物件。
    例子：
        lis = [2]
        lis.append('nihao') #在列表最後追加元素
        print(lis)------>[2, 'nihao']

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

    用法:在索引index位置，新增一個物件.
            如果index超過了給點列表的索引最大值，該物件會被插到列表最後位置。
    例子：
        lis = [2, 3, 4]
        lis.insert(1, [3,3]) #在索引位置新增元素
        print(lis)------>[2, [3, 3], 3, 4]

        lis = [2, 3, 4]
        lis.insert(5, [3,3]) #在索引位置新增元素
        print(lis)------>[2, 3, 4, [3, 3]]

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

    用法:用來擴充套件列表，但是給的引數是一個可迭代物件。是將可迭代物件的每個元素加入原列表的尾部。

    例子：
        lis = [2]
        lis.extend(['nihao '])
        print(lis)------>[2, 'nihao ']
        lis = [2]
        lis.extend('nihai')
        print(lis)------>[2, 'n', 'i', 'h', 'a', 'i']

2.列表的刪除
    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

    用法:刪除列表中第一個指定的元素value.如果該元素不存在列表中，會報錯。
    例子:
        lis = ['你好', 1, [1, 2, 2]]
        lis.remove('你好') #刪除指定元素，列表中第一個出現的
        print(lis)------>[1, [1, 2, 2]]

        lis.remove('0')   #如果刪除不存在的元素會報錯
        print(lis)------>ValueError

    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

    用法:如果沒有引數預設刪除的是列表的最後一個元素。(和棧的那個一樣)
        而index引數表示所刪元素的索引。而且該方法會返回你所刪元素的值。
        如果index引數不在列表的索引範圍內，會報錯。
    例子：
        lis = ['你好', 1, [1, 2, 2]]
        e = lis.pop()  #預設刪除最後一個元素，有返回值
        print(e)------>[1, 2, 3]
        print(lis)------>['你好', 1]

        lis = ['你好', 1, [1, 2, 2]]
        e = lis.pop(0) #引數為所刪元素的位置，如果位置不存在會報錯
        print(e)------>你好
        print(lis)------>[1, [1, 2, 2]]

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

    用法:直接清空列表。返回[]
    例子：
        l = [1, 2]
        lis.clear()  #直接清空列表
        print(lis)------>[]

    del L[index]          用法:直接刪除索引位置的元素
       del L[start:end]      用法:直接刪除切片出來的所有元素
       del L[start:end:step] 用法:直接刪除切片出來的帶步長的元素

3.列表的修改
    列表的修改只有索引和切片修改
    1）索引修改
        lis = [1, 2, '1', '2', ['33', '44']]
        lis[4] = (2, 4)
        print(lis) ---->[11111, 2, '1', '2', (2, 4)]
        ------
        lis[7] = '888'  #如果超出列表索引位置，會報錯
        print(lis) ---->報錯(IndexError)
    2）切片修改  注：切片修改是迭代修改
        lis = [1, 2, '1', '2', ['33', '44']]
        lis[1:] = '好好好'  #迭代修改
        print(lis)------>[1, '好', '好', '好']

        lis = [1, 2, '1', '2', ['33', '44']]
        lis[1:-1] = [1, 2, 3]
        print(lis)------>[1, 1, 2, 3, ['33', '44']]

        lis = [1, 2, '1', '2', ['33', '44']]
        lis[0:4:2] = '你好'
        print(lis)------>['你', 2, '好', '2', ['33', '44']]

        is = [1, 2, '1', '2', ['33', '44']]
        lis[0:4:4] = '你好'  #步長不能越過切片的界，否則會報錯
        print(lis)------>(ValueError)
4.列表的查詢
    列表是一個可迭代物件所以可以進行for迴圈。
        for e in L:
            print(e)

5.其他方法
    def count(self, value): # real signature unknown; restored from __doc__
    """ L.count(value) -> integer -- return number of occurrences of value """
    return 0

    用法:統計元素value出現的次數。

    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

    用法:對列表L進行排序，預設從小到大。reverse=Falsec(從小到大)reverse=True(從大到小)
        注:他只是一個操作，沒有返回值。

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

    用法:反轉列表L    
        注:他只是一個操作，沒有返回值。

    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

    用法:返回列表中value的第一個索引，或者在找不到索引的時候引發 ValueError異常，可定義索引的範圍為L[start:end].

    def copy(self): # real signature unknown; restored from __doc__
    """ L.copy() -> list -- a shallow copy of L """
    return []

    (這是一個淺拷貝，等後面詳細介紹深淺拷貝！)

    len(L)----->求列表L的長度。(系統內建方法)
 

二、元組
俗稱不可變的列表又稱只讀列表
1）元組的內建方法
def count(self, value): # real signature unknown; restored from doc
“”” T.count(value) -> integer – return number of occurrences of value “””
return 0

    用法:統計元素value出現的次數。

    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
    """
    T.index(value, [start, [stop]]) -> integer -- return first index of value.
    Raises ValueError if the value is not present.
    """
    return 0

    用法:返回元組中value的第一個索引，或者在找不到索引的時候引發 ValueError異常，可定義索引的範圍為T[start:end].

2）注意
    (1)
        tu = (1, "哈哈", [], "呵呵")
        tu[2].append("麻花") # 可以改. 沒報錯 
        tu[2].append("林林")
        print(tu)------>(1, '哈哈', ['麻花', '林林'], '呵呵')
        注：這裡的元組的不可變的意思是子元素不可變，而子元素內部的子元素是可以變，這取決於字元素是否是可變物件。


        程式碼得多敲，不能光看！