面向对象术语简介
1、类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例
2、方法：类中定义的函数
3、类变量(属性)：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体(方法)之外。类变量通常不作为实例变量使用，类变量也称作属性
4、数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据
5、方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写
6、实例变量：定义在__init__方法中的变量，只作用于当前实例的类
7、继承：即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待,以普通的类为基础建立专门的类对象
8、实例化：创建一个类的实例，类的具体对象。一个类可以实例化出无数个对象
9、对象：通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法
10、多态：对不同类的对象使用同样的操作
11、封装：对外部世界隐藏对象的工作细节
Python类
1、类提供了一种组合数据和功能的方法。创建一个新类意味着创建一个新的对象类型，从而允许创建一个该类型的新实例
2、每个类的实例可以拥有保存自己状态的属性。一个类的实例也可以有改变自己状态的（定义在类中的）方法
3、Python的类提供了面向对象编程的所有标准特性：
⑴类继承机制允许多个基类，派生类可以覆盖它基类的任何方法，一个方法可以调用基类中相同名称的的方法
⑵对象可以包含任意数量和类型的数据
⑶和模块一样，类也拥有Python天然的动态特性：它们在运行时创建，可以在创建后修改
Python类的定义
1、python中定义类使用class关键字，class后面紧接类名，类名通常是大写开头的单词(无类继承时类名后可以加括号也可以不加括号)
2、python中类的定义语法如下：
class ClassName:
语句1
...
语句n
注：
1、类定义与函数定义(def语句)一样：只有在被执行才会起作用。在定义阶段只是语法检查。
2、类是属性和方法的组合，所以语句1可能是内部变量(数据、属性)的定义和赋值语句，也可能是内部方法(函数)的定义语句
⑴一个对象的特征称为"属性"
⑵一个对象的行为称为"方法"
⑶属性在代码层面上来看就是变量，方法实际就是函数，通过调用这些函数来完成某些工作
3、进入类定义时，就会创建一个新的命名空间，并把它用作局部作用域
⑴因此，所有对局部变量的赋值都是在这个新命名空间内进行的。特别的，函数定义会绑定到这个局部作用域里的新函数名称
4、正常离开(从结尾出)类定义时，就会创建一个类对象
⑴它基本上是一个包围在类定义所创建的命名空间内容周围的包装器
⑵元素的(在进入类定义之前起作用的)局部作用域将重新生效，类对象将在这里被绑定到类定义头给出的类名称(在上面的例子中就是ClassName)
例1：
class MyClass:
"""定义一个MyClass类"""
i = 12345
def func(self):
return 'hello world'
注：
1、类包含属性和方法
⑴属性：分为类属性和实例属性
①"i = 12345"：表示定义了一个类属性i其值为12345(实例属性后面介绍)
⑵方法：即定义在类中的函数(与普通的函数类似)
②func：表示定义了一个名为func的实例方法，实际上就是一个稍微特殊点的函数(方法的第一个参数必须为self)
2、在类中定义方法的形式和函数差不多，但其不称为函数，而是叫方法。方法的调用需要绑定到特定的对象上(通过self.或实例对象名)，而函数不需要。
⑴类内部的函数定义通常具有一种特别形式的参数列表，这个特别形式就是第一个参数必须是self(self参数后面介绍)
⑵方法是所有实例都共用的：类外所有实例都可以调用类中的方法，类中方法之间也可以相互调用
3、上面例子中创建了一个MyClass抽象类，定义好类后会在当前作用域定义名字MyClass，指向类对象MyClass
4、类也是一种对象类型，跟前面学习过的数值、字符串、列表等等是一样的，比如这里构建的类名字叫做MyClass，那么就是我们要试图建立一种对象类型，这种类型被称之为MyClass，就如同有一种对象类型是list一样
5、Python中一切皆对象。不管是我们自己定义的类、6种基本数据类型还是内置的类(第三方类)等都称作为对象，一个对象，就会拥有自己的属性和方法。我们可以通过一定的方式来调用一个对象的属性和方法。这一点自定义类与其他Python类型是一样的。
6、Python类中的方法分为：实例方法、类方法、静态方法。这里主要介绍实例方法(方法中第一个参数必须为self)，感觉其他两种方法用的比较少
类对象
1、类是抽象的概念，它是一种数据结构：就好比一个模型，该模型是生活中具有相同属性(特征)和方法(动作)的同一类事务，可以用它来生产真实的物体(实例)
⑴在python中，把具有相同属性和方法的对象归为一个类(class)
2、比如，我们可以将类看做是一个"饼干模具"，这个模具上有一些饼干的特征(属性)和行为(方法)，有了这个模具之后我们就可以通过这个模块来制作很多具有相同属性和行为的不同饼干了(制作出来的肯定不是同一块饼干)。
3、定义一个类后，就相当于有了一个类对象了：Python中"一切皆对象"。类也称为"类对象"，比如前面例1中定义了类MyClass，其也可以成为类对象。
4、类对象支持两种操作：属性引用和实例化
⑴实例化：使用instance_name = class_name()的方式实例化，实例化操作创建该类的实例(格式：实例对象名 = 类名()，实例对象名是我们自己定义的)
⑵属性引用：使用class_name.attr_name的方式引用类属性(类名.属性名)
例2：属性引用
class MyClass:
"""定义一个MyClass类"""
i = 12345
def func(self):
return 'hello world'
print(MyClass.i) # 引用类属性
print(MyClass.func) # 引用实例方法：实例方法可以这样被引用，但是这样引用无意义(知道即可)
# 类属性也可以被赋值，因此可以通过赋值来更改类属性的值
MyClass.i = 123
print(MyClass.i)
"""
12345
<function MyClass.func at 0x00000229FB3F0840>
123
"""
例2_1：实例化
class MyClass:
"""定义一个MyClass类"""
i = 12345
def func(self):
return 'hello world'
#实例化一个类
my_class = MyClass()
print(my_class)
# <__main__.MyClass object at 0x0000025C05DFE4A8>
#可以看到实例化类后返回的是一个MyClass对象，这个对象跟python中的数字、字符串、列表等是一样的
#对象都可以拥有属性、方法
注：
1、类的实例化：是使用函数表示法，可以把类对象看做是会返回一个新的类实例的函数。比如上面类对象的实例化就是：my_class = MyClass()。这就创建了一个类的新实例并将此对象分配给局部变量my_class。
2、实例化操作可以看成是"调用"类对象：将一个类实例化后获得的对象(所赋值的变量)称为实例对象。my_class就称为实例对象
3、类只是一个抽象的概念，只有经过实例化后(获得实例对象)，才会有意义，才能正常使用这个类中的属性和方法
实例对象
1、实例对象就是具有类属性和方法的具体事物：是基于类而创建的一个具体的事物，比如类可以看做制作饼干的模板，那么通过这个模板制作出来的一块块饼干就是实例对象。
2、通过类产生实例对象的过程称为实例化
⑴格式：实例对象名 = 类名()
⑵通过简单的赋值操作，就实例化了一个对象，得到一个实例对象
3、一个类可以实例化出无数个实例对象：这些实例对象之间的属性和方法都是独立的，互不干扰，一个饼干模具可以生产出无数块饼干。
4、实例对象是类对象实例化的产物，实例对象仅支持一个操作：属性引用
⑴实例对象名.属性名
⑵实例对象名.方法名()
例3：
class MyClass:
"""定义一个MyClass类"""
i = 12345
def func(self):
return 'hello world'
#第一个实例对象
my_class = MyClass()
print(id(my_class))
print(my_class.i) # 引用类属性
print(my_class.func()) # 引用实例方法
#第二个实例对象
my_class1 = MyClass()
print(id(my_class1))
# 类属性重新赋值
my_class1.i = 123
print(my_class1.i) # 引用类属性
print(my_class1.func()) # 引用实例方法
#第三个实例对象
my_class2 = MyClass()
print(id(my_class2))
print(my_class2.i) # 引用类属性
print(my_class2.func()) # 引用实例方法
"""
2205374276776
12345
hello world
2205374276552
123
hello world
2205374279632
12345
hello world
"""
注：
1、一个类可以实例化出无数个实例对象：这些实例对象之间的属性和方法都是独立的，互不干扰。
my_class、my_class1、my_class2...这些都是通过MyClass类实例化后得到的实例对象，他们之间是互不干扰的
2、在未实例化类时(my_class = MyClass()前)，只是定义了类对象的属性和方法，此时其还不是一个完整的对象，将定义的这些称为类(抽象类)。需要使用类来创建一个真正的对象，这个对象就叫做这个类的一个实例，也叫作实例对象(一个类可以有无数个实例)
3、创建一个对象也叫做类的实例化，即my_class = MyClass()(此时得到的my_class变量称为类的具体对象)。注意此时类名后面是跟着小括号的，这跟调用函数一样。
另外赋值操作是必须的，但如果没有将创建好的实例对象赋值给一个变量，那这个对象就没办法使用，因为没有任何引用指向这个实例(其实也可以说赋值操作是必须的)
4、使用class语句只能创建一个类，而无法创建类的实例对象，因此要想使用已创建好的类，还需要手动创建类的实例对象，创建类对象的过程又称为类的实例化
例3_1：
"""这种写法知道就好了，实际中肯定不能这么写：未进行赋值操作！！！！！"""
class MyClass:
"""定义一个MyClass类"""
i = 12345
def __init__(self,name):
self.name = name
def func(self):
print(self)
print("名字是：%s" % self.name)
# 未进行赋值操作
print(MyClass("张三").i) # 引用类属性
print(MyClass("张三").func()) # 引用实例方法
print(MyClass("李四").i) # 引用类属性
print(MyClass("李四").func()) # 引用实例方法
"""
12345
<__main__.MyClass object at 0x000001356F83D780>
名字是：张三
None
12345
<__main__.MyClass object at 0x000001356F83D780>
名字是：李四
None
"""
注：
1、如果在实例化类时，未将实例赋值给一个变量：虽然可以正常调用类的属性和方法。
但是这样是没有意义的。因为：没有任何引用指向这个实例，都没法调用这个实例(只有赋值后才会产生实例对象)
2、如果这样写的话，每次调用这个类的实例对象都需要去实例化一次了，那么就显得很麻烦了，还不如实例化一次并赋值给一个变量，此后每次去调用这个变量(实例对象)就好了
3、因此：类在使用前必须先实例化，并将实例赋值给一个变量(得到实例对象)
self参数
1、在定义实例变量、实例方法时的第一个参数必须是self
⑴其实：self名称不是必须的，在python中self不是关键词，你可以定义成a或b或其它名字都可以，只是约定成俗都使用了self
⑵也就是说在定义实例方法时必须有一个参数是默认已经存在了的，可以是self，可以是a，也可以是b。不管这个参数名是什么，但必须得有这个参数
2、self在定义时需要定义，但是在调用时会自动传入(不需要手动传入了)
3、self其实就相当于C++中的this指针
4、如果把类比作图纸，那么由类实例化后的对象才是真正可以住人的房子。根据一张图纸就可以设计出成千上万的房子，他们都长得差不多，但他们都有不同的主人，每个人都只能回自己的家里.....所以self这里就相当于每个房子的门牌号，有了self就可以轻松找到自己房子
5、python中的self参数就是同一个道理，由同一个类可以生成无数对象，当一个对象的方法被调用的时候，对象会将自身的引用作为第一个参数传给该方法，那么python就知道需要操作哪个对象的方法了
6、简单的来说就是：self代表的当前的实例对象本身，这样在调用实例方法等时Python就知道当前是哪个实例对象了
⑴一个抽象类实例化后，实例对象为a，那么此时self就代表实例对象a
⑵一个抽象类实例化后，实例对象为b，那么此时self就代表实例对象b
例4：
class MyClass:
"""定义一个MyClass类"""
i = 12345
def func(self):
print("self参数：",self)
return 'hello world'
a = MyClass()
print("实例对象：",a)
a.func()
b = MyClass()
print("实例对象：",b)
b.func()
"""
实例对象：<__main__.MyClass object at 0x000002D29354E3C8>
self参数：<__main__.MyClass object at 0x000002D29354E3C8>
实例对象：<__main__.MyClass object at 0x000002D29354EFD0>
self参数：<__main__.MyClass object at 0x000002D29354EFD0>
"""
注：
1、通过打印的id值可以看出，self参数实际上就是类通过实例化后得到的实例对象。不同的实例对象对应的self参数是不一样的(self参数始终与当前实例对象时一一对应的)
2、在这个例子可中可能并不能很好的理解self参数的含义，感觉是实例变量中能更好的理解self参数
3、目前我们只需记住：
⑴实例方法第一个参数必须是self，在调用时会自动传入(不需要手动传入了)
⑵self代表的当前的实例对象本身
例4_1：
class Ball:
def setname(self,name,age):
self.name = name
print(age)
def kick(self):
return "我叫%s" % self.name
a = Ball()
b = Ball()
c = Ball()
a.setname("A",1)
b.setname("B",2)
c.setname("C",3)
print(a.kick())
print(b.kick())
print(c.kick())
"""
1
2
3
我叫A
我叫B
我叫C
"""
注：从上面例子可以看出
1、有Ball类生成了三个实例对象a,b,c，这三个对象在调用kick()方法时，是通过self参数去确定究竟当前是哪个对象在调用方法的。
因此在写实例方法时一定要写self参数且其位置在第一个，在调用时就不需要传入self参数了
2、在方法中定义的参数，一般来说只能在当前方法中使用(作用域)
⑴如果想要一个方法中的参数能在其他方法中使用，那么就可以使用"self."来将这个参数变成一个实例变量(实例变量后面介绍，这里主要是遇到了这种写法)
⑵name参数：在方法中使用了"self.name = name"，这步就相当于是将这个name参数变成了一个实例变量，因此可以在所有方法中使用(这种写法了解即可，没啥意义，因为一个实例变量最好直接定义在__init__方法中)
⑶age参数：age参数就没有使用name参数那样的写法，仅仅是在setname()方法中定义并使用，因此age参数就只能在setname()方法中使用，而不能在kick()方法中使用，即使他们是在同一个类中(经常遇到的是这种写法)
类变量
1、类变量：是该类所有实例对象共享的属性(也可以叫"类属性")
⑴类属性是所有实例都共用的：所有实例都可以调用这个类属性
⑵在类中任意地方(所有方法中)都可以使用"类名.类属性名"来调用类属性
⑶在类外任意地方都可以使用"类名.类属性名"或"实例名.类属性名"来调用类属性
2、类变量是直接定义在类中的，比如例1中的"i = 12345"，变量i就是一个类属性，该变量是所有实例对象共有的。类中的所有方法、实例都可以使用它
例5：
class Car():
"""这是一个汽车类"""
brand = "宝马"
def run(self, s):
# 类中调用类属性：类名.属性名
print("当前车型为：%s,当前行驶速度：%s KM/S" % (Car.brand,s))
a = Car()
# 类外调用类属性：实例名.属性名
print(a.brand, id(a.brand))
a.run(110)
b = Car()
print(b.brand, id(b.brand))
b.run(200)
"""
宝马 1744629351728
当前车型为：宝马,当前行驶速度：110 KM/S
宝马 1744629351728
当前车型为：宝马,当前行驶速度：200 KM/S
"""
实例变量
1、类变量是所有实例公用的属性。也就是说一些属性是所有实例都共有的，那么此时我们可以将该属性定义为类属性。
那么如果某些属性是每个实例独有的(每个实例的属性值都不一致)，那么我们就可以将这些属性定义为实例属性
2、实例变量：是每个实例都独有的数据(也可以叫"实例属性")
⑴即某个属性对于每个实例都是独有的，就需要将其定义为实例变量
⑵某个属性是每个实例同共有的就可以定义为类属性
3、实例变量是定义在__init__方法中的
⑴__init__()方法也是类中的一个方法，因此其第一个参数也必须是self
⑵实例变量是每个实例对象独有的，因此在定义实例变量时，必须是：self.实例变量名 = 外部形参名(通过self来绑定当前实例对象)
⑶在类中任意地方(所有方法中)都可以使用"self.实例属性名"来调用实例属性
⑷在类外任意地方都可以使用"实例名.实例属性名"来调用实例属性
例6：
class People():
country = "china"
def __init__(self,name):
self.name = name
def speak(self, age):
# 类中调用类属性：类名.属性名
# 类中调用实例属性：self.属性名
print("我的名字是：%s,来自：%s，年龄是：%s" % (self.name,People.country,age))
# 实例化类时传入实例变量值
a = People("Tom")
a.speak(11)
b = People("Jack")
b.speak(12)
"""
我的名字是：Tom,来自：china，年龄是：11
我的名字是：Jack,来自：china，年龄是：12
"""
注：
1、上面例子中定义了一个类属性"country"，是所有实例共有的；定义了一个实例属性"name"，是每个实例独有的
2、一个类中存在实例变量(定义了init方法且init方法中存在形参)时，那么在实例化类时就需要传入对应的实参，否则会报错
3、实例方法、类方法、静态方法中可以有自己参数(例子中的参数age)，方法中的参数的作用域为方法本身内部(只能在该方法中使用，即使是同一个类中的不同方法，也不能使用)
⑴方法中的参数类型与普通函数的参数类型是一样的(只是第一个参数必须是self)。可以是位置参数(必填参数)、关键字参数、默认参数、可变参数等
⑵如果方法中定义了一些参数，那么在调用这些方法时就必须传入对应参数的值了
4、上面实例化了两个实例对象a、b，在方法speak()中都调用了实例属性name。那么Python是怎么确定当前实例变量name的值是"Tom"或"Jack"的呢？
其实就是通过self参数来确定的：一个类可以实例化出无数个实例对象，通过self参数来确定当前是哪个实例对象在调用了
⑴比如当前为实例对象a在调用时，此时self参数就表示实例对象a，此时Python就去找实例对象a的实例属性name的值
⑵比如当前为实例对象b在调用时，此时self参数就表示实例对象b，此时Python就去找实例对象b的实例属性name的值
⑶这样就不会出现什么，实例对象a在调用，但找的是实例对象b的实例属性值了
5、在类中是不可能出现实例对象名的(实例对象是实例化后才产生的)，因此在类中使用self参数来表示实例对象
⑴类中的self参数就相当于一个形参，当类实例化后，实例对象就相当于self参数的实参
⑵哪个实例对象在调用，self参数就表示哪个实例对象
6、self.name = name表示：将外部传来的变量name的值赋值给当前实例对象的name属性(两个name之间无任何关系，只是变量名一致)
⑴name：只是一个形参，用来接收外部传入的实参值
⑵self.name：表示当前实例对象的实例属性(当前是哪个实例对象，就表示哪个实例对象的实例属性)
7、因此在类中调用实例属性时都必须使用"self.实例属性名"的方式来调用，这样才能通过self参数来确定当前是哪个实例对象在调用
类变量与实例变量
1、在调用一个类中的属性时，Python会按照一定的顺序去查找这个属性：先在当前实例中找，有就用当前实例中的，如果没有就找类中的
例15：
class C:
count = 0
a = C()
b = C()
c = C()
print(a.count,b.count,c.count) #output:0,0,0
a.count += 10 #实例对象调用类属性
print(a.count,b.count,c.count) #output:10,0,0
C.count += 100 #类对象调用类属性
print(a.count,b.count,c.count) #output:10 100 100
#print(count) #name 'count' is not defined，不能直接访问类属性，具体访问方法参考前面的属性访问
注：
1、对实例对象的count属性进行赋值后，就相当于覆盖了类对象C的count属性，如果没有赋值覆盖，那么引用的就是类对象的count属性
⑴通过"实例对象名.属性名"来覆盖类属性，只会影响到当前实例对象，不会影响到其他实例对象中的类属性
⑵通过"类名.属性名"来覆盖类属性，会影响到所有实例的类属性
⑶因此在类外调用类变量时，最好使用"实例对象名.属性名"，避免在重新赋值时影响到其他实例
2、类变量和实例变量的区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象
3、获取一个实例对象的属性时，其属性名后面都是不需要加园括号的(不管是我们自己定义的类还是Python自带的类)；如果属性名后面带上了园括号，那么就变成了一个方法名了。这肯定是不对的。
所以要分清楚调用的是类的属性还是类的方法.不管是调用类方法还是属性，都是通过"."点操作来实现的。
类的使用
1、定义个类主要是将一些具有相同属性的数据、方法放到一个类中整合起来方便代码的管理。最终目的还是调用类中的属性和方法
2、在调用类中的方法或属性时都必须遵循一定的规则：调用类的属性或方法分类在类中调用、在类外调用。不同地方调用，调用的方式也会有一定的差距
3、调用类属性：
⑴类中访问类变量：类名. 类变量名
⑵类外访问类变量：类名.类变量名或实例名.类变量名
4、调用实例属性：
⑴类中访问实例变量：self.实例变量名
⑵类外访问实例变量：实例名.实例变量名
5、调用实例方法：
⑴类中访问实例方法：self.方法名(参数)或类名.方法名(self,参数)
⑵类外访问实例方法：实例名.方法名(参数)
例7：
class MyClass:
"""一个简单的类实例"""
i = 12345#定义一个类属性
def f(self):#定义一个实例方法
print(MyClass.i) #类中调用类属性
return 'hello world'
def g(self):
# 类中调用实例方法
self.f()
MyClass.f(self)
x = MyClass() # 实例化类
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i) #类外调用类属性
print("MyClass 类的属性 i 为：", MyClass.i)
print("MyClass 类的方法 f 输出为：", x.f()) #类外调用实例方法
x.g()
"""
MyClass 类的属性 i 为：12345
MyClass 类的属性 i 为：12345
12345
MyClass 类的方法 f 输出为：hello world
12345
12345
"""
注：
1、在未实例化类时(x = MyClass()前)，只是定义了对象的属性和方法，此时其还不是一个完整的对象，将定义的这些称为类(抽象类)。
需要使用类来创建一个真正的对象，这个对象就叫做这个类的一个实例，也叫作实例对象(一个类可以有无数个实例)
2、创建一个对象也叫做类的实例化，即x = MyClass()。(此时得到的x变量称为类的具体对象)。注意此时类名后面是跟着小括号的，这跟调用函数一样。
另外赋值操作并不是必须的，但如果没有将创建好的实例对象赋值给一个变量，那这个对象就没办法使用，因为没有任何引用指向这个实例
3、如果要调用对象里的方法，就需要判断是在类中调用还是在类外调用：
⑴在类中调用实例方法：self.方法名(参数)或类名.方法名(self,参数)这个这里只是提一下，可以先不纠结
⑵在类外调用实例方法：实例对象名.方法名(参数)。这里的例子就是类外调用方法，只是说实例方法中没有定义参数。x.f()：x为实例对象名，f()为类中定义的实例方法
4、 x.i和MyClass.i都是用于调用类的属性，也就是我们前面所说的类变量；x.f()用于调用类的实例方法
调用类属性可以使用：实例对象名.类属性名或类名.类属性名。虽然这两种方法都可以调用类属性，但是两者在调用使用还是有区别的，后面介绍
5、类中定义方法的要求：在类中定义方法时，第一个参数必须是self，除第一个参数外，类的方法和普通的函数没什么区别，如可以使用默认参数，可变参数，关键字参数和命名关键字参数等
⑴虽然在定义方法时会定义一个self参数，但是不管是在类中或是在类外调用方法都不用传递self，其他参数正常传入
⑵self参数究竟是什么，这里也可以先不纠结，目前只需要知道定义一个实例方法时，第一个参数必须是self，但是在调用实例方法时，不需要传递这个self参数
6、类对象(抽象类)支持两种操作：即属性引用和实例化
⑴属性引用：方法为类名.类属性名(也可以实例对象名.类属性名)
⑵实例化：将一个抽象类实例化成一个实例对象(x = MyClass() )。一个类可以实例化出无数个对象
7、类是一个抽象的概念，对象则是一个实际存在的东西。就像我们说的"狮子"，它只是一个抽象的东西，只有具体到狮子这种动物身上它才是实际存在的。
在比如设计房子的图纸只能告诉你房子是什么样的，并不是真正的房子，只有通过钢筋水泥建造出来的房子才实际存在，才能住人。
"造房子"这个过程就相当于是"实例化类'，一个抽象类只有实例化成一个具体的实例对象后，才会有意义(抽象类只有实例化后才能使用，才会有意义)
例8：
class Student():
address = "china" #定义类变量address
def __init__(self,name,age): #定义实例变量age和name
self.name = name
self.age = age
def Info(self,score):#定义在方法中的变量(普通的变量：作用域为这个方法内)
return "学生来自于%s,名字为%s,年龄为%s,成绩为%s"%(Student.address,self.name,self.age,score)
#类中访问实例变量：self.实例变量名
#类中访问类变量：类名.类变量名
#类中访问方法中的普通变量：直接变量名(且该变量只能在这个方法中使用，不能再其他方法或类外调用)
student = Student("张三",18) #实例化类
print(student.name) #类外访问实例变量：实例名.实例属性名
print(Student.address) #类外访问类变量：类名.类属性名(也可以实例名.类属性名)
print(student.Info(98)) #类外访问实例方法：实例名.方法名(参数)
#另一个实例对象
student_1 = Student("李四",20)
print(student_1.name)
print(student_1.address)
print(student_1.Info(100))
"""
张三
china
学生来自于china,名字为张三,年龄为18,成绩为98
李四
china
学生来自于china,名字为李四,年龄为20,成绩为100
"""
注：
在Student类中，类属性address为所有实例所共享；实例属性name和age每个student的实例独有(每个实例有不同的name和age)
⑴类属性：实例对象student和student_1拥有一样的address属性
⑵实例属性：实例对象student和student_1拥有不一样的name和age属性(每个实例独有的属性)
以上就是本次分享的所有内容，想要了解更多欢迎前往公众号：Python编程学习圈，每日干货分享
