python入门与进阶篇(五)之面向对象

类的概念：类是现实世界或思维世界的实体在计算机中的反映，它将数据以及数据上的一些操作封装在一起。

类首字母大写 大驼峰命名 如StudentHomeWork

函数和方法的区别:

方法:设计层面 函数:程序运行、过程式的一种称谓

模块中的称作变量和函数

python面向对象的特点：

1.sum在类中被称作类变量(数据成员) do_homework()被称为类中的实例方法

2.self.name 和self.age被称作实例变量

3.实例化访问变量的时候首先会查找实例变量 找不到再找类变量 然后往上继承

4.self指向的是实例对象

5. 构造函数__init__() 实例化的时候默认会执行 但是也可以手动调用执行student.__init__()，构造函数默认返回None 并且只能返回None 构造函数可以称作特殊的实例方法

6.实例方法中访问类变量Student.sum 或self.__class__.sum

7.通过@classmethod装饰器将方法设置为类方法 cls代表类本身

8.通过@staticmethod装饰器将方法设置为静态方法 

class1.py:

class Student():
    # 类变量
    sum=0
    # 构造函数__init__() 实例化的时候默认会执行 但是也可以手动调用执行student.__init__()
    def __init__(self,name,age):
        # 实例变量
        self.name=name
        self.age=age
        # 实例方法中访问类变量Student.sum 或self.__class__.sum
        print("类变量访问方式1",Student.sum)
        print("类变量访问方式2",self.__class__.sum)
        print ("构造函数默认返回None 并且只能返回None")
    # 实例方法
    def do_homework(self):
        print("做家庭作业")
    # 类方法 cls代表类本身
    @classmethod
    def plus_sum(cls):
        cls.sum+=1
        print("sum:"+str(cls.sum))
    #当该方法与类和实例没什么关系的时候可以使用,但不推荐使用静态方法
    @staticmethod
    def add(x,y):
        print("this is a static methods!")

class2.py

#引入class1模块中的Student类
from class1 import Student

student1=Student("张三",18)
Student.plus_sum() # sum=1
student2=Student("李四",20)
Student.plus_sum() # sum=2
# 实例对象也可以调用类方法 但是通常不建议这样做
student1.plus_sum() # sum=3
# 实例对象也可以调用静态方法
student1.add(1,2)  # this is a static methods!
print(student1.name)   #张三  
print(student2.name)   #李四
print(student1.__dict__) #__dict__实例变量 {'name': '张三', 'age': 18}
#外部通过Student.name访问类变量
print(Student.sum)    #类变量

成员的可见性：

公共public 和私有private

__让类中的变量和方法称为私有变量和方法

通过方法去改变类中的私有变量 

python通过将私有变量改变名字隐藏起来

class Student():
    # 类变量
    sum=0
    #私有变量
    __sum1=0
    # 构造函数__init__() 实例化的时候默认会执行 但是也可以手动调用执行student.__init__()
    def __init__(self,name,age):
        # 实例变量
        self.name=name
        self.age=age
        # 私有变量
        self.__score=0
        # 实例方法中访问类变量Student.sum 或self.__class__.sum
        print("类变量访问方式1",Student.sum)
        print("类变量访问方式2",self.__class__.sum)
        print ("构造函数默认返回None 并且只能返回None")
    # 实例方法 私有方法
    def __do_homework(self):
        #内部调用实例方法
        self.do_english_homework()
        print("做家庭作业")
    def do_english_homework(self):
        print("做英语家庭作业")
    # 通过方法去改变私有变量
    def mark(self,score):
        if self.__score<0:
            print("分数不能为负")
            return None
        self.__score=score
        print("得分为:"+str(self.__score))

    # 类方法 cls代表类本身
    @classmethod
    def plus_sum(cls):
        cls.sum+=1
        print("sum:"+str(cls.sum))
    #当该方法与类和实例没什么关系的时候可以使用,但不推荐使用静态方法
    @staticmethod
    def add(x,y):
        print("this is a static methods!")


student1=Student('张三',18)
student2=Student('李四',20)
student1.mark(59)
student1.__score=12
# {'name': '张三', 'age': 18, '_Student__score': 59, '__score': 12} 通过将私有变量改变名字隐藏起来
print(student1.__dict__)
#动态添加实例变量__score
print(student1.__score)  #2
print(student2.__score)  #报错

 

继承:python中子类是可以继承多个父类的

推荐使用super的方式来调用父类的构造函数 而不是通过Human.__init__的显式调用方式

可以在实例方法中通过super的方式来调用父类的实例方法

extend1:

class Human():
    sum=0
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def get_name(self):
        print(self.name)
    def do_homework(self):
        print("这是父类的一个方法")

extend2:

#引入extend1模块 Human类
from extend1 import Human

#传入父类Human类 继承Human类
class Student(Human):
    def __init__(self,school,name,age):
        self.school=school
        # 显示调用父类__init__方法继承Human类的name和age 类来调用实例方法需要传入self
        # Human.__init__(self,name,age)
        #super的方式来调用父类的构造函数
        super(Student,self).__init__(name,age)
    def do_homework(self):
        #super的方式来调用父类的实例方法
        super(Student,self).do_homework()
        print("做家庭作业")

student1=Student("湖南长沙学院","张三",20)
#继承父类Human的sum类变量
print(student1.sum)  # 0
print(student1.name) # 张三
print(student1.age)  # 20
# 继承父类Human的get_name()实例方法
student1.get_name()  # 张三
#执行自己的do_homework()实例方法
student1.do_homework() #这是父类的一个方法 做家庭作业

思维导图

枚举:枚举实际上是一个类

from enum import Enum
# IntEnum限制枚举类型为数字
from enum import IntEnum,unique

# 钻石的类型 YELLOW:黄钻 GREEN:绿钻 BLACK:黑钻 RED:红钻
class Vip(Enum):
    YELLOW=1
    #YELLOW_ALIAS 为YELLOW的别名    
    YELLOW_ALIAS=1
    GREEN=2
    BLACK=3
    RED=4

# 枚举的特点:相比于字典和普通的类 值不可变 且不允许重复的值
print(Vip.YELLOW.name)  # name 枚举的名字
print(Vip.YELLOW.value) # value 枚举的值

print(type(Vip.YELLOW.name)) #<class 'str'>
print(type(Vip.YELLOW)) #<enum 'Vip'> 枚举的类型
print(Vip['YELLOW']) #Vip.YELLOW

#遍历枚举
for v in Vip:
    print(v)   #Vip.YELLOW Vip.GREEN Vip.BLACK Vip.RED

# 遍历枚举包括别名
for v in Vip.__members__:
    print(v)  #YELLOW YELLOW_ALIAS GREEN BLACK RED

# 枚举不支持>比较运算符  支持==、is运算符

#将数字转化为枚举类型
a=1
print(Vip(a)) #Vip.YELLOW

#@unique 让枚举的值唯一
@unique
class Vip(Enum):
    YELLOW=1    
    GREEN=1 # 报错
    BLACK=3
    RED=4