Python基础笔记系列三:list列表

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python基础笔记系列三:list列表相关的知识,希望对你有一定的参考价值。

  本系列教程供个人学习笔记使用,如果您要浏览可能需要其它编程语言基础(如C语言),why?因为我写得烂啊,只有我自己看得懂!!

  python中的list列表是一种序列型数据类型,一有序数据集合用逗号间隔用方括号括起来,和字符串一样可以通过索引index和切片来访问某个元素或子列表。

  元组相当于一个只读的列表,它的元素不可修改。

  字典是一种键值对。

  • list列表
    可以类比于其它语言(如,C语言)的数组,其起始下标为也为0。
    1.列表的索引访问
      1)通过list_name[index]来访问,每个列表的起始下标为0。
    例子:
    1 demolist = [1,2,3,4] #列表的定义
    2 print type(demolist) #打印类型
    3 print demolist[0] #输出第一个元素
    4 print demolist[1] #输出第二个元素

    输出:

    <type list>
    1
    2

      2)可以通过del list_name[index]来删除列表的下标是index的数据。
    例子:

    1 demolist = [1,2,3,4] #列表的定义
    2 del demolist[2] #删除第三个元素
    3 print demolist #输出整个列表

    输出:

    [1, 2, 4]

    2.列表的切片访问
      1)想访问列表里一段连续的元素(或规则间隔的元素)可以指定列表的起止位置和终止位置、间隔的步长(可省,默认为1)。语法格式list_name(start:end[:step])表示访问下标为start至end-1的元素,step可省略,可以简记为前闭后开。
    例子:

    1 demolist = [1,2,3,4,5,6,7,8,9] #列表的定义
    2 print demolist[0:5]  #访问第1-5的元素
    3 print demolist[0:8:2] #访问第1-8的元素,步长为2

    输出:

    1 [1, 2, 3, 4, 5]
    2 [1, 3, 5, 7]

      2)同样也可以使用del list_name(start:end[:step])来删除对应的元素。
    例子:

    1 demolist = [1,2,3,4,5,6,7,8,9] #列表的定义
    2 del demolist[0:8:2]  #删除下标为0到7的元素
    3 print demolist  #输出整个列表

    输出:

    1 [2, 4, 6, 8, 9]

    3.列表的基本运算
      1)列表的加法:列表可以同字符串一样相加。
    例子:

    1 demolist = [1,2,3,4] #列表的定义
    2 print demolist+[5,6,7,8,9]

    输出:

    1 [1, 2, 3, 4, 5, 6, 7, 8, 9]

      2)列表的乘法:相当于字符串的乘法,一个列表乘(*)以N次,表示这个列表相加了N次。
    例子:

    1 demolist = ["y","y","c"] #列表的定义
    2 print  demolist* 3   #列表可以做乘法

    输出:

    1 [y, y, c, y, y, c, y, y, c]

      3)列表的in和not in运算:用于判断某个元素是否在(不在)列表中。在返回True,不在返回False。
    例子:

    1 demolist = [1,2,3,4] #列表的定义
    2 print 2 in demolist #判断元素是否在列表中
    3 print 21 in demolist

    输出:

    1 True
    2 False

      4)列表的遍历:可以通过像字符串那样使用for循环来遍历列表。
    例子:

    1 demolist = [1,2,3,4] #列表的定义
    2 i = 0
    3 for value in demolist:
    4     print demolist[%d]: %(i),value
    5     i += 1

    输出:

    1 demolist[0]:  1
    2 demolist[1]:  2
    3 demolist[2]:  3
    4 demolist[3]:  4

      5)列表的解析:可以方便的对列表中的元素进行运算,语法格式:[val_expr for val in list_name],val_expr是一个关于val的运算表达式,val用于存储for每次从列表中取出的元素,然后通过val_expr的运算形成一个新的列表项,for循环结束则生成一个新的列表。
    例子:计算1-9每个数本身的次方,如2**2 = 4

    1 demolist = range(1,10) #列表的定义:生成一个[1,10)的列表
    2 print demolist
    3 new_list = [x**x for x in demolist]
    4 print new_list 

    输出:

    1 [1, 2, 3, 4, 5, 6, 7, 8, 9]
    2 [1, 4, 27, 256, 3125, 46656, 823543, 16777216, 387420489]

    4.列表相关函数
      TIPS--->列表的函数很多,这里有个小技巧:遇到这种很多函数又记不住,可以通过help 函数查看该类型拥有的所有方法,例如:

    1 demolist = [1,2,3,4] #列表的定义
    2 print help(demolist) #通过help函数查看该类型所有的函数方法

    输出:太多,已折叠代码

    技术分享图片
      1 Help on list object:
      2 
      3 class list(object)
      4  |  list() -> new empty list
      5  |  list(iterable) -> new list initialized from iterables items
      6  |  
      7  |  Methods defined here:
      8  |  
      9  |  __add__(...)
     10  |      x.__add__(y) <==> x+y
     11  |  
     12  |  __contains__(...)
     13  |      x.__contains__(y) <==> y in x
     14  |  
     15  |  __delitem__(...)
     16  |      x.__delitem__(y) <==> del x[y]
     17  |  
     18  |  __delslice__(...)
     19  |      x.__delslice__(i, j) <==> del x[i:j]
     20  |      
     21  |      Use of negative indices is not supported.
     22  |  
     23  |  __eq__(...)
     24  |      x.__eq__(y) <==> x==y
     25  |  
     26  |  __ge__(...)
     27  |      x.__ge__(y) <==> x>=y
     28  |  
     29  |  __getattribute__(...)
     30  |      x.__getattribute__(name) <==> x.name
     31  |  
     32  |  __getitem__(...)
     33  |      x.__getitem__(y) <==> x[y]
     34  |  
     35  |  __getslice__(...)
     36  |      x.__getslice__(i, j) <==> x[i:j]
     37  |      
     38  |      Use of negative indices is not supported.
     39  |  
     40  |  __gt__(...)
     41  |      x.__gt__(y) <==> x>y
     42  |  
     43  |  __iadd__(...)
     44  |      x.__iadd__(y) <==> x+=y
     45  |  
     46  |  __imul__(...)
     47  |      x.__imul__(y) <==> x*=y
     48  |  
     49  |  __init__(...)
     50  |      x.__init__(...) initializes x; see help(type(x)) for signature
     51  |  
     52  |  __iter__(...)
     53  |      x.__iter__() <==> iter(x)
     54  |  
     55  |  __le__(...)
     56  |      x.__le__(y) <==> x<=y
     57  |  
     58  |  __len__(...)
     59  |      x.__len__() <==> len(x)
     60  |  
     61  |  __lt__(...)
     62  |      x.__lt__(y) <==> x<y
     63  |  
     64  |  __mul__(...)
     65  |      x.__mul__(n) <==> x*n
     66  |  
     67  |  __ne__(...)
     68  |      x.__ne__(y) <==> x!=y
     69  |  
     70  |  __repr__(...)
     71  |      x.__repr__() <==> repr(x)
     72  |  
     73  |  __reversed__(...)
     74  |      L.__reversed__() -- return a reverse iterator over the list
     75  |  
     76  |  __rmul__(...)
     77  |      x.__rmul__(n) <==> n*x
     78  |  
     79  |  __setitem__(...)
     80  |      x.__setitem__(i, y) <==> x[i]=y
     81  |  
     82  |  __setslice__(...)
     83  |      x.__setslice__(i, j, y) <==> x[i:j]=y
     84  |      
     85  |      Use  of negative indices is not supported.
     86  |  
     87  |  __sizeof__(...)
     88  |      L.__sizeof__() -- size of L in memory, in bytes
     89  |  
     90  |  append(...)
     91  |      L.append(object) -- append object to end
     92  |  
     93  |  count(...)
     94  |      L.count(value) -> integer -- return number of occurrences of value
     95  |  
     96  |  extend(...)
     97  |      L.extend(iterable) -- extend list by appending elements from the iterable
     98  |  
     99  |  index(...)
    100  |      L.index(value, [start, [stop]]) -> integer -- return first index of value.
    101  |      Raises ValueError if the value is not present.
    102  |  
    103  |  insert(...)
    104  |      L.insert(index, object) -- insert object before index
    105  |  
    106  |  pop(...)
    107  |      L.pop([index]) -> item -- remove and return item at index (default last).
    108  |      Raises IndexError if list is empty or index is out of range.
    109  |  
    110  |  remove(...)
    111  |      L.remove(value) -- remove first occurrence of value.
    112  |      Raises ValueError if the value is not present.
    113  |  
    114  |  reverse(...)
    115  |      L.reverse() -- reverse *IN PLACE*
    116  |  
    117  |  sort(...)
    118  |      L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
    119  |      cmp(x, y) -> -1, 0, 1
    120  |  
    121  |  ----------------------------------------------------------------------
    122  |  Data and other attributes defined here:
    123  |  
    124  |  __hash__ = None
    125  |  
    126  |  __new__ = <built-in method __new__ of type object>
    127  |      T.__new__(S, ...) -> a new object with type S, a subtype of T
    128 
    129 None
    通过help查看的list相关函数

    如果只记得方法名不知道参数怎么传了,可以用help(变量名.方法名),例如:

    1 demolist = [1,2,3,4] #列表的定义
    2 print help(demolist.insert) #通过help函数查看具体某方法的用法

    输出:

    1 Help on built-in function insert:
    2 
    3 insert(...)
    4     L.insert(index, object) -- insert object before index
    5 
    6 None

      1) 所以呢,列表的方法太多了,下面列举几个常用的函数:

     1 demolist = [1,2,3,4] #列表的定义
     2 demolist.pop() #1出桟,删除最后一个元素
     3 print demolist 
     4 
     5 demolist.pop(1) #2出桟,删除下标为1的元素
     6 print demolist
     7 
     8 demolist.append(20) #3追加一个数
     9 print demolist
    10 
    11 demolist.append(hello) #4还可以追加一个字符串、实型等任何类型
    12 print demolist
    13 
    14 demolist.append([a,b,"c",20]) #5甚至还可以追加一个列表,(注:python中字符用单引号双引号都一样)
    15 print demolist
    16 
    17 print len(demolist) #6列表长度
    18 
    19 demolist.insert(2, [8,9,10]) #7在列表的指定位置插入元素(可以时任意对象,如这里就是插入的一个列表)
    20 print demolist
    21 
    22 print demolist.count(20) #8统计某个值在列表中出现的次数
    23 
    24 demolist.extend([20,100,200,300]) #9将指定的列表以个体的方式追加到列表的末尾
    25 print demolist 
    26 
    27 demolist.remove(20) #10删除列表中第一次出现的指定元素
    28 print demolist

    输出:

     1 [1, 2, 3]
     2 [1, 3]
     3 [1, 3, 20]
     4 [1, 3, 20, hello]
     5 [1, 3, 20, hello, [a, b, c, 20]]
     6 5
     7 [1, 3, [8, 9, 10], 20, hello, [a, b, c, 20]]
     8 1
     9 [1, 3, [8, 9, 10], 20, hello, [a, b, c, 20], 20, 100, 200, 300]
    10 [1, 3, [8, 9, 10], hello, [a, b, c, 20], 20, 100, 200, 300]

     



















以上是关于Python基础笔记系列三:list列表的主要内容,如果未能解决你的问题,请参考以下文章

python基础笔记-4python删除两个列表中相同的元素

python基础学习笔记

Python学习笔记-列表

Python全栈自动化系列之Python编程基础(列表元组字典)

《C#零基础入门之百识百例》(八十四)系统类List列表类解析 -- 扑克排序

《C#零基础入门之百识百例》(八十四)系统类List列表类解析 -- 扑克排序