python 序列

python序列
序列基本概念：
python数据的集合总称序列，分为有序序列和无序序列两类；
有序序列包括：
    列表，元组，字符串
无序序列包括：
    字典，集合，控制集合数据的对象

一、列表

列表：python中是有序的、可变数据集合，使用一对标识[ ]；

#列表初始化语法
①li=[]

②li=list()

#1.列表的增、删、改、查、排、序

     #增

①list.append(obj)  添加 obj 对象到列表，返回None
#range 返回range对象，表示一个范围
x=range(5)#0-4范围
② list.extend(seq) 添加seq的内容到列表中
# extend(可序列化对象)
③ list.insert(index, obj) 插入 obj 对象到列表的 index 索引位置  *唯一不存在越界错误

例如：
x=list(range(3))
c=x.insert(0,3)
print(c,x)#None [3, 0, 1, 2]
x.insert(8,66)
x.insert(-8,44)#[44, 3, 0, 1, 2, 66]
#按下标查询元素，存在越界错误
print(x[5])#返回66

     #删

①list.pop(obj=list[-1]) 移除并返回列表中最后一个对象或 obj 对象
#从集合弹出最后个元素的值
#存在越界错误

② list.remove(obj) 从列表中移除 obj 对象，返回None
注意：
如果删除的内容不存在，报错；

③del 列表对象 或
del 列表对象[索引] 注意：索引从0开始，支持负数
#按索引删除指定位置的元素
#-1对应列表中的最后一个位置
del x[-1]  #返回[1,2,3]
#引用对象删除
del x

注意：
del指定索引，存在越界现象

python中当使用del删除引用对象，对象所引用的堆中对象形成垃圾，python中
使用标准库gc.collect()方法，手工回收垃圾；

      #改

①直接赋值 li[1]=1

      #查

① list.index(obj) 返回列表中 obj 对象对应最低索引值，如果找不到则报错(n is not in list)
② list.count(obj) 返回obj对象在列表中出现的次数

      #排序

① list.reverse() 倒转列表对象位置，返回None

② list.sort([func]) 排序列表的对象，如果给定请使用func比较

注意 sorted和sort区别？reverse和reversed区别？
 已知sort和convert在集合本事提供排序和反转的功能，列表对象本身提供sort和reverse方法；
 但是reversed和sorted是内置函数，经过反转和排序的原列表对象没有形成修改，这两个内置函数
 另个返回list_reverseiterator对象和排序的列表对象；

#具体局别在这个帖子里我有写

https://blog.csdn.net/joob000/article/details/81746959

#2.对列表的内置函数

① cmp(list1, list2) 比较两个列表中的元素
 python3中取消该函数
② len(list) 计算列表的长度

③ max(list) 从列表项中返回最大值

④ min(list) 从列表项中返回最小值

⑤ list(seq)转换一个元组为列表 ，返回转换后的列表对象

⑥ sum(可迭代对象)统计和

⑦ zip(可迭代对象A,可迭代对象B) 拉链操作

c=zip(lia,lib)
print(type(c),",",c)
#zip对象c是可迭代，转换list对象
li=list(c)
print(li) #[(1, 4), (2, 5)]

⑧ 枚举对象
例如：
li=list(range(3,6))
#列表转换枚举对象, 能够将单元素的集合按按索引与元素进行组合
me=enumerate(li)
print(list(me))#[(0, 3), (1, 4), (2, 5)]

#3.map、reduce、filter函数

① map函数
#map(函数或lambda,集合)，作用将集合中每一个元素以参数的形式传递给第一个函数并返回计算后结果，形成新集合Map对象；
#lambda是关键字 ，后面的x表示参数，参数之间使用逗号分隔；冒号后的表达式计算后返回的结果

#lambda表达式，无函数名称的函数，目标简化代码，和map函数结合更紧密；

②reduce函数

reduce函数将集合中元素从左到右依次累计操作
#[表达式 循环体] ----推导式
#reduce函数,集合中的值从左到右叠加处理
#python3中使用reduce之前需要导包

③filter函数

作用：
   通过将集合中每一个元素传递给第一个参数作为实参，如果函数计算后返回True，则将该元素
   存在filter对象中，否则舍弃该元素；
语法：
返回filter对象=filter(lambda表达式或函数,数据集)
注意：
函数和lambda表达式的参数个数是一个

④列表推导式
基本语法：
[表达式A for 变量 in 可迭代的对象 [if表达式]]
该列表推导式，将每次循环中表达式A，通过if表达式的判断返回True之后（如果有if表达式），
将表达式A存储到列表中；

#4.切片

4 切片语法：（有人觉得切片很复杂，这里我给出一种简单的记法）
序列对象[起始索引:结束索引]，返回起始索引:结束索引的数据集合
序列对象[起始索引:结束索引:步长]，返回起始索引:结束索引没有指定步长的数据集合

特点：1.第一个冒号左边值比右边值大（真实位置坐标）那么步进就要小于0，反之。

          2.下标不能越界，左不填默认负无穷，右不填默认正无穷，步长默认1

          3.步长不为1时，切片的替换列表个数，与所切的数据的个数相同，否则报错

           # li[::2]=[5,6]
           # 结果：[5, 2, 6, 4]
           li[::]=[8,9,10,11,12]
           #结果：[8, 9, 10, 11, 12]

