list文档

文档

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
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
  

  

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
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)

  

posted @   人生不如戏  阅读(357)  评论(0编辑  收藏  举报
点击右上角即可分享
微信分享提示