python面向对象编程（一）：各种类方法解释

在python中，一切皆对象。

1、类对象

类定义的格式为“class  类名”，实际上当解释器执行class语句是，就会创建一个类对象

class Student:
       pass #空语句

print(type(Student))
print(id(Student))

Stu2=Student  #将类的地址赋给了Stu2
s1=Stu2()
print(s1)

2、类属性

类属性是从属于“类对象”的属性，也称为“类变量”，类属性从属于类对象，可被所有实例对象共享

（1）定义方法：

  class    类名：

           类变量名=初始值

（2）在类中或类外，我们通过“类名.变量名”的方式来读写

#类属性的使用测试
class Student(object):
    company="SAT" #类属性
    count=0
    def __init__(self,name,score):
        self.name=name #实例属性
        self.score=score
        Student.count=Student.count+1 #每创建一个类对象类属性count加一
    def say_score(self): #类方法
        print('我的公司是',Student.company)
        print(self.name,"的分数是",self.score)
s1=Student('yin',18) #s1实例类对象，自动调用_init_方法
s1.say_score()
print('一共创建了{}个对象'.format(Student.count))#在类中或类外都可以使用类名.变量名调用类属性

#我的公司是 SAT
#yin 的分数是 18
#一共创建了1个对象

3、类方法

类方法从属于“类对象”的方法，类方法通过装饰器@classmethod来定义

@classmethod
def 类方法名（cls,[形参列表]） #cls指类对象本身
   函数体

调用类方法：类名.方法名（参数列表），参数列表中不能给类对象传送值

class Student:
    company="SXT" #类属性
    @classmethod
    def printCompany(cls):   #cls是类对象本身
        print(cls.company)
Student.printCompany()

4、静态方法

用于定义与“类对象”无关的方法，称为“静态方法”，放到“类名字空间里面”，需要通过“类调用”

定义格式：

@staticmethod
def 静态方法名（[形参列表]）：
     函数体

5、_del_方法（析构方法）：用于实现对象销毁时所需的操作，实现自动的垃圾回收

class Person:
    def __del__(self):
        print("销毁对象{}".format(self))
        
p1=Person()
p2=Person()
del p2  #删除销毁对象p2
print("程序结束")
print(p1)  #p2已被销毁，p1要等到程序结束才被销毁
print(p2)

6、_call_方法和可调用对象

定义了_call_方法的对象，称为“可调用对象”，即该对象可以像函数一样被调用（object()实际上调用的是call方法）

class SalaryAccount:
    #工资计算类
    
    def __call__(self, salary):
        print("计算工资")
        yearsalary=salary*12
        daysalary=salary//22.5 #国家规定的每个月的平均工作天数
        hoursalary=daysalary//8
        return dict(yearsalary=yearsalary,monthsalary=salary,daysalary=daysalary,hoursalary=hoursalary)
s=SalaryAccount()#定义实例对象s
print(s(3000))#打印输出，object()默认调用call方法

#计算工资
#{'yearsalary': 36000, 'monthsalary': 3000, 'daysalary': 133.0, 'hoursalary': 16.0}

7、方法没有重载

在其他语言中，重名的函数，参数的类型和数量可以不一样，称为函数重载；而在python中，没有数据类型，参数的数量也可由可变参数控制，因此python中是没有方法重载的，一个方法可有多种调用方式

可以定义多个重名函数，但后面的那个重名函数会覆盖掉之前定义的那个函数，因此不要使用重名的方法

8、方法的动态性

可以动态的为类添加新的方法，动态的修改类的已有方法

class Person:
    def work(self):
        print("努力学习")

def play_game(s):  #动态的增加方法
    print("{}在玩游戏".format(s))

Person.play=play_game; #将方法的地址赋给实例属性(新增加的属性)定义了新的方法
p=Person()#创建实例对象
p.work()
p.play()#调用新的方法

#努力学习
#<__main__.Person object at 0x0000000002118630>在玩游戏

9、私有属性和私有方法（实现封装）：封装后细节私有化，外部访问不了

（1）两个下划线开头的属性是私有的（private）,其他为公共的（public）

（2）类内部可访问私有属性（方法）

（3）类外部不可直接访问私有属性

（4）类外部使用“_类名_私有属性（方法）名”访问私有属性

class Employee:

    def __init__(self,name,age):#构造方法
        self.name=name#共有属性
        self.__age=age#私有属性
    def __work(self):#私有方法
        print("好好学习")
e=Employee("YIN",18)#定义初始化实例对象
print(e.name)
print(e._Employee__age)#访问私有属性的方式  _类名_私有属性名
e._Employee__work()#访问私有方法

10、@property装饰器

@property可以将一个方法的调用方式变成“属性调用”

class Employee:

    @property
    def salary(self):
        print("salary run...")
        return 10000
emp1=Employee()
print(emp1.salary)#将方法用作属性一样使用

#salary run...
#10000

class Employee:

    def __init__(self,name,salary):
        self.__name=name#将属性进行私有化实现封装的效果
        self.__salary=salary
    @property
    def salary(self):  #相当于为salary增加了get方法
        return self.__salary
    @salary.setter  #相当于对salary属性的设置，装饰器
    def salary(self,salary):
        if 1000<salary<5000:
            self.__salary=salary
        else:
            print("录入错误，应在1000-5000之间")
emp1=Employee('yin',1000)
print(emp1.salary)#使用property修饰后可作为属性直接引用，相当于调用get方法
emp1.salary=2000#salary setter修饰后，可直接作为属性引用
print(emp1.salary)

#1000
#2000