python 静态类型_Python静态方法 类方法

通常情况下，类中函数中定义的所有函数,,都是对象的绑定方法，除此之外，还有专门的静态方法和类方法，这两个是专门给类使用的，但是对象非要调用也是不会报错的。

对象在调用的时候会把自己传递给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 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 >

bound method Foo.test of >

打印的的都是类的绑定方法，

即便是实例一个对象，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就是谁来调用，谁就执行