Python基础教程 第二章 列表和元组

2017年11月10日16:16:04
  • A+
所属分类:Python基础

数据结构

数据结构是通过某种方式(例如对元素进行编号)组织在一起的数据元素的集合,这些数据元素可以是数字或者字符,甚至可以是其他数据结构。

 

Python中,最基本的数据结构是序列(sequence)。

序列中的每个元素被分配一个序号—即元素的位置,也称为索引。第一个索引是0,第二个则是1,以此类推。

 

 

列表和元组的主要区别

列表可以修改,元组则不能,同时,序列也可以包含其他的序列

在几乎所有的情况下列表都可以替代元组,使用元组作为字典的键。在这种情况下,因为键不可修改,所以就不能使用列表

在需要操作一组数值的时候,序列很好用。可以用序列表示数据库中一个人的信息-

>>>edward =[’Edward Gumby', 42]

 

数据结构容器(container)

容器基本上是包含其他对象的任意对象。序列(例如列表和元组)和映射(例如字典)是两类主要的容器。

序列中的每个元素都有自己的编号,而映射中的每个元素则有一个名字(也称为键

既不是序列也不是映射的容器类型,集合(set)就是一个例子。

 

 

序列操作

所有序列类型都可以进行某些特定的操作。这些操作包括:索引(indexing)、分片(sliceing) ,加(adding )、乘(multiplying)

以及检查某个元素是否属于序列的成员(成员资格)。除此之外,Python还有计算序列长度、找出最大元素和最小元素的内建函数。

 

dad = 100
list1 = ['232',23,'asdad',[2,'sd'],dad]
dict1 = {'sd':'',dad:12,'a':{1:1,2:2}}
# print list1
for ss in list1:
if (type(ss) == list) :
print ss

for dd in dict1:
if (type(dict1[dd]) == dict ) :
print dict1[dd]

print '12','2','2'

 

以上知识点:列表和字典都可以嵌套;类型的判断方式;字典值的访问方式

 

索引

字符串索引:

greeting='Hello

greeting[0]

 

output:

H

 

使用负数索引时,Python会从右边,也就是从最后1个元素开始计数。最后1个元素的位置编号是-1

 

 

Keyboar =  raw_input("year:")[3]
print Keyboar

 

索引 就想java数组的索引一样

 

换行必须使用转义字符放在上一行的末尾

str2 = '2323'\

+ 'sddsd'

print(str2)

 

输出:

C:\Python27\python,exe C:/Python27/untitled2/test22,py

2323sddsd

 

 

list2 = ['ad']*10

print list2

 

输出:

['ad', 'ad', 'ad', 'ad', 'ad', 'ad', 'ad', 'ad', 'ad', 'ad']

 

 

 

分片

可以使用分片操作来访问一定范围内的元素。分片通过冒号相隔的两个索引来实现:分片操作对于提取序列的一部分是很有用的

>>>tag = '<a href="http://www,python,org">即thon web site</a>'

>>>tagC9:30]

'http://www,python,org'

>>>tag[32:-4]

,即thon web site'

 

numbers =[3, 4, 5, 6, 7, 8,9, 10]

print numbers[3:6]

print numbers[6:]

 

C:\Python27\python,exe C:/Python27/untitled2/test22,py

[6, 7, 8]

[9, 10]

注意:访问最后几个元素的方法,分片的第二个索引记为空,这种方法同样适用于序列开始的元素:

>>> numbers[:3]

[1, 2, 3]

 

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

 

分片的步长

numbers[0:10:1]

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

如果需要将每4个元素中的第i个提取出来,那么只要将步长设置为4即可:

>>> numbers[::4]

[1, 5, 9]

当然,步长不能为。一一一那不会向下执行一一但步长可以是负数(必须让开始点(开始索引)大于结束点),即从右到左提取元素:

>>> numbers[8:3:-1]

[9, 8, 7, 6, 5]

 

 

序列相加

通过使用加号可以进行序列的连接操作:

>>>fl ,z, a]+[4, 5, 6]

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

>>>'Hello’+’world!’

Hello, world!’

 

乘法

[42]*10

[42, 42,42, 42, 42, 42, 42,42, 42,42]

 

None

None是一个Python的内建值,它的确切含意是“这里什么也没有”。因此,如果想初始化一个长度为30的列表,可以按照下面的例子来实现:

sequence = [None] * 10

sequence

[None, None, None, None, None, None, None, None, None, None]

 

成员资格

为了检查一个值是否在序列中,可以使用怕运算符。

permissions= 'rw'
if ('s' in permissions) :
print True
else:
print False

 

users=['mlh','foo','bar']
if ('mlh' in users) :
print True
else:
print False

 

长度、最小值和最大值

