List的功能介绍

1. 列表的两种方法

1. 列表的内置方法

列表的相加

格式：x.__add__(y)等同于x+y

例如：list1 = [1,2,3]

     print(list1.__add__([4,5,6]))

 >>> [1,2,3,4,5,6]

返回值：list

注：上述的y可以是list/tuple/str/dict/set等，但不可以是int。

是否是包含关系

格式：x.__contains__(y)等同于y in x

例如：list1 = [1,2,3]

     print(list1.__contains__([2,3]))

 >>> True

返回值：bool

注：上述的y可以是list/tuple/str/dict/set等，但不可以是int。

指定列表索引删除(修改原列表)

格式：x.__delitem__(index)等同于delete x[index]

例如：list1 = [1,2,3]

     list1.__delitem__(2)

     print(list1)

 >>> [1,2]

返回值：None

判断两个列表是否相等

格式：x.__eq__(y)等同于x==y

例如：list1 = [1,2,3]

     print(list1.__eq__([2,3]))

 >>> False

返回值：bool

判断列表1是否大于等于列表2

格式：x.__ge__(y)等同于x>=y

例如：list1 = [1,2,3]

     print(list1.__ge__([1,2]))

 >>> True

返回值：bool

注：该方法主要判断依据是列表的第一个元素

访问属性的方法

格式：x.__getattribute__(self,name)

返回值：tuple

取出指定列表索引的元素

格式：x.__getitem__(index)等同于x[index]

例如：list1 = [1,2,3]

     print(list1.__getitem(2))

 >>> 3

返回值：object

判断列表1是否大于列表2

格式：x.__gt__(y)等同于x>y

例如：list1 = [1,2,3]

     print(list1.__gt__([2]))

 >>> False

返回值：bool

注：该方法主要判断依据是列表的第一个元素

赋值相加

格式：x.__iadd__(y)等同于x += y

例如：list1 = [1,2,3]

     print(list1__iadd__('3'))

 >>> [1, 2, 3, '3']

返回值：list

注：上述的y可以是list/tuple/str/dict/set等，但不可以是int,而且原列表也会改变。

赋值相乘

格式：x.__imul__(num)等同于x *= num

例如：list1 = [1,2,3]

     print(list1.__imul__(2))

 >>> [1,2,3,1,2,3]

返回值：list

注：num只能是int类型，而且原列表也会改变。

构造方法(修改原列表)

格式：x.__init__(y)

例如：list1 = [1,2,3]

     list1.__init__([4,5])

     print(list1)

 >>> [4,5]

返回值：list

注：y不指定表示构造一个空列表

迭代器

格式：x.__iter__()等同于iter(x)

例如：list1 = [1,2,3]

     die = list1.__iter__()

     print(die.__next__())

 >>> 1

返回值：迭代器

判断列表1是否小于等于列表2

格式：x.__le__(y)等同于x<=y

例如：list1 = [1,2,3]

     print(list1.__le__([2]))

 >>> True

返回值：bool

注：该方法主要判断依据是列表的第一个元素

列表长度

格式：x.__len__()等同于len(x)

例如：list1 = [1,2,3]

     print(list1.__len__())

 >>> 3

返回值：int

判断列表1是否小于列表2

格式：x.__lt__(y)等同于x<y

例如：list1 = [1,2,3]

     print(list1.__lt__([2]))

 >>> True

返回值：bool

注：该方法主要判断依据是列表的第一个元素

列表的相乘

格式：x.__mul__(num)等同于x*y

例如：list1 = [1,2,3]

     print(list.__mul__(2))

 >>> [1,2,3,1,2,3]

返回值：list

判断两个列表是否不相等

格式：x.__ne__(y)等同于x!=y

例如：list1 = [1,2,3]

     print(list1.__ne__([4,5]))

 >>> True

返回值：bool

重新定义列表

格式：x.__new__(list)

例如：list1 = [1,2,3]

     print(list1.__new__(list))

 >>> []

