python学习总结

列表的使用情况：

enumerate（）

重新定义排序：

        #重载比较大小

        cmp = lambda a, b: 1 if a + b > b + a else -1

        #排序

        nums.sort(key = functools.cmp_to_key(cmp))

集合的使用：

创建集合： a = set()

字典的使用情况：

创建字典

set = dict()

set.item()   set.key()   set.value()  

 mp.get(pre, 0)：尝试从字典 mp 中获取键为 pre 的值，如果该键存在，则返回其对应的值；如果不存在，则返回默认值0。

字典表达式：

这个的意思就是k还是原来的k，但是v都合并了。然后sum里面的空列表是防止出现v没有的情况

 concatenated_examples = {k: sum(examples[k], []) for k in examples.keys()}

• set 是一种无序的集合数据结构，它用于存储不重复的元素。集合中的元素不按顺序排列，并且每个元素在集合中只能出现一次。集合通常用于存储一组唯一的值。（这个会在自然语言处理邻域中，词汇表用到）

设置递归深度：

import sys

sys.setrecursionlimit(100000)

匿名函数的使用：

str ="".join((lambda x:(x.sort(),x)[1])(list(str)))

队列的使用：

import queue
queue.put()
queue.get()

切片的使用：

temp = temp[:-1]  #取除了最后一个

异常捕获

print('start')
try:
    print('step1')
    a = 3/0
    print('step2')
except BaseException as e :
    print('出错了')
    print(e)
print('end')

#结果会跳过异常捕获模块，继续执行
start
step1
出错了
division by zero
end

什么是闭包函数？

函数可以作为变量进行传入。

def f1(a):
    def inner(*args,**kargs):
        return a(*args,**kargs)
    return inner

def f(a,b):
    return a + b

func = f1(f)

c = func(4,5)
print(c)

#像这样的函数就叫闭包函数：1、函数嵌套 2、外部函数返回了内部函数的引用 3、内部函数使用了外部函数的引用
def f1(a,b):
    def inner(x):
        return f(a,b) * x
    return inner

def f(a,b):
    return a + b

func = f1(2,3)

c = func(4)
print(c)

迭代器

【15分钟彻底搞懂迭代器、可迭代对象、生成器【python迭代器】-哔哩哔哩】 https://b23.tv/3oeJBbB

生成器

【15分钟彻底搞懂迭代器、可迭代对象、生成器【python迭代器】-哔哩哔哩】 https://b23.tv/3oeJBbB

装饰器

【【专题】彻底学会Python装饰器-哔哩哔哩】 https://b23.tv/jf8r7Bk

我自己构造了一个需求，然后让大批量的函数去实现

def outer(f):
        def inner(*args,**kwargs):
            res = f(*args,**kwargs)
            return res
        return inner

@outer # f1 = outer(f1)
def f1(a):

@outer # f2 = outer(f2)
def f2(a,c):

文件操作

文件复制：

def copy_file(source_path, destination_path):
    try:
        with open(source_path, 'rb') as source_file:
            with open(destination_path, 'wb') as destination_file:
                destination_file.write(source_file.read())
        print(f"文件复制成功: {source_path} -> {destination_path}")
    except Exception as e:
        print(f"文件复制失败: {e}")

# 指定源文件和目标文件路径
source_file_path = '/path/to/your/source/file.txt'
destination_file_path = '/path/to/your/destination/file.txt'

# 调用函数进行文件复制
copy_file(source_file_path, destination_file_path)

大文件复制方法：

while True:
    content = source_file.read(1024)
    if len(content) == 0:
        break
    print('----',content)
    target_file.write(content)
    

文件分类：

# 0,获取所有的文件名称列表
import os
import shutil
path = 'files'
if not os.path.exists(path):
    exit()

os.chdir('files')#切换至当前文件夹
file_list = os.listdir('files')
#print(file_list)

#1、遍历所有文件（名称）
for  file_name in file_list:
    print(file_name)
    #2、分解文件名后缀
    #2.1获取最后一个.的索引
    index = file_name.rfind('.')
    if index == -1:#如果是一个目录跳过
        continue 
    #2.2根据这个索引位置，当做起始位置，来截取后续的所有字符串
    extension = file_name[index + 1:]
    #3.查看一下，是否存在同名的目录
    os.path
    #4.如果不存在这样的目录，直接创造一个
        #目录存在-移动过去
    if not os.path.exists(extension):
        os.mkdir(extension)
    shutil.move(file_name,extension)

