文档章节

Python复习笔记之“列表和元组”

程序媛syuu
 程序媛syuu
发布于 2016/08/06 14:52
字数 4382
阅读 11
收藏 0

                在复习之前,我们先来引入一个概念:数据结构。数据结构是通过某种方式(例如对元素进行编号)组织在一起的数据元素集合,这些数据元素可以是数字或者字符,甚至可以是其他数据结构

                在Python中最基本的数据结构是序列(sequence·)。序列中的每个元素被分配一个序号--即元素的位置,也称为索引。第一个索引是0,第二个则是1,以此类推。

1.1序列概览

  • Python包含6种内建的序列,本次重点讨论最常用的两种类型:列表元组。其他的内建序列类型有字符串,Unicode字符串,buffer对象和xrange对象。
  • 列表和元组的主要区别在于,列表可以修改,元组则不能。(也就是说,如果要根据要求来添加元素,那么列表可能会更好用;而出于某种原因,序列不能修改的时候,使用元组更为合适。)
  • 序列也可以包含其他的序列。
    #构建一个人员信息列表
    >>> edward=['Edward Gumby',42]
    >>> john=['John Smith',50]
    >>> database=[edward,john]
    >>> database
    [['Edward Gumby', 42], ['John Smith', 50]]

           

1.2通用序列操作

                所有序列类型都可以进行某些特定的操作。这些操作包括:索引(indexing),分片(slicing),加(adding),乘(multiplying)以及检查某个元素是否属于序列的成员(成员资格)。除此之外,Python还有计算序列的长度,找出最大元素和最小元素的内建函数。

        1.2.1索引

                    序列中所有的元素都是有编号的—从0开始递增。这些元素可以通过编号分别访问。如下例所示:

>>> greeting='Hello'  #字符串就是一个由字符组成的序列。
>>> greeting[0]
'H'

                    这就是索引。可以通过索引获取元素。所有的序列都可以通过这种方式进行索引。使用负数索引时,Python会从右边,也就是从最后1个元素开始计数。最后1个元素的位置编号是-1.

                    字符串字面值(就此而言,其他序列字面量亦可)能够直接使用索引,而不需要一个变量引用它们。两种做法的效果是一样的。 

>>> 'Hello'[1]
'e'
>>> [1,2,3,4,5][3]
4

                    如果一个函数调用返回一个序列,那么可以直接对返回结果进行索引操作。例如,假如你只对用户输入年份的第4个数字感兴趣,那么,可以进行如下操作。

>>> fourth=input('Year:')[3]
Year:2014
>>> fourth
'4'

                索引示例:它要求输入年,月(1-12的数字),日(1-31),然后打印出相应日期的月份名称。

#根据给定的年月日以数字的形式打印出日期
months=['January'
		'February',
		'Marth',
		'April',
		'May',
		'June',
		'August',
		'September',
		'October',
		'November',
		'December'
	]
endings=['st','nd','rd']+17*['th']\
	   +['st','nd','rd']+7*['th']\
	   +['st']
year   =input('Year:')
month  =input('Month(1-12):')
day    =input('day(1-31):')
month_number=int(month)
day_number=int(day)
#记得要将月份和天数减1,以获得正确的索引
month_name=months[month_number-1]
ordinal=day+endings[day_number-1]
print(month_name+' '+ordinal+'.'+year)

        1.2.2分片

                    与使用索引来访问单个元素类似,可以使用分片操作来访问一定范围内的元素。分片通过冒号隔开的两个索引来实现。

                    分片操作的实现需要提供两个索引作为边界,第1个索引的元素是包含在分片内的,而第2个则不包含在内。

>>> tag='my.oschina.net'
>>> tag[3:10]
'oschina'
>>> tag[3:-4]
'oschina'
>>>

                   1,优雅的捷径

                    假设需要访问最后3个元素,那么当然可以进行显式的操作:

>>> numbers=[1,2,3,4,5,6,7,8,9,10]
>>> numbers[7:10]  #索引10指向的是第11个元素,但是这个元素并不存在,却是在最后一个元素之后。
[8, 9, 10]

                    现在,这种做法是可行的。但是如果需要从列表的结尾开始计数呢?

