python是怎么定义类的，看了下面的文章大家就会了，不用多说，开始学习。

一、类定义：

class <类名>:
 <语句>

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。如果直接使用类名修改其属性，那么将直接影响到已经实例化的对象

类的私有属性：

　　__private_attrs 两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs

在 Python 中，面向对象编程 （OOP） 是一种在编程中使用对象和类的编程范式。它旨在在编程中实现现实世界的实体，如继承、多态性、封装等。OOP 的主要概念是将数据和处理该数据的函数绑定为一个单元，以便代码的其他部分无法访问此数据。

__init__初始化函数的简单写法

• 类的初始化方法一般是这么定义的
• self.变量名 = 参数, 需要写很多遍，显得不优雅以及繁琐

# 定义一个购物清单类，传入物品名字，价格，想买的意愿
class Buy:
    def __init__(self, name, price, want):
        self.name = name
        self.price = price
        self.want = want

Python完全采用了面向对象的程序设计的思想，是真正面向对象的高级动态编程语言。支持面向对象的基本功能，如继承、封装、多态以及对基类方法的重写与覆盖。但和其他面向对象程序设计语言不同的是，python中对象的概念很广泛，python中的一切内容都是可以称为对象的。

python使用class关键字来定义类的，class关键字之后是一个空格，然后是类的名字，再然后是一个冒号，最后换行定义类的内部实现。类名的首字母一般是要大写，当然也可以按照自己的习惯定义类名

1. 定义和使用类

引言

在上一篇文章中，我们简单聊了一下Python中元类的概念，以及如何定义一个简单的元类。虽然，我们已经学会了定义元类，但是，相信不少刚接触Python的同学，大多会产生这样的疑问：这个不太好理解的元类，费工夫学来，到底有什么用呢？

这篇文章中，我们就接着来介绍下Python中元类的应用场景。

类是面向对象编程的基石，在面向对象编程中具有无可替代的作用。前面我们介绍了类的概念，即：具有相同属性和方法的对象的集合。在实际开发中，我们通常将需求中的名次进行提取将其抽象为类。例如：学生、动物、交通工具等等。

自定义类

那么我们需要如何创建一个类呢？在Python中使用关键字class来创建类，具体如下create_class.py程序所示：

# -- coding: utf-8 --
# @Time : 2022/8/29 16:31
# @Author : siyu.yang
# @File : demo_05.py
# @desc : 第五章
# 面向对象继续概念
# 创建类和对象
# 属性 、 方法
# 三大特性之封装实现
# 三大特性之继承实现
# 抽象类
# 三大特性之多态实现
#                          面向对象基础概念
#    python 是解释性语言，但是它同时和java等高级语言一样，可以采用面向对象的编程
# 思想和方式进行编程。
# 什么是面向对象(Object Oriented)?
#     面向对象是一种程序设计设计方阿飞，它以对象作为基本的单元来构建系统，它利用对象
# 将系统的复杂性隐形在对象里，从而构建出系统。面向对象包括三个过程：面向对象分析(OOA)
# 、面向对象设计(OOD)、面向对象编程(OOP).
# * 面向对象分析指的是分析要开发的系统的各个方面，从而找出类和对象
# * 面向对象设计指我们设计出一些特殊的类(如：抽象类)来表达系统种不通对象的共性和机制，
# 系统的对象相互协作，满足系统需要实现功能的设计过程；
# * 面向对象编程指我们能用特定的面型对象编程语言实现我们的设计，实现系统种的对象和类
# 的过程。
# 即：
# 面向对象
# 类：具有相同特征和行为的某一类事物的总称，是抽象化出来的。
# 对象：类中具体的实例
'''
# 狗-----颜色、身高、体重（属性）  抓老鼠、看家（方法）
class Dog:    # class 类名
    color = '黄色'   # 类属性
    height = '60cm'
    weight = 30

    # 类中的方法都会自带self参数，标识当前类的所有的属性和方法
    def catch_the_mouse(self):
        print('我会抓老鼠')

    def eat(self):
        print('我需要吃饭')

# 创建对象 对象名 = 类名（）
tom = Dog()
tom.color = '黄色'
tom.height = '30cm'
jeck = Dog()
print('颜色：{}，身高：{}，体重：{}'.format(tom.color,tom.height,tom.weight))
tom.catch_the_mouse()
print('颜色：{}，身高：{}，体重：{}'.format(jeck.color,jeck.height,jeck.weight))
jeck.eat()
'''