列表清单：

import os

def list_files_and_folders(directory):
    # 获取当前目录下的所有文件和文件夹
    files_and_folders = os.listdir(directory)

    # 遍历当前目录下的所有文件和文件夹
    for item in files_and_folders:
        item_path = os.path.join(directory, item)

        # 如果是文件夹，则递归调用该函数
        if os.path.isdir(item_path):
            print("文件夹:", item_path)
            list_files_and_folders(item_path)
        else:
            # 如果是文件，则打印文件路径
            print("文件:", item_path)

# 指定目录路径
directory_path = '/path/to/your/directory'

# 调用函数开始列举
list_files_and_folders(directory_path)

#其中可以添加‘\t’和‘/’等操作来使排版清晰

写入进文件

import os

def list_files_and_folders(directory, output_file):
    with open(output_file, 'a') as file:
        # 获取当前目录下的所有文件和文件夹
        files_and_folders = os.listdir(directory)

        # 遍历当前目录下的所有文件和文件夹
        for item in files_and_folders:
            item_path = os.path.join(directory, item)

            # 如果是文件夹，则递归调用该函数
            if os.path.isdir(item_path):
                file.write("文件夹: {}\n".format(item_path))
                list_files_and_folders(item_path, output_file)
            else:
                # 如果是文件，则写入文件路径
                file.write("文件: {}\n".format(item_path))

# 指定目录路径和输出文件路径
directory_path = '/path/to/your/directory'
output_file_path = '/path/to/your/output_file.txt'

# 调用函数开始列举并写入文件
list_files_and_folders(directory_path, output_file_path)

sys标准库

【Python基础之标准库sys-哔哩哔哩】 https://b23.tv/Q6lt6hs

Logging标准库

【Python基础之标准库logging 你还在用print来调试程序吗，OUT啦-哔哩哔哩】 https://b23.tv/iQ3fXPU

import logging
#默认的输出级别是warning以上
# logging.basicConfig(format='%(asctime)s | %(levelname)s|%(filename)s|%(lineno)s|%(message)s',level=logging.DEBUG)
# logging.debug('this is debug log')
# logging.info('this is debug log')
# logging.warning('this is debug log')
# logging.error('this is debug log')
# logging.critical('this is debug log')
#
# logging.debug()

#高级用法
#记录器
logger = logging.getLogger('fff')
logger.setLevel(logging.INFO)

#处理器
consolehandle = logging.StreamHandler()
consolehandle.setLevel(logging.DEBUG)

#没有给handle设置日志级别，将使用logger的级别
fileHandler = logging.FileHandler(filename='addDemo.log')

#fomatter格式
formatter  = logging.Formatter('%(asctime)s | %(levelname)s|%(filename)s|%(lineno)s|%(message)s')

#给处理器设置格式
consolehandle.setFormatter(formatter)
fileHandler.setFormatter(formatter)

#记录器要设置处理器
logger.addHandler(consolehandle)
logger.addHandler(fileHandler)

#定义一个过滤器
flt = logging.Filter('fff')

#关联过滤器
logger.addFilter(flt)
#打印日志的代码
logger.debug('this')
logger.info('this')

time标准库

import time
time.time()#时间戳：时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。
format_time = time.strftime("%Y-%m-%d %H:%M:%S")
print(format_time, type(format_time))

#结构化的时间(struct time)：struct_time元组共有9个元素共九个元素，分别为(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)
本地时区time.localtime()
UTC时区time.gmtime()

# 把结构化时间转换为时间戳格式
now_time = time.localtime()
print(time.mktime(now_time))

# 把结构化时间转换为格式化时间
now_time = time.localtime()
print(time.strftime("%Y-%m-%d %H:%M:%S", now_time))

# 把格式化时间化为结构化时间，它和strftime()是逆操作
print(time.strptime('2013-05-20 13:14:52', '%Y-%m-%d %X'))

# 把结构化时间表示为这种形式：'Sun Jun 20 23:21:05 1993'。
print(time.asctime())

