内置方法及模块初识,set的hash算法面试题
析构方法__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规范
所有的模块导入都应该尽量放在这个文件的开头
模块的导入也是有顺序的
先导入内置模块
再导入第三方模块
最后导入自定义模块
# 一个类
# 对象的属性 : 姓名 性别 年龄 部门
# 员工管理系统
# 内部转岗 python开发 - go开发
# 姓名 性别 年龄 新的部门
# alex None 83 python
# alex None 85 luffy
# 1000个员工
# 如果几个员工对象的姓名和性别相同,这是一个人
# 请对这1000个员工做去重
class Employee:
def __init__(self,name,age,sex,partment):
self.name = name
self.age = age
self.sex = sex
self.partment = partment
def __hash__(self):
return hash('%s%s'%(self.name,self.sex))
def __eq__(self, other):
if self.name == other.name and self.sex == other.sex:
return True
employ_lst = []
for i in range(200):
employ_lst.append(Employee('alex',i,'male','python'))
for i in range(200):
employ_lst.append(Employee('wusir',i,'male','python'))
for i in range(200):
employ_lst.append(Employee('taibai', i, 'male', 'python'))
# print(employ_lst)
employ_set = set(employ_lst)
for person in employ_set:
print(person.__dict__)
# set集合的去重机制 : 先调用hash,再调用eq,eq不是每次都触发,只有hash值相等的时候才会触发
