内置方法及模块初识

Posted 2020-12-27 duanpengpeng

析构方法__del__

构造方法  申请一个空间
析构方法  释放一个空间之前执行
某对象借用了操作系统的资源,还要通过析构方法归还回去 : 文件资源  网络资源


垃圾回收机制
class A:
    def __del__(self):
        # 析构方法 del A的对象 会自动触发这个方法
        print(‘执行我了‘)
a = A()
del a  # 对象的删除 del
print(a)

class File():
    # 处理文件的
    def __init__(self,file_path):
        self.f = open(file_path)
        self.name = ‘alex‘

    def read(self):
        self.f.read(1024)

    def __del__(self):   # 是去归还/释放一些在创建对象的时候借用的一些资源
        # del 对象的时候   程序员触发
        # python解释器的垃圾回收机制 回收这个对象所占得内存的时候  python自动触发的
        self.f.close()
f = File(‘文件名‘)
f.read()
不管是主动还是被动,这个f对象总会被清理掉,被清理掉就触发__del__方法,触发这个方法就会归还操作系统的文件资源

__item__

item系列 和对象使用[]访问值有联系
obj = {‘k‘:‘v‘}
print(obj)   # 字典的对象
print(obj[‘k‘])

在内置的模块中,
有一些特殊的方法,要求对象必须实现__getitem__/__setitem__才能使用
class B:
    def __getitem__(self, item):
        return getattr(self,item)
    def __setitem__(self, key, value):
        setattr(self,key,value*2)
    def __delitem__(self, key):
        delattr(self,key)
b = B()
# b.k2 = ‘v2‘
# print(b.k2)
b[‘k1‘] = ‘v1‘  # __setitem__
print(b[‘k1‘])  # __getitem__
del b[‘k1‘]     # __delitem__
print(b[‘k1‘])

class B:
    def __init__(self,lst):
        self.lst = lst
    def __getitem__(self, item):
        return self.lst[item]
    def __setitem__(self, key, value):
        self.lst[key] = value
    def __delitem__(self, key):
        self.lst.pop(key)
b = B([‘111‘,‘222‘,‘ccc‘,‘ddd‘])
print(b.lst[0])
print(b[0])
b[3] = ‘alex‘
print(b.lst)
del b[2]
print(b.lst)

__hash__

hash方法
底层数据结构基于hash值寻址的优化操作
hash是一个算法
能够把某一个要存在内存里的值通过一系列计算,
保证不同值的hash结果是不一样的
‘127647862861596‘  ==> 927189778748
对同一个值在多次执行python代码的时候hash值是不同
但是对同一个值 在同一次执行python代码的时候hash值永远不变
print(hash(‘abc‘))  # 6048279107854451739
print(hash(‘abc‘))
print(hash(‘abc‘))
print(hash(‘abc‘))
print(hash(‘abc‘))
print(hash(‘abc‘))

字典的寻址  - hash算法
d = {‘key‘:‘value‘}
hash - 内置函数

set集合
se = {1,2,2,3,4,5,‘a‘,‘b‘,‘d‘,‘f‘}
print(se)

d = {‘key‘:‘v1‘,‘key‘:‘v2‘}
print(d[‘key‘])

__eq__

class A:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __eq__(self, other):
        if self.name == other.name and self.age == other.age:
            return True
a = A(‘alex‘,83)
aa = A(‘alex‘,83)
aa2 = A(‘alex‘,83)
aa3 = A(‘alex‘,83)
aa4 = A(‘alex‘,83)
aa5 = A(‘alex‘,83)
aa6 = A(‘alex‘,83)
print(a,aa)
print(aa3 == aa == aa4)  # ==这个语法 是完全和__eq__

高阶面试题/读源码/简化操作

模块
模块的分类
    内置模块
        安装python解释器的时候跟着装上的那些方法
    第三方模块/扩展模块
        没在安装python解释器的时候安装的那些功能
    自定义模块
        你写的功能如果是一个通用的功能,那你就把它当做一个模块

什么是模块
    有的功能开发者自己无法完成,这样的话需要借助已经实现的函数类来完成这些功能
    你实现不了的功能都由别人替你实现了
        操作系统打交道
        和时间
        1000取随机数
        压缩一个文件
        和网络通信
    别人写好的一组功能  文件夹/py文件/C语言编译好的一些编译文件
        分类 管理方法
        节省内存
        提供更多的功能
为什么要有模块?
    分类 管理方法
    节省内存
    提供更多的功能
模块怎么用?在哪儿用?

import my_module  # 要导入一个py文件的名字,但是不加.py后缀名
import my_module  # 模块的名字必须要满足变量的命名规范
                   # 一般情况下 模块都是小写字母开头的名字

# import这个语句相当于什么???
# import这个模块相当于执行了这个模块所在的py文件

# 模块可以被多次导入么? 一个模块不会被重复导入

# 如何使用模块?
def login():print(‘in mine login‘)
name = ‘太亮‘
login()
my_module.login()
# print(my_module.name)

在导入一个模块的过程中到底发生了哪些事情

模块的重命名
import my_module as m
m.login()
my_module.login()

导入多个模块
import os
import my_module
PEP8规范
所有的模块导入都应该尽量放在这个文件的开头
模块的导入也是有顺序的
    先导入内置模块
    再导入第三方模块
    最后导入自定义模块