二、元组        

元组概念
在python中元组使用一对英文小括号扩住，元素使用英文逗号分隔；元素本身不能改变的;
元组初始化：
注意：有空元组、元组中的元素必须有逗号分隔、内置方法tuple

元组支持使用del删除元组引用对象；

元组支持切片中查询操作；

#li返回range对象
# li=tuple(range(5))
# print(li)
li=(8,[1,2],9)
print(li)
li[1].append(88)
print(li)
#试图修改元素的第二个元素的值，元组中的元素不能修改
li[1]=9
#正确的
li[1][::]=[6,9,7,12]
print(li)

三、字典

概念：
使用一对英文大括号标识，元素中间使用英文逗号，元素包括key和value，其中键使用
不可变类型(例如，整数、字符串、元组等，不能是列表)，key和value之间使用冒号分割；
key不能重复的；

1.字典的定义

#定义字典对象
d={1:["中华","玉溪"],(2,):["五粮液","茅台","郎酒"],1:["蓝带","百威","青岛"]}
# <class 'dict'> {1: ['蓝带', '百威', '青岛'], (2,): ['五粮液', '茅台', '郎酒']}
print(type(d),d)

#定义空字典
d2={}

#通过dict内置函数，得到字典
xli=("中华","一汽","奇瑞")
yli=[["尊驰","骏捷","V5"],["迈腾","速腾"],["QQ","路虎"]]
z=zip(xli,yli)
print(type(z),z)
#通过dict函数将zip对象转换成字典对象
d3=dict(z)
# {'中华': ['尊驰', '骏捷', 'V5'], '一汽': ['迈腾', '速腾'], '奇瑞': ['QQ', '路虎']}
print(d3)

2.字典增删改查（默认遍历key）

#添加
①d[key]

②update（{字典对象}）

③setdefault（key，value）不存在则添加 存在则查询 返回值是value

#删除

①#pop、popitem和通过key获取value的区别？
pop()方法按key获取对应value，并从字典中删除该key-value；
popitem()方法弹出最后一对key-value，并从字典中删除该key-value；
pop()和popitem()当找不到要删除的key时报错；

②#按key一对数据删除

③#del删除引用对象

#查询

A：fromkey，创建值为None的字段对象

B：get方法，获取key对应的值，如果key不存在，返回默认值

C：从字典集合中获取key      默认遍历key

D: 迭代字典项目    .items()

E: 获取字典对象的key集合    .keys()

F：获取字典对象的values部分    .values()

扩展：
使用使用collections包中defaultdict对象
例
#导入包
from collections import defaultdict
#生成defaultdict
d=defaultdict(int)
#d['B']如果key不存在，在自动添加key-value  ('B':0)，
d['B']+=8
print(d['B'])
	
统计字符出现的最多次数？
#导入Counter
from collections import Counter
#通过字符串实例化Counter对象
co=Counter(mres)
# print(type(co),co)
# 遍历Counter对象
for it in co.items():
    print(it)
#通过出现次数最多的字
v=co.most_common(3)
print(v)

四、集合

概念：
   无序可变序列，使用一对大括号，集合中的元素不能重复，每个集合元素使用逗号分隔；① 初始化

x={1,3,5,7,9,5}
#输出结果：<class 'set'> {1, 3, 5, 7, 9}
print(type(x),x)
# 初始化集合对象

# y={range(6)}
# # <class 'set'> {range(0, 6)} 1
# print(type(y),y,len(y))
#可以使用set内置函数，将可序列化的对象转换集合对象
y=set(range(6))
#<class 'set'> {0, 1, 2, 3, 4, 5} 6
print(type(y),y,len(y))

注意：
集合中每个元素除了不能重复外，元素类型不能使用可变集合(列表、字段和集合)；
在python规定不能使用hash()函数计算hash值的数据，都不能作为集合的元素；

② 针对for..in, 列表比集合和字典遍历慢
原因是集合和字典元素存储使用hash获取元素

例:
import random
import time
x=[random.randint(1,10000) for i in range(8000)]
y={random.randint(1,10000) for i in range(8000)}
t1=time.time();
for i in x:
    print(i)
t2=time.time();

③ set集合添加方法
 add(添加单个元素)
 update(另一个set集合)

例：
s={3}
# <class 'set'> {3}
print(type(s),s)
#add方法添加单元素
s.add(88)
s.add(6)

#update方法
y={"下","月","顶"}
s.update(y)

④ 集合删除
pop弹出并返回集合中的随机一个元素，如果集合为空，则报错；
remove方法从集合中删除对应的元素，如果元素不存在，则报错；
discard从集合中删除对应的元素，如果元素不存储则忽略

例：
h=set("1230456789704561")
print(h)
#pop弹出并返回集合中的第一个元素，如果集合为空，则报错；
p=h.pop()
print(p,h)
#remove方法从集合中删除对应的元素，如果元素不存在，则报错
v=h.remove("81")
print(v,h)
# discard从集合中删除对应的元素，如果元素不存储则忽略
v=h.discard('8')
h.discard(8)
print(h)