>>> numbers=[1,2,3,4,5,6,7,8,9,10]
>>> numbers[-3:0]   #只要分片中最左边的索引比它右边的晚出现在序列中,结果就是一个空的序列。
[]

                    这并不是我们所要的结果。幸好,可以使用一个捷径:如果分片所得部分包括序列结尾的元素,那么,只需置空最后一个索引即可

                    这种方法也同样适用于序列开始的元素。

                    实际上,如果需要复制整个序列,可以讲将两个索引都置空。

>>> numbers=[1,2,3,4,5,6,7,8,9,10]
>>> numbers[-3:]  #结尾的元素
[8, 9, 10]
>>> numbers[:3]  #开始的元素
[1, 2, 3]
>>> numbers[:]  #复制整个序列
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

                    分片示例:一个小程序,它会提示输入URL(假设它的形式为http://www.somedomainname.com),然后提取域名。

url=input('Please enter the URL:')
domain=url[11:-4]
print("Domain name:domain")

                    2,更大的步长

                    进行分片的时候,分片的开始和结束点需要进行指定(不管是直接还是间接)。而另外一个参数—步长(step length)——通常都是隐式设置的。在普通的分片中,步长是1——分片操作就是按照这个步长逐个遍历序列的元素,然后返回开始和结束点之间的所有元素。

>>> numbers=[1,2,3,4,5,6,7,8,9,10]
>>> numbers[0:10:1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

                    在这个例子中,分片包含了另外一个数字。这就是步长的显式设置。如果步长被设置为比1大的数,那么就会跳过某些元素。例如,步长为2的分片包括的是从开始到结束每隔1个的元素。

                    之前提及的捷径也可以使用。如果需要将每4个元素中的第1个提取出来,那么只需要将步长设置为4即可:

>>> numbers=[1,2,3,4,5,6,7,8,9,10]
>>> numbers[0:10:2]
[1, 3, 5, 7, 9]
>>> numbers[::4]
[1, 5, 9]

                    当然,步长不能为0(那不会执行),但步长可以是负数,此时分片从右到左提取元素

                    当使用负数作为步长时,必须让开始点(开始索引)大于结束点。

>>> numbers=[1,2,3,4,5,6,7,8,9,10]
>>> numbers[8:3:-1]
[9, 8, 7, 6, 5]
>>> numbers[10:0:-2]
[10, 8, 6, 4, 2]
>>> numbers[::-2]
[10, 8, 6, 4, 2]
>>> numbers[:5:-2]
[10, 8]

            1.2.3序列相加

                    通过使用加运算符可以进行序列的连续操作。

>>> [1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]
>>> 'Hello, '+'world'
'Hello, world'
>>> [1,2,3]+'world'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "str") to list

                    正如错误信息所提示的,列表和字符串是无法连接在一起的,jinguan 他们都是序列。简单来说,两种相同类型的序列才能进行连接操作。

            1.2.4乘法

                    用数字x乘以一个序列会生成新的数列,而在新的序列中,原来的序列将被重复x次。

>>> 'python'*5
'pythonpythonpythonpythonpython'
>>> [42]*5
[42, 42, 42, 42, 42]

                    若想要初始化一个长度为10的列表,可以按照下面的例子来实现:

>>> sequence=[None]*10  #None是一个Python的内建值,它的确切含义是“这里什么也没有”
>>> sequence
[None, None, None, None, None, None, None, None, None, None]

            1.2.5成员资格

                    为了检查一个值是否在序列中,可以使用in运算符。这个运算符和之前讨论过的(例如+,*运算符)有一点不同。这个运算符检查某个条件是否为真,然后返回相应的值:条件为真返回True,条件为假返回False。这样的运算符叫做布尔运算符,而返回的值叫做布尔值

>>> permissions='rw'
>>> 'w' in permissions
True
>>> 'x' in permissions  #在UNIX系统中,这两行代码可以作为查看文件可写和可执行权限的脚本。
False
>>> subject='$$$Get rich now!!!$$$'
>>> '$$$' in subject  #可以作为垃圾邮件过滤器的一部分
True

                    下例中给出了一个查看用户输入的用户名和PIN码是否存在于数据库(实际是一个列表)中的程序。

#查看用户名和PIN码
database=[
	['albert','1234'],
	['dilber','4242'],
	['smith', '7542'],
	['jones', '9843']
]
username=input('User name:')
pin=input('PIN code:')
if [username,pin] in database:
	print('Access granted')

            1.2.6长度,最小值和最大值

                    len函数返回序列中所包含元素的数量。

                    min函数和max函数分别返回序列中最大和最小的元素。

>>> numbers=[100,34,678]
>>> len(numbers)
3
>>> min(numbers)
34
>>> max(numbers)
678
>>> max(2,3)  #在这里max函数和min函数的参数并不是一个序列,而是以多个数字直接作为参数。
3
>>> min(3,4,7,1)
1

1.3列表:Python的“苦力”

                本节会讨论列表不同于元组和字符串的地方:列表是可变的——可以改变列表的内容,并且列表有很多有用的专门的方法。

            1.3.1list函数

                    因为字符串不能像列表一样被修改,所以有时根据字符串创建列表会很有用。list函数会实现这个操作:

>>> list('hello')
['h', 'e', 'l', 'l', 'o']

                    *注意:list函数适用于所有类型的序列,而不只是字符串。

                    可以用''.join(somelist)将一个由字符组成的列表转换为字符串。在这里somelist是需要转换的列表。

 

            1.3.2基本的列表操作

                    1,改变列表:元素赋值

                    使用索引标记来为某个特定的,位置明确的元素赋值。

                    不能为一个位置不存在的元素进行赋值。

>>> x=[1,1,1]
>>> x[1]=2
>>> x
[1, 2, 1]

                   2,删除元素

                    使用del语句来实现。

>>> names=['Alice','Beth','Ceil','Dee-Dee','Earl']
>>> del names[2]
>>> names
['Alice', 'Beth', 'Dee-Dee', 'Earl']

                    del语句还能用于删除其他元素。它可以用于字典元素甚至是其他变量的删除操作。

                    3,分片赋值

                    分片是一个非常强大的特性,分片赋值则更显现它的强大。

>>> name
['P', 'e', 'r', 'l']
>>> name[2:]=list('ar')
>>> name
['P', 'e', 'a', 'r']
  •                     程序可以一次为多个元素赋值
  •                     可以使用与原序列不等长的序列将分片替换
    >>> name=list('Perl')
    >>> name[1:]=list('ython')
    >>> name
    ['P', 'y', 't', 'h', 'o', 'n']

     

  •                       分片赋值语句可以在不需要替换任何原有元素的情况下插入新的元素。

  •                      通过分片赋值来删除元素也是可行的。

    >>> name=list('Perl')
    >>> name[1:]=list('ython')
    >>> name
    ['P', 'y', 't', 'h', 'o', 'n']
    >>> numbers=[1,5]
    >>> numbers[1:1]=[2,3,4]  #通过分片赋值在不需要替换任何原有元素的情况下插入新的元素
    >>> numbers
    [1, 2, 3, 4, 5]
    >>> numbers[1:4]=[]  #通过分片赋值来删除元素
    >>> numbers
    [1, 5]

     

             1.3.3列表方法

                    方法是一个与某些对象有紧密联系的函数,对象可能是列表,数字,也可能是字符串或者其他类型的对象。一般来说,方法可以这样进行调用:

                    对象.方法(参数)

                    1.append

                    append方法用于在列表末尾追加新的对象。

>>> lst=[1,2,3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]

                    append方法和其他一些方法类似,只是在恰当的位置修改原来的列表。这意味着,它不是简单地返回一个修改过的列表———而是直接修改原来的列表。

                    2.count

                    count方法统计某个元素在列表中出现的次数。

>>> ['to','be','or','not','to','be'].count('be')
2

                    3.extend

                    extend方法可以在列表的末尾一次性追加另一个序列中的多个值。换句话说,可以用新列表扩展原有的列表。

>>> a=[1,2,3]
>>> b=[4,5,6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]

                    这个操作看起来很像连接操作,两者最主要的区别在于:extend方法修改了被扩展的序列(在这个例子中就是a)。而原始的连接操作则不然,它会返回一个全新的列表。

>>> a=[1,2,3]
>>> b=[4,5,6]
>>> a+b
[1, 2, 3, 4, 5, 6]
>>> a
[1, 2, 3]

                    我们同样可以使用分片赋值来实现相同的结果,虽然这么做是可行的的,但是代码的可读性就不如使用extend方法了。

>>> a=[1,2,3]
>>> b=[4,5,6]
>>> a[len(a):]=b
>>> a
[1, 2, 3, 4, 5, 6]

                    4.index

                    index方法用于从列表中找到某个值第一个匹配项的索引位置。

>>> knights=['We','are','the','knights','who','say','ni']
>>> knights.index('who')
4

                    5.insert

                    insert方法用于将对象插入到列表中:

>>> numbers=[1,2,3,5,6,7]
>>> numbers.insert(3,'four')
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]

                    与extend方法一样,insert方法的操作也可以用分片赋值来实现。但是可读性不如insert方法。

