魔术方法

1.特殊属性：
__ name__ : 类，函数，方法等的名字
__ modue__ ： 类定义所在的模块 ， 查看类定义的模块
__ class__： 对象或者类所属的类 ， 类是由谁实例化出来的对象。 （python中一切皆为对象，看到的类实际上也是对象。）
__ bases__： 当前类的父类（基类）
__ doc__ ： 类，函数的帮助文档，没有定义的时候为None
__ mro__ ： 方法解析顺序
__ dict__： 类或者实例的属性，可写的字典
__ dir__: 返回类或者对象所有成员的列表，插卡对应模块都有什么属性。 dir() 函数就是调用 __ dir__()

point： 1） 如果dir( [ object ] ) 参数 obj 包含 __ dir__() ，则该方法将会被调用
2）如果dir( [ object ] ) 参数 obj 不包含 __ dir__() ，则该方法将最大限度地收集属性信息
dir( obj ) : 对于不同类型的对象 obj 具有不同的行为 ：
1） 如果对象是模块对象，返回的列表包含模块的属性名和变量名
2） 如果对象是类型或者是类对象，返回的列表包含类的属性名，及它的基类的属性名
3） 如果 obj 不写 —> dir() 返回列表包含的内容不同
- 在模块中，返回模块的属性和变量名
- 在函数中， 返回本地作用域的变量名
- 在方法中，返回本地作用域的变量名

2. 创建初始化和销毁
   __ new__ ， __ init__ ， __del___之间的区别

__new __ 是在生成对象之前做操作，接收类名 ， 主要用于对象的创建，可以再对象创建之前对对象进行处理 （第一个传的是类名） 对象生成是在 __new __ 里面 return （返回一个对象）

__init __ 完善对象的属性，用于对象的初始化 ， （第一个传的是对象）

__del __ 对象删除的时候自动调用

(ps . 构造方法： 在实例化对象的时候调用
析构方法：在删除对象的时候自动调用 （eg . def __ del(self): ）
因为在程序执行的时候将变量存储在内存中，当程序执行完成后会释放内存，因此会自动调用析构方法
)

实验代码如下：

class Student(object):
    def __new__(cls, name):
        print('正在new.....')
        # 不知道new方法是怎么用的, 直接返回父类的new方法
        return  super(Student, cls).__new__(cls)

    # 初始化(构造)方法: 创建对象时自动执行
    def __init__(self, name):
        print("正在初始化对象.....")
        self.name = name

    # 析构方法: 对象删除时自动调用
    def __del__(self):
        print("正在删除对象.....")


# 当程序运行结束之后, 会自动释放变量信息. 会自动调用析构方法;
s = Student('westos')
print(s.name)

实验结果如下：

3. 可视化
   类型判断需要用到type 或 isinstance ， 不能通过判断 print 输出是否带有引号来判断输出值的类型
   1）str() 和 repr() 都是python中的内置方法，是直接用来格式化字符串的函数
   2）__ str__ 和 __ repr__ 是在类（对象）中对类（对象）本身进行字符串的处理
   str __ 是对象的字符串打印 ，显示出来的对象会变得友好 —> 更方便我们去看，否则就是该对象所保存的地址
   repr __ : 是在python 中的交互式环境中产生作用
   str 返回一个可以用来表示对象的可打印的友好的字符串
   没有参数的时候，返回的是空字符串
   对于类：可以通过 __ str() 成员控制其行为，如果该成员不存在，则使用 __ repr() 成员

实验代码如下：

class Student(object):
    # 初始化(构造)方法: 创建对象时自动执行
    def __init__(self, name):
        print("正在初始化对象.....")
        self.name = name
    # 如果没有__str__, 自动返回__repr__的内容
    # 对象的字符串打印
    def __str__(self):
        return  "" %(self.name)

    # 在交互式python环境中产生作用
    def __repr__(self):
        return  self.name

s = Student("root")
print(s)

实验结果如下：

4.类型转换

__int __(self) ： 转换成整型 ： int (对象名) 会自动调用 ， 将能转换成 int 型的转换成 int 型
__ fioat __(self) ： 转换成浮点型
__ complex __(self) ： 转换成复数型
__ oct __(self) ： 转换成八进制
__ hex __(self) ： 转换成十六进制
__ index __(self) ： 可以用来被切片的整数型
__ trunc __(self) : 当使用math.trunc(self) 时 ， 被调用 __trunc __ 返回自身类型的整型截取

实验代码如下：

class Example(object):
    def __init__(self, url, pwd):
      self.url = url
      self.pwd = pwd
      self.count = 10

    # int(对象名)会自动调用
    def __int__(self):
        return  int(self.count)

    def __float__(self):
        return  float(self.count)

p1 = Password('类型转换例子', 'root')
print(int(p1))
print(float(p1))

运行结果为：

（类型转换就是将能转换的转换成指定的形式，然后输出）

5 . 切片和索引

__getitem __ : python3中获取索引切片的魔术方法
__ setitem __ : 对指定索引进行值的修改
__delete __ : 对指定索引进行删除

实验代码如下：

class Student(object):
    # 函数的默认值必须是不可变数据类型
    def __init__(self, name, scores=(90, 95)):
        self.name = name
        self.scores = list(scores)

    # 索引的时候, 是对成绩进行索引/切片的;
    def __getitem__(self, index):
        # print(index)
        # 如果是查看索引, 传递的index是索引值;
        # 如果是切片, index是slice对象;
        return  self.scores[index]

    # 对指定索引index修改值; s[0] = 89 ====> index=0, value=89
    def __setitem__(self, index, value):
        self.scores[index] = value

    def __delitem__(self, index):
        del self.scores[index]

    # 设置该类创建的对象是可迭代对象(生成器 ---> 迭代器 ---> 可迭代对象)
    # 生成器都是迭代器; 迭代器都是可迭代对象; 可迭代对象不一定是迭代器; eg:str, list.
    # iter(): j将可迭代对象转换程迭代器;
    def __iter__(self):
        return  iter(self.scores) # 迭代器
        # return  iter([1, 2, 3, 4, 5])



s = Student('root')
for item in s:
    print(item)
print(s[:2])

print("before:", s[0])
s[0] = 89
print("after:", s[0])


print('delete before:', s.scores)
del s[-1]
print('delete after:', s.scores)

运行结果为：

6. with语句的安全上下文
   with语句的实现机制：

__ enter __ (打开文件)
__ exit __ (关闭文件)

eg.

class myopen(object):
    """为了模拟文件中with语句的实现机制"""
    def __init__(self, filename, mode='r'):
        self.name = filename
        self.mode = mode

    def __enter__(self):
        """当with语句开始执行时, 做的操作"""
        # 返回的时文件对象
        print('文件打开')
        self.f = open(self.name, self.mode)
        return  self.f

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()
        print("文件关闭")

with myopen('test1.txt', 'r') as f:
    print(f.read())

运行结果如下：

7.自省功能
hasattr() ----> 判断类里面有没有制定的属性
getattr() -----> 获取类里面指定属性对应的内容
setattr() -----> 设置类里面的属性 eg . setattr(Prettyable , 'a ’ ,1 )
delattr() ------> 删除类里面的属性