python——自定义序列类

关注
发布于: 2020 年 09 月 16 日
﻿
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-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]
﻿
生成器
将字典换成括号之后就是生成器了
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>
字典
my_dict = {"lizeyi":22,"like":21,"wukailin":5}
reversed_dict = {value:key for key,value in my_dict.items()}
将字典中的key和value进行翻转
集合推导式
下面的这个代码比起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'}