>>> numbers=[1,2,3,5,6,7]
>>> numbers[3:3]=['four']
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]

                    6.pop

                    pop方法会移除列表中的一个元素(默认是最后一个),并且返回该元素的值。

>>> x=[1,2,3]
>>> x.pop()
3
>>> x.pop(0)
1
>>> x
[2]

                    pop方法是唯一一个既能修改列表又返回元素值(除了None)的列表方法。

                    使用pop方法可以实现一种常见的数据结构——。栈的原理就像堆放盘子那样。只能在顶部放一个盘子,同样,也只能从顶部拿走一个盘子。最后放入堆栈的最先被移除(这个原则称为LIFO,即后进先出)。

                    对于上述两个栈操作(放入和移除),它们有大家都认可的称谓——入栈(push)出栈(pop)。Python没有入栈方法,但可以使用 append方法来代替。pop方法和append方法的操作结果恰好相反,如果入栈刚刚出栈的值,最后得到的结果还是原来的栈。

>>> x=[1,2,3]
>>> x.append(x.pop())
>>> x
[1, 2, 3]

                    7.remove

                    remove方法用于移除列表中某个值的第一个匹配项。值得注意的是,remove是一个没有返回值的原位置改变方法。

>>> x=['to','be','or','not','to','be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']

                    8.reverse

                    reverse方法将列表中的元素反向存放。