# 如果没有参数，将会将time.localtime()作为参数传入。
print(time.asctime(time.localtime()))

# 把一个时间戳转化为time.asctime()的形式。
print(time.ctime())

# 如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
print(time.ctime(time.time()))

# 推迟指定的时间运行，单位为秒
start = time.time()
time.sleep(3)
end = time.time()
print(end-start)

os标准库

os.getcwd()	获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")	改变当前脚本工作目录；相当于shell下cd
os.curdir	返回当前目录: ('.')
os.pardir	获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')	可生成多层递归目录
os.removedirs('dirname1')	若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')	生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')	删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')	列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()	删除一个文件
os.rename("oldname","newname")	重命名文件/目录
os.stat('path/filename')	获取文件/目录信息
os.sep	输出操作系统特定的路径分隔符，win下为"",Linux下为"/"
os.linesep	输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep	输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name	输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")	运行shell命令，直接显示
os.environ	获取系统环境变量
os.path.abspath(path)	返回path规范化的绝对路径
os.path.split(path)	将path分割成目录和文件名二元组返回
os.path.dirname(path)	返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)	返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)	如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)	如果path是绝对路径，返回True
os.path.isfile(path)	如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)	如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])	将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)	返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)	返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path)	返回path的大小

面对对象：万物皆可对象

实例方法、类方法、静态方法。

静态方法的由来：

def fun():
    a = "hello"
    
    class A(object):
        count = 0
    
        def fun(self):
            b = "world"
            return b
    return A

#调用
res=fun()
a=res()
print(a.fun())

• 于是会想到，在类里面是不是也可以写一个函数呢？【类里面写函数，注意不是方法】
• 于是就有了静态方法(@staticmethod)，静态方法的出现就是为了在类里面可以写一个函数，当普通的函数去调用。(而不是方法，需要将类实例化)
• 定义静态方法需使用@staticmethod装饰器，并且括号后面不需要self参数了

静态方法不需要实例化可以直接调用，实例化后也能调用。

class A(object):
    count = 0

    def fun(self):
        b = "world"
        return b

    @staticmethod
    def start():
        print("start-----")

# 不用实例化也能调用
A.start()
# 实例化也能调用
a = A()
a.start()

类方法

既然A()实例对象有实例方法，那么A类当然也有类方法的概念了，于是可以在方法上加上@classmethod装饰器声明它是类方法，并且括号第一个参数cls是指类本身。

不需要实例化，类名称直接调用类方法；实例化也能调用类方法

class DataTest(object):
    day = 0
    month = 0
    year = 0

    def __init__(self, year=0, month=0, day=0):
        self.day = day
        self.month = month
        self.year = year

    def out_date(self):
        print("year :", self.year)
        print("month :", self.month)
        print("day :", self.day)

t = DataTest(2021, 8, 18)
t.out_date()

但是如果用户输入的是 "2016-8-1" 这样的字符格式，那么就需要调用Date_test 类前做一下处理： 

string_date = '2018-8-18'
year, month, day = map(int, string_date.split('-'))
s = DataTest(year, month, day)
print(s.out_date())

先把‘2018-8-18’ 分解成 year，month，day三个变量，然后转成int，再调用DataTest(year, month, day) 也很符合期望。

那我可不可以把这个字符串处理的函数放到 DateTest 类当中呢？

那么@classmethod 就开始出场了：【类最基本的作用是实例化出一个对象，但是有的时候再实例化之前，就需要先和类做一定的交互，这种交互可能会影响实际实例化的过程，所以必须放在调用构造函数之前。】

class DataTest(object):
    day = 0
    month = 0
    year = 0

    def __init__(self, year=0, month=0, day=0):
        self.day = day
        self.month = month
        self.year = year

    def out_date(self):
        print("year :", self.year)
        print("month :", self.month)
        print("day :", self.day)

    @classmethod
    def get_data(cls, string_date):
        """处理'2018-8-18'字符格式"""
        year, month, day = map(int, string_date.split('-'))
        return cls(year, month, day)

 定义一个get_data类方法，处理完字符串后返回这个类的实例对象。这样有一举两得的效果，在处理字符串的同时，还能实现实例化。

r = DataTest.get_data('2018-8-18') 
r.out_date()

