六、自定义序列类

一、python中的序列分类

​​

二、python中序列类型的abc继承关系

在Python中，序列类型的ABC（Abstract Base Classes）继承关系如下：
1.Iterable（可迭代的）：定义了__iter__()​方法，表示对象可以被迭代。
-Collection（集合）：继承自Iterable，定义了__contains__()​方法，表示对象可以使用in​操作符进行成员检测。
-Container（容器）：继承自Collection，定义了__len__()​方法，表示对象具有长度。
2.Sequence（不可变序列）：继承自Iterable，定义了__getitem__()​和__len__()​方法，表示对象可以按索引访问和具有长度。
-MutableSequence（可变序列）：继承自Sequence，定义了可变序列的操作方法，如__setitem__()​和__delitem__()​。
3.ByteString（字节序列）：定义了字节序列的操作方法，如__getitem__()​和__len__()​。
4.Set（集合）：定义了集合的操作方法，如__contains__()​和__len__()​。
5.Mapping（映射）：定义了映射的操作方法，如__getitem__()​和__len__()​。
这些ABC定义了序列类型应该具有的基本行为和方法，可以帮助开发者编写符合规范的序列类型，并且可以方便地进行类型检查和类型推断。

三、list中extend方法区别

1.extend()方法是用于将一个可迭代对象中的元素添加到列表中，而不是将整个可迭代对象作为一个元素添加到列表中。例如，如果有一个列表a=[1,2,3]和一个元组b=(4,5,6)，使用extend()方法将b中的元素添加到a中，结果为a=[1,2,3,4,5,6]。
2.extend()方法不会创建新的列表，而是直接在原列表上进行操作，将新元素添加到原列表中。
3.extend()方法可以接受任何可迭代对象作为参数，包括列表、元组、集合等。
4.extend()方法没有返回值，它只是在原列表上进行操作，将新元素添加到原列表中。

from collections import abc

a = [1,2]

# a = a +(3,4)
# print(a)
# #TypeError: can only concatenate list (not "tuple") to list

a += (3,4)  #实际上执行的为 __iadd()__ 方法，入参是个可迭代的对象
print(a)

b = (5,6)
a.extend(b) #入参是迭代器，for in 方法将元素进行添加到原list中
print(a)

a.append((7,8))
print(a)

# [1, 2, 3, 4]
# [1, 2, 3, 4, 5, 6]
# [1, 2, 3, 4, 5, 6, (7, 8)]

四、实现可切片的对象

import collections.abc
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

    # in 关键字
    def __contains__(self, item):
        if item in self.staffs:
            return True
        return False

    def __len__(self):
        return len(self.staffs)

    # 实现翻转
    def __reversed__(self):
        self.staffs.reverse()

    def __getitem__(self, item):
        cls = type(self) #根据实例对象找到类
        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): #int函数
            return cls(group_name=self.group_name, company_name=self.company_name, staffs=[self.staffs[item]])

    def __str__(self):
        return "group_name:{},company_name:{},staffs:{}".format(self.group_name,self.company_name,",".join(self.staffs))

if __name__ == '__main__':
    staffs = ["zhangsan","lisi","wangwu"]
    group = Group(group_name="组名",company_name="慕课网",staffs=staffs)
    sub_group = group[1:]  #需要返回新元素
    print(sub_group)  #group_name:组名,company_name:慕课网,staffs:lisi,wangwu

    sub_group2 = group[0]
    print(sub_group2) #group_name:组名,company_name:慕课网,staffs:zhangsan


    reversed(group)
    for item in group:
        print(item)
    # group_name: 组名, company_name: 慕课网, staffs: wangwu
    # group_name: 组名, company_name: 慕课网, staffs: lisi
    # group_name: 组名, company_name: 慕课网, staffs: zhangsan

    print(len(group))

五、bisect维护已排序序列

bisect模块主要用于在有序序列中进行二分查找，找到插入位置并保持序列有序。它的使用场景包括但不限于：
1.在有序列表中查找特定元素的插入位置，以便将元素插入到正确的位置。
2.在有序列表中查找某个元素是否存在。
3.在有序列表中查找最接近某个值的元素。
4.在有序列表中查找第一个大于或等于某个值的元素。
5.在有序列表中查找第一个小于或等于某个值的元素。
总的来说，bisect模块适用于需要在有序序列中进行高效查找和插入操作的场景。

六、什么时候我们不该使用列表

#array,deque
#数组
import array
#array.和1st的一个重要区别，array只能存放指定的数据类型
my_arrayarray.array("i")  #指定存储的类型
my_array.append(1)
my_array.append("abc") #报错，不允许存储字符串

七、列表推导式、生成器表达式、字典推导式

列表推导式 (列表生成式性能高于列表操作)

list = [1,2,3,4,5,6,7,8,9,10]
odd_list = []
for item in list:
    if item % 2 == 1:
        odd_list.append(item)

print(odd_list)

odd_list = [item for item in list if item % 2 ==1]
print(odd_list)

def handle(item):
    return item * item
result_list = [handle(item) for item in list if item % 2 ==1]
print(result_list)

生成器表达式

#生成器表达式
odd_gen =(i for i in range(21) if i%2 == 1)
print(type(odd_gen))
odd_list = list(odd_gen)
print(type(odd_list))
print(odd_list)

字典推导式

#字段推导式
my_dict = { "key1": 11, "key2": 22, "key3":33}
my_dict_reverse = {value:key for key,value in my_dict.items()}
print(my_dict_reverse)

#集合推导式
my_set = set(my_dict.keys())
print(my_set)
my_set = {key for key,value in my_dict.items()}
print(my_set)