类和对象的绑定和解除绑定
在类内部定义的函数无非三种用途
所谓方法就是函数和类或者类对象进行绑定
一：绑定到对象的方法
只要是在类内部定义的，并且没有被任何装饰器修饰过的方法，都是绑定到对象的
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)
#
# 给谁用：给对象
# 场景：简化函数操作，增加增删改查功能
# 好处：利用属性的操作比属性更加强大的功能
