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基础之模块
模块,用一砣代码实现了某个功能的代码集合. 类似于函数式编程和面向过程编程,函数式编程则完成一个功能,其他代码用来调用即可,提供了代码的重用性和代码间的耦合.而对于一个复杂的功能来,可能需要多个函数才 ...
随机推荐
- 安天透过北美DDoS事件解读IoT设备安全——Mirai的主要感染对象是linux物联网设备，包括：路由器、网络摄像头、DVR设备，入侵主要通过telnet端口进行流行密码档暴力破解，或默认密码登陆，下载DDoS功能的bot，运行控制物联网设备
安天透过北美DDoS事件解读IoT设备安全 安天安全研究与应急处理中心(安天CERT)在北京时间10月22日下午启动高等级分析流程,针对美国东海岸DNS服务商Dyn遭遇DDoS攻击事件进行了跟进分析. ...
- java爬虫进阶 —— ip池使用，iframe嵌套，异步访问破解
写之前稍微说一下我对爬与反爬关系的理解 一.什么是爬虫 爬虫英文是splider,也就是蜘蛛的意思,web网络爬虫系统的功能是下载网页数据,进行所需数据的采集.主体也就是根据开始的超链接,下 ...
- summary_22rd Nov 2018
一. 列表:记录同种属性的多个值 定义:在[]中用逗号分隔开多个任意的值 类型转换:L=list( ) 括号中的内容必须是可迭代类型,包括字符串,列表,字典等 常用操作和内置方法: 1.按照索引位置 ...
- SpringMVC中JSP页面显示为源码
@RequestMapping(value = "login") public ModelAndView login(ModelAndView mav) throws Except ...
- Theano笔记
scan函数 theano.scan(fn, sequences=None, outputs_info=None,non_sequences=None, n_steps=None, truncate_ ...
- jquery checkbox的使用
获取单个checkbox选中的写法: $('input:checkbox:checked').val(); $("input:[type='checkbox']:checked") ...
- SQL 常用判断语句
我们在做sql更新时,为防止sql重复执行报错,需要对所需要执行的对象进行判断是否存在: 常用判断脚本如下: 判断视图是否存在 IF object_id('viewname') IS not NULL ...
- vue引用样式
cnpm i sass-loader node-sass -D <link rel="stylesheet" href="./static/reset.css&qu ...
- python常见面试题（mark）
1.大数据的文件读取 ① 利用生成器generator ②迭代器进行迭代遍历:for line in file 2.迭代器和生成器的区别 1)迭代器是一个更抽象的概念,任何对象,如果它的类有next方 ...
- 7.1 C++模板基本概念及语法 《C++模板与标准模板库》
参考:http://www.weixueyuan.net/view/6398.html 总结: 模板是另一种代码重用机制. 需要设计的几个类,其功能都是一样的,仅仅只是需要操作的数据类型不同. 有更好 ...