# 世界是由深组成的？ ---- 万物皆可是对象

# 对象的特性 ---- 属性
# 属性 ---- 对象具有的各种特性
# 每个对象的每个属性都拥有特定值

# 对象的特征 ---- 方法
# 方法 ---- 对象执行的操作

# 类是对象的类型
#  不同于一般数据类型：具有方法
'''
# 练习1：
# 创建一个猫类：属性 品种、价格、颜色   方法--- 睡觉、吃鱼、被撸
# 创建一个对象对该类进行测试，输出改对象的所有信息
class Cat:
    name = '喵星人'  # 类属性

    # 构造方法
    def __init__(self,bread,color,price):   # 实例属性
        self.bread = bread
        self.color = color
        self.price = price

    def sleep(self):
        print('我喜欢睡觉')

    def eat_fish(self):
        print('我喜欢吃鱼')

    def bei_lu(self):
        print('我喜欢被主人撸')

tom = Cat('星罗猫','白色',2000)
jeck = Cat('狸花猫','渐变色',1500)
print(tom.name)
print(jeck.name)
print('种类：{}，颜色：{}，价格：{}'.format(tom.bread,tom.color,tom.price))
print('种类：{}，颜色：{}，价格：{}'.format(jeck.bread,jeck.color,jeck.price))
tom.sleep()
jeck.eat_fish()
'''

# 关于抽象的而理解：
# 把相同的或相似的对象归为一类的这个过程就是抽象，所以，抽象就是分析文件的方法；
# 抽象程度基本原则：
#   只关心主要问题，而不关系次要问题；
#   只关心主要矛盾，尔不关系次要矛盾；
#   只关心相同的东西，而不关心不通的东西；
#   只关心问题是什么，能够完成什么，而不关系怎么样区完成。
#  抽象的过程其实就是面向对象编程的核心思想

# 类和对象有什么区别？
#  - 类士抽象的概念，仅仅是模板，比如说‘人’
#  - 对象是一个你能看得到、摸得着的具体实体，

#                             创建类和对象
# python实现类的语法：
# class ClassName:
#       '类的帮助信息'   # 类文档字符串
#       class_suit    # 类体
#      在class_suit里面就可以定义属性、方法、实例属性等。但一个类定义完成之后，就
#   产生了一个类对象。类对象支持两种操作：引用和实例化。引用操作是通过类对象区调用
#   类种的属性或者方法，而实例化是产生出一个类对象的实例，称作实例对象。

# 创建实例对象语法：
# objectName = ClassName(args) # 其中args初始化参数列表
# 访问属性
# 可以使用. 来访问对象的属性

# 举例：
'''
class people:
    name = '人类'  # 类属性
    def __init__(self,name,age):
        self.name = name  # 实例属性
        self.age = age


liuze = people('刘泽',30)      # 创建对象
print(people.name)  # 访问类属性
print(liuze.name)   # 访问对象属性
'''

# 该段代码定义了一个people类，里面定义了name属性
# people.name 表示进行引用操作，类对象区应用类属性
# liuze.name 表示实例化操作，实例对象去引用实例属性

# python 种的类是由属性和方法组成的，具体的划分如下图：
'''
        属性       类属性
                  实例属性（私有）
                  内置属性

类       方法       构造方法
                   类方法
                   实例方法(私有)
                   静态方法
                   内置方法
'''
# 类属性：类对象的属性，如之前例子中 name = '人类'
# 实例属性：通过实例化对象后，对象可以使用的属性，如print(liuze.name)
# 私有属性：在类中，两个下划线开头，声明该属性属于私有，不能在类的外部被使用或
# 直接访问，在类内部的方法中使用时 self.__private_attrs; 也可以使用object.
# __className_attrName(对象名._类名_私有属性名) 访问属性
# 内置属性：python 类中系统默认自带的属性

# 内置属性如下：
# _dict_:类的属性(包含一个字典，由类的数据属性组成)
# _doc_ : 类的文档字符串
# _name_: 类名
# _module_:类定义所在的模块(类的全名是‘_main_.className’),如果类位于一个
# 导入模块mymod中，那么className._module_ 等于mymod)
# _bases_:类的所有父类构成元素(包含了一个由所有父类组成的元组)
'''
#  创建一个人类，属性：姓名、年龄、性别   使用构造方法完成
class People:
    # 我是People类，是类说明，只能放在类名下面
    name = '好人'
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

Person1 = People('Michael',32,'formal')
# 内置属性：python类中系统默认自带的属性
# 类名.内置属性
print(People.__dict__)   # 类属性
print(People.__doc__)    # 类的文档字符串， 类说明
print(People.__name__)   # 返回类名
print(People.__module__)  # 类定义所在模块
print(People.__base__)     # 类的父类，如果没有默认就是object
'''

