Python中的类与对象
（1）类(class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对 象所共有的属性和方法。对象是类的实例。
案例：人类===xiu（对象）

（2）实例化：创建一个类的实例，类的具体对象。

（3）对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和 方法。
（4）方法：类中定义的函数。
（5）类变量：类变量在整个实例化的对象中是公用的。 类变量定义在类中且在函数体之外。 类变量通常不作为实例变量使用。
（6）实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变 量，实例变量就是一个用 self 修饰的变量。
（7）继承：即一个派生类（derived class）继承基类（base class）的字段和方 法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样 一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a） "关系（例图，Dog是一个Animal）。
（8）方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写， 这个过程叫方法的覆盖（override），也称为方法的重写。

===============================================
二、定义类：
（1）类的类型：新式类、经典类
（2）单词：class
（3）格式：
案例：
class dcs(object): #class 定义一个类名 dcs 类名 object 新式类 （空）经典类
name=“xiaosir” #类变量
def init(self,name,age): #构造函数 #初始化
self.name=name #实例变量
self.age=age ##实例变量
def xiandcs(self): #方法1
print(self.name)
def hzdcs(self):#方法2
print(self.age)
def shdcs(self): #方法3
print(self.name,self.age)
if name == ‘main’:
dx=dcs(“xiu”,18) #创建一个类的对象 #xiu和18是实例
dx.xiandcs() #通过类的对象调用函数
dx.hzdcs()
dx.shdcs()
print(dcs.name) #通过类名调类变量

（4）一个模块中可以有很多个类，类中可以有很多个函数

（5）__init__讲解：
1、定义类的时候__init__是一个构造函数，该函数是两个下划线开头和两个下 划线结束，其作用就是当创建类的对象和实例时系统会自动调用构造函数，通 过构造函数对类进行初始化操作
2、定义类的时候__init__方法中有一个参数self，这也是类中的方法与普通函 数的区别，类的中的方法必须有一个参数self，而且位于参数列表的开头，在 类中self就是代表类的当前类的实例（对象）自身，在python调用时无需传值， python会将对象自动传给self接受
(6)类中的类变量、实例变量
在整个类里面有的属于类的，有的属于对象的，
那么属于类的属性叫类变量，

属 于对象的属性叫做实例变量

(7)类中的实例方法、动态方法、静态方法
1,实例方法
class dcs(object): #class 定义一个类名 dcs 类名 object 新式类 （空）经典类
name=“xiaosir” #类变量
def init(self,name,age): #构造函数 #初始化
self.name=name #实例变量
self.age=age ##实例变量
def xiandcs(self): #方法1
print(self.name)
def hzdcs(self):#方法2
print(self.age)
def shdcs(self): #方法3
print(self.name,self.age)
if name == ‘main’:
dx=dcs(“meng”,18) #创建一个类的对象 #xiu和18是实例
dx.xiandcs() #通过类的对象调用函数
dx.hzdcs()
dx.shdcs()
dcs(“meng”,“18”).xiandcs() #通过类名调函数
==============================
2、动态方法也叫类方法：
class dcs(object): #class 定义一个类名 dcs 类名 object 新式类 （空）经典类
name=“xiaosir” #类变量
def init(self,name,age): #构造函数 #初始化
self.name=name #实例变量
self.age=age ##实例变量
def xiandcs(self): #方法1
print(self.name)
def hzdcs(self):#方法2
print(self.age)
def shdcs(self): #方法3
print(self.name,self.age)
@classmethod #类方法也叫动态方法
def lei(cls): #类方法
print(cls.name) #调用类变量
if name == ‘main’:
dx=dcs(“meng”,18) #创建一个类的对象 #xiu和18是实例
dx.lei()

静态方法也叫私有方法
单词：@staticmethod
class dcs(object): #class 定义一个类名 dcs 类名 object 新式类 （空）经典类
name=“xiaosir” #类变量
def init(self,name,age): #构造函数 #初始化
self.name=name #实例变量
self.age=age ##实例变量
def xiandcs(self): #方法1
print(self.name)
def hzdcs(self):#方法2
print(self.age)
def shdcs(self): #方法3
print(self.name,self.age)
@classmethod #类方法也叫动态方法
def lei(cls): #类方法
print(cls.name) #调用类变量
@staticmethod #私有方法
def zy():
print(“wo是私有方法”)
if name == ‘main’:
dx=dcs(“meng”,18) #创建一个类的对象 #xiu和18是实例
dx.zy()
简洁版：
class xian():
lei=5
def init(self,x,y):
self.x=x
self.y=y
def a(self):
print(1)
def b(self):
print(2)
def c(self):
print(self.x)
def d(self):
print(self.y)
if name == ‘main’:
dx1=xian(3,4)
dx1.a()
dx1.b()
dx1.c()
dx1.d()
print(dx1.lei)

============================
python 的三大特性：封装、继承、多态

1、封装
定义：封装就是指隐藏中一对象中一些不希望外部所访问的属性和方法，即为保证安全
2、概念：是在设计类时，不对外提供，隐藏起来，提供公共方法以外的方（就是把属性和方法封装到一个抽象的类中）
3、封装就相当于一个对象的盒子，将事务相关的属性和方法封装在一个类中，在调用类创建实例，不关心内部代码的实现细节，只要调用结果就可以
4、封装的优点：
（1）封装数据，可以很好的保护隐私
（2）提高代码复用性
（3）隐藏对象的属性和实现细节，提供公共方法对其访问
5、python中封装有两种：
（1）公用方法
类中的变量和方法，他们名称前没有下划线，共有的变量和方法在类的外部，内部以及子类都可以使用
案例：数据封装

方法封装：

（2）私用方法
a、在类的变量和方法下，用下划线开头命名，变为私用变量和方法，只能在类的内部使用，
格式：私有属性
b、__属性名=值 在类的外部不能使用（对象不能调用属性）
c、私有封装后的限制：
（1）类内部可以调用
（2）类外，对象不可调用
（3）子类和子类对象 不可调用

案例1：在方法上加上__
class xian():
lei=5
def init(self,x,y):
self.x=x
self.y=y
def __b(self):
print(2)
def d(self):
self.b()
if name == ‘main’:
dx1=xian(3,4)
# dx1.b()
dx1.d()
案例2：在实例变量上加上
class xian():
lei=5
def init(self,x,y):
self.__x=x
self.y=y
def __b(self):
print(2)
def d(self):
self.__b()
if name == ‘main’:
dx1=xian(3,4)
print(dx1.x)
案例3：
class xian():
lei=5
def init(self,x,y):
self.__x=x
self.y=y
def __b(self):
print(2)
def d(self):
self.__b()
def setx(self,newx):
self.__x=newx
def getx(self):
print(self.__x)
if name == ‘main’:
dx1=xian(3,4)
dx1.setx(5)
dx1.getx()
=================================
继承：
1、类的继承是面向对象程序设计一个重要思想，继承子类，继承父类的内容，包括变量和函数。
2、在继承中一个类被另一个类继承这个类称之为父类，则另一个类为子类，也称为派生类。
案例1：单继承
class f():
def car(self):
print(“豪车”)
def fz(self):
print(“别墅”)
def qian(self):
print(“100个亿”)
class s(f):
def ds(self):
print(“单身”)
def sy(self):
print(“失业”)
def zs(self):
print(“桥洞”)
if name == ‘main’:
dx1=s()
dx1.ds()
dx1.sy()
dx1.zs()
dx1.car()
dx1.qian()
dx1.fz()
案例2：多继承
class f():
def car(self):
print(“豪车”)
def fz(self):
print(“别墅”)
def qian(self):
print(“100个亿”)
class m():
def mv(self):
print(“美女”)
def bz(self):
print(“宝藏”)
def gs(self):
print(“公司”)
class s(f,m):
def ds(self):
print(“单身”)
def sy(self):
print(“失业”)
def zs(self):
print(“桥洞”)
if name == ‘main’:
dx1=s()
dx1.ds()
dx1.sy()
dx1.zs()
dx1.car()
dx1.qian()
dx1.fz()
dx1.mv()
dx1.gs()
dx1.bz()
=====================================================
多态：
1、多态是以继承和重写父类方法为前提，对所有子类实例化产生的对象 调用相同的方法，执行产生不同的执行结果。
2、一个对象的属性和行为不是由他所继承的父类决定的，而是由其本身 包含的属性和方法决定
3、优点：
a、增加程序的灵活性
b、增加程序的可拓展性
4、案例1：
class sj():
def init(self,a,b):
self.a=a
self.b=b
def h(self):
print(self.a+self.b)
if name == ‘main’:
dx=sj(1,2)
dx=sj(“1”,“2”)
dx=sj(“中国”,“人”)
dx.h()
===========================
案例2
class Animal(object):
def talk(self):
print(‘我是动物’)
class Cat(Animal):
def talk(self):
print(‘喵喵’)
class Dog(Animal):
def talk(self):
print(‘汪汪’)
if name == ‘main’:
a=Animal()
c = Cat()
d=Dog()
a.talk()
c.talk()
d.talk()
=========================
拓展知识一：
装饰器
（1）定义
（2）装饰器的运用场景
（3）你写过装饰器？