#DataTest.get_data('2018-8-18') 实际上会调用类方法 get_data 来创建一个 DataTest 类的实例。在这个过程中，会先调用类方法，然后再调用 __init__ 方法进行初始化。

方法加括号，属性不加括号

class Num:  #类，既可以是类，也可以是变量，也可以是对象
   #方类的属性
     pass

n = Num() #对象

写一个方法：

方法：分为实例方法、类方法、静态方法。三种方法都储存在类里面
实例属性可以访问类属性。类属性不访问实例属性。
划分本质时将p称为对象，其他则称为实例（实例属性）。

class Num:
    def eat2(self): #实例方法
        print(1)
        print(2)
        print(3)
    @classmethod
    def leifangfa(cls): #类方法
        print('这是一个类方法')
    @staticmethod
    def jingtaifangfa(): #静态方法
        print('这是一个静态方法')

怎么使用方法？1、语法 2、不同类型的方法的规则 3、不同类型的方法的调用 

实例方法：少穿一个参数
        用实例标准调用。不用写形参

类方法：   

class Num:
    @classmethod
    def leifangfa(cls,a): #类方法
        print('这是一个类方法',cls,a)
Num.leifangfa(123)
p =Num()
p.leifangfa(666)

func = Num.leifangfa
func(111)

#装饰器的作用，在不改变原函数的情况下，给原函数增加一些功能

class A(Num):
    pass
A.leifangfa(0)

静态方法：

class Num:
    @staticmethod
    def jingtaifangfa(): #静态方法
        print('这是一个静态方法')

class Person:
    age = 0
    def shilifangfa(self): #self是实例
        print(self)
        print(self.age) #实例可以访问类的属性
        print(self.num)
    
    @classmethod
    def leifangfa(cls):
        print(cls)
        print(cls.age)
        print(cls.num) #访问不到，因为只能访问类方法属性，就不能访问实例属性
    @staticmethod
    def jingtaifangfa():#什么都不能访问



p = Person()
p.num = 10

p.shilifangfa()

type是元类，可以创建类对象。元类的应用场景：1、拦截类的创建 2、修改类 3、返回修改之后的类

类的描述：

生成项目文档：
        python3 -m pydoc name
        python3 -m pydoc -k name
        python3 -m pydoc -p 端口号（如果没有，可能是文件中文的原因）
        python3 -m pydoc -b 自动检测未用端口
        python3 -m pydoc -w xxx   写入进文件
        epydoc 第三方模块

属性：
        公有化属性（子类可以访问，非类也可以访问，跨模块也可以访问），
        私有化属性（1、一个下划线：子类可以访问，非类可以强行访问但有警告，跨模块不能访问。2、两个下划线：子类不能访问，跨模块不能）。怎么去访问？用其他手段（__dict__）
        应用：
        

只读属性。优化：因为多了一括号获取，另一个是可以赋值容易误导。解决：增加装饰器property。

property的用法：

1. 定义时，在实例方法的基础上添加 @property 装饰器；并且仅有一个self参数

2. 调用时，无需括号
        

新式类，具有三种 @property 装饰器：

#coding=utf-8
# ############### 定义 ###############
class Goods:
    """python3中默认继承object类
        以python2、3执行此程序的结果不同，因为只有在python3中才有@xxx.setter  @xxx.deleter
    """

    @property
    def price(self):
        print('@property')

    @price.setter
    def price(self, value):
        print('@price.setter')

    @price.deleter
    def price(self):
        print('@price.deleter')


# ############### 调用 ###############
obj = Goods()
obj.price  # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
obj.price = 123  # 自动执行 @price.setter 修饰的 price 方法，并将  123 赋值给方法的参数
del obj.price  # 自动执行 @price.deleter 修饰的 price 方法

创建值为property对象的类属性。注意：当使用类属性的方式创建property属性时，经典类和新式类无区别。思考为什么叫类属性方法？
property方法中有个四个参数

1. 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
2. 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
3. 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
4. 第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息

#coding=utf-8
class Foo(object):
    def get_bar(self):
        print("getter...")
        return 'laowang'

    def set_bar(self, value):
        """必须两个参数"""
        print("setter...")
        return 'set value' + value

    def del_bar(self):
        print("deleter...")
        return 'laowang'

    BAR = property(get_bar, set_bar, del_bar, "description...")


