类和对象的绑定和解除绑定
在类内部定义的函数无非三种用途
所谓方法就是函数和类或者类对象进行绑定
一:绑定到对象的方法
只要是在类内部定义的,并且没有被任何装饰器修饰过的方法,都是绑定到对象的
class Foo:
def test(self): #绑定到对象的方法
pass
def test1(): #也是绑定到对象的方法,只是对象.test1(),会把对象本身自动传给test1,因test1没有参数所以会抛出异常
pass
绑定到对象,指的是:就给对象去用,
使用方式:对象.对象的绑定方法(),不用为self传值
特性:调用时会把对象本身当做第一个参数传给对象的绑定方法
二:绑定到类的方法:classmethod
在类内部定义的,并且被装饰器@classmethod修饰过的方法,都是绑定到类的
@classmethod
def test3(cls):
pass
@classmethod
def test4():
pass
绑定到对象,指的是:就给对象去用,
使用方式:类.类的绑定方法;对象.对象的绑定方法(),绑定到类的对象也可以使用
特性:调用时会把对象本身当做第一个参数传给对象的绑定方法
三:解除绑定的方法:staticmethod
既不与类绑定,也不与对象绑定,不与任何事物绑定
绑定的特性:自动传值(绑定到类的就是自动传类,绑定到对象的就自动传对象)
解除绑定的特性:不管是类还是对象来调用,都没有自动传值这么一说了,那就是普通函数
所以说staticmethod就是相当于一个普通的工具包
class Foo:
def test1(self):
pass
def test2():
pass
@classmethod
def test3(cls):
pass
@classmethod
def test4():
pass
@staticmethod
def test5():
pass
test1与test2都是绑定到对象方法:调用时就是操作对象本身
<function Foo.test1 at 0x0000000000D8E488>
<function Foo.test2 at 0x0000000000D8E510>
test3与test4都是绑定到类的方法:调用时就是操作类本身
<bound method Foo.test3 of <class '__main__.Foo'>>
<bound method Foo.test4 of <class '__main__.Foo'>>
test5是不与任何事物绑定的:就是一个工具包,谁来都可以用,没说专门操作谁这么一说
<function Foo.test5 at 0x0000000000D8E6A8>
@classmethod 装饰器
# classmethod,绑定类的方法,类和实例都可以使用且相等,但是传入的是类,子类可以调用
class Foo:
def bar(self):
pass
@classmethod
def testh(cls,x):
print(cls,x)
Foo.testh(122)
f=Foo()
f.testh(123)
import time
print(time.localtime(time.time()))
@staticmethod 装饰器
# @staticmethod 专门给类用的调用自己的方法,给类扩展方法,计算机只认识时间秒,并把所有的秒作为时间戳格式,就是time.time
# time.localtime()转换为当前年月日是分秒格式
import time
# print(time.time())
# print(time.localtime())
class Date:
def __init__(self,y,m,d):
self.y=y
self.m=m
self.d=d
@staticmethod
def today():
t=time.localtime()
obj=Date(t.tm_year, t.tm_mon, t.tm_mday)
return obj
@staticmethod
def tomorrow():
t=time.localtime(time.time()+86400)
obj=Date(t.tm_year, t.tm_mon, t.tm_mday)
return obj
print(Date.today())
d=Date.today()
print(d.y,d.m,d.d)
print(Date.tomorrow())
t=Date.tomorrow()
print(t.y,t.m,t.d)
print(t)
@property装饰器
# @property把类函数变成实例自己的属性,调用时候去掉()操作,动态计算,优先于对象的使用
import math
class Circle:
def __init__(self,r):
self.r=r
@property
def area(self):
return math.pi*self.r**2
@property
def perimiter(self):
return 2*math.pi*self.r
c=Circle(4.5)
# print(c.area())
# print(c.perimiter())
print(c.area)
print(c.perimiter)
@方法名.setter/@方法名.deleter
class People:
def __init__(self,name,sex):
self.name=name
self.sex=sex
@property
def sex(self):
return self.__sex
@sex.setter
def sex(self,value):
if not isinstance(value,str):
raise TypeError("type error")
else:
self.__sex=value
@sex.deleter
def sex(self):
del self.__sex
alex=People("alex","male")
alex.sex="female"
print(alex.sex)
总结回答
1.什么是绑定到对象的方法,如何定义,如何调用,给谁用?有什么特性
#
# 绑定到对象的方法指的是:只要是在类内部定义的,并且没有被任何装饰器修饰过的方法,都是绑定到对象的
# 定义:
# class Foo:
# def test(self): #绑定到对象的方法
# pass
# def test1(): #也是绑定到对象的方法,只是对象.test1(),会把对象本身自动传给test1,因test1没有参数所以会抛出异常
# pass
#
# 调用:对象.对象的绑定方法(),不用为self传值
# 给谁用:给类的实例
# 特性:调用时会把对象本身当做第一个参数传给对象的绑定方法
#
#
# 2.什么是绑定到类的方法,如何定义,如何调用,给谁用?有什么特性
# 绑定到类的方法指的是:classmethod,在类内部定义的,并且被装饰器@classmethod修饰过的方法,都是绑定到类的
# 绑定类的方法,类和实例都可以使用且相等,但是传入的是类,子类可以调用
# 定义:
# @classmethod
# def test3(cls):
# pass
# @classmethod
# def test4():
# pass
# 调用:类.类的的绑定方法(),不用为cls传值
# 给谁用:给类的实例
# 特性:调用时会把类本身当做第一个参数传给类的绑定方法
#
#
# 3.什么是解除绑定的函数,如何定义,如何调用,给谁用?有什么特性
# 解除绑定的函数指的是:staticmethod既不与类绑定,也不与对象绑定,不与任何事物绑定
# 定义:
# @staticmethod
# def test5():
# pass
#
# 调用:类.类的的绑定方法(),对象.对象的绑定方法()
# 给谁用:给类以及对象
# 特性:绑定的特性:自动传值(绑定到类的就是自动传类,绑定到对象的就自动传对象),
# 解除绑定的特性:不管是类还是对象来调用,都没有自动传值这么一说了,就是手动传,所以说staticmethod就是相当于一个普通的工具包
#
#
#
# 4.什么是property,如何定义,如何使用,给谁用,什么情况下应该将一个属性定义成property,有什么好处?
# property:@property把类函数变成实例自己的属性,调用时候去掉()操作,动态计算,优先于对象的使用
# 定义:
# import math
# class Circle:
#
# def __init__(self,r):
# self.r=r
#
# @property
# def area(self):
# return math.pi*self.r**2
#
# @property
# def perimiter(self):
# return 2*math.pi*self.r
#
# 使用:
# c=Circle(4.5)
# # print(c.area())
# # print(c.perimiter())
# print(c.area)
# print(c.perimiter)
#
# 给谁用:给对象
# 场景:简化函数操作,增加增删改查功能
# 好处:利用属性的操作比属性更加强大的功能