一:__new__

   在__init__之前,实例化对象的第一步是__new__创建了一个空间

class Foo:
def __init__(self): # 初始化方法
print('执行了init')
def __new__(cls, *args, **kwargs): # 构造方法
print('执行了new')
return object.__new__(cls)
obj = Foo()
'''
执行了new
执行了init 创造一个对象比喻成捏小人
new是小人捏出来了
init就是给小人穿衣服
'''

   单例模式:

    一个类,只有一个实例的时候

class Foo:
__instance = None
def __init__(self,name,age): # 初始化方法
self.name = name
self.age = age
def __new__(cls, *args, **kwargs):
if cls.__instance is None:
cls.__instance = object.__new__(cls)
return cls.__instance
obj1 = Foo('alex',38)
obj2 = Foo('taibai',28)
print(obj1,obj2) # <__main__.Foo object at 0x0132CE70> <__main__.Foo object at 0x0132CE70>
print(obj1.name,obj2.name) # taibai taibai
'''
单例模式的时候,不管实例化多少个对象,永远只取最后一个对象的值
'''

二、__del__

   析构方法,当对象在内存中被删除(释放)时,自动触发执行。

class Foo:
def __init__(self,name,age):
self.name = name
self.age = age
self.file = open('file', mode='w')
def write(self):
self.file.write('sdfsdgsdgs')
def __del__(self): # 析构方法 : 在删除这个类创建的对象的时候会先触发这个方法,再删除对象
# 做一些清理工作,比如说关闭文件,关闭网络的链接,数据库的链接
self.file.close()
print('执行del了')
f = Foo('alex',38)
del f
print('hahahaha')
'''
执行del了
hahahaha
'''

三、__len__

    __len__支持的数据类型跟函数len()是一样的:lst dict set tuple str

# len()函数支持的数据类型---> lst dict set tuple str
print('__len__' in dir(list)) # True
print('__len__' in dir(dict)) # True
print('__len__' in dir(set)) # True
print('__len__' in dir(tuple)) # True
print('__len__' in dir(str)) # True print('__len__' in dir(int)) # False
print('__len__' in dir(float)) # False class Foo:
def __len__(self):
return 1
obj = Foo()
print(len(obj)) # class Class:
def __init__(self,name,course):
self.name = name
self.course = course
self.students = []
def __len__(self):
return len(self.students)
s1 = Class('骑士1班','python')
s1.students.append('laowang')
s1.students.append('laoliu')
s1.students.append('laocheng')
print(len(s1)) #

四、__eq__

   自定义两个实例化对象的值是否相等,是的话返回True

class Staff:
def __init__(self,name,sex):
self.name = name
self.sex = sex
def __eq__(self, other):
return self.__dict__ == other.__dict__
alex = Staff('alex','男')
alex1 = Staff('alex','男')
alex2 = Staff('alex','female')
print(alex == alex1) # True 两个对象的值相同
print(alex2 == alex1) # False 两个对象的值不同 l1 = [1,2,3,4]
l2 = [1,2,3,4]
print(id(l1),id(l2)) # 1787304 1788464
print(l1 == l2) # True
print(l1 is l2) # False

五、__hash__

    1、每次执行hash值都会变化

    2、在一次执行的过程中对同一个值的hash结果总是不变的

class Foo():
pass
obj1 = Foo()
obj2 = Foo()
print(hash(obj1)) # 内存地址:319039 print(hash(obj2)) # 内存地址:318993
print(hash(obj2)) # 内存地址:318993
print(hash(obj2)) # 内存地址:318993
print(hash(obj2)) # 内存地址:318993
print(hash(obj2)) # 内存地址:318993
'''
hash算法
1、对于相同的值在一次程序的运行中是不会变化的
2、对于不同的值在一次程序的运行中总是不同的
'''
# 不用set去重
new_lst = []
lst = [2,2,43,53,238579,14780]
for i in lst:
if i in new_lst:
pass
else:
new_lst.append(i) set = {1,2,'abc',3,4,5,6,7,8,9,'bca'}
# 不能通过逐个判断值相等这件事儿来做去重工作
# hash算法也不是完全的靠谱
#
# set 的去重机制
# 1.对每一个元素进行hash计算出一个内存地址
# 2.到这个内存地址上查看
# 如果这块内存中没有值
# 将这个元素存到对应的内存地址上
# 如果这块内存中已经有值
# 判断这两个值是否相等
# 如果相等 就舍弃后面的值
# 如果不相等 就二次寻址再找一个新的空间来存储这个值

