LearnPython–Day03@TOC
序列
序列是一种数据存储方式,用来存储一系列的数据。在内存中,序列就是一块用来存储多个值的连续的内存空间。
系列中存储的是对象的地址,而非值。
常用的序列结构有:字符串,列表,元组,字典,集合
列表简介
列表:用于任意数目,任意类型的数据集合。
列表是内置可变序列,是包含多个元素的连续内存空间
列表的常用方法:
序号 | 函数 |
---|---|
1 | cmp(list1, list2) 比较两个列表的元素 |
2 | len(list) 列表元素个数 |
3 | max(list) 返回列表元素最大值 |
4 | min(list) 返回列表元素最小值 |
5 | list(seq) 将元组转换为列表 |
6 | sum(list)将列表中数字求和,若列表中元素为数值则求和,若为非数值则报错。 |
序号 | 方法 |
---|---|
1 | list.append(obj) 在列表末尾添加新的对象 |
2 | list.count(obj) 统计某个元素在列表中出现的次数 |
3 | list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) |
4 | list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 |
5 | list.insert(index, obj) 将对象插入列表 |
6 | [list.pop(index=-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值 |
7 | list.remove(obj) 移除列表中某个值的第一个匹配项 |
8 | list.reverse() 反向列表中元素 |
9 | list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序, cmp–可选参数, 如果指定了该参数会使用该参数的方法进行排序。 key–主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。 reverse – 排序规则,reverse = True 降序, reverse = False 升序(默认)。 |
10 | list.sorted(cmp=None, key=None, reverse=False)] 对原列表进行排序,返回新列表,不对原列表进行修改 |
Python列表大小可变,根据需要增加或缩小。
列表中删除或添加元素实质是元素的拷贝,即所删除(添加)的元素之后的元素依次往前(往后)拷贝移动。
列表的创建
基本语法[]创建
a = [],即创建一个空列表。
list()创建
使用list()可将任何可迭代的数据转化成列表。
a = list(range(3)) ==> a ==> [0,1,2]
range()生成整数列表
语法格式:range([star,]end[,step])
star参数:可选,表示起始数字,默认为0.
end参数:必选,表示终止数字。
step参数:可选,表示步长,默认为1。
python3中range()返回的是一个range的对象,而不是列表,需要通过list()将其转换成列表。
推导式生成列表(详见for循环部分)
循环创建多个元素:a = [x*2 for x in range(5)] ==> a ==> [0,2,4,6,8]
通过if过滤元素:
a =[x*2 for x in range(100) if x%9 == 0] ==> a ==> [0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]
关于列表的应用:
1.去除列表中的重复元素
a = [1,1,2,2,3,3,4,4,5,5,6,6]
b = list(set(a))
print(b)
a = [1,1,2,2,3,3,4,4,5,5,6,6]
b = []
for i in a:
if i not in b:
b.append(i)
print b
2.将二维列表转换成一维列表
a = [[1,2,3], [4,5]]
b = [n for c in a for n in c ]
print(b)
a = [[1,2,3], [4,5]]
print(sum(a,[]))
a = [[1,2,3], [4,5]]
result=[]
for c in a:
for n in c:
result.append(n)
print(result)
元组
Python的元组与列表类似,不同之处在于元组的元素不能修改,所以没有增加,删除,修改元素的方法。
元组使用小括号,列表使用方括号。
元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。
元组的创建
-
通过()创建小括号可以省略。
a = (20,30,40) 或者 a = 20,30,40
如果元组中只有一个元素,则其后必须加逗号,因为解释器会将(1)理解为整数1,将(1,)理解为元组。
-
通过tuple()创建元组
tuple(可迭代的对象)
-
生成器推导式创建元祖(只能访问一次,第二次就成空了,需要再次生成)
与列表推导式类似,只是生成器推导式使用的是小括号。列表推导式生成的是列表,生成器推导式生成的不是列表也不是元组,而是一个生成器对象,再将该对象转换成想要的形式,或者使用_ next _()方法进行遍历。
zip(将多个列表对应位置的元素组合成为元组)
a = [20,30] b = [50,60] c = [80,90] ==> d = zip(a,b,c) ==> list(d) ==> [(20,50,80),(30,60,90)]
tips:和整数,字符串一样,元组也可以作为字典的键,列表则不能。
字典
Python字典是另一种可变容器模型,且可存储任意类型对象,如字符串、数字、元组等其他容器模型。
字典的创建
字典由键和对应值成对组成。字典也被称作关联数组或哈希表。基本语法如下:
-
通过{},dict{}创建
a = {‘Alice’: ‘2341’, ‘Beth’: ‘9102’, ‘Cecil’: ‘3258’}
dict = {‘Alice’: ‘2341’, ‘Beth’: ‘9102’, ‘Cecil’: ‘3258’}
-
通过zip()创建
a =['dict','cuple','list'] b = [6,7,8] c = dict(zip(a,b)) print(c) {'list': 8, 'dict': 6, 'cuple': 7}
-
通过fromkeys创建值为空的字典:
a =['dict','cuple','list'] print(dict.fromkeys(a)) {'dict': None, 'cuple': None, 'list': None}
注意:
每个键与值用冒号隔开(:),每对用逗号,每对用逗号分割,整体放在花括号中({})。
键必须独一无二,但值则不必。
值可以取任何数据类型,但必须是不可变的,如字符串,数或元组。
字典的访问
1.通过键获得值,若键不存在则抛出异常。
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print ("dict['Name']")
Zara
2.通过get()方法获得值,优点为指定键不存在返回None,也可指定默认返回对象:
a = {‘dict’: 6, ‘list’: 8, ‘cuple’: 7} > a.get(‘dict’)>6
a = {‘dict’: 6, ‘list’: 8, ‘cuple’: 7} ==> a.get(‘str’,‘不存在’) ==> 不存在
3.列出所有的键值对:items()
a = {‘dict’: 6, ‘list’: 8, ‘cuple’: 7} ==> a.items() ==> dict_items([(‘dict’, 6), (‘cuple’, 7), (‘list’, 8)])
4.列出所有键,所有值:
a.keys()/a.values() ==> dict_keys([‘dict’, ‘list’, ‘cuple’]) / dict_values([6, 8, 7])
5.len()键值对的个数
6.检测一个键是否在字典中:
‘dict’ in a ==> True
修改字典
**1.**给字典新增键值对,如果键已存在,则覆盖旧的键值对,若键不存在,则添加新的键值对。
**2.**使用update()将新字典中所有键值对全部添加到旧的字典对象中,如果key有重复,则直接覆盖。
**3.**字典中元素的删除,可以使用del()方法,或者clean()方法删除所有键值对,pop()返回指定键值对并返回对应的值对象。
**4.**popitem():随机删除和返回该键值对。
字典方法的应用:
将字典中的键与值互换
mydict={"a":1,"b":2,"c":3}
mydict_new={}
for key,val in mydict.items():
mydict_new[val]=key
print(mydict_new)
mydict={"a":1,"b":2,"c":3}
mydict_new=dict([val,key] for key,val in mydict.items())
print(mydict_new)
mydict={"a":1,"b":2,"c":3}
mydict_new=dict(zip(mydict.values(),mydict.keys()))
print(mydict_new)
序列解包
可用于元组,列表,字典,方便于对多个变量赋值。
(x,y,z) = (1,2,3) / [x,y,z] = [1,2,3] ==> x ==> 1
序列解包用于字典时默认是对键进行操作,若要对键值对操作,则用items(),若对值操作,则用values()。
a = {'dict': 6, 'list': 8, 'cuple': 7}
dict,list,cuple = s
dict
'dict' #默认对键操作
dict,list,cuple = s.itmes()
dict
{'dice',6} #对键值对操作
dict,list,cuple = s.values()
dict
6 #对值操作
Python字典包含了以下内置函数:
cmp(dict1, dict2) #比较两个字典元素。
len(dict) #计算字典元素个数,即键的总数。
str(dict) #输出字典可打印的字符串表示。
type(variable) #返回输入的变量类型,如果变量是字典就返回字典类型。
Python字典包含了以下内置方法:
radiansdict.clear() #删除字典内所有元素
radiansdict.copy() #返回一个字典的浅复制
radiansdict.fromkeys() #创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
radiansdict.get(key, default=None) #返回指定键的值,如果值不在字典中返回default值
radiansdict.has_key(key) #如果键在字典dict里返回true,否则返回false
radiansdict.items() #以列表返回可遍历的(键, 值) 元组数组
radiansdict.keys() #以列表返回一个字典所有的键
radiansdict.setdefault(key, default=None) #和get()类似, 但如果键不已经存在于字典中,将会添 加键并将值设为default
radiansdict.update(dict2) #把字典dict2的键/值对更新到dict里
radiansdict.values() #以列表返回字典中的所有值
用法总结:
1.键必须可散列:
(1)数字,字符串,元组,都是可散列的
(2)自定义对象需要支持以下三点:
- 支持hash()函数
- 支持通过_ eq _()方法检测相等性
- 若a == b 为真,则hash(a) == hash(b)以为真。
2.字典在内存中开销巨大,典型的空间换时间
3.键查询速度很快
4.往字典里添加新建可能导致扩容,导致散列表中键的次序变化。因此,不要在遍历字典的同时修改字典。
集合
集合是无序可变的,元素不能重复,集合底层是字典的实现,集合的所有元素都是字典中的’键对象‘,因此是不重复且唯一的。
集合内置方法完整列表
方法 | 描述 |
---|---|
add() | 为集合添加元素 |
clear() | 移除集合中的所有元素 |
copy() | 拷贝一个集合 |
difference() | 返回多个集合的差集 |
difference_update() | 移除集合中的元素,该元素在指定的集合也存在。 |
discard() | 删除集合中指定的元素 |
intersection() | 返回集合的交集 |
intersection_update() | 删除集合中的元素,该元素在指定的集合中不存在。 |
isdisjoint() | 判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。 |
issubset() | 判断指定集合是否为该方法参数集合的子集。 |
issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
pop() | 随机移除元素 |
remove() | 移除指定元素 |
symmetric_difference() | 返回两个集合中不重复的元素集合。 |
symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。 |
union() | 返回两个集合的并集 |
update() | 给集合添加元素 |
子集
子集,为某个集合中一部分的集合,故亦称部分集合。
使用操作符 <
执行子集操作,同样地,也可使用方法 issubset() 完成。
`>>> A ``=` `set``(``'abcd'``)``>>> B ``=` `set``(``'cdef'``)``>>> C ``=` `set``(``"ab"``)``>>> C < A``True` `# C 是 A 的子集``>>> C < B``False``>>> C.issubset(A)``True`
并集
一组集合的并集是这些集合的所有元素构成的集合,而不包含其他元素。
使用操作符 |
执行并集操作,同样地,也可使用方法 union() 完成。
`>>> A | B``{``'c'``, ``'b'``, ``'f'``, ``'d'``, ``'e'``, ``'a'``}``>>> A.union(B)``{``'c'``, ``'b'``, ``'f'``, ``'d'``, ``'e'``, ``'a'``}`
交集
两个集合 A 和 B 的交集是含有所有既属于 A 又属于 B 的元素,而没有其他元素的集合。
使用 &
操作符执行交集操作,同样地,也可使用方法 intersection() 完成。
`>>> A & B``{``'c'``, ``'d'``}``>>> A.intersection(B)``{``'c'``, ``'d'``}`
差集
A 与 B 的差集是所有属于 A 且不属于 B 的元素构成的集合
使用操作符 -
执行差集操作,同样地,也可使用方法 difference() 完成。
`>>> A ``-` `B``{``'b'``, ``'a'``}``>>> A.difference(B)``{``'b'``, ``'a'``}`
对称差
两个集合的对称差是只属于其中一个集合,而不属于另一个集合的元素组成的集合。
使用 ^
操作符执行差集操作,同样地,也可使用方法 symmetric_difference() 完成。
`>>> A ^ B``{``'b'``, ``'f'``, ``'e'``, ``'a'``}``>>> A.symmetric_difference(B)``{``'b'``, ``'f'``, ``'e'``, ``'a'``}`