#                              属性、方法
# 构造方法：
#    构造方法是负责对象成员初始化工作，为实例变量(对象属性)赋予合适的初始化值
#    在python中构造方法使用的是__init__()方法，当创建了这个类的实例时就会
#    调用该方法
# self 是什么？
#    在上页PPT的例子中，构造方法中第一个形参为self，它代表类的实例。在python
# 中，slef在定义类的方法时必须有一个参数，且必须是第一个参数，但我们在调用
# 类的方法时不需要传入相应的参数。是否方法中存在self也是区分类的方法与普通的函数
# 的一个标识。
#     self 不是python 关键字，我们把它换成其它的也是可以正常执行的。但建议用
# self。如下：
'''
def __init__(this,name,age): # 可以改为this
    this.name = name
    this.age = age
'''

# 实例方法
#    在类中最常定义的成员方法，它至少有一个参数并且必须以实例对象作为其第一个参数，
# 一般以名为‘self’的变量作为第一个参数。(注意：不能通过类对象引用实例方法)
#    在实例方法中，以两个下划线开头，则表示改方法为私有方法，不能在类外部调用。在类
# 的内部调用方法： self.__private_methods,在外部调用方法：实例._方法名()
# 举例如下：
'''
class people:
    def __init__(self,name):
        self.name = name
    
    def getName(self):
        return self.name

    def __say(self,con):
        print(self.name+'说：'+con)

liuze = people('刘泽')
print(liuze.getName())  # 通过实例对象引用
liuze._people__say('你好') # 外部调用私有方法
'''

# 类方法
#    时类对象所拥有的方法，需要用修饰器“@classmethod”来标识其它类方法，它能够
# 够通过实现对象和类对象去访问。类方法的用途就是可以对类属性进行修改。对于类方法，
# 第一个参数必须是类对象，一般以"cls"作为抵押给参数。
# 静态方法：
#    需要通过修饰器“@staticmethod”来进行修饰，静态方法不需要多定义参数。类和实例
# 都能调用。
'''
class country:
    name = 'china'
    @classmethod
    def setName(cls,name):  #类方法
        cls.name = name
    @staticmethod
    def getName():  # 静态方法
        print(country.name)
'''
'''
# 属性：类属性、实例属性、了内置属性
# 方法：类方法、实例方法、静态方法
class People:
    name = '无名氏'   # 类属性

    def __init__(self,name,age,sex):   # 实例属性
        self.name = name
        self.age = age
        self.sex = sex

    def say(self):   # 实例方法,类当中的普通方法
        print('我是实例方法 say() ')

    @classmethod    # 修饰器，它下main的方法就是类方法
    def sleep(cls): # 类方法的第一个参数默认就是cls
        print('我是类方法 sleep() ')

    @staticmethod     # 它下面的方法就是静态方法
    def goto_wc():    # 静态方法不会带默认的参数
        print('我是静态方法 goto_wc()')

tom = People('汤姆',22,'男')
# 1、可以通过 类和对象 访问类属性
print(People.name)
print(tom.name)

# 2、只能通过对象 访问实例属性
# print(People.age)
print(tom.age)

# 3、可以通过 类和对象 访问内置属性,但是还值是不一样的
print(People.__dict__)
print(tom.__dict__)

# 4、可以通过 类和对象 访问类方法
print(People.sleep())
print(tom.sleep())

# 5、通过对象 访问实例方法
# People.say()   # 通过类直接访问时，它会被当作一个普通方法啊，所以需要对self传参
tom.say()

# 6、可以通过 类和对象 访问静态方法
People.goto_wc()
tom.goto_wc()
'''

# 常用内置方法：
#    在 python 中有一些内置的方法，这些方法命名都有比较特殊的地方(其方法名以2个下划线)
# 开始然后以2个下划线结束。
#     1、__init__(self,.....): 构造方法，在生成对象时调用，可以用来进行一些初始化
# 操作，不需要显示去调用，系统回默认去执行。构造方法支持重载，如果用户自己没有重新定义构
# 造方法，系统就会自动执行默认的构造方法。
#     2、__del__(self,......): 析构方法，在释放对象时调用，支持重载，可以在里面进行一些释
# 放资源的操作，不需要显示调用
#     3、__str__(self,.......): 自定义实例输出方法，写好改方法后，替换实例默认的输出操作。
#     4、__add__(self,......): 两个实例的加法操作。
#     5、__getattribute__(.....): 获取实例属性的值，柯直接结合对象使用。
'''
# 内置方法
class People:
    # 1、构造方法，支持重载(使用最后一个)
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # def __init__(self, name):
    #     self.name = name

    # 2、析构方法，作用时释放资源
    def __del__(self):
        print('我是析构方法，作用是释放资源')

    # 3、自定义输出方法
    def __str__(self):
        return '我是默认的str实例输出方法'

    # 4、两个实例的加法操作
    def __add__(self, other):
        return self.name + other.name



zs = People('张三',20)
tom = People('tom',15)
print(zs+tom)
print(zs)
# del zs
# print(zs.name)
'''

#                              面向对象编程三大特性
#    面向对象编程三大特性：封装，继承和多态
# 封装：
#    面向对象的程序设计中，某个类把所需要的数据（也可以说是类的属性）和对数据的操作
# （也可以说是类的行为）全部封装在类中，分别称为类的成员变量和方法（或成员函数），这
# 种把成员变量和成员函数封装在一起的编程特性称为封装。
'''
# 封装： 数据封装、方法封装
class People:
    # 1、构造方法，支持重载(使用最后一个)
    def __init__(self, name, age,money):
        self.name = name
        self.age = age
        # 私有属性：只能在类的内部使用，类外部访问不来（数据封装）
        self.__money = money

    # 方法封装
    def get_money(self):
        return self.__money

    def set_money(self,m):
        self.__money = m

zs = People('张三',20,100)
zs.set_money(200)
print('我叫{}，我有{}块钱！'.format(zs.name,zs.get_money()))
'''

# 继承：
#    继承也指可以使用现有类的所有功能，并在无重新编写原来的类的情况下对这些功能进行扩展
# 多态：
#    多态指的是一类事务有多种形态。如序列类型有多种形态：字符串，列表，元组；动物有多种
# 形态：牛、狗、猪
#    多态性是允许你将父对象设置称为和一个或更多的他的子对象相等的技术，赋值之后，父对象
# 就可以根据当前赋值给它的子对象的特性以不同的方式运作。

# 封装分为数据封装与方法封装
#    数据封装即把对象的属性具体的值隐藏起来，对外显示的只是对象的属性名。比如刘泽的名字，
# 钱包里的钱等。
#    方法封装即对外只需要通过方法就能调用方法，而不选哟了解具体方法种的细节。比如洗衣机
# 按洗衣的功能按钮，就能进行洗衣，我们不需要知道这个过程中的原理；在用支付宝进行付款的时候，
# 只需要在用的时候把二维码给收款方或是扫一下收款方提供的二维码就可以完成支付，不需要
# 知道支付宝的支付接口，以及后台处理数据的能力等。
#    封装的而作用：封装数据的主要原因是保护隐私；封装方法的而主要原因是隔离复杂度。
# 封装分为两个层面：
# 第一层面的封面：创建类和对象时，分别创建两种的名称空间。只能通过类名加“.”或者obj
# .的方式访问里面的名字。
# 第二层面的封装，类种把某些属性和方法隐藏起来，或者定义为私有，只在类的内部使用，在类
# 的外部无法访问，或者留下少量的接口（函数）供外部访问

#    当我们定义一个class 的时候，可以从某个现有的class继承属性和方法，新的class
# 称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class，Super
# class）。如下图:
'''
              object
    Animal             Plant  
Dog        Cat     Tree      Flower
'''

#    在python中，object类时所有类的父类。Python3 中默认都是继承object ,称为
# 新式类；在python2中，不能指定继承object类的类称为经典类。