set的去重机制

# 员工类
# 姓名 年龄 性别 部门
# 转岗位后
# 姓名 年龄变化了 性别 部门变化了
# 100个员工,去掉重复的
# 员工的姓名 性别 是相同的,就认为是同一个员工 class Staff:
def __init__(self,name,age,sex,dep):
self.name = name
self.age = age
self.sex = sex
self.dep = dep
def __hash__(self):
return hash(self.name + self.sex)
def __eq__(self, other):
if self.name == other.name and self.sex == other.sex:
return True
name_lst = ['alex','taibai','egon','peiqi']
obj_lst = []
for i in range(100):
name = name_lst[i % 4]
obj = Staff(name, i, 'male', 'python')
obj_lst.append(obj)
print(obj_lst) # 打印出了100个对象的内存地址
ret = set(obj_lst)
print(ret) # 去掉重复的,只剩4个了 # 查看保留的值是保留前面的还是保留后面的
for i in ret: # 结果是保留前面的
print(i.name,i.age)
'''
peiqi 3
taibai 1
egon 2
alex 0
'''

面试题

六、初识模块

   别人写好的功能放在一个文件里

     内置模块: 安装Python解释器的时候一起装上的

     第三方模块、扩展模块: 需要自己安装

     自定义模块: 自己写的py文件

   序列化模块:

     什么叫序列化:

       将原本的字典、列表等内容转换成一个字符串、byets类型的过程就叫做序列化。

比如,我们在python代码中计算的一个数据需要给另外一段程序使用,那我们怎么给?
现在我们能想到的方法就是存在文件里,然后另一个python程序再从文件里读出来。
但是我们都知道,对于文件来说是没有字典这个概念的,所以我们只能将数据转换成字典放到文件中。
你一定会问,将字典转换成一个字符串很简单,就是str(dic)就可以办到了,为什么我们还要学习序列化模块呢?
没错序列化的过程就是从dic 变成str(dic)的过程。现在你可以通过str(dic),将一个名为dic的字典转换成一个字符串,
但是你要怎么把一个字符串转换成字典呢?
聪明的你肯定想到了eval(),如果我们将一个字符串类型的字典str_dic传给eval,就会得到一个返回的字典类型了。
eval()函数十分强大,但是eval是做什么的?e官方demo解释为:将字符串str当成有效的表达式来求值并返回计算结果。
BUT!强大的函数有代价。安全性是其最大的缺点。
想象一下,如果我们从文件中读出的不是一个数据结构,而是一句"删除文件"类似的破坏性语句,那么后果实在不堪设设想。
而使用eval就要担这个风险。
所以,我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构) 为什么要有序列化模块

为什么要有序列化模块

     序列化的目的:

       1、以某种存储形式使自定义对象持久化

       2、将对象从一个地方传递到另一个地方

       3、使程序更具维护性

  json模块 & pickle模块

    用于序列化的两个模块

      json:用于字符串和Python数据类型间进行转换

      pickle:用于Python特有的类型和Python的数据类型间进行转换

    json模块:

      json模块提供了四个功能:dumps、dump、loads、load

      优点:

        所有的语言都通用

      缺点:

        只支持非常少的数据类型

        对数据类型的约束很苛刻

          字典的key必须是字符串

          只支持:数字、字符串、列表、字典

