大话Python类语义

类
　　物以类聚，人以群分，就是相同特征的人和事物会自动聚集在一起，核心驱动点就是具有相同特征或相类似的特征，我们把具有相同特征或相似特征的事物放在一起，被称为分类，把分类依据的特征称为类属性

　　计算机中分类的思想叫做面向对象，Python中把数据抽象成对象，通过对象或对象间的关系来描叙数据。

　　我们把一些相似事物的共同特征通过一个方式描叙出来，也就是说，你是按什么标准对事物进行分类，相似点是什么，计算机把对相似事物的特征数据进行描叙称为类定义

计算机中类的三大特征
　　1. 封装 对数据的可见性进行约束，分为公有public、私有private、非公有， 公有数据可以直接通过属性访问语法 obj.attr 直接访问，但是私有、非公有则通过方法进行访问，访问行为其实就是SQL中的增删改查，查称为读，增删改称为写，在Python中类的数据称为数据属性，类中定义的函数称为方法，方法是关联对象的函数

class Person:
    """数据封装实现"""
    def __init__(self, name, age, sex):
        """名字是公开的， 性别是非公有， 年龄是私有"""
        # 现在给实例插入数据
        # 公有数据
        self.name = name
        # 非公有使用一个下划线
        self._sex = sex
        # 私有变量使用两个下划线
        self.__age = age
 
    def get_name(self):
        """通过方法读取名称"""
        return self.name
 
    def set_age(self, value):
        """对年龄进行修改"""
        self.__age == value
 
    def get_age(self):
        """通过方法获取私有属性年龄"""
        return self.__age
 
if __name__ == '__main__':
    # 类的实例话类似函数调用，也可以使用关键字参数和位置参数
    p = Person("北门吹雪", 20, "male")
    # 通过 obj.name 属性访问语言访问实例的属性，这个饭方法只能访问公有属性
    print(p.name)
 
    # 通过方法修改年龄
    p.set_age(22)
    # 通过方法访问私有属性
    print(p.get_age())
    pass

　　2. 继承 需要理清几个概念，父类、子类、基类、派生类，父类就是基类，子类就是派生类。继承是建立在类的基础上，子类完全继承父类的所有属性以及控制属性访问的方法。继承要理清差异共相同点，对依据对事物进行分类的特征要非常确定才能写计算机中的类，不然不是分类，分类的前提是公共特征，继承的前提是共性与差异，如果不理解共同特征你就无法分类，你不理解同一类的共性与差异你无法写出继承，继承强调的是公共特征，包括属性和方法

class Human(object):
    """定义人类， 每个人类都有名字和国家， 都会说话"""
    def __init__(self, name, country):
        self.name = name
        self.country = country
 
    def say(self, language):
        """交流说话"""
        print(f"{self.name} 能说 {language}")
 
class Chinese(Human):
    """定义一个中国人，继承人类
 
     Human被称为这个类的基类或这个类的父类，Chinese被成为Human的派生类"""
 
    def __init__(self, name, country, skin):
        """中国人和外国人最大的不同是肤色"""
        # 调用父类的构造函数
        super(Chinese, self).__init__(name, country)
        self.skin = skin
 
if __name__ == '__main__':
    c = Chinese("北门吹雪", 20, "yellow")
    print(c.skin)
    c.say("中文")
    pass

　　　3. 多态 同一个行为具有不同表现形式或形态的能力，计算机中最接近多态的是接口interface，接口定义相同行为，然后我们对接口行为的分类，就产生所谓的抽象基类，通过继承机制，然后子类重写方法从而实现多态，说白了就是同一个方法中有不同的实现，再说漏骨一点就是函数的名称相同，函数的形参相同，函数的返回值相同，但是函数体内的语句逻辑不一样，这个函数体不同被称为多态。多态是建立在继承的基础上然后对方法进行重写，其实能重写(又称为重载)的只有函数体，多态强调的是方法

class HumanInterface(object):
    """定义一个人类的抽象接口，用于实现多态, 多态强调的是方法
 
    定义了两个接口，一个是吃 一个是说
    """
    def say(self, language):
        """说"""
        pass
 
    def eat(self, what):
        """吃"""
        pass
 
class Chinese(HumanInterface):
    """定义一个中国人，继承人类"""
 
    def __init__(self, name, country):
        """中国人和外国人最大的不同是肤色"""
        # 调用父类的构造函数
        self.name = name
        self.country = country
 
    def eat(self, what):
        """重载或重写 父类中的方法，实现多态"""
        print(f"{self.name} 正在吃{what}ing")
        pass
 
    def say(self, language):
        print(f"{self.name} 能说 {language}")
        pass
 
