通常情况下，类中函数中定义的所有函数,,都是对象的绑定方法，除此之外，还有专门的静态方法和类方法，这两个是专门给类使用的，但是对象非要调用也是不会报错的。
对象在调用的时候会把自己传递给self，也就是绑定方法的第一个参数。
1 静态方法
这里定义spam的时候没有self,而是传入了xyz,类在使用的时候必须传入3个参数
class Foo:
@staticmethod # spam = staticmethod(apam)
def spam(x,y,z):
print(x,y,z)
# spm = staticmethod(spam)
Foo.spam(1,2,3)
应用场景
首相先了解下时间模块的使用
>>>import time
>>> time.localtime()
time.struct_time(tm_year=2017, tm_mon=4, tm_mday=22, tm_hour=20, tm_min=7, tm_se
c=41, tm_wday=5, tm_yday=112, tm_isdst=0)
>>> t=time.localtime()
>>> print(t.tm_year)
2017
应用场景
# 应用场景
import time
class Date:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
@staticmethod
def now():
t = time.localtime()
obj = Date(t.tm_year,t.tm_mon,t.tm_mday)
return obj
# d1 = Date(2017,1,12)
# print(d1.year)
date_now =Date.now() # 使用的时候就不同传参数了 直接调用
print(date_now.year)
print(date_now.month)
print(date_now.day)
**date_now =Date.now() **对类来说就是一种实例化，
专门给类用的
增加一个新的
import time
class Date:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
@staticmethod
def now():
t = time.localtime()
obj = Date(t.tm_year,t.tm_mon,t.tm_mday)
return obj
@staticmethod
def tomorrow():
t1 = time.localtime(time.time()+86400)
obj = Date(t1.tm_year, t1.tm_mon, t1.tm_mday)
return obj
# d1 = Date(2017,1,12)
# print(d1.year)
date_now =Date.now() # 使用的时候就不同传参数了 直接调用
print(date_now.year)
print(date_now.month)
print(date_now.day)
date_tomorrow = Date.tomorrow() #此时使用的是调用方法是一样的
print(date_tomorrow.year)
print(date_tomorrow.month)
print(date_tomorrow.day)
2 类方法
类方法是专门类的绑定方法
class Foo:
def bar(self):
pass
@classmethod # 类的绑定方法
def test(cls,x): # 可以传入多个值
print(cls,x)
print(Foo.bar)
print(Foo.test)
结果：
function Foo.bar at 0x0000000002B0AB70> 类的函数
bound method Foo.test of <class 'main.Foo'>> 类的绑定方法
类的绑定方法和对象的绑定方法是一样的，会把类本身当做第一个参数传递给类的方法
class Foo:
def bar(self):
pass
@classmethod
def test(cls,x):
print(cls,x) #cls是类的内存地址
cls() # 类实例化
# print(Foo.bar)
# print(Foo.test)
Foo.test(124)
f = Foo() #实例化一个对象
print(f.test)
print(Foo.test)
结果：
bound method Foo.test of <class 'main.Foo'>>
bound method Foo.test of <class 'main.Foo'>>
打印的的都是类的绑定方法，
即便是实例一个对象，f.test(123) 也是使用的类的绑定方法
获得了类的内存地址，加括号就能实例化
str
定义在类的内部，必须返回一个字符串类型
什么时候出发执行？打印这个类的对象时，会出发执行
class People:
def init(self,name,age):
self.name=name
self.age = age
def __str__(self):
return 'name:%s,age:%s' %(self.name,self.age)
p1=People("aa",18)
print(p1)
应用场景
import time
class Date:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
@staticmethod
def now():
t = time.localtime()
obj = Date(t.tm_year,t.tm_mon,t.tm_mday)
return obj
@staticmethod
def tomorrow():
t1 = time.localtime(time.time()+86400)
obj = Date(t1.tm_year, t1.tm_mon, t1.tm_mday)
return obj
class EuropeDate(Date): # 定义一个子类类继承
pass
e1 = EuropeDate.now() # 实例化
print(e1) # 打印这个实例化的对象的时候仍然是Date的对象
结果：
main.Date object at 0x0000000002330B38>
也就是说自己儿子确实别人的
解决方案
import time
class Date:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
@classmethod
def now(cls):
print(cls) # 打印一下，测试传入的类是
t = time.localtime()
obj = Date(t.tm_year,t.tm_mon,t.tm_mday)
return obj
@classmethod
def tomorrow(cls):
t1 = time.localtime(time.time()+86400)
obj = Date(t1.tm_year, t1.tm_mon, t1.tm_mday)
return obj
class EuropeDate(Date): # 定义一个子类类继承
def __str__(self):
return 'year:%s,month:%s,day:%s' %(self.year,self.month,self.day)
e1 = EuropeDate.now() #
通过测试，此时打印的的类是Europe
class 'main.EuropeDate'>
终极版：
import time
class Date:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
@classmethod
def now(cls):
print(cls) # 打印一下，测试传入的类是
t = time.localtime()
obj = cls(t.tm_year,t.tm_mon,t.tm_mday)
return obj
@classmethod
def tomorrow(cls):
t1 = time.localtime(time.time()+86400)
obj = cls(t1.tm_year, t1.tm_mon, t1.tm_mday)
return obj
class EuropeDate(Date): # 定义一个子类类继承
def __str__(self):
return 'year:%s,month:%s,day:%s' %(self.year,self.month,self.day)
e1 = EuropeDate.now() #
print(e1)
结果是：
class 'main.EuropeDate'>
year:2017,month:4,day:23
在程序中改的是
**obj = cls(t.tm_year,t.tm_mon,t.tm_mday) **，这是用子类实例化
引入cls就是谁来调用，谁就执行