import json
stu = {'name':'王瑞臣','sex':'male'} ret = json.dumps(stu) # 序列化的过程
print(stu,type(stu)) # {'name': '王瑞臣', 'sex': 'male'} <class 'dict'>
print(ret,type(ret)) # {"name": "\u738b\u745e\u81e3", "sex": "male"} <class 'str'> d = json.loads(ret) # 反序列化的过程
print('d--->',d,type(d)) # d---> {'name': '王瑞臣', 'sex': 'male'} <class 'dict'> lst = [1,2,3,4,'aaa','bbb']
ret = json.dumps(lst) # 序列化的过程
print(lst,type(lst)) # [1, 2, 3, 4, 'aaa', 'bbb'] <class 'list'>
print(ret,type(ret)) # [1, 2, 3, 4, 'aaa', 'bbb'] <class 'list'> d = json.loads(ret) # 反序列化的过程
print('d-->',d,type(d)) # d--> [1, 2, 3, 4, 'aaa', 'bbb'] <class 'list'> stu = {'name':'王瑞臣','sex':'male',1:('a','b')}
ret = json.dumps(stu) # 序列化的过程
print(stu,type(stu)) # {'name': '王瑞臣', 'sex': 'male', 1: ('a', 'b')} <class 'dict'>
print(ret,type(ret)) # {"name": "\u738b\u745e\u81e3", "sex": "male", "1": ["a", "b"]} <class 'str'>
d = json.loads(ret) # 反序列化的过程
print('d-->',d,type(d)) # d--> {'name': '王瑞臣', 'sex': 'male', '1': ['a', 'b']} <class 'dict'>
# 把元祖变成列表了
import json
data = {'username':['李华','二愣子'],'sex':'male','age':16}
json_dic2 = json.dumps(data,sort_keys=True,indent=4,separators=(',',':'),ensure_ascii=False)
print(json_dic2)
'''
sort_keys=True:将数据根据keys的值进行排序
indent=4: 表示每行开头4个空格
separators=(',',':'):分隔符,keys之间用“,”隔开,而key和value之间用“:”隔开
ensure_ascii=False:当False时,非ascii码才能正常显示
'''

