写点什么

python——自定义序列类

发布于: 2020 年 09 月 16 日
python——自定义序列类



a = [1,2]
c = a+[3,4]
a += (3,4)
print(a)

代码块中的就地相加+=他是可以迭代不同类型的,从源码里面的细节我们可以看到

+=和extend效果一样,而且extend是没有返回值。接着对比一下append方法

a = [1,2]
c = a+[3,4]
a += (3,4)
a.extend((5,6))
a.append((5,6))
print(a)

其中append里面只可以添加一个元素内容,不可以append(5,6)这样的操作;

运行结果是:[1, 2, 3, 4, 5, 6, (5, 6)]




可切片编程

模式[start:end:step]

其中,第一个数字start表示切片开始位置,默认为0;

第二个数字end表示切片截止(但不包含)位置(默认为列表长度);

第三个数字step表示切片的步长(默认为1)。

当start为0时可以省略,当end为列表长度时可以省略,

当step为1时可以省略,并且省略步长时可以同时省略最后一个冒号。

另外,当step为负整数时,表示反向切片,这时start应该比end的值要大才行。



#模式[start:end:step]
"""
其中,第一个数字start表示切片开始位置,默认为0;
第二个数字end表示切片截止(但不包含)位置(默认为列表长度);
第三个数字step表示切片的步长(默认为1)。
当start为0时可以省略,当end为列表长度时可以省略,
当step为1时可以省略,并且省略步长时可以同时省略最后一个冒号。
另外,当step为负整数时,表示反向切片,这时start应该比end的值要大才行。
"""
aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
print (aList[::]) # 返回包含原列表中所有元素的新列表
print (aList[::-1]) # 返回包含原列表中所有元素的逆序列表
print (aList[::2]) # 隔一个取一个,获取偶数位置的元素
print (aList[1::2]) # 隔一个取一个,获取奇数位置的元素
print (aList[3:6]) # 指定切片的开始和结束位置
aList[0:100] # 切片结束位置大于列表长度时,从列表尾部截断
aList[100:] # 切片开始位置大于列表长度时,返回空列表
aList[len(aList):] = [9] # 在列表尾部增加元素
aList[:0] = [1, 2] # 在列表头部插入元素
aList[3:3] = [4] # 在列表中间位置插入元素
aList[:3] = [1, 2] # 替换列表元素,等号两边的列表长度相等
aList[3:] = [4, 5, 6] # 等号两边的列表长度也可以不相等
aList[::2] = [0] * 3 # 隔一个修改一个
print (aList)
aList[::2] = ['a', 'b', 'c'] # 隔一个修改一个
aList[::2] = [1,2] # 左侧切片不连续,等号两边列表长度必须相等
aList[:3] = [] # 删除列表中前3个元素
del aList[:3] # 切片元素连续
del aList[::2] # 切片元素不连续,隔一个删一个

运行结果分别是:

[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

[3, 5, 7, 11, 15]取偶数位置的数字

[4, 6, 9, 13, 17]取奇数位置的数字

[6, 7, 9]

[0, 2, 0, 4, 0, 6]一个隔一个位置换为0

在第三个位置开始和第三个位置结束aList[3:3] = [4]




实现切片操作的对象

class Group:
# 支持切片操作
def __init__(self,group_name,company_name,staffs):
self.group_name = group_name
self.company_name = company_name
self.staffs = staffs
def __reversed__(self):
pass
def __getitem__(self, item):
return self.staffs[item]
def __len__(self):
pass
def __iter__(self):
pass
def __contains__(self, item):
pass
staffs = ["wukailin","imooc","lizeyi","python"]
group = Group(company_name="imooc",group_name="user",staffs = staffs)
sub_group = group[:2]
print(sub_group)
pass

sub_group = group[:2]从0开始到第二个位置之前(不包括第二个位置)只含 0 和1

但是是切出来是list对象不是group

从源头发现主要是在item里面已经是silce的切片对象

def getitem(self, item):

return self.staffs[item]

如何将其变成group类型呢,则需要在__getitem__魔法函数中做变化

import numbers
class Group:
# 支持切片操作
def __init__(self,group_name,company_name,staffs):
self.group_name = group_name
self.company_name = company_name
self.staffs = staffs
def __reversed__(self):
self.staffs.reverse()
def __getitem__(self, item):
# 通过该方法编程可切面对象
cls = type(self)#取到当前的class
if isinstance(item,slice):
return cls(group_name=self.group_name,company_name=self.company_name,staffs = self.staffs[item])
elif isinstance(item,numbers.Integral):
return cls(group_name=self.group_name,company_name=self.company_name,staffs = [self.staffs[item]])
def __len__(self):
return len(self.staffs)
def __iter__(self):
# 迭代器
return iter()
def __contains__(self, item):
if item in self.staffs:
return True
else:
return False
staffs = ["wukailin","imooc","lizeyi","python"]
group = Group(company_name="imooc",group_name="user",staffs = staffs)
sub_group = group[:1]
print(sub_group)
pass

sub_group = group[:1]是选取的Group里面的一个类型数据,就会调用到[0,1)范围内,选择0为item。并且观察他的类型为切片对象(none, 1,none) start:none ,step:none,stop:1,把其对象改为group;最后让sub_group取出来的对象是一个Group的对象






bisect维护已排序序列

import bisect
from collections import deque
#用来处理已排序的序列,用来维持已排序的序列, 升序
#二分查找
inter_list = deque()
bisect.insort(inter_list, 3)
bisect.insort(inter_list, 2)
bisect.insort(inter_list, 5)
bisect.insort(inter_list, 1)
bisect.insort(inter_list, 6)
print(bisect.bisect_left(inter_list, 3))
#学习成绩
print(inter_list)






array使用方法

与list不同的是array是只能存放指定的数据类型。在此,我们需确定类型码,可以是i,这样指定了int类型如果添加了str则报错。





import array
my_array = array.array("i")
my_array.append(1)




三大推导式:列表、生成器和字典

  1. 列表生成式

提取出1-20之间的奇数

odd_list = []
for i in range(21):
if i%2 == 1:
odd_list.append(i)

在上述代码中可以将内容进行替换

即可以用这个odd_list = [i for i in range(21) if i%2 ==1]代替

遇到较为复杂情况时

def handle(item):
item*item
odd_list = [handle(i) for i in range(21) if i%2 ==1]



  1. 生成器

将字典换成括号之后就是生成器了

odd_list = (i for i in range(21) if i%2 ==1)
print(type(odd_list))
print(odd_list)

<class 'generator'>

<generator object <genexpr> at 0x000001B4E4A04348>

  1. 字典

my_dict = {"lizeyi":22,"like":21,"wukailin":5}
reversed_dict = {value:key for key,value in my_dict.items()}

将字典中的key和value进行翻转

  1. 集合推导式

下面的这个代码比起my_set = set(my_dict.items())会更加灵活

my_set = {key for key,value in my_dict.items()}
print(type(my_set))
print(my_set)

<class 'set'>

{'wukailin', 'like', 'lizeyi'}

发布于: 2020 年 09 月 16 日阅读数: 41
用户头像

一个孤独的撰写者 2020.07.30 加入

主攻云计算、云安全,c++、python、java均有涉猎

评论

发布
暂无评论
python——自定义序列类