Python基础教程学习笔记 第二章 列表和元组

1、序列中元素的索引:

  第一个元素索引是0,第二个是1,依次递增
  最后一个元素索引是-1,倒数第二个是-2,依次递减

2、序列(Sequence)的种类:

  列表(list)、元组(tuple)、字符串(string)、Unicode 字符串、buffer对象、xrange对象

3、列表和元组的区别:列表可以进行修改,但是元组不行

4、tuple常作为字典的键

5、序列都可以进行以下操作:

  索引(indexing)、分片(sliceing)、加(adding)、乘(multiplying)、以及检查元素是否属于序列(in)、最大值(max)、最小值(min)、长度(len)、迭代器(iterator)等操作

6、序列中也可以包含其他的序列

7、索引

  7.1、第一个元素的索引是0,第二个是1,依次递增;最后一个元素的索引是-1,倒数第二个是-2,依次递减

  7.2、对于序列可以直接进行索引,而不是一定非要通过变量进行索引,如:"Hello"[0],得到H

  7.3、如果一个函数返回一个序列,可直接对结果进行索引而得到指定的元素

8、分片

  访问一定范围内的元素

  [start:end:step]:从start索引开始,每隔step个元素取一个元素,但是不包括end元素

  [start:end]:从start索引开始,每隔1个元素取一个元素,但是不包括end元素

  [start:]:从start索引开始取到结尾,每隔1个元素取一个元素

  [:end]:从0开始,每隔1个元素取一个元素,但是不包括end元素

  [:]:取所有元素

  [::step]:从0开始取到结尾,每隔step个元素取一个元素

  [:end:step]:从0开始,每隔step个元素取一个元素,取到end前一个元素

  [start::step]:从start开始,取到结尾,步长step

  [start:start]:取得start元素

  8.1、step > 0 从前往后取;step < 0 从后往前取;step 不能为0

9、相同类型的序列才能相加,第二个序列追加到第一个序列后面,生成新的序列副本

  a = [1,2,3,4,5]

  b = [4,5,6,7,8]

  a + b的结果是:[1, 2, 3, 4, 5, 4, 5, 6, 7, 8];a、b的内容不发生改变

10、序列乘以一个数字N,大小扩展为现在N倍,内容重复N倍,如:

  a = [1,2,3,4,5]

  a * 5的结果是:[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5];a的内容不发生改变

11、可以使用in运算符一个对象是否属于一个序列,返回True或者False,例如:

  element1 = 1

  element2 = 'c'

  element3 = "LLO"

  sequence1 = [1,2,3,4,5]

  sequence2 = "abcdefg"

  sequence3 = "HELLOWORLD"

  --------

  >>> element1 in sequence1
  True

  >>> element2 in sequence2
  True

  #下面这个操作在2.3以上的版本才支持

  >>> element3 in sequence3
  True

12、求最大值、最小值、长度的函数分别是:max()、min()、len()

