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 iterable's 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]　

　　　5.多维列表
　　　　其实前面已经体会到了，列表里可以嵌套一个列表，这就形成了多维列表。

　　　例子：

1 demolist = [[1,2,3],[4,5,6],[7,8,9]] #定义二维列表相当于一个3*3的二维数组
2 print demolist
3 print demolist[0] #输出第一行
4 del demolist[0]  #删除第一行
5 print demolist

　　输出：

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

转载于:https://www.cnblogs.com/hyyq/p/8904182.html