obj = Foo()

obj.BAR  # 自动调用第一个参数中定义的方法：get_bar
obj.BAR = "alex"  # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入
desc = Foo.BAR.__doc__  # 自动获取第四个参数中设置的值：description...
print(desc)
del obj.BAR  # 自动调用第三个参数中定义的方法：del_bar方法

内置特殊属性：

__setattr__:【(强推)Python面向对象编程五步曲-从零到就业【中】-哔哩哔哩】 https://b23.tv/4IVMDRp(62节)

__dict__:查找属性

 _slots_:可以限制对象属性

__class__:找到对象的类。可叠加

__metaclass__:

__all__:可以跨模块访问

__init__:初始化实例

__bases__:查找新式类（继承object类）和经典类（不继承）

方法相关补充：方法变为私有方法。内置特殊方法：

def _str_(self):主要面向用户
        

def _repr_(self):

__call__:调用对象

__setitem__:索引操作、切片操作：

比较类： __eq__, __ne__,等六种。__bool__

遍历操作：__getitem__（）, __iter__:哪个优先级高？后面这个 

判定是否是迭代器，和重复使用迭代器。一个迭代器肯定是可迭代对象。可遍历不一定是迭代器

描述器：第一种使用property，下面这张是第二种新式类才行（通过实例操作，而不是通过类操作）。资料描述器大于实例属性大于非资料描述器

类的装饰器：

对象的生命周期：

__new__

__init__

__del__

内存管理机制 ：所有对象都会有内存。id(),hex(id()).常用的有缓存。引用计数器。sys, sys.getrefcount(注意值会大一)。内存泄漏就是内存循环，要使用垃圾回收机制：检测容器对象
gc.collect 手动释放

面向对象三大特性：

什么样的查找顺序。单调原则。有好几节课讲的是继承算法的演变

insepect.getmro

C3算法

类的继承打印

A.mro

A.__bases__

继承

class B:
    a = 1
    def __init__(self): #相当于给实例增加了b属性
        self.b  = 2
    def t1(self):
        print('t1')
    @classmethod
    def t2(cls):
        print('t2')
    @staticmethod
    def t3():
        print('t3')

class A(B): #继承了classB
    c = 3
    def __init__(self): #如果子类加了初始化方法，那么子类就调用自己的，不会再调用父类。相当于覆盖了。
        self.e  = 2
    pass
a_obj = A() #创建实例
print(A.a)
print(a_obj.b) #

a_obj.t1()
A.t2()

解决__init__覆盖问题有几种方法：1、复制 2、

class B:
    a = 1
    def __init__(self): #相当于给实例增加了b属性
        self.b  = 2
        self.l = 33
    def t1(self):
        print('t1')
    @classmethod
    def t2(cls):
        print('t2')
    @staticmethod
    def t3():
        print('t3')

class A(B): #继承了classB
    c = 3
    def __init__(self): #如果子类加了初始化方法，那么子类就调用自己的，不会再调用父类
        B.__init__(self) #解决覆盖问题的第一种方法,这样做的缺点是，父类名称变了，则要手动换字母，且菱形继承时会重复
        self.e  = 2
    pass


a = A()
print(a.__dict__)

 上面这种方法会引起下面这种结果重复。

class D(object):
    def __init__(self):
        print('1')

class B(D):
    def __init__(self):
        D.__init__(self)
        print('2')

class C(D):
    def __init__(self):
        D.__init__(self)
        print('3')
class A(B,C):
    def __init__(self):
        B.__init__(self)
        C.__init__(self)
        print('4')
a = A()
print(a.__dict__) #结果重复了

所以怎么办呢？使用__super__去继承。并不代表按父类，而是按照MRO链条。

class B:
    a = 1
    def __init__(self): #相当于给实例增加了b属性
        self.b  = 2
        self.l = 33
    def t1(self):
        print('t1')
    @classmethod
    def t2(cls):
        print('t2')
    @staticmethod
    def t3():
        print('t3')

class A(B): #继承了classB
    c = 3
    def __init__(self): #如果子类加了初始化方法，那么子类就调用自己的，不会再调用父类
        super().__init__() #换成super
        self.e  = 2
    @classmethod
    def tt2(cls):
        super().t2() #换成super
        print('t2')
    pass