内建函数len、 min和max非常有用

 

 

 

 

列表:Python的苦力

列表是可变的(mutable )—可以改变列表的内容

 

list函数:

限据字符串创建列表,注意,list函数适用于所有类型的序列,而不只是字符串,

同时可以反向转换,将列表转为字符串

 

list2 =  list('hello')
print list2
str2= ''.join(list2)
print str2

 

C:\Python27\python.exe C:/Users/hspcadmin/PycharmProjects/untitled/MyData.py

['h', 'e', 'l', 'l', 'o']

hello

 

基本的列表操作

.改变列表的方法:元素赋值、元素删除、分片赋值以及列表方法(请注意,并不是所有的列表方法都真正地改变列表)。

元素赋值: list2[1]=2

删除元素:del list2[2]

分片赋值 :  list2[:]='test22',list2[:]=[1,2,3,4],  list2[:]=[]

可以使用与原序列不等长的序列将分片替换,分片赋值语句可以在不需要替换任何原有元素的情况下插入(删除)新的元素

 

列表方法

1 .append

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

>>> list =[1. 2. 3]

>>>list.append(4)

 

 

  1. count

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

list2=[1,2,3,4]

list2.count(4)

输出:

2

 

  1. extend

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

list1=[1,2,3,4]

list2=[6,7]

list1.extend(list2)

print list1

输出:

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

 

注意 list1+list2 这种连接方式会返回一个全新的列表

 

  1. index

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

 

 

  1. insert

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

>>> numbers=[1. 2. 3. 5. 6. 7]

>>> numbers.insert(3‘four')

 

也可以用分片来实现:

numbers[3:3] =['four']

 

  1. pop

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

numbers=[1. 2. 3. 5. 6. 7]

numbers.pop()

 

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

 

 

对于上述两个栈操作(放人和移出),它们有大家都认可的称谓—入找(push)和出栈(PoP).

Python没有入栈方法,但可以使用append方法来代替。pop方法和append方法的操作结果恰好相反,

如果入找(或者追加)刚刚出找的值,最后得到的结果还是原来的栈。

 

 

  1. remove

remove方法用于移除列表中某个值的第一个匹配项:

numbers=[1. 2. 3. 5. 6. 7]

numbers.premoveop(1)

 

  1. reverse

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

 

 

请注意,该方法也改变了列表但不返回值(就像remove和sort).

 

  1. sort

sort方法用于在原位置①对列表进行排序。在“原位置排序”意味着改变原来的列表,从而

让其中的元素能按一定的顺序排列,而不是简单地返回一个已排序的列表副本。

numbers=[1. 2. 3. 5. 6. 7]

numbers.sort();

 

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

>>>X=[4. 6. 2. 1, 7. 9]

>>>y=sorted(x)

 

print y

>>> [1,2,4,6,7,9]

 

注意:反向排序就是再调用一次reverse方法

 

 

sort方法的3个参数—cmp、key和reverse

list1=[1,8,6,2,3,4]
list1.sort(cmp)
print list1
list1.sort(reverse=True)
print list1
list3 = ['a','aaa','aa','aaaa']
list3.sort(key=len)
print list3
list3.reverse()
print list3

 

输出

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

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

['a', 'aa', 'aaa', 'aaaa']

['aaaa', 'aaa', 'aa', 'a']

 

元组:不可变序列

>>>1. 2. 3

(1 .2, 3)

元组也是(大部分时候是)通过圆括号括起来的:

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

>>>42

42

>>>42.

(42,)

>>>(42.)

(42,)

 

tuple函数

tuple函数的功能与list函数基本上是一样的

>>>tuple([1, 2, 3])

(1. 2. 3)

>>>tuple('abc')

('a','b','c')

>>>tuple((1. 2. 3))

(1. 2. 3)

 

:元组操作

元组其实并不复杂—除了创建元组和访问元组元素之外,也没有太多其他操作,可以参照

其他类型的序列来实现:

 

元组可以在映射(和集合的成员)中当作键使用—而列表则不行

元组作为很多内建函数和方法的返回值存在,也就是说你必须对元组进行处理。只要不

尝试修改元组,那么,“处理”元组在绝大多数情况下就是把它们当作列表来进行操作(除

非需要使用一些元组没有的方法,例如index和count).

 

 

本章的新函数

 

函数          描述

cmp(x, y)比较两个值

len(seq)返回序列的长度

list(seq)把序列转换成列表

max(args)返回序列或者参数集合中的最大值

min(args)返回序列或者参数集合中的最小值

reversed(seq)对序列进行反向迭代

sorted(seq)返回已排序的包含seq所有元素的列表

tuple(seq)把序列转换成元组

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

avatar

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: