类
物以类聚，人以群分，就是相同特征的人和事物会自动聚集在一起，核心驱动点就是具有相同特征或相类似的特征，我们把具有相同特征或相似特征的事物放在一起，被称为分类，把分类依据的特征称为类属性
计算机中分类的思想叫做面向对象，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)