序列(sequence)

python3

在Python中,最基本的数据结构就是序列(sequence).序列中的每个元素都会分配一个序号即元素的位置也称为索引.序列的第一索引是0,最后一个是-1.

序列有6种内建的序列.最常用的是元组(不可以改),列表(可以修改)和字符串,还有Unicode字符串,buffer对象,xrange对象.内建函数会返回元组,它与Python内部的动作方式有关,几乎在所有的情况下都可以用列表替代元组.例外的情况是:使用元组作为字典的键.

通用的序列操作

所有序列类型都可以进行某些特定的操作:索引(indexing),分片(slicing),加(adding两种相同的类型的序列才能进行连接操作),乘(multiplying),以及检查某个元素是否属于序列成员(成员资格) in,除此之处,Python还有计算序列长度len(),找出最大元素max()和最小元素min()的内建函数以及迭代(iterator)

l = list(‘hello’) [‘h’,’e’,’l’,’l’,’o’]list函数适用于所有类型的序列,而不仅仅是字符串.list()为内建函数.

x=[31,5,7,8]
y=sorted(x),这个函数实际上可以用于任何序列,任何可迭代对象,却总是返回一个列表. sorted(‘Python’)

1
2
3
4
5
6
7
8
9
10
11
12
13
# 分片操作第二个索引不包含在分片内
numbers = [1,2,3,4,5,6,7,8,9,10]
number[-3: ] # 8-10
number[:3] # 1-3
number[:] # 取所有
# 步长
numbers[0:10:2]
numbers[::4] # 步长不能为 0,但是可以为负数,如
numbers[8:3:-1]  # 得到[9, 8, 7, 6, 5]
numbers[10:0:-2]  # 得到[10, 8, 6, 4, 2]
number[::-2]  # 得到[10, 8, 6, 4, 2]
number[5::-2]  # 得到[6, 4, 2]
number[:5:-2]  # 得到 [10, 8]

基本的列表操作(list)

元素赋值(不能超过索引进行赋值):是替换而不是累加

1
l[4]= 1

删除元素

1
2
3
4
5
6
7
8
9
10
11
del l[4]
remove('h')
# 用于移除列表中某个值的第一个匹配元素.
pop()
# 会移除列表中的一个元素(默认是最后 一个)并返回该元素的值.
# 后进先出(LIFO)唯一个修改了列表以返回元素值的列表方法.(出栈)
l[1:5] = []
['h', 'e', 'l', 'l']

追加元素

1
2
3
4
5
6
7
8
9
10
11
12
insert(索引位置,要插入的对象) # 将对象插入到列表中,(累加)
l.insert(4,'four')
l.append(5)
# 在列表末尾追加新的对象,它不是简单的返回一个修改过的新列表,
# 而是直接修改的原来的列表.(入栈)
l.extend()
# 可用新的列表来扩展原有的列表,只是修改(扩展)了原有的列表.
# 而原始的连接操作(+),则会返回一个新的列表.
l.extend(list('o femn'))

分片赋值

1
2
l[1:1] = list('femn')
['h', 'f', 'e', 'm', 'n', 'e', 'l', 'l']

l.count(‘h’):统计某元素在列表中出现的次数.

l.index(‘h’):用于列表中找出某个元素在列表中第一个匹配的索引位置.

l.reverse():将列表元素反向存放,它返回的是一个迭代器(iterator)对象.

sort():在原位置对列表进行排序.在”原位置排序”意味着改变原来的列表,从而让其中的元素按一定的顺序排列,而不是简单地返回一个已经排序的列表副本.

1
2
y=x[:] # y=x 错误,这样会让x,y都指向同一个列表.
y.sort()

元组:不可变序列(字符串也是不能修改)

元组通过圆括号 括起来的.如果你用逗号分隔了一些值,那么你就自动创建的元组.
tuple([1,2,3]):以一个序列作为参数并把它转换为元组.tuple并不是真正的函数,而是一种类型.

字典

dict()像list,tuple,str一样,不是真正的函数,都只是类型.这些方法如果都不带参数,返回的都是对应的空字典,列表,元组,字符串.

创建字典

1
2
3
4
5
6
7
8
9
10
d = dict(host='1',name = 'femn')
d = dict([('name','femn'),('age',18)])
u = dict({'love':'sport'},**d) 
for l in d.items() 
# 将字典中所有项以列表的方式返回,但返回时并没有特定的次序(dict_items)
for k,v in d.items()
d.iteritmes() # 返回的是一个迭代器对象,而不是列表.
d.keys()
# 将字典中所有的K(dict_keys),以列表形式返回d.values() (dict_values)
d.iterkeys() # 返回针对键的迭代器 d.itervalues()

典的基本操作

1
len(d) # 键值对的数量

到V

1
2
d['name'] # 返回k对应的v
d.get('name','femn')

修改V

1
d['name'] = 'femnyy'

删除 K-V

1
2
3
del d['name'] # 删除K为name的那一个项
d.pop('name') # 用来取得给定K的V,并将K-V移除.
d.clear() # 清除字典中所有的项

更新

1
2
3
4
5
6
7
d[x] = y 
# 若键x存在,则修改x对应的值为y,若键x不存在,则在字典d中增加键值对x:y
# 利用一个字典项更新另一个字典
d1.update(d) 
# 将字典x所有键值对添加到字典d中(不重复,重复的键值对用字典x中的键值对替代字典d中)
# update可以使用与调用dict函数(或者类型构造函数)同样的方式进行调用
# 这意味着update可以和映射,拥有键值对的队列(或者其它可迭代对象)以及关键字参数一起调用.

K in d # 检查d中是否含有键为K的项. v in l:# 查找列表的值,而不索引

1
d.has_key('name') # 返回True 或 False

键视图的一个很少被了解的特性就是它们也支持集合操作,比如集合并、交、差运算

1
2
3
4
5
6
a = {'x': 1,'y': 2,'z': 3}
b = {'w': 10,'x': 11,'y': 2}
a.keys() & b.keys()  # {'x', 'y'}
a.keys() - b.keys() # {'z'}
a.items() & b.items() # {('y', 2)}
{key: a[key] for key in a.keys() - ['z', 'w']} # {'y': 2, 'x': 1}

dict copy
copy 拷贝返回一个相同的字典,此处是 Java 中的浅拷贝
共用对象的引用,独立的基本类型的引用

1
2
3
4
5
6
7
x = {'username':'admin', 'machines':['foo', 'bar', 'baz']}
y = x.copy()
y['username'] = 'mlh'
y # {'machines': ['foo', 'bar', 'baz'], 'username': 'mlh'}
y['machines'].remove('bar')
y # {'machines': ['foo', 'baz'], 'username': 'mlh'}
x # {'machines': ['foo', 'baz'], 'username': 'admin'}

deepcopy 是深拷贝,有自己独立的存储空间

1
2
3
4
5
6
7
8
from copy import deepcopy
d={}
d['names'] = ['Alfred', 'Bertrand']
c = d.copy()
dc = deepcopy(d)
d['names'].append('Clive')
c # {'names': ['Alfred', 'Bertrand', 'Clive']}
dc # {'names': ['Alfred', 'Bertrand']}

迭代工具

zip():并行迭代,返回一个元组的列表,zip可以处理不等长的序列,当最短的序列用完的时候就会停止.

1
2
3
name = ['femn','femnyy','femnhh']
age = [18,25]
zip(name,age) # [('femn', 18), ('femnyy', 25)]

Share Comments