class American(HumanInterface):
    """美国人"""
    def __init__(self, name, country):
        """中国人和外国人最大的不同是肤色"""
        # 调用父类的构造函数
        self.name = name
        self.country = country
 
    def eat(self, what):
        """重载或重写 父类中的方法，实现多态"""
        print(f"{self.name}吃{what}再跳舞")
        pass
 
    def say(self, language):
        print(f"{self.name} 不仅能说 {language}， 还会其他国家语言")
        pass
 
if __name__ == '__main__':
    c = Chinese("北门吹雪", "中国")
    a = American("alex", "美国")
    c.eat("大米")
    a.eat("汉堡包")
 
    c.say("中文")
    a.say("英语")
    # 你会发现他们方法名相同，但是输出不同，也就是形态不同

Python中类定义
类定义

class Name:
    pass

　　# 定义是可执行的语句，在被import语句导入或以main文件执行时，定义就会被执行
　　# 类定义的执行，首先会在当前作用域引入一个用于存储类中属性的命名空间。然后把这个类命名空间封装成对象返回，并把这个类对象绑定到class关键字指定的名称，这个名称又被绑定到class关键子所在的命名空间
　　# Name -> 类对象 > 类命名空间
　　# 其实类定义中包含的一般是函数定义，函数定义的第一个参数其实时实例本身，通过实例本身就可以访问实例中的数据属性和方法

类对象
　　# 支持两种操作：属性引用 和 实例化
　　# 属性引用使用Python标准属性引用语法 obj.name
　　# 实例化: 类的实例化，类似于函数调用，把括号里的参数传递给类的__init__方法，通过__init__方法为类的新实例初始化特定的属性，这个init方法又被称为工厂函数， 其他语言中的类通过new关键字创建。Python中通过函数调用传参的形式实现类的实例化

class Person(object):
    """人类"""
    # 能说话
    can_say = True
    # 能吃
    can_eat = True
    # 能睡觉
    can_sleep = True
 
    def __init__(self, name, age, country):
        self.name = name
        self.__age = age
        self.country = country
 
    def show_country(self):
        """显示国籍"""
        print(f"{self.name}的国籍是: {self.country}")
 
if __name__ == '__main__':
    # 属性引用
    print(Person.can_eat)
    print(Person.can_sleep)
    print(Person.can_sleep)
 
    # 实例化
    c = Person("北门吹雪", 20, "中国")

实例对象
　　# 支持唯一的操作就是属性引用， 其实和普通的变量引用一样，只是多个归属前缀而已，通过方法对实例里的变量进行修改，实际上在函数封装过程的基础上再把数据和函数绑定起来

class Person(object):
    """人类"""
    # 能说话
    can_say = True
    # 能吃
    can_eat = True
    # 能睡觉
    can_sleep = True
 
    def __init__(self, name, age, country):
        self.name = name
        self.__age = age
        self.country = country
 
    def show_country(self):
        """显示国籍"""
        print(f"{self.name}的国籍是: {self.country}")
 
    def set_age(self, value):
        """修改年龄"""
        self.__age = value
 
    def get_age(self):
        """获取年龄"""
        return self.__age
 
if __name__ == '__main__':
    # 实例化
    user = Person("北门吹雪", 20, "中国")
    # 属性引用
    user_age = user.get_age()
    print(user_age)
 
    # 设置年龄
    user.set_age(22)
    print(user.get_age())

方法对象
　　# 方法是从属某个对象的函数，类中的函数定义了类的实例所拥有的方法，也就是说对象的类型决定了对象支持的操作
　　# 方法对比函数，函数定义在模块或函数中，方法定义在类定义中，方法的第一个参数固定时实例对象

类和实例变量
　　# 实例变量是每个实例的唯一数据，而类变量是该类的所有实例共享的属性和方法
　　# 相同属性名称出现在类和实例中，首先被找到的时实例属性

class Person(object):
    """人类"""
    # 该类被实例化多少次
    object_count = 0
 
    # 默认全球通用语言是英语
    language = "En"
 
    def __init__(self, name, age, country, language):
        self.name = name
        self.__age = age
        self.country = country
        self.language = language
 
    def show_country(self):
        """显示国籍"""
        print(f"{self.name}的国籍是: {self.country}")
 
    def set_age(self, value):
        """修改年龄"""
        self.__age = value
 
    def get_age(self):
        """获取年龄"""
        return self.__age
 
    @classmethod
    def add_obj(cls):
        cls.object_count += 1
 
if __name__ == '__main__':
    # 实例化
    user = Person("北门吹雪", 20, "中国", "Cn")
    # 实例化一次则类变量增加一次
    Person.add_obj()
 
    user_two = Person("alex", 30, "美国", "En")
    Person.add_obj()
 
    # 打印被实例化几次
    print(Person.object_count)
 
    # 类变量和属性同名访问，优先选择实例
    print(user.language)