a = A()
print(a.__dict__)
A.tt2() #拥有上述所有资源

多态。与其他语言作对比。

class Animal(object):
    def jiao(self):
        pass
class Dog(Animal):
    def jiao(self):
        print('wangwangwangwang')
class Cat(Animal):
    def jiao(self):
        print('miaomiaomiaomiao')

def test(obj):
    obj.jiao()
d = Dog()
c = Cat()
test(c)
test(d)

面对对象进阶：

instance和issubclass:

        既然有了type()来判断类型，为什么还有isinstance()呢？
        一个明显的区别是在判断子类。
        type()不会认为子类是一种父类类型；isinstance()会认为子类是一种父类类型。

class Foo(object):
    pass
 
class Bar(Foo):
    pass
 
print(type(Foo()) == Foo)
print(type(Bar()) == Foo)
# isinstance参数为对象和类
print(isinstance(Bar(),Foo))


class Parent:
    pass

class Sub(Parent):
    pass


print(issubclass(Sub, Parent))

 反射：

        注意：getattr,hasattr,setattr,delattr对模块的修改都在内存中进行，并不会影响文件中真实内容。

反射就是通过字符串来操作类或者对象的属性

• 反射本质就是在使用内置函数，其中反射有以下四个内置函数：

1. hasattr：判断一个方法是否存在与这个类中
2. getattr：根据字符串去获取obj对象里的对应的方法的内存地址，加"()"括号即可执行
3. setattr：通过setattr将外部的一个函数绑定到实例中
4. delattr：删除一个实例或者类中的方法

        我们要导入另外一个模块,可以使用import.现在有这样的需求,我动态输入一个模块名，可以随时访问到导入模块中的方法或者变量，怎么做呢？

__module__和__class__:

        __module__ 表示当前操作的对象在那个模块
        __class__表示当前操作的对象的类是什么

__str__和__repr__:

class Foo:
    pass

obj = Foo()
print（obj）#直接打印对象

class Foo:
    def __init__(self, name, age):
        """对象实例化的时候自动触发"""
        self.name = name
        self.age = age

    def __str__(self):
        print('打印的时候自动触发，但是其实不需要print即可打印')
        return f'{self.name}:{self.age}'  # 如果不返回字符串类型，则会报错


obj = Foo('nick', 18)

class School:
    def __init__(self, name, addr, type):
        self.name = name
        self.addr = addr
        self.type = type

    def __repr__(self):
        return 'School(%s,%s)' % (self.name, self.addr)

    def __str__(self):
        return '(%s,%s)' % (self.name, self.addr)


s1 = School('oldboy1', '北京', '私立')

print(str(s1))
print(repr(s1))
print(s1)

 __call__:

class Foo:
    def __init__(self):
        print('__init__触发了')

    def __call__(self, *args, **kwargs):

        print('__call__触发了')


obj = Foo()  # 执行 __init__
obj()

  __doc__:

        返回类的注释信息
        该属性无法被继承

__del__:

     

__getitem__:直接使用index来获取

from torch.utils.data import Dataset

class MyDataset(Dataset):

    def __init__(self) -> None:
        super().__init__()
        self.data = pd.read_csv("./ChnSentiCorp_htl_all.csv")
        self.data = self.data.dropna()

    def __getitem__(self, index):
        return self.data.iloc[index]["review"], self.data.iloc[index]["label"]
    
    def __len__(self):
        return len(self.data)


dataset = MyDataset()
for i in range(5):
    print(dataset[i])

class CustomImageDataset(Dataset):
    def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):
        self.img_labels = pd.read_csv(annotations_file)
        self.img_dir = img_dir
        self.transform = transform
        self.target_transform = target_transform

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

    def __getitem__(self, idx):
        img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])
        image = read_image(img_path)
        label = self.img_labels.iloc[idx, 1]
        if self.transform:
            image = self.transform(image)
        if self.target_transform:
            label = self.target_transform(label)
        return image, label

        

全局__all__的使用：

在 Python 中，__all__ 是一个特殊的变量，用于定义一个模块的公共接口。它是一个包含模块中所有应该被公开的对象的列表。当使用 from module import * 语法导入模块时，只有在 __all__ 列表中的对象才会被导入到当前命名空间。