list文档

文档

class list(object):
    """
    list() -> new empty list
    list(iterable) -> new list initialized from iterable's items
    """
    def append(self, p_object): # real signature unknown; restored from __doc__
        """
         L.append(object) -> None -- append object to end
         在列表的最后添加元素
        """
        pass

    def clear(self): # real signature unknown; restored from __doc__
        """
         L.clear() -> None -- remove all items from L
         清楚列表所有元素
         """
        pass

    def copy(self): # real signature unknown; restored from __doc__
        """
        L.copy() -> list -- a shallow copy of L
        复制一个列表
        需要注意的是这个拷贝是‘浅拷贝’：
        如果列表只有一层（如：l=[1,2,3]）,那么l的copy后列表跟l的内存地址是不同的，但是，
        但是，如果l里面嵌套的还有列表（如：l = [1,2,3,[5,6]]）,那么，虽然外层列表地址不同
        但是嵌套的[5,6]这个列表（也就是l[3]）的内存地址跟copy后的内存地址不同

        ----------------------------------------------------------------------------
        l1 = [1,2,[3,4]]
        l2 = l1.copy()
        print(l1 == l2)         # True
        print(l1 is l2)         # False
        print(l1[2] is l2[2])   # True

        l1[2].append('8')       # 往子列表l[2]里添加元素，l2也会随之改变
        print(l2)               # [1, 2, [3, 4, '8']]
        ----------------------------------------------------------------------------
        如果要深拷贝，则需要导入deepcopy模块
        import copy

        l1 = [1,2,[3,4]]
        l2 = copy.deepcopy(l1)
        print(l1 == l2)         # True
        print(l2 is l1)         # False

        l1[2].append('8')       #往子列表l[2]里添加元素，l2不会随之改变
        print(l1)               # [1, 2, [3, 4, '8']]
        print(l2)               # [1, 2, [3, 4]]
        """
        return []

    def count(self, value): # real signature unknown; restored from __doc__
        """
        L.count(value) -> integer -- return number of occurrences of value
        计算一个元素在一个列表里出现的次数
        """
        return 0

    def extend(self, iterable): # real signature unknown; restored from __doc__
        """
        L.extend(iterable) -> None -- extend list by appending elements from the iterable
        往列表里拓展元素，参数必须是一个可迭代对象（包括列表，元组以及字符串等……）
        """
        pass

    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.
        获取列表中某一个元素的索引值，如果有重复元素，只返回第一个
        也可以用可选参数start和stop来指定查找范围
        """
        return 0

    def insert(self, index, p_object): # real signature unknown; restored from __doc__
        """
        L.insert(index, object) -- insert object before index
        在指定位置的前一个位置插入指定元素
        """

        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 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 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*
        将列表按照指定的规则排序
        可以用key来指定排序规则，不指定的话默认按照asc码来排序
        字符串不能跟数字类型一起排序
        ----------------------------------------------------------------------
        l1 = [1,2,5,3,8,6]
        l1.sort()
        print(l1)               # [1, 2, 3, 5, 6, 8]

        l2 = ['c','b','a']      # ['a', 'b', 'c']
        l2.sort()
        print(l2)

        l3 = ['fuyong','age','name']
        l3.sort()
        print(l3)               # ['age', 'fuyong', 'name']
        ----------------------------------------------------------------------
        key是一个可选的参数，接收一个函数名或者一个匿名函数
        l4 = [(1,3),(2,1),(3,2)]
        l4.sort(key=lambda x:x[0])
        print(l4)                   # [(1, 3), (2, 1), (3, 2)]
        l4.sort(key=lambda x:x[1])
        print(l4)                   # [(2, 1), (3, 2), (1, 3)]
        ----------------------------------------------------------------------
        l5 = [{'age':13},{'age':18},{'age':16}]
        l5.sort(key=lambda x:x['age'])
        print(l5)               # [{'age': 13}, {'age': 16}, {'age': 18}]
        ----------------------------------------------------------------------
        可以用reverse参数来指定是正序还是倒叙，不指定的话默认正序
        l5.sort(key=lambda x:x['age'],reverse=True
        print(l5)               # [{'age': 18}, {'age': 16}, {'age': 13}]
        """
        pass
　　

　　

示例

l1 = [1,2,[3,4]]
l2 = l1.copy()

print(l1 == l2)
print(l1 is l2)
print(l1[2] is l2[2])

l1[2].append('8')
print(l2)

import copy

l1 = [1,2,[3,4]]
l2 = copy.deepcopy(l1)
print(l1 == l2)
print(l2 is l1)

l1[2].append('8')
print(l1)
print(l2)

l = [1,2,3,4,5,6]
l.pop()
print(l)
l.pop(3)
print(l)

l1 = [1,2,5,3,8,6]
l1.sort()
print(l1)

l2 = ['c','b','a']
l2.sort()
print(l2)

l3 = ['fuyong','age','name']
l3.sort()
print(l3)

l4 = [(1,3),(2,1),(3,2)]
l4.sort(key=lambda x:x[0])
print(l4)
l4.sort(key=lambda x:x[1])
print(l4)

l5 = [{'age':13},{'age':18},{'age':16}]
l5.sort(key=lambda x:x['age'])
print(l5)
l5.sort(key=lambda x:x['age'],reverse=True)
print(l5)