返回值：list

内置转换

格式：x.__repr__(self)

返回值：list

反转后迭代

格式：x.__reversed__()等同于reversed(x)

例如：list1 = [1,'2',3,'d','$']

     die = list1.__reversed__()

     print(die.__next__())

 >>> '$'

返回值：迭代器

右→左列表相乘

格式：x.__rmul__(num)等同于num*x

例如：list1 = [1,2,3]

     print(list1.__rmul__(2))

 >>> [1,2,3,1,2,3]

返回值：list

修改指定索引的元素(修改原列表)

格式：x.__getitem__(index,value)等同于x[index]=value

例如：list1 = [1,2,3]

     list1.__getitem__(1,5)

     print(list1)

 >>> [1,5,3]

返回值：None

列表在内存中大小，转换为字节进行计算

格式：x.__sizeof__()

例如：list1 = [1,2,3]

     list2 = [2,3]

     print(list1.__sizeof__())

 >>> 64

     print(list2.__sizeof__())

 >>> 56

返回值：int

#列表长度的不同，导致类别在内存中的大小也不一样。

2. 常用方法

原列表添加一个元素

格式：x.append(y)

    #直接修改原列表，添加的元素可以任意对象，每次只能添加一个元素

例如：list1 = [1,2,3,4]

     list1.append([1,2,3])

     print(list1)

 >>> [1,2,3,4,[1,2,3]]

返回值：None

清空原列表

格式：x.clear()

    #删除列表中所有元素，列表本身不删除

例如：list1 = [1,2,3,4]

     list1.clear()

     print(list1)

 >>> []

返回值：None

复制列表

格式：x.copy()

    #复制原列表，生成一个新列表

例如：list1 = [1,2,3,4]

     print(list1.copy())

 >>> [1,2,3,4]

返回值：list

计数

格式：x.count(value)

    #统计列表中指定元素的个数

例如：list1 = [1,2,2,3,4,2,3]

     print(list1.count(2))

 >>> 3

返回值：int

扩充列表

格式：x.extend()

    #在原列表中扩充列表(修改原列表)，两个列表合并为一个列表

例如：list1 = [1,2,3,4]

     list1.extend(['1','2'])

     print(list1)

 >>> [1, 2, 3, 4, '1', '2']

返回值：None

取出指定元素值的索引

格式：x.index(value,strat,end)

    #在指定的索引范围内，查找元素的索引，默认全列表查找

例如：list1 = [1, 2, 3, 4, '1', '2']

     print(list1.index('1',2,5))

 >>> 4

返回值：int

插入元素

格式：x.insert(index,object)

    #在原列表中，指定索引位置处添加一个元素，元素可以是任意对象

例如：list1 = [1, 2, 3, 4, '1', '2']

     list1.insert(3,'four')

     print(list1)

 >>> [1, 2, 3, 'four', 4, '1', '2']

 返回值：None

取出指定索引的值

格式：x.pop(index)

    #删除指定索引的值，默认从列表的最后面开始删除

例如：list1 = [1, 2, 3, 'four', 4, '1', '2']

     print(list1.pop())

 >>> '2'

     print(list1.pop(2))

 >>> 3

     print(list1)

 >>> [1, 2, 'four', 4, '1']

返回值：object

移除指定的元素

格式：x.remove(value)

    #删除指定元素，直接修改原列表

例如：list1 = [1, 2, 3, 'four', 4, '1', '2']

     list1.remove(3)

     print(list1)

 >>> [1, 2, 'four', 4, '1', '2']

返回值：None

反转

格式：x.reverse()

    #对列表进行升序排序后再进行颠倒

例如：list1 = [1, 2, 3, 'four', 4, '1', '2']

     list1.reverse()

     print(list1)

 >>> ['2', '1', 4, 'four', 3, 2, 1]

返回值：None

升序排序

格式：x.sort()

    #对列表进行升序排序，一般int和str类型不能同时存在

