Python之路，第十八篇：Python入门与基础18
python3 面向对象编程2
类方法：
@classmethod
作用：1，类方法是只能访问类变量的方法；
2，类方法需要使用@classmethod 装饰器定义；
3，类方法的第一个参数是类的实例， 约定写成cls
说明：1， 类实例和对象实例都可以调用类方法；
2， 类方法不能方法实例变量
类方法和实例方法对比：
1，类方法能够访问类变量，不能访问实例变量；
实例方法能够访问类变量，也能访问实例变量
2，类方法可以用实例来调用，也可以用类来调用；
实例方法在调用时必须传入实例；
class Bank:
moneys = 10000000 #一千万
@classmethod
def total_money(cls):
print("某银行总行资金数：", cls.moneys) def __init__(self, b):
self.branch = b
self.moneys = 5000000
self.__class__.moneys -= 5000000 Bank.total_money() #某银行总行资金数： 10000000
b1 = Bank("xxx地址支行")
b1.total_money() #某银行总行资金数： 5000000
静态方法
@staticmethod
作用：1， 静态方法是普通的函数；
2，静态方法定义在类的内部，只能凭借该类和实例调用
3，静态方法需要使用@staticmethod 装饰器定义
4，静态方法与普通函数定义相同，不需要传入self实例参数和cls类参数；
说明：1， 类实例和对象实例都可以调用静态方法；
2， 静态方法不能访问类变量和实例变量；
class A:
@staticmethod
def myadd(a, b):
return a + b print(A.myadd(100, 200)) #
a = A()
print(a.myadd(200, 300)) #
实例方法，类方法，静态方法总结：
不想访问类变量的实例变量（属性），用静态方法；
只想访问类内变量，不想访问实例属性用类方法；
既想访问类内变量，也想访问实例变量用实例方法；
特性属性
@property 用来模拟一个属性；
通过@property 装饰器可以对模拟属性赋值和取值加以控制失效其他语言所拥有的getter 和 setter 功能；
import math
class Circle:
def __init__(self,r): #圆类
self.radius = r #半径
@property
def area(self): #面积
print("area函数被调用。。。")
return math.pi * self.radius ** 2
def area(self, a): #a代表面积
self.radius = math.sqrt(a/math.pi)
c1 = Circle(10)
print(c1.area)
#area函数被调用。。。
#314.1592653589793
c1.area = 31415.926
print(c1.radius)
print(c1.area)
#<bound method Circle.area of <__main__.Circle object at 0x00000000021ABB00>>
#
#31415.926
函数 id
id（obj） 返回对象的标识（identity）；
例： id（a） == id（a1） #F
>>> class A:
pass >>> a = A()
>>> a1 = A()
>>> a is a1
False
>>> id(a)
54961992
>>> id(a1)
54905488
>>> a
<__main__.A object at 0x000000000346A748>
>>> 0x000000000346A748
54961992
>>>
运算符重载
什么是运算符重载？
用自定义的规则实现实例之间的运算符操作或函数操作；
作用：
1， 让实例像数学表达式一样的进行运算操作；
2， 让实例像内建对象一样函数操作；
3， 让程序简洁起来；
对象转字符串函数重载方法；
repr（） 函数的重载方法：
def __repr__(self):
.....
str( ) 函数的重载方法：
def __str__(str):
....
注： 如果对象没有__str__方法， 则用repr（obj）函数的结果代替；
class MyNumber:
"此类用于定义一个整型数字类，用于演示str函数重载"
def __init__(self,v):
self.data = v def __repr__(self):
print("__repr__被调用")
return "MyNumber(" + repr(self.data) + ")" def __str__(self):
print("__str__被调用")
return "整数数值(" + str(self.data) + ")" n1 = MyNumber(100)
n2 = MyNumber(200)
print(repr(n1))
print(str(n2))
#__repr__被调用
#MyNumber(100)
#__str__被调用
#整数数值(200)
print(n2) #等同于print(str(n2))
#__str__被调用
#整数数值(200)
print(n1,(1,2,3),2j)
#__str__被调用
#整数数值(100) (1, 2, 3) 2j
算数运算符的重载：
+ __add__
- __sub__
* __mul__
/ __truediv__
// __floordiv__
% __mod__
** __pow__
二元运算符的重载的格式；
def __xxx__(self, other):
....
注： 二元运算符的重载方法的参数列表找中只能有两个参数；
重载说明： 运算符重载的方法参数已经有固定的含义，不可改变原有意义，除 __call__方法之外，其他重载方法的参数个数不可改变；
练习1： 自定义两个列表类；
class MyList:
def __init__(self, a):
self.data = a.copy()
def infos(self):
return "MyList(" + str(self.data) + ")"
def __str__(self):
return self.infos()
L = [1,2,3]
L1 = MyList(L)
#L[2] = 3.14
print(L1.infos()) #MyList([1, 2, 3])
print(L1) #MyList([1, 2, 3])
L2 = MyList([4,5,6])
print(L2.infos()) #MyList([4, 5, 6])
print(L2) #MyList([4, 5, 6])
练习2： 实现两个类相加；
#自定义两个列表类，实现两个列表类相加
class MyList: def __init__(self, a):
self.data = a.copy() def infos(self):
return "MyList(" + str(self.data) + ")" def __str__(self):
return self.infos() def myadd(self,other):
r = []
r.extend(self.data)
r.extend(other.data)
#self.data.clear() #L1 = MyList([])
#other.data.clear() #L2 = MyList([])
return MyList(r) L1 = MyList([1,2,3])
L2 = MyList([4,5,6])
L3 = L1.myadd(L2)
print("L1=",L1)
print("L2=",L2)
#L3 = L1 + L2
print(L3) #MyList([1, 2, 3, 4, 5, 6])
class MyList:
def __init__(self, a):
self.data = a.copy()
def infos(self):
return "MyList(" + str(self.data) + ")"
def __str__(self):
return self.infos()
def myadd(self,other):
r = []
r.extend(self.data)
r.extend(other.data)
#self.data.clear() #L1 = MyList([])
#other.data.clear() #L2 = MyList([])
return MyList(r)
def __add__(self, other):
return self.myadd(other)
L1 = MyList([1,2,3])
L2 = MyList([4,5,6])
#L3 = L1.myadd(L2)
L3 = L1 + L2
print("L1=",L1)
print("L2=",L2)
print(L3) #MyList([1, 2, 3, 4, 5, 6])
class MyList:
def __init__(self, a):
self.data = a.copy()
def infos(self):
return "MyList(" + str(self.data) + ")"
def __str__(self):
return self.infos()
def myadd(self,other):
r = []
r.extend(self.data)
if type(other) == int:
r.append(other)
elif type(other) == MyList:
r.extend(other.data)
else:
raise ValueError("other 不能出现其他值")
#self.data.clear() #L1 = MyList([])
#other.data.clear() #L2 = MyList([])
return MyList(r)
def __add__(self, other):
return self.myadd(other)
L1 = MyList([1,2,3])
L2 = MyList([4,5,6])
#L3 = L1.myadd(L2)
L3 = L1 + L2
print("L1=",L1)
print("L2=",L2)
print(L3) #MyList([1, 2, 3, 4, 5, 6])
L3 = L1 + 10 #追加一个值
print(L3) #MyList([1, 2, 3, 10])
class MyList:
def __init__(self, a):
self.data = a.copy()
def infos(self):
return "MyList(" + str(self.data) + ")"
def __str__(self):
return self.infos()
#def myadd(self,other):
# r = []
# r.extend(self.data)
# if type(other) == int:
# r.append(other)
# elif type(other) == MyList:
# r.extend(other.data)
# else:
# raise ValueError("other 不能出现其他值")
# #self.data.clear() #L1 = MyList([])
# #other.data.clear() #L2 = MyList([])
# return MyList(r)
def __add__(self, other):
return self.myadd(other)
def __mul__(self, rhs): #right hand side
return MyList(self.data * rhs)
#以下方法可以实现
#L0 = MyList([])
#for x in range(rhs):
# L0 += MyList(self.data)
#return L0
L1 = MyList([1,2,3])
L2 = MyList([4,5,6])
L3 = L1 * 3
print(L3) #MyList([1, 2, 3, 1, 2, 3, 1, 2, 3])
反向算数运算符重载；
+ __radd__ (self, lhs) # 加法 lhs + self
- __rsub__(self, lhs) # 减法 lhs - self
* __rmul__(self, lhs) # 乘法 lhs * self
/ __rtruediv__(self, lhs) # 除法 lhs / self
// __rfloordiv__(self, lhs) #地板除 lhs // self
% __rmod__(self, lhs) #求余（取模） lhs % self
** __rpow__(self, lhs) #幂 lhs ** self
class MyList:
def __init__(self, a):
self.data = a.copy()
def __str__(self):
return "MyList("+ str(self.data) +")"
def __mul__(self, rhs): #right hand side
return MyList(self.data * rhs)
def __rmul__(self, lhs): #左
#return MyList(self.data * lhs)
#return self * lhs
return self.__mul__(lhs)
L1 = MyList([1,2,3])
L2 = MyList([4,5,6])
L3 = 3 * L1
print(L3) #MyList([1, 2, 3, 1, 2, 3, 1, 2, 3])
复合赋值运算符：
__iadd__(self, rhs) #加法 self += rhs
__isub__(self, rhs) #减法 self -= rhs
__imul__(self, rhs) #乘法 self *= rhs
__itruediv__(self, rhs) #除法 self /= rhs
__ifloordiv__(self, rhs) #地板除 self /= rhs
__imod__(self, rhs) #取模（求余） self %= rhs
__ipow__(self, rhs) #幂 self **= rhs
class MyList:
def __init__(self,a):
self.data = a.copy() def __str__(self):
return "MyList("+ str(self.data) +")" def __mul__(self, rhs): #right hand side
print("__mul__")
return MyList(self.data * rhs) def __imul__(self, rhs):
print("__imul__")
self.data = self.data * rhs
return self L1 = MyList([1,2,3])
L1 *= 2
print(L1)
#__mul__
#MyList([1, 2, 3, 1, 2, 3])
一元运算符的重载：
__neg__ -(负号)
__pos__ +(正号)
__invert__ ~(取反)
重载方法：
def __xxx__(self):
....
class MyList:
def __init__(self, a):
self.data = a.copy()
def __str__(self):
return "MyList("+ str(self.data) +")"
def __neg__(self):
ml = MyList(self.data)
for i in range(len(ml.data)):
ml.data[i] = -ml.data[i]
return ml
L1 = MyList([1,2,3])
L3 = -L1
print(L3) #MyList([-1, -2, -3])
class MyList:
def __init__(self, a):
self.data = a.copy()
def __str__(self):
return "MyList("+ str(self.data) +")"
def __invert__(self):
ml = MyList(self.data)
ml.data.reverse()
return ml
L1 = MyList([1,2,3])
L3 = ~L1
print(L3) #MyList([3, 2, 1])
比较运算符的重载：
__lt__ < 小于
__le__ <=
__gt__ >
__ge__ >=
__eq__ ==
__ne__ !=
比较运算的通常用于返回True 和 False；
class Tree:
def __init__(self, h): #h 树的高度
self.height = h def show(self):
"描述"
print(" * ")
print("***")
print(" * ")
print(" * ") def __lt__(self, rhs):
print("__lt__")
return self.height < rhs.height def __le__(self,rhs):
print("__le__")
return self.height < rhs.height def __gt__(self, rhs):
return not (self <= rhs) t1 = Tree(5)
t2 = Tree(10)
if t1 < t2:
print("t2树高")
else:
print("t1树高")
print(t1 <= t2)
print(t1 > t2)
位运算符重载
__invert__ ~取反
__and__ &位与
__or__ | 位或
__xor__ ^ 位异或
__lshift__ << 左移
__rshift__ >> 右移
内建函数的重载：
__abs__ abs(obj) 函数调用
__len__ len(obj)
__reversed__ reversed(obj)
__round__ round(obj)
class MyList:
def __init__(self, a):
self.data = a.copy()
def __str__(self):
return "MyList("+ str(self.data) +")"
def __abs__(self):
temp = self.data.copy() #列表
for i in range(len(temp)):
if temp[i] < 0:
temp[i] = -temp[i]
return MyList(temp)
L1 = MyList([1,-2,3,-4])
L2 = abs(L1)
print(L2) #MyList([1, 2, 3, 4])
repr() __repr__
str() _str__
__add__ self + other
__radd__ other + self
__iadd__ self += other
Python之路，第十八篇：Python入门与基础18的更多相关文章
- Python之路(第二十八篇) 面向对象进阶：类的装饰器、元类
一.类的装饰器 类作为一个对象,也可以被装饰. 例子 def wrap(obj): print("装饰器-----") obj.x = 1 obj.y = 3 obj.z = 5 ...
- Python之路(第十八篇)shutil 模块、zipfile模块、configparser模块
一.shutil 模块 1.shutil.copyfileobj(fsrc, fdst[, length]) 将文件内容拷贝到另一个文件中,需要打开文件 import shutil shutil.co ...
- 【Python之路】第八篇--Python基础之网络编程
Socket socket通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄,应用程序通常通过"套接字"向网络发出请求或者应答网络请求. sock ...
- Python之路【第八篇】：堡垒机实例以及数据库操作
Python之路[第八篇]:堡垒机实例以及数据库操作 堡垒机前戏 开发堡垒机之前,先来学习Python的paramiko模块,该模块机遇SSH用于连接远程服务器并执行相关操作 SSHClient ...
- Python之路【第八篇】:Python模块
阅读目录 一.模块和包 模块(module)的概念: 在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码会越来越长,越来越不容易维护. 为了编写可维护的代码,我们把很多函数分组,分别放到 ...
- Python自动化 【第十八篇】：JavaScript 正则表达式及Django初识
本节内容 JavaScript 正则表达式 Django初识 正则表达式 1.定义正则表达式 /.../ 用于定义正则表达式 /.../g 表示全局匹配 /.../i 表示不区分大小写 /.../m ...
- Python之路(第二十四篇) 面向对象初级：多态、封装
一.多态 多态 多态:一类事物有多种形态,同一种事物的多种形态,动物分为鸡类,猪类.狗类 例子 import abc class H2o(metaclass=abc.ABCMeta): def _ ...
- Python之路(第十五篇)sys模块、json模块、pickle模块、shelve模块
一.sys模块 1.sys.argv 命令行参数List,第一个元素是程序本身路径 2.sys.exit(n) 退出程序,正常退出时exit(0) 3.sys.version . sys.maxint ...
- Python之路(第十二篇)程序解耦、模块介绍\导入\安装、包
一.程序解耦 解耦总的一句话来说,减少依赖,抽象业务和逻辑,让各个功能实现独立. 直观理解“解耦”,就是我可以替换某个模块,对原来系统的功能不造成影响.是两个东西原来互相影响,现在让他们独立发展:核心 ...
- 【Python之路】第六篇--Python基础之模块
模块,用一砣代码实现了某个功能的代码集合. 类似于函数式编程和面向过程编程,函数式编程则完成一个功能,其他代码用来调用即可,提供了代码的重用性和代码间的耦合.而对于一个复杂的功能来,可能需要多个函数才 ...
随机推荐
- java高级---->Serializable的过程分析
本次讲解中我们在上次的基础上,深入的了解一下序列化的流程以及其中的原理.关于序列化的一些知识与使用,请参见我的另一篇博客:java基础---->Serializable的使用.好了,我们进行以下 ...
- 2015-09-28认识js1
Javascript 一.特点 1. 区分大小写 2. 弱类型变量,只能用关键字“var" 3.注释 /*….*/ 二. 变量 1.变量通过关键字var声明. 2.var ...
- [LeetCode] 99. Recover Binary Search Tree(复原BST) ☆☆☆☆☆
Recover Binary Search Tree leetcode java https://leetcode.com/problems/recover-binary-search-tree/di ...
- nodejs 解析excel文件
app.js: var FileUpload = require('express-fileupload') app.use(FileUpload()); service.js: npm instal ...
- jeasyUI DataGrid 根据屏幕宽度自适应, 改变右侧滚动条Size
PC浏览器的Datagrid可以显示多几列,但是在手机浏览器时,只能有选择性的显示前几列. $(window).resize(function () { if (document.body.clien ...
- VS中常用快捷键
常用的快捷键 这里仅列出一些个人觉得好用的快捷键: 调用智能提示:使用组合键“Ctrl+J” 注释/取消注释: 注释用组合键“Ctrl+K+C” 取消注释用组合键“Ctrl+K+U” 大小写转 ...
- webpack分离打包css和less
github仓库:https://github.com/llcMite/webpack.git 为什么要分离打包? 答:刚开始学webpack的时候就很郁闷,明明没几个文件,打包出来体积特 ...
- [CodeForces332E]Binary Key
Problem 题目给出一个加密前的字符串长度为p和加密后的字符串长度为s,让你求一个长度为K字典序最小的密钥. 密钥是循环的,第i位为1表示加密前的第i为是有用的否则是没用的. Solution 首 ...
- java⑨
do-while,先执行一次,再判断! do{ 循环体 }while(循环条件); 经典案例: 1. 需求: 01.记录每次用户购买的商品金额! 之后进行 结账! 02.增加购买商品的数量 ...
- bootstrap学习参考网站
----https://www. evget .com /article /