json的格式化输出

    pickle模块

      pickle模块提供了四个功能:dumps、dump(序列化,存)、loads(反序列化,读)、load  (不仅可以序列化字典,列表...可以把python中任意的数据类型序列化

      

import pickle
stu = {'name':'王瑞臣','sex':'male',1:('a','b')}
ret = pickle.dumps(stu) # 序列化的过程
print(ret) # b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\t\x00\x00\x00\xe7\x8e\x8b\xe7\x91\x9e\xe8\x87\xa3q\x02X\x03\x00\x00\x00sexq\x03X\x04\x00\x00\x00maleq\x04K\x01X\x01\x00\x00\x00aq\x05X\x01\x00\x00\x00bq\x06\x86q\x07u.'
d = pickle.loads(ret) # 反序列化的过程
print(d,type(d)) # {'name': '王瑞臣', 'sex': 'male', 1: ('a', 'b')} <class 'dict'> class Course():
def __init__(self,name,price):
self.name = name
self.price = price
python = Course('python',29800)
ret = pickle.dumps(python) # 序列化的过程
print(ret) # b'\x80\x03c__main__\nCourse\nq\x00)\x81q\x01}q\x02(X\x04\x00\x00\x00nameq\x03X\x06\x00\x00\x00pythonq\x04X\x05\x00\x00\x00priceq\x05Mhtub.'
p = pickle.loads(ret) # 反序列化的过程
print(p.name,p.price) # python 29800

    

      

   

《Python》内置方法进阶和常用模块的更多相关文章

  1. 匿名函数 python内置方法(max/min/filter/map/sorted/reduce)面向过程编程

    目录 函数进阶三 1. 匿名函数 1. 什么是匿名函数 2. 匿名函数的语法 3. 能和匿名函数联用的一些方法 2. python解释器内置方法 3. 异常处理 面向过程编程 函数进阶三 1. 匿名函 ...

  2. Python内置方法详解

    1. 字符串内置方法详解 为何要有字符串?相对于元组.列表等,对于唯一类型的定义,字符串具有最简单的形式. 字符串往往以变量接收,变量名. 可以查看所有的字符串的内置方法,如: 1> count ...

  3. python 内置方法、数据序列化

    abc(*args, **kwargs) 取绝对值 def add(a,b,f): return f(a)+f(b) res = add(3,-6,abs) print(res) all(*args, ...

  4. python内置方法

    1. 简介 本指南归纳于我的几个月的博客,主题是 魔法方法 . 什么是魔法方法呢?它们在面向对象的Python的处处皆是.它们是一些可以让你对类添加"魔法"的特殊方法. 它们经常是 ...

  5. 基于python内置方法进行代码混淆

    0x00 动态加载模块 在python脚本中,直接使用import os.import subprocess或from os import system这种方法很容易被规则检测,即使使用其它执行命令的 ...

  6. Python内置方法的时间复杂度(转)

    原文:http://www.orangecube.net/python-time-complexity 本文翻译自Python Wiki本文基于GPL v2协议,转载请保留此协议. 本页面涵盖了Pyt ...

  7. Python内置方法的时间复杂度

    转载自:http://www.orangecube.NET/Python-time-complexity 本页面涵盖了Python中若干方法的时间复杂度(或者叫"大欧"," ...

  8. 常用的python内置方法

    all  ( )                                 循环参数,参数全为真就返回Ture  any()                              只要有一个 ...

  9. Python内置方法/函数

    abs() 返回数字的绝对值. abs(x) all() 用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE,如果是返回 True,否则返回 False. 元素除了是 0.空. ...

随机推荐

  1. BZOJ4887: [Tjoi2017]可乐 矩阵快速幂

    Description 加里敦星球的人们特别喜欢喝可乐.因而,他们的敌对星球研发出了一个可乐机器人,并且 放在了加里敦星球的1号城市上.这个可乐机器人有三种行为:停在原地,去下一个相邻的 城市,自爆. ...

  2. Docker operation

    Docker 容器镜像删除 1.停止所有的container,这样才能够删除其中的images: docker stop $(docker ps -a -q) 如果想要删除所有container的话再 ...

  3. Linux基础※※※※Linux中的图形相关工具

    kolourPaint类似于Win中个mspaint: Ubuntu安装:sudo apt-get install kolourpaint4 图1 kolourPaint界面 其他类似的画图工具见链接 ...

  4. Jmeter 之 ServerAgent 在性能测试的时候通过插件监听数据库状态

    https://jmeter-plugins.org/downloads/old/ 下载几个jar包,导入到Jmeter对应到目录下/lib/ext文件夹下,注意只支持Jmeter3.2(不含)以下版 ...

  5. TypeScript基础学习

    什么是TypeScript? TypeScript是一种由微软开发的自由的和开源的编程语言,它是JavaScript的一个超集,扩展了JavaScript的语法. TypeScript支持任意浏览器, ...

  6. linux下模拟FTP服务器(笔记)

    要在linux下做一个模仿ftp的小型服务器,后来在百度文库中找到一份算是比较完整的实现,就在原代码一些重要部分上备注自己的理解(可能有误,千万不要轻易相信). 客户端: 客户端要从服务器端中读取数据 ...

  7. NIO 之 ByteBuffer

    前言 对于刚接触ByteBuffer人来说,想要完全理解会稍微有点困难,正巧前几天有人问我,想到好久没写文章,就整理一下. 概念理解 对于ByteBuffer的一些概念不理解的情况下,如果直接打开源码 ...

  8. node 工程化 web项目

    1.结构 node_modules   ( ... ) routers     ( main.js  ) views    ( index.html   about.HTML  404.html ) ...

  9. UVA - 11853 Paintball(dfs)

    UVA - 11853 思路:dfs,从最上面超过上边界的圆开始搜索,看能不能搜到最下面超过下边界的圆. 代码: #include<bits/stdc++.h> using namespa ...

  10. CAS-自旋锁

    自旋锁 自旋锁(spinlock):是指当一个线程在获取锁的时候,如果锁已经被其它线程获取,那么该线程将循环等待,然后不断的判断锁是否能够被成功获取,直到获取到锁才会退出循环.  获取锁的线程一直处于 ...