LearnPython--Day03

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'``}`