# 继承的语法如下；
# class 派生类名（基类名）：
#    ...
# 举例：
'''
class Parent:  # 定义父类
    parentAttr = 100

    def __init__(self):
        print("调用父类的构造函数")

    def parentMethod(self):
        print("调用父类的方法")


class Child(Parent):
    def __init__(self):
        print("调用子类构造方法")

    def childMethod(self):
        print("调用子类方法")


child_01 = Child()
child_01.parentMethod()  # 调用父类的方法
print(child_01.parentAttr) # 调用父类的属性
child_01.childMethod()   # 调用自己的方法

# 继承：一个类(子类)获取另外一个类（父类）的属性和方法的过程
# 人类：name,age,sex   方法:say()   sleep()
# 学生： name、age、sex、class、id  方法：say()  sleep()   study()
class People:
    def __init__(self,name,age,sex):   #私有的方法和属性是不能被继承的
        self.name = name
        self.age = age
        self.sex = sex

    def say(self):
        print('我是people类的say()方法。') 

    def sleep(self):
        print('我是people类的sleep()方法。')

class Student(People):     # 父类是people
    # 当子类由构造方法的时候，子类必须实现父类的构造方法
    def __init__(self,name,age,sex,class_name,id):
       # 1.父类名.__init__()  必须传self
        People.__init__(self,name,age,sex)
        # 2.super().__init__() 不需要传self
        super().__init__(name,age,sex)
        # 3.super(子类,self).__init()
        super(Student,self).__init__(name,age,sex)
        self.class_name = class_name
        self.id = id

    def study(self):    # 子类重写父类方法，子类对象会优先调用自己方法
        print('study()！！！')

    def say(self):
        print('我是学生类中的say()!!!1')

zs = Student('张三',21,'男','火箭班','1班')
print(zs.class_name,zs.id)
zs.sleep()
zs.say()
zs.study()
'''

# isinstance() 及 issubclass()
#    python 与其他语言不同点在于，当我们定义一个class 的时候，我们实际上就定义了一个
# 数据类型。我们定义的数据类型和 Python 自带的数据类型,比如： str、list、dict没什么
# 两样。
#    python 有两个判断继承的函数： isinstance(obj,Class)用于检查实例类；
# issubclass(sub,sup)用于检查类继承。

# python 中的继承特定
#    1）在 Python 中,如果父类和子类都重新定义构造方法__init__(),在进行子类实例化的
# 时候，子类的构造方法不会自动调用父类的构造方法，必须在子类中显示调用。
#    2）如果需要在子类中调用父类的方法：需要以 父类名.方法 这种方式调用，以这种方式
# 调用的时候，注意：要传递self参数过去；另一种方法啊是使用super(),直接使用super()
# .xxx 或 super(Class,self).xxx
#    3) Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才
# 开始到基类中逐个查找。（现在本类中查找调用方法，找不到才去基类中找）
#    4）对于继承关系，子类继承父类所有的共有的属性和方法，可以在子类中通过父类名来调用，
# 而对于私有的属性和方法，子类时不进行继承的，因此子类中无法通过父类名来访问的。
#    5）python中支持多继承，能够让又给子类有多个父类。如果有多个父类，多个父类名之间
# 用都好隔开。
#                        class SubClass(SuperClass1,SuperClass2)
#     如果SubClass没有重新定义构造方法，它自动调用第一个父类的构造方法，以第一个父类
# 为中心。
#     如果Subclass 没有定义构造方法，需要显示去调用父类的构造方法，此时调用那个父类
# 的构造方法由你自己决定；若SubClass 没有重新定义构造方法，则只会执行第一个父类的构造
# 方法。并且若SuperClass1和SuperClass2中有同名的方法，通过子类的实例化对象去
# 调用改方法时嗲用的时第一个父类中的方法。
# 实例：
'''
class UniversityMember:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def getName(self):
        return self.name

class Student(UniversityMember):
    def __init__(self,name,age,sno,mark):
        UniversityMember.__init__(self,name,age)  # 注意显示调用父类构造方法
        self.sno = sno
        self.mark = mark

    def getMark(self):
        return self.mark

    # 代码解释：大学中的每个成员都有姓名和名称，而学生有学号和分数2个属性，大学成员
    # 为父类，学生为子类



# 多继承：一个子类可以有多个父类
# 人类、动物 --- 学生
class People:
    def __init__(self, name):
        self.name = name

    def say(self):
        print('我是people类')


class Animal:
    def __init__(self, age):
        self.age = age

    def say(self):
        print('我是Animal类')


class Student(People, Animal):   # 多继承
    # 当父类中有同名的方法时，按照继承的先后顺序调用
    # 实现多个父类构造方法(非必须实现)
    def __init__(self, name, age, id):
        People.__init__(self,name)
        Animal.__init__(self,age)
        self.id = id
    #
    # def say(self):
    #     print('我是一个好学生')


zs = Student('张三', 16, 11)
print(zs.name)
print(zs.age)
print(zs.id)
zs.say()
'''

