面向对象的三个内置函数

总共有：property、classmethod、staticmethod三个

property

内置装饰器函数，只在面向对象这里使用

from math import pi
class Circle:
    def __init__(self,r):
        self.r=r

    def perimeter(self):
        return 2*pi*self.r
    def area(self):
        return pi*self.r*self.r

c1=Circle(5)
print(c1.area())
print(c1.perimeter())#注意这里是将area和perimeter分别当作方法来使用的

小知识：在类中定义一个函数就是方法，定义一个名字是属性。

那么area，perimeter本身就是名词，可否当作属性使用？可以

from math import pi
class Circle:
    def __init__(self,r):
        self.r=r

    @property
    def perimeter(self):
        return 2*pi*self.r

    @property
    def area(self):
        return pi*self.r*self.r

c1=Circle(5)
print(c1.area)
print(c1.perimeter)#注意这里是将area和perimeter分别伪装成属性来使用的

下一个例子

class Person:
    def __init__(self,name):
        self.__name=name
    @property
    def name(self):
        return self.__name+'123'
Jack=Person('jack')
print(Jack.name)
Jack.name='456'#这里显而易见，一旦名字确定后，就不能修改

那么如果想修改？

class Person:
    def __init__(self,name):
        self.__name=name
    @property
    def name(self):#注意这里的方法名字
        return self.__name+'123'
    @name.setter#因为下面的方法和上面的方法同名，一般情况下，代码中不允许有同名的方法，但是这里使用了装饰器以后可以这样做；这里的方法名字
    def name(self,new_name):#注意这里只能传一个参数；这里的方法名字
#注意三处方法的名字必须一致
        self.__name=new_name
Jack=Person('jack')
print(Jack.name)
Jack.name='456'
print(Jack.name)

举一个更加实际的例子：

一个超市，打折

class Goods:
    discount=0.5#定义一个静态属性，表示打五折
    def __init__(self,name,price):
        self.name=name
        self.price=price

Apple=Goods('苹果',5)
print(Apple.price)#这里只能显示出目前的价格，那么如何实现打折以后的价格呢？

利用property

class Goods:
    discount=0.5#定义一个静态属性，表示打五折
    def __init__(self,name,price):
        self.name=name
        self.__price=price
    @property
    def price(self):
        return self.__price*self.discount

Apple=Goods('苹果',5)
print(Apple.price)
#这样以后超市无论打几折，就可以直接改折扣即可

 

classmethod

类方法
面向类的一些操作

把一个方法变成一个类中的方法，这个方法就直接可以被调用，不需要依托任何对象。但这个方法的操作方法只涉及静态属性的时候，就应该使classmethod这个方法。

class Goods:
    __discount=0.8
    def __init__(self,name,price):
        self.name=name
        self.__price = price
    def price(self):
        return self.__price*self.__discount

    @classmethod
    def change_discount(cls,new_discount):
        cls.__discount=new_discount

Apple=Goods('苹果',5)
print(Apple.price())
Goods.change_discount(0.5)
print(Apple.price())

 

staticmethod

静态方法

 在完全面向对象的程序中，如果一个函数既和对象没有关系，也和类没有关系，那么就用staticmethod将这个函数变成一个静态方法。

class Login:
    def __init__(self,username,password):
        self.username=username
        self.password = password
    def login(self):pass


    def get_user_pwd():
        user=input('请输入用户名：')
        pwd=input('请输入密码：')
        Login(user,pwd)

Login.get_user_pwd()

上面是自己写的代码，实现了老师的功能

下面的是老师的代码，感觉优点问题。

class Login:
    def __init__(self,name,password):
        self.name = name
        self.pwd = password
    def login(self):pass

    @staticmethod
    def get_usr_pwd():   # 静态方法
        usr = input('用户名 ：')
        pwd = input('密码 ：')
        Login(usr,pwd)

Login.get_usr_pwd()

# 类方法和静态方法 都是类调用的
# 对象可以调用类方法和静态方法么？   可以   一般情况下 推荐用类名调用
# 类方法 有一个默认参数 cls 代表这个类  cls
# 静态方法 没有默认的参数 就象函数一样

classmethod
staticmethod

 

面向对象的方法总结：
普通方法：self
静态方法：@staticmethod
类方法：@classmethod
属性方法：@property