例如：list1 = [6,2,3,4]

     list1.sort()

     print(list1)

 >>> [2,3,4,6]

返回值：None

2. 列表的操作

1. 列表的基础操作

列表的相加

符号： +

格式： list1 + list2

返回值：list

列表的相乘

符号： *

格式： list * num

返回值：list

索引操作

符号： [index]

格式： list[index]

返回值：object

切片操作

符号：[::]

格式：list[index1:index2:num]

返回值：list

成员检测

符号： in

格式： object in list

返回值：bool

2. 列表序列操作函数

长度
```
格式：len(list)

返回值：int
```
最大值
```
格式：max(list)

返回值：int
```
注：该函数只能用于纯数字的列表。
最小值
```
格式：min(list)

返回值：int
```
注：该函数只能用于纯数字的列表。
转换为列表
```
格式：list(序列)

返回值：list
```
注：主要用于将其他对象转换为列表，或生成一个空列表

3. 列表的遍历函数

使用for...in遍历

格式：for variable in list:

        使用variable

例如：list1 = [1,2,3]

     for i in list1:

        print(i)

  >>> 1

  >>> 2

  >>> 3

while循环遍历

格式：variable = 0

     while variable < len(list):

        使用列表中的元素(list[variable])

        variable += 1

例如：list1 = [1,2,3]

     i = 0

     while i < len(list1):

         print(list1[i])

         i += 1

  >>> 1

  >>> 2

  >>> 3

二级列表的遍历

1. 格式：for variable1 in list:

            for variable2 in variable1:

                使用variable

   例如：list1 = [['a','b','c'],['d','e','f'],['g','h','i']]

        for i in list1:

            for j in i:

                print(j)

   #输出的j就是大列表中列表的元素

2. 格式：for variable1,variable2,... in list:

            直接使用variable1,variable2,...

   例如：list1 = [['a','b','c'],['d','e','f'],['g','h','i']]

        for n1,n2,n3 in list1:

            print(n1)

    >>> 'a'

    >>> 'd'

    >>> 'g'

注：方法2只能遍历同等长度的二级列表。

列表推导式

简单的列表推导式

格式：[variable for variable in list]

例如：list1 = [1,3,4,5]

     print([i for i in list1])

 >>> [1,3,4,5]

返回值：list

#只是把原来的列表遍历了一遍，生成了和原列表一样的列表

稍作修改的列表推导式

格式：['*'+variable+'*' for variable in list]

例如：list1 = ['a','b','c']

     print(['*'+i+'*' for i in list1])

 >>> ['*a*', '*b*', '*c*']

返回值：list

#对variable进行修改，可以是int的操作，也可以是str的操作，具体需根据列表元素来执行

带有判断条件的列表推导式

格式：[variable for variable in list if 条件表达式]

例如：list1 = [2,3,4,2,1,2,23,54,21,33]

     print([i for i in list1 if i>20])

 >>> [23, 54, 21, 33]

返回值：list

多个列表推导式

格式：[variable1+variable2 for variable1 in list1 for variable2 in list2]

例如：list1 = ['a','b','c']

     list2 = ['I','love','you','!']

     print([x+y for x in list1 for y in list2])

 >>> ['aI', 'alove', 'ayou', 'a!', 'bI', 'blove', 'byou', 'b!', 'cI', 'clove', 'cyou', 'c!']

返回值：list

带有判断条件的多个列表推导式

格式：[variable1+variable2 for variable1 in list1 for variable2 in list2 if 条件表达式]

例如：list1 = ['a','b','c']

     list2 = ['I','love','you','!']

     print([x+y for x in list1 for y in list2 if list1.index(x)==list2.index(y)])

 >>> ['aI', 'blove', 'cyou']

返回值：list

巴特西

Python中list的功能介绍

List的功能介绍

1. 列表的两种方法

1. 列表的内置方法

2. 常用方法

2. 列表的操作

1. 列表的基础操作

2. 列表序列操作函数

3. 列表的遍历函数

最新文章

热门文章