Python内置数据结构:列表、元组、字符串、集合、字典
列表:
一种容器类型。列表可以包含任何种类的对象,比如说数字、子串、嵌套其他列表、嵌套元组。
任意对象的有序集合,通过索引访问其中的元素。其长度可变,支持异构(在一个列表中可以包含多种不同类型的元素),可以任意嵌套。
列表是可变对象,支持在原处修改。列表的可变变现在其内部的每一个元素存储在列表中不是对象本身,而是对象的引用。因此其修改的是对象的引用。
1. 初始化list(),里面可以什么都不放,也可以放可迭代对象。
2. 下标/索引操作:
python中list的索引从0开始。绝大多数语言的下标是从0开始的。
负数的索引表示从后往前数,由-1开始,-1表示最后一个元素。
3. 列表的操作
1.增:
append():原地修改list,给list最后增加一个元素,返回值是None。时间复杂度是O(1)
extend():时间复杂度是O(n),这个n是可迭代对象的长度,并不是原有list的长度n。
insert():insert方法操作的索引超出范围时,如果是正索引,等效于append,如果是负索引,等效于insert(0, object)。insert的时间复杂度是O(n),append的时间复杂度是O(1)。因为insert是要做一个遍历的。
删:
clear():clear方法删除列表的所有元素。
pop():可以传入index,默认从最后移除一个元素,并且把这个元素返回回来。
remove():
pop是弹出索引对应的值,remove是删除最左边的一个值。
想删最后一个,可以reverse一下,然后remove,再然后reverse回去
pop针对的是索引,remove针对的是值。
pop和remove的时间复杂度都是O(n)
改:
reverse(): in place
sort():直接修改List in place
查:
count():指定的value在list中出现的次数
注:这里增加一个python内置方法:len():用于检查List元素个数。并不仅仅是针对List,可以针对很多对象。
index():根据值查找索引
其他:
copy():
成员关系的判断:
in
not in
举例:去除list中的重复元素
列表相加:
合并两个列表,生成了一个新列表。不会修改原列表。这个和子串的相加是一样的,生成新的子串。
序列相乘:就是重复元素多次。都是生成新对象。
子串乘法:
列表乘法:
切片:切片函数原型,用C实现的,底层速度特别快
切片[::]通常是用来访问数据的,如果你对切片赋值的话,产生的结果是不可预料的。切片操作总是返回一个新的list,不会改变原有的list seq[start, end] [start, end)
如果想获取到最后一个元素,省略end
以上都是从左往右切片,所以左边的数字要小于右边的数字。
start超出索引范围从0开始,end超出索引范围到到len(lst)结束。
start为0时可以省略,end省略表示打印到最后一个元素,start和end都省略就是copy。
切片还有一个第3个参数:step,默认是1
当step为负数的时候,从后往前数,此时start应该大于end,否则返回空列表。
List[::-1] 反转一个链表
Lst[0::2] 求list中偶数下标的元素 从0开始到结束,step=2
Lst[1::2] 求lst中奇数下标的元素 从1开始到结束,step=2
切片赋值
对切片赋值,会替换切片原来的元素。
通常我们是不会对切片进行赋值的,会造成很多的误解。
5. 解包/封包
a, b = b, a
最简单的解包就是如下:把右边的元组或者列表(可迭代对象都行)解开成了左边的两个变量,这种就是解包.网络编程中url的获取
封包就是把一组变量,变成元组。把若干变量或常量封装到一个变量里,这就是封包。
解包是把集合里的元素赋值给变量(集合可以是可迭代对象),赋值完的变量要么是一个值,要么是个list,而不管右侧集合是列表还是元组。
封包是把变量构建成元组
只要两边结构是一样的,解包多少层都是可以的
只要两边结构是一样的,解包多少层都是可以的只要两边结构是一样的,解包多少层都是可以的
tuple 元祖 ()
tuple是另一种有序的列表,中文翻译为“ 元组 ”。tuple 和 list 非常类似,但是,tuple一旦创建完毕,就不能修改了。相当于只读的list。
创建包含1个元素的 tuple,防止歧义:t = (1,)
tuple一开始指向的list并没有改成别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向’a’,就不能改成指向’b’,指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的
t = ('a', 'b', ['A', 'B'])
L = t[2]
L[0] = 'X'
L[1] = 'Y'print t
t元祖就变成了 (’a’,’b’,[‘X’,’Y’])
元组的遍历
t = (("apple","banana"),("grape","orange"),("watermelon",))for i in range(len(t)):
print("t[%d]:"%i),
for j in range(len(t[i])):
print(t[i][j]),
或for i in t:
for j in i:
print j
dict 字典 {}
dict的作用是建立一组 key 和一组 value 的映射关系,dict的key是不能重复的。
dict的 特点:
查找速度快,无论dict有10个元素还是10万个元素,查找速度都一样。而list的查找速度随着元素增加而逐渐下降。(缺点是占用内存大,还会浪费很多内容)
存储的key-value序对是没有顺序的
作为 key 的元素必须不可变
for key in d:
print key,':',d[key]
删除
del(dict(key))
dict.pop(key)
获得value
dict[key]
dict.get(key,novalue) #不存在返回novalue
更新,相当于合并
dict.update(dict2)
创建新元素
dict.setdefault(key,value)
复制
import copy
dict = {}
普通拷贝
m = dict.copy()
浅拷贝,b变化则a变化
b = copy.copy(dict)
深拷贝,不会随之变化
c =copy.deepcopy(dict)
迭代dict的value
d{}
d.values()
d.itervalues()
values() 方法实际上把一个 dict 转换成了包含 value 的list。
但是 itervalues() 方法不会转换,它会在迭代过程中依次从 dict 中取出 value,所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。
打印 itervalues() 发现它返回一个 <\dictionary-valueiterator> 对象
同时迭代 key和value
d.items()
set
set 持有一系列元素,这一点和 list 很像,但是set的元素没有重复,而且是无序的,这点和 dict 的 key很像,必须是不变对象。
由于set存储的是无序集合,所以我们没法通过索引来访问。
访问 set中的某个元素实际上就是判断一个元素是否在set中。
s = set(['Adam', 'Lisa', 'Bart', 'Paul'])for name in s:
print name'Bart' in s
返回True
更新set
s.add()
s.remove()
给定一个list,对list中的每一个元素,如果在set中,就将其删除,如果不在set中,就添加进去。
s = set(['Adam', 'Lisa', 'Paul'])
L = ['Adam', 'Lisa', 'Bart', 'Paul']for i in L:
if i in s:
s.remove(i)
continue
else:
s.add(i)
print s