#                         抽 象 类
#    抽象类是包含抽象方法的类，而抽象方法不包含任可实现的代码，只能在其子类中实现抽象
# 函数的代码。
# 为什么要有抽象的类？
#    如果说类是从一堆对象中抽象相同的内容而来的，那么抽象类就是从一堆类中抽取形同
# 内容来的，内容包括数据属性和函数属性。
#     比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类中抽取相同的内容就是水果
# 这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么吃一个具体的桃子，你永远无法
# 吃到一个叫做水果的食物。
#     在定义抽象时需要在类定义中加入如下代码：__metaclass__ABCmeta,即指定该类
# 的元类时ABCmeta。所谓元类就是创建类的类。
#     在定义抽象方法时需要在前面加入如下代码：@abstractmethod 因为抽象方法不包含
# 任何可实现的代码，因此其函数体通常使用pass
# 抽象类实现举例；
'''
from abc import ABCMeta, abstractmethod


class People:
    __metaclass__ = ABCMeta

    @abstractmethod
    def set_name(self):
        pass


class Student(People):
    def set_name(self, name):  # 参数个数不同,重载
        print('Student,set_name = %s' % name)
        
# 抽象类：
# 1.必须包含抽象方法
# 2.抽象方法只声明不实现
# 3.抽象类就是用来被继承的，子类必须实现父类的抽象方法。
from abc import abstractmethod, ABCMeta


class Animal(metaclass=ABCMeta):  # 这种方式子类继承Animal后必须实现
    # __metclass__ = ABCMeta  # 定义抽象类，这种方式子类继承后不必须实现抽象方法【不推荐】

    def __init__(self, name):
        self.name = name

    @abstractmethod  # 定义抽象方法修饰器
    def say(self):  # 只声明不实现
        pass


class Cat(Animal):
    def say(self):
        print('实现父类抽象say()方法')

    def eat(self):
        print('猫喜欢吃鱼！')


tom = Cat('汤姆')
print(tom.name)
tom.eat()
tom.say()
'''

#    多态指的时一类事务具有多种形态，只有存在父子类关系才会让一类事物具有多种不
# 同的形态，因而多态的实现过程中，经常会使用抽象类。
# 举例：
# 1、序列类型有多种形态：字符串，列表，元组
# 2、动物有多种形态：猪，狗，牛

# 多态性：
#    多态性是指具有不通功能的函数可以使用相同的函数名，这样就可以用一个函数名
# 调用不同的内容的函数。在面向对象方法中一般是这样表述多态性；向不通的对象发送
# 同一条消息，不通对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可
# 以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同
# 的实现，即执行不同的函数。
# 举例：
#    内置函数len(object),len函数不仅可以计算字符串的长度，还可以计算列表、
# 元组等对象中的数据个数，这里在运行时通过擦拭农户类型确定其具体的计算过程，正
# 是多态的一种体现。

# 举例编码：
# 多态：一类事物具有多种形态
# 多态性：只具有不同功能的函数可以使用相同的函数名
'''
import abc


class File(metaclass=abc.ABCMeta):  # 同一类事物：文件
    @abc.abstractmethod
    def click(self):
        pass

# 实现多态
class Text(File):  # 文件的形态之一：文本文件
    def click(self):
        print('open file')

# 实现多态
class ExeFile(File):  # 文件的形态之一：可执行文件
    def click(self):
        print('execute file')

# 多态性
def openFile(obj):
    obj.click()


txt = Text()
exe = ExeFile()

# 调用openFile()实现多态性
openFile(txt)
openFile(exe)
'''

Python 是一种面向对象的编程语言。这意味着几乎所有代码都可以使用称为“类”的特殊结构实现。

什么是类和对象

一、面向对象编程

1、面向对象编程（Object-oriented Programming简称 OOP）

之前已经聊过了Java的运行体系，这期主要了解下编译产生的Class文件。

1．平台无关性

Java诞生时提出一个著名的口号“一次编写，到处运行（Write Once, Run Anywhere）”，而这一特性的实现基础就是字节码（Byte Code）。各种不同平台的Java虚拟机和统一的程序存储格式字节码，是Java平台无关性的基石。

Java中的各种语法、关键词、变量和运算符号等，最终都会被编译成多条字节码指令组合，因此字节码所能提供的能力要比Java强大很多。字节码一般存储在Class文件中，但并非一定，也可以通过其方式存储和获取。