>>> x=[1,2,3]
>>> x.reverse()
>>> x
[3, 2, 1]

                    如果需要对一个序列进行反向迭代,那么可以使用reversed函数。这个函数并不返回一个列表,而是返回一个迭代器(iterator)对象。尽管如此,使用list函数把返回的对象转换成列表也是可行的。

>>> x=[1,2,3]
>>> list(reversed(x))
[3, 2, 1]

                    9.sort

                    sort方法用于在原位置对列表进行排序。在“原位置排序”意味着改变原来的列表,从而让其中的元素能按一定的顺序排列,而不是简单地返回一个已排序的列表副本。

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

                    前面介绍过了几个改变列表却不返回值得方法,在大多数情况下这样的行为方式是很合常理的(例如append方法)。但是,当用户需要一个排好序列的列表副本,同时又保留原有列表不变的时候,问题就出现了。注意:下面的做法是错误的。

>>> x=[4,6,2,1,7,9]
>>> y=x.sort()
>>> print(y)
None

                    因为sort方法修改了x却返回了空值,那么最后得到的是已排序的x以及值为None的y。

                    实现这个功能的正确做法是,首先把x的副本赋值给y,然后对y进行排序。

>>> x=[4,6,2,1,7,9]
>>> y=x[:]
>>> y.sort()
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]

                    再次调用x[:]得到的是包含了x所有元素的分片,这是一种很有效率的复制整个列表的方法。只是简单的把x赋值给y是没用的,因为这样做就让x和y都指向同一个列表了。

                    另一种获取已排序的列表副本的方法是,使用sorted函数:

>>> x=[4,6,2,1,7,9]
>>> y=sorted(x)
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]

                    这种函数实际上可以用于任何序列,却总是返回一个列表:

>>> sorted('Python')   # sorted函数用于字符串得到的也是列表
['P', 'h', 'n', 'o', 't', 'y']

                    10.高级排序

1.4元组:不可变序列

                    元组与列表一样,也是一种序列。唯一的不同是元组不能修改。元组没有像列表一样的方法

                    创建元组的方法很简单:如果你用逗号分隔了一些值,那么你就自动创建了元组。

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

                    空元组可以用没有包含内容的两个圆括号来表示。

                    那么如何实现包括一个值得元组呢。实现的方法有些奇特——必须加个逗号,即使只有一个值。

>>> ()  #空元组
()
>>> 42  #必须加逗号,只加上一个()也是没有用的
42
>>> 42,
(42,)
>>> (42,)
(42,)

                逗号是很重要的,只加上一个括号也是没有用的:(42)和42是完全一样的。但是,一个逗号能彻底改变表达式的值:

>>> 3*(40+2)
126
>>> 3*(40+2,)
(42, 42, 42)

        1.4.1tuple函数

                    tuple函数的功能与list函数基本是一样的:以一个序列作为参数并把它转换为元组。如果参数就是元组,那么该参数就会被原样返回。

>>> tuple([1,2,3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple([1,2,3])
(1, 2, 3)

        1.4.2基本元组操作

                    元组其实并不复杂——除了创建元组访问元素外,也没有太多其他操作,可以参照其他类型的序列来实现。

>>> x=1,2,3
>>> x[1]
2
>>> x[0:2]
(1, 2)

            元组的分片还是元组,就像列表的分片还是列表一样。

        1.4.3那么,意义何在

                    由于以下两个重要原因,元组是不可替代的。

  •                     元组可以在映射中当做键使用——而列表则不行。
  •                     

本文转载自:

程序媛syuu
粉丝 4
博文 7
码字总数 8440
作品 0
海淀
私信 提问
python学习10.06:Python tuple元组详解

元组是 Python 中另一个重要的序列结构,和列表类似,也是由一系列按特定顺序排序的元素组成。和列表不同的是,列表可以任意操作元素,是可变序列;而元组是不可变序列,即元组中的元素不可以...

太空堡垒185
昨天
10
0
Python编程实践 学习笔记

Practical Programming-An Introduction to Computer Science Using Python 这本书是Jennifer Campbell等著,唐学韬(汕头大学)译,全书300页,虽内容不多,但个人认为译者比较负责,如未统一...

Honghe
2013/01/04
1K
1
python(二)列表,元组,循环

1,列表 python中除去基本的数据类型之外还包括多种扩展数据类型,在学习的时候掌握不同数据类型的特性以及基本的“CURD”操作就好了,当然,前提是这个类型它支持! 你看,是不是就这么简单...

Koma
2015/01/15
1K
0
总结学习 Python 的 14 张思维导图汇总

本文主要涵盖了 Python 编程的核心知识(暂不包括标准库及第三方库,后续会发布相应专题的文章)。 首先,按顺序依次展示了以下内容的一系列思维导图:基础知识,数据类型(数字,字符串,列...

两味真火
2017/10/01
7.9K
10
python核心编程-第四章-个人笔记

1.所有的python对象都拥有三个特性: ①身份:每个对象都有唯一的身份标识自己,可用内建函数id()来得到。基本不会用到,不用太关心 >>> a = 2>>> id(2)39411616L>>> id(a)39411616L 这个例子...

好好先生_1028
2015/11/18
47
0

没有更多内容

加载失败,请刷新页面

加载更多

iOS苹果应用IPA一键签名工具及重签教程

开心签名工具,是一款跨平台ios签名和重签名工具。 同时支持在windows、linux、mac运行,数据同步,方便使用及管理! 开心重签名工具官网 功能特点 1、支持图形界面及命令行重签(部署到服务...

tintong
31分钟前
5
0
2.4G有源卡核心芯片供应商

有源2.4G RFID的防盗标签,在与无源标签相比较,通信距离远,通信时效高。我司的SI24R2E这颗芯片专门为2.4G有源标签而设计,具有低功耗,发送距离远,厂商设计简单等优势;广泛应用于现在城市...

文刀石
37分钟前
2
0
设置Ubuntu16.04启动为命令行界面

1. 修改/etc/default/grub文件,将GRUB_CMDLINE_LINUX_DEFAULT设置成”quiet splash 3” 2. 使用命令update-grub使得在/boot下重新生成GRUB2配置文件。 3. 重启...

JosiahMg
37分钟前
3
0
C++基础知识点

计算机语言 计算机不能理解高级语言,只能理解机器语言,必须要将高级语言翻译成机器语言,翻译的方式有两种,一种是编译,一种是解释 解释型语言,在运行程序时进行翻译,每个语句在执行时逐...

大瑞清_liurq
44分钟前
4
0
EFCore 多条数据更新不能同时savechanges()的解决方法

1 在ModelContext定义下增加var transaction = ctx.Database.BeginTransaction(); 1.2 在最后一个SaveChanges()后增加transaction.Commit(); 3 在finally的if (sMsgCode != "")分支中增加tra......

_Somuns
47分钟前
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部