python中的类
一、面向对象的基本概念
(1)类(class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对 象所共有的属性和方法。对象是类的实例。
(2)实例化：创建一个类的实例，类的具体对象。
(3)对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和 方法。
(4)方法：类中定义的函数。
(5) 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。 类变量通常不作为实例变量使用。
(6) 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变 量，实例变量就是一个用 self 修饰的变量
(7)继承：即一个派生类（derived class）继承基类（base class）的字段和方 法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样 一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a） "关系（例图，Dog是一个Animal）
(8)方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写， 这个过程叫方法的覆盖（override），也称为方法的重写。
二、类的定义和使用
1、定义类
(1)class关键字来声明一个类
(2)class类定义方法
第一：class People(object):
第二：class People():
第三：class People
案例1：
class HzDcs(object):
def init(self,name): #构造函数
self.name=name #实例变量
def a(self): #创建函数 也叫方法
print(self.name)
s=HzDcs(“hzdcs”)#创建一个类的对象
s.a() #类的对象调函数
案例2:
class HzDcs(object):
def init(self,name): #构造函数
self.name=name #实例变量
def a(self): #创建函数
print(self.name)
def b(self):
print(self.name+self.name)
s=HzDcs(“LQ”)#创建一个类的对象
s.a() #类的对象调函数
s.b()
名词解释：
1、定义类的时候__init__是一个构造函数，该函数是两个下划线开头和两个下 划线结束，其作用就是当创建类的对象和实例时系统会自动调用构造函数，通 过构造函数对类进行初始化操作
2、定义类的时候__init__方法中有一个参数self，这也是类中的方法与普通函 数的区别，类的中的方法必须有一个参数self，而且位于参数列表的开头，在 类中self就是代表类的当前类的实例（对象）自身，在python调用时无需传值， python会将对象自动传给self接受
class HzDcs(object):
name=“sh” #类变量
def init(self,name): #构造函数
self.name=name #实例变量
def a(self): #创建函数
print(self.name)
def b(self):
print(self.name+self.name)
s=HzDcs(“hz”)#创建一个类的对象
s.a() #类的对象调函数
s.b()
print(s.name)#通过对象调用类变量
print(HzDcs.name) #通过类名调类变量
HzDcs.name=“sz” #通过类名修改类变量，
print(HzDcs.name)#通过类名调用类变量
二、类中的实例方法、动态方法、静态方法
（1）实例方法：
class Dcs(object):
def init(self,name):
self.name=name
def cs(self):#实例方法
print(self.name+“学测试”)
def kf(self):
print(self.name+“学开发”)
if name == ‘main’:
d=Dcs(“hz”)
d.cs()
d.kf()
（2）#类方法 也叫类变量class Dcs(object):
name=“sz”
def init(self,name):
self.name=name
def cs(self):#实例方法
print(self.name+“学测试”)
def kf(self):
print(self.name+“学开发”)
@classmethod #定义一个类变量
def dsj(cls):
print(cls.name)
if name == ‘main’:
d=Dcs(“hz”)
d.cs()
d.kf()
d.dsj()
（3）静态方法 @staticmethod
class Dcs(object):
name=“sz”
def init(self,name):
self.name=name
def cs(self):#实例方法
print(self.name+“学测试”)
def kf(self):
print(self.name+“学开发”)
@classmethod #定义一个类变量
def dsj(cls):
print(cls.name)
@staticmethod
def sy():
print(“我是私有的方法+”)
if name == ‘main’:
d=Dcs(“hz”)
d.cs()
d.kf()
d.dsj()
d.sy()
备注：
（1）静态方法和普通方法没有什么区别，就是参数中有self ，cls
（2）静态方式都不存在，索引私有功能
=================
类的三大特性
1、封装
2、基础
3、多态
1、封装
定义：封装就是隐藏对象一些不希望外部所访问到的属性和方法，即为保证安全。
概念：指的是在设计时，不对外提供，隐藏起来，提供公共方法以外对其方法。
（就是把属性和方法封装到一个抽象类中）
封装相当于一个黑盒子，我们将事务相关的属性和方法封装在一个类中，在调用类创建实例，不用关系内部代码的实现的细节，我们只要调用结果就可以。
2、封装的优点：
1、封装数据可以很好的保护隐私，
2、封装方法主要原因是隔离复杂度
3、封装提高了代码的复用性
4、隐藏对象的属性和实现细节，提供公共方法对其访问
3、python中类的封装分为两种：
（1）公用（共有）
类中的变量和方法公用，他们名称前没有下划线，公有的变量和方法，在类的外部，内部以及子类都可以使用
（2）私有：在类中变量或方法中，___下划线开头命名,则改变变量或方法为私用，私有的变量和方法，只能在内部使用，类的外部以及子类都无法使用
私有属性：
格式：___属性名=值 在类的外部不能使用（对象不能调用属性）
私有化封装后的限制：
（1）类可以访问
（2）类外/对象外 不可访问
（3）子类和子类对象 不可访问
案例1：数据封装
class people():
def init(self,name,age):
self.name=name
self.age=age
案例2：方法封装
class people():
def init(self,name,age):
self.name=name
self.age=age
def getname(self):# 方法封装
print( self.name)
案例3：___ 方法的封装，方法私用
class Dcs(object):
name=“sz”
def init(self,name):
self.name=name
def cs(self):#实例方法
print(self.name+“学测试”)
def __kf(self):
print(self.name+“学开发”)
def dsj(self):
print(self.name+“大数据”)
def qd(self):
self.__kf()
if name == ‘main’:
d=Dcs("hz")
d.cs()
d.dsj()
d.qd()
案例2：实例变量前加上__ 无法直接调用
class Dcs(object):
name=“sz”
def init(self,name,addre):
self.name=name
self.__addre=addre
def cs(self):#实例方法
print(self.name+“学测试”)
print(self.__addre)
def __kf(self):
print(self.name+“学开发”)
def dsj(self):
print(self.name+“大数据”)
def qd(self):
self.__kf()
if name == ‘main’:
d=Dcs(“hz”,“bj”)
print(d.name)
print(d.__addre)
案例4：set get
def set_name(self,name):#set 设置姓名
self.name=name
def get_name(self): #get 获取姓名
return self.name
if name == ‘main’:
b=A()
b.set_name(“cc”)
print(b.get_name())
继承特性
1、继承：类的继承是面向对象程序设计的一个重要思想，继承时子 类可以继承父类的内容，包括成员变量和成员函数
2、在继承中一个类被另外一个类继承这个类称之为父类也称之为基 类，则另外一个类则为子类也称之为派生类。
案例1：类的继承（单继承）
class father(object):
def fy(self):
print(“有钱人”)
class son(father):
def qg(self):
print(“讨饭”)
if name == ‘main’:
a=father()
a.fy()
b=son()
b.qg()
b.fy()
案例2：
class father(object):
def c(self):
print(“车”)
def f(self):
print(“房”)
def k(self):
print(“存款”)
class mother(object):
def s(self):
print(“山”)
def h(self):
print(“湖”)
def d(self):
print(“地”)
class son(father,mother):
def w(self):
print(“无业”)
def z(self):
print(“屌丝”)
def l(self):
print(“邋遢”)
if name == ‘main’:
x=father()
x.k()
x.c()
x.f()
m=mother()
m.s()
m.d()
m.h()
s=son()
s.z()
s.w()
s.l()
s.c()
s.f()
s.k()
s.h()
s.d()
s.s()
=============
多态特性
1、多态是以继承和重写父类方法为前提，对所有子类实例化产生的对象 调用相同的方法，执行产生不同的执行结果。
2、例如同样是人，但是当问起一个人的职业时会有不同的结果，可能是 软件测试工程师，可能是HR
3、一个对象的属性和行为不是由他所继承的父类决定的，而是由其本身 包含的属性和方法决定的。
案例1：
class Animal(object):
def talk(self):
print(‘我是动物’)
class Cat(Animal):
def talk(self):
print(‘喵喵’)
class Dog(Animal):
def talk(self):
print(‘汪汪’)
if name == ‘main’:
c = Cat()
c.talk()
案例2：
class cc(object):
def cs(self,x,y):
print(x+y)
sj=cc()
sj.cs(1,2) #3 数值
sj.cs(“1”,“2”) #12 字符
sj.cs(“中国”,“多测师”) #中国多测师 汉字
案例3：
class father():#定义一个父类
def work(self):
print(“测试”)
class son1(father): #定义一个类，重写父类方法
def work(self):#重写父类方法
print(“开发”)
class son2(father):
def work(self): #重写父类方法
print(“测试开发”)
class p(object):
def r_work(self,father):
father.work()
if name == ‘main’:
a=father()
a.work()
b=son1()
b.work()
c=son2()
c.work()
d=p()
d.r_work(b)
d.r_work(a)
d.r_work©
==========
拓展知识：
一、
二、
拓展知识一：
（1）装饰器定义：
装饰器，本质是一个pyhton函数，他可以让其他函数在不需要做任何代码改动的前提下（增加额外功能），装饰器的返回值也是一个函数对象。
（2）应用场景：
插入日志，性能测试，事务处理，缓存，权限校验等场景
常见的装饰器:
内置装饰器，类装饰器，函数装饰器，带参数的函数装饰器
案例：
class A():
def init(self):
self.name =“wangwang”
self.__myname=“jingjing”
def a(self):
print(“001”)
def __b(self):
print(“002”)
def c(self):
print(“003”)
self.__b()
@property
def age(self):
return self.__myname
if name == ‘main’:
x=A()
print(x.name)
print(x.age)
