Python基础笔记系列三(1):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]

原文地址:https://www.cnblogs.com/hyyq/p/8904182.html

时间: 2024-08-12 07:43:17

Python基础笔记系列三(1):list列表的相关文章

Python基础笔记系列十一:标准输入输出、文件读写和指针等操作

本系列教程供个人学习笔记使用,如果您要浏览可能需要其它编程语言基础(如C语言),why?因为我写得烂啊,只有我自己看得懂!! 标准输入输出一.输入 在sublime中这个时候需要安装SublimeREPL插件. Ctrl+shift+p 键入 install packages,再继续键入 SublimeREPL 安装即可然后每次编译运行的操作是:tools->sublimeREPL->python->python-Run current file.点击之后会出现新的页面*REPL*[py

Python基础笔记系列十:模块

本系列教程供个人学习笔记使用,如果您要浏览可能需要其它编程语言基础(如C语言),why?因为我写得烂啊,只有我自己看得懂!! 模块 #1.类比于java中的jar包,模块能让你能够有逻辑地组织你的Python代码段.#2.把相关的代码分配到一个模块里能让你的代码个更好用,更易懂.#3.模块也是Python对象,具有随机的名字属性用来绑定或引用.#4.简单来说,模块就是一个保存了Python代码的文件.模块能自定义函数,类和变量.模块里也能包含可执行的代码. 模块引入python提供了很多第三方的

Python基础笔记系列四:工具的安装与配置

本系列教程供个人学习笔记使用,如果您要浏览可能需要其它编程语言基础(如C语言),why?因为我写得烂啊,只有我自己看得懂!! 一开始是没有打算写工具这篇的,后来发现在某些情况下会遇到一些奇怪的问题,这里记录一下. 环境基础我是用的是windows 10操作系统python版本:python2.7  地址-->https://www.python.org/downloads/ Sublime Text3:地址-->https://www.sublimetext.com/ 安装python的坑:直

Python基础笔记系列十三:socket网络编程

本系列教程供个人学习笔记使用,如果您要浏览可能需要其它编程语言基础(如C语言),why?因为我写得烂啊,只有我自己看得懂!!使用python编写一个简易的服务端程序和客户端程序,启动服务端和客户端(监听的ip和端口一致),服务端对客户端进行指定Ip和端口的监听,实现接收客户端发送的数据以及对客户端发送数据. 使用原生socket主要运用到python的socket模块,直接使用自己的代码进行socket对象的创建.ip和端口的绑定.接收和发送数据等操作.服务端:server1.py 1 #inc

python基础深入(元组、字符串、列表、字典)

python基础深入(元组.字符串.列表.字典) 一.列表 1.追加 1 >>>list = [1,2,3,4] #用于在列表末尾添加新的对象,只能单个添加,该方法无返回值,但是会修改原来的列表. 2 >>>list.append(5) 3 >>>print(list) 4 [1, 2, 3, 4, 5] 2.统计 1 >>>list = [1,"a","b","c",1,4

python基础语法(三)

--------------------------------------------接 Python 基础语法(二)-------------------------------------------- 七.面向对象编程 python支持面向对象编程:类和对象是面向对象编程的两个主要方面,类创建一个新的类型,对象是这个类的实例. 对象可以使用普通的属于对象的变量存储数据,属于对象或类的变量被称为域:对象也可以使用属于类的函数,这样的函数称为类的方法:域和方法可以合称为类的属性. 域有两种类

Python基础(Django三——Model)

本篇内容接上篇Python基础(Django二) 七.Model 1.说明: Model是Django为方便程序操作数据库而诞生的,使用的是ORM模式. 对象关系映射(Object Relational Mapping,简称ORM)模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术.简单的说,ORM是通过使用描述对象和数据库之间映射的关系,将程序中的对象自动持久化到关系数据库中. 2.使用: 2-1.创建Model(编辑应用目录下的models.py) from django.db

python基础之数字、字符串、列表、元组、字典

第二天Python基础二: 1.运算符: 判断某个东西是否在某个东西里面包含: in  为真 not in  为假 (1).算术运算符: 运算符 描述 实例 + 加  表示两个对象相加 a + b输出结果30 - 减  表示一个数减去另一个数 a - b输出结果-10 * 乘  两个数相乘或是返回一个被重复若干次的字符串 a * b输出结果200 / 除  两个数相除 b / a 输出结果2 ** 幂  返回一个数的n次幂 3 ** 3 输出结果27 % 取余  返回除法的余数 b % a 输出

python基础--基本数据类型(List(列表)--可变数据)

python基础--基本数据类型(Number(数字) String(字符串) List(列表) Tuple(元组) Sets(集合) Dictionary(字典)) Python3 中有六个标准的数据类型:Number(数字)String(字符串)List(列表)Tuple(元组)Sets(集合)Dictionary(字典) Python3 的六个标准数据类型中:不可变数据(四个):Number(数字).String(字符串).Tuple(元组).Sets(集合):可变数据(两个):List(