13、列表

  13.1、list函数适用于所有的类型的序列,而不仅仅是字符串:lst = list("Helloworld")

  13.2、"".join(lst)将lst转换为字符串

  13.3、元素赋值:x=[1,2,3,4,5],x[0] = 5;要赋值的元素必须存在,否则报错;赋值之后将修改指定的元素

  13.4、删除元素:names=["alice","beth","ceil","dee-dee","earl"];del names[2];删除指定下标的元素;删除之后将影响列表元素

  13.5、分片赋值:name = list("perl")

    >>> name = list("perl")
  >>> name
    ['p', 'e', 'r', 'l']
  >>> name[2:] = "ar"
  >>> name
    ['p', 'e', 'a', 'r']
  >>> name[2:] = "HELLO WORLD"
  >>> name
    ['p', 'e', 'H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D']
  >>> name[1:1] = list("12345")
  >>> name
    ['p', '1', '2', '3', '4', '5', 'e', 'H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D']
  >>> name[5:] = []
  >>> name
    ['p', '1', '2', '3', '4']

  13.6、列表方法:对象.方法(参数)

    13.6.1、append():在列表末尾添加元素你,会修改调用者并且直接返回

      >>> a = list("12345")
      >>> a
      ['1', '2', '3', '4', '5']
      >>> a.append(6)
      >>> a
      ['1', '2', '3', '4', '5', 6]

    13.6.2、count():返回列表的指定元素的个数

      >>> a = list("HelloWorld")
      >>> a.count('l')
      3

    13.6.3、extend():追加一个列表到调用者的后面并修改调用者内容

      >>> a = list("Hello ")
      >>> b = list("World")
      >>> a.extend(b)
      >>> a
      ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

    13.6.4、index():指定元素在list中第一次出现的索引,如果元素不存在,会出现错误

      >>> a = list("Hello")
      >>> a.index("l")
      2

    13.6.5、insert():插入对象到列表中

      >>> a = list("Hello")
      >>> a.insert(3,"XINYE")
      >>> a
      ['H', 'e', 'l', 'XINYE', 'l', 'o']

    13.6.6、pop():默认弹出最后一个元素,指定一个参数时,删除指定索引的元素,并返回

      >>> a = list("Hello")
      >>> a.pop()
      'o'
      >>> a.pop(1)
      'e'
      >>> a
      ['H', 'l', 'l']

      pop()方法是唯一一个能修改列表并且返回列表元素的方法

    13.6.7、常见的数据结构:栈

      FIFO:First Input First Output,先入先出:入栈——insert(0,元素);出栈——pop()

      LIFO:Last Input First Output,后入先出:入栈——append();出栈——pop(0)

    13.6.8、remove():删除列表中第一个匹配项,会修改调用者,但没有返回值,如果删除的元素不存在,则会报错

      >>> a = list("HelloWorld")
      >>> a
      ['H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd']
      >>> a.remove("a")
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      ValueError: list.remove(x): x not in list
      >>> a.remove("e")
      >>> a
      ['H', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd']

    13.6.9、reverse():反向存放列表,会修改调用者

      >>> a = list("Hello")
      >>> a.reverse()
      >>> a
      ['o', 'l', 'l', 'e', 'H']

    13.6.10、reversed()函数:反向存储序列,生成副本,不会修改参数内容,但是不会返回列表,而是返回迭代器,使用list()函数可以把迭代器转化为list:list(reversed(list))

      >>> a = list("Hello")
      >>> reversed(a)
      <list_reverseiterator object at 0x0000000002C2F0F0>
      >>> a
      ['H', 'e', 'l', 'l', 'o']
      >>> list(reversed(a))
      ['o', 'l', 'l', 'e', 'H']

  13.6.11、sort():改变被排序里诶包,但是不会返回值

    >>> a = [4,6,2,1,7,9]
    >>> a.sort()
    >>> a
    [1, 2, 4, 6, 7, 9]

  如果不想改变a的内容,只想得到一个副本的排序结果,则需要先生成一个a的副本,然后对这个副本进行排序(副本的生成不能直接赋值哦,因为赋值实际上引用的是同一个对象,只能按照以下的方式):

    >>> a = list("hello world")
    >>> b = a[:]
    >>> b.sort()
    >>> a
    ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
    >>> b
    [' ', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']

  13.6.12、sorted()函数:不修改参数的内容,返回排序的副本

    >>> a = list("hello world")
    >>> b = sorted(a)
    >>> a
    ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
    >>> b
    [' ', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']

  13.6.13、高级排序:按照特定的方式进行排序

    a.按照compare(x,y)的形式自定义一个函数进行排序,这个自定义函数在x<y的时候返回-1;需要的时候返回0;x>y的时候返回1;

    默认的系统提供了一个cmp的函数,用来进行排序,遵循在x<y的时候返回-1;需要的时候返回0;x>y的时候返回1的规则(3.0以上不再支持这个内置函数)

    b.sort方法支持两个可选参数key和reverse

    key制定一个排序的函数和cmp类似,但是这个函数并不会直接用来确定对象的大小,而是为每一个元素创建一个键,然后根据键来排序,例如要按照元素的长度来进行排序,则可以使用len函数来指定

      r = ["aardvark","abalone","acme","add","aerate"]

      r.sort(key=len)

      排序之后r的内容为:['add', 'acme', 'aerate', 'abalone', 'aardvark']

    reverse的值为True或者False,来指明是否进行反序排列

      >>> x = [2,8,4,6,5,7,9]
      >>> x.sort(reverse=True)
      >>> x
      [9, 8, 7, 6, 5, 4, 2]

  以上这些都可以通过sorted()函数进行替换

14、元组:不可改变的序列。如果用逗号分隔开一些值就创建了一个元组,一般都用圆括号括起来

  >>> 1,2,3,4,5
  (1, 2, 3, 4, 5)
  >>> a = 1,2,3
  >>> a
  (1, 2, 3)
  >>> a = (1,)
  >>> a
  (1,)

如果想要创建一个非空元组,必须使用逗号,哪怕只有一个元素;若要创建空的元组,则直接使用一个()

tuple([1,2,3])、tuple("123")、tuple((1,2,3))把其他的序列转换为元组

元组可以作为映射的键,但是list却不行,这个也是元组的主要应用场合

(0)

相关推荐

  • Python字符串、元组、列表、字典互相转换的方法

    废话不多说了,直接给大家贴代码了,代码写的不好还去各位大侠见谅. #-*-coding:utf-8-*- #1.字典 dict = {'name': 'Zara', 'age': 7, 'class': 'First'} #字典转为字符串,返回:<type 'str'> {'age': 7, 'name': 'Zara', 'class': 'First'} print type(str(dict)), str(dict) #字典可以转为元组,返回:('age', 'name', 'class

  • Python中对元组和列表按条件进行排序的方法示例

    在python中对一个元组排序 我的同事Axel Hecht 给我展示了一些我所不知道的关于python排序的东西. 在python里你可以对一个元组进行排序.例子是最好的说明: >>> items = [(1, 'B'), (1, 'A'), (2, 'A'), (0, 'B'), (0, 'a')] >>> sorted(items) [(0, 'B'), (0, 'a'), (1, 'A'), (1, 'B'), (2, 'A')] 默认情况下内置的sort和so

  • python列表与元组详解实例

    在这章中引入了数据结构的概念.数据结构是通过某种方式组织在一起的数据元素的集合.在python中,最基本的数据结构就是序列.序列中的每个元素被分配一个序号,即元素的位置,也被称为索引.注意:第一个索引是0.1.序列概览python有6种内建的序列:列表,元组,字符串,Unicode字符串,buffer对象和xrange对象. 这里重点介绍列表和元组.列表和元组主要区别在于,列表可以修改,元组不可修改.一般来说,在几乎所有情况下列表都可以代替元组.在需要操作一组数值的时候,序列很好用: 复制代码

  • Python随手笔记第一篇(2)之初识列表和元组

    Python中,列表和元组是一种数据结构:序列,序列中的每个元素都被分配一个序号,元素的位置,第一原元素的位置为0,因此类推.序列是最基本的数据结构,列表和元组他们之间具有一定的区别,即列表可以修改,而元组则不能修改!如果要添加元素最好是用列表. 1. 在python中,最基本的数据结构是序列,序列中每一个元素被分配一个序号,即元素的位置,称为索引.索引从0开始,-1表示倒数第一个元素,-2表示倒数第二个元素,因此既可以是从前到后开始对元素进行访问,也可以从后往前对元素进行访问. 2. pyth

  • Python中列表和元组的使用方法和区别详解

    一.二者区别 列表: 1.可以增加列表内容 append 2.可以统计某个列表段在整个列表中出现的次数 count 3.可以插入一个字符串,并把整个字符串的每个字母拆分当作一个列表段追加到列表当中 extedn 4.可以查询某个列表段在整个列表的位置 index 5.可以在指定位置插入一个列表段 insert 6.可以删除列表的最后一个列表段 pop 7.可以删除指定列表中的某个列表段 remove 8.可以正向反向排序 reverse 9.可以按字母或数字排序 sort 10.定义列表时候使用

  • Python中3种内建数据结构:列表、元组和字典

    Python中有3种内建的数据结构:列表.元组和字典.参考简明Python教程 1. 列表 list是处理一组有序项目的数据结构,即你可以在一个列表中存储一个 序列 的项目.假想你有一个购物列表,上面记载着你要买的东西,你就容易理解列表了.只不过在你的购物表上,可能每样东西都独自占有一行,而在Python中,你在每个项目之间用逗号分割. 列表中的项目应该包括在方括号中,这样Python就知道你是在指明一个列表.一旦你创建了一个列表,你可以添加.删除或是搜索列表中的项目.由于你可以增加或删除项目,

  • python数据结构之列表和元组的详解

    python数据结构之 列表和元组 序列:序列是一种数据结构,它包含的元素都进行了编号(从0开始).典型的序列包括列表.字符串和元组.其中,列表是可变的(可以进行修改),而元组和字符串是不可变的(一旦创建了就是固定的).序列中包含6种内建的序列,包括列表.元组.字符串.Unicode字符串.buffer对象.xrange对象. 列表的声明: mylist = [] 2.列表的操作: (1) 序列的分片: 用法:mylist[startIndex:endIndex:step] exam: myli

  • Python中列表和元组的相关语句和方法讲解

    列表(list): 首先,列表属于序列,那么序列类型可用如下内建函数-- list(iter):把可迭代对象转换为列表. str(obj):把obj对象转换为字符串,即用字符串来表示这个对象. tuple(iter):把一个可迭代对象转换为一个元组. unicode(obj):把对象转换成Unicode字符串. basestring():抽象工厂函数,其作用仅仅是为str和unicode函数提供父类,所以不能被实例化,也不能被调用. enumerate(iter):接受一个可迭代对象作为参数,返

  • Python中列表、字典、元组数据结构的简单学习笔记

    列表 列表是Python中最具灵活性的有序集合对象类型.与字符串不同的是,列表可以包含任何类型的对象:数字.字符串甚至其他列表.列表是可变对象,它支持原地修改的操作. Python的列表是: 任意对象的有序集合 通过偏移读取 可变长度.异构以及任意嵌套 属于可变序列的分类 对象引用数组(列表中的存储的是对象的引用,而不是对象的拷贝) 实际应用中的列表 >>基本列表操作 由于列表是序列,它支持很多与字符串相同的操作.列表对"+"和"*"操作的响应与字符串很

  • Python入门篇之列表和元组

    列表和元组的主要区别在于,列表可以修改,元组则不能.一般情况下,在几乎所有的情况下列表都可以代替元组 例如:使用序列可以表示数据库中一个人的信息(姓名,年龄) 复制代码 代码如下: >>> edward=['Edward Gumby',42] 序列还可以包含其他序列 复制代码 代码如下: >>> edward=['Edward Gumby',42] >>> john=['John Smith',50] >>> database=[ed

  • Python中列表、字典、元组、集合数据结构整理

    本文详细归纳整理了Python中列表.字典.元组.集合数据结构.分享给大家供大家参考.具体分析如下: 列表: 复制代码 代码如下: shoplist = ['apple', 'mango', 'carrot', 'banana'] 字典: 复制代码 代码如下: di = {'a':123,'b':'something'} 集合: 复制代码 代码如下: jihe = {'apple','pear','apple'} 元组: 复制代码 代码如下: t = 123,456,'hello' 1.列表 空

随机推荐