python
（1）python是一门面向对象的语言，在python中创建对象和类。
（2）类(class)定义: 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例
人类： hpl 实例 对象
（3）实例化：创建一个类的实例，类的具体对象。
（4）对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和
方法
（5）方法：类中定义的函数。
（6）类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。
类变量通常不作为实例变量使用。
(7) 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
(8)继承：即一个派生类（derived class）继承基类（base class）的字
(9)方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，
这个过程叫方法的覆盖（override），也称为方法的重写.
================================
二、定义和使用类
1、定义类三种类型
（1）class Test(object): #新式类
pass
（2）class Test1(): #经典类1
pass
（3）class Test2: #经典类2
pass
==========================
格式：
class Test(object): #新式类 clss创建一个类 ，类名，英文：
name1='pl' #类变量
def __init__(self,name,age): #构建后函数，初始化
self.name=name #实例变量
self.age=age #实例变量
def ff1(self): #一个函数就是方法
print(self.name)
def ff2(self): ##一个函数就是方法
print(self.age)
if __name__ == '__main__': # 主入口
dx=Test('xk','18') #创建一个类的对象 （实例）
# dx.ff1() #通过对象调用方法
# dx.ff2() #通过对象调用方法
print(Test.name1) #通过类名调类变量
print(dx.name1) ##通过对象调类变量
Test.name1="gp" #通过类名调类变量修改类变量
print(Test.name1) #打印类变量
==========================================
类中的实例方法、动态方法、静态方法
(1)实例方法:
class People(object):
def __init__(self,name):
self.name = name #实例变量
def play(self): #实例方法
print(self.name + '打篮球')
#创建对象
# p = People('xm')
# p.play() #对象调用实例方法
People("s").play() #类调用实例方法
(2)动态方法
简写：cls
动态方法：@classmethod
案例：
class People(object):
a=100
name="ss"
def __init__(self,name):
self.name = name #实例变量
def play(self): #实例方法
print(self.name + '打篮球')
@classmethod
def lff(cls): #l类方法也叫动态方法
print(cls.name)
#创建对象
p = People('kk')
p.lff()
（3）静态方法
静态方法其实和普通方法没有什么区别，
它的参数列表里面没有cls或者self。
这就是与类和对象无关的原因
class People(object):
a=100
name="ss"
def __init__(self,name):
self.name = name #实例变量
def play(self): #实例方法
print(self.name + '打篮球')
@classmethod
def lff(cls): #l类方法也叫动态方法
print(cls.name)
@staticmethod
def syff():
print("name")
#创建对象
p = People('kk')
p.syff()
==========================================
类的三大特性
1、封装
2、继承
3、多态
=====================================
封装：
（1）封装定义：
封装就是指隐藏对象中一些不希望外部所访问到的属性或方法，即为了保证安全。
概念：指的是在设计类时，不对外提供，隐藏起来，提供公共方法以外边对其方法。（就是把属性和方法封装到一个抽象的类中）
封装的相当于一个黑盒子，我们将事物相关的属性和方法封装在一个类中，
在调用类创建实例，不用关心类内部代码的实现的细节，我们只要调用结果就可以
（2）封装的优点：
2.1封装数据可以很好的保护隐私，（将不需要对外提供的内容都隐藏起来）
2.2 封装方法主要原因是隔离复杂度
2.3 封装提高了代码的复用性。
2.4隐藏对象的属性和实现细节，提供公共方法对其访问
（3）python类的封装两种
3.1公用（共有）：类中的变量和方法公用；他们名称前都没有下划线，公有的变量和方法，在类的外部，内部，以及子类都可以使用
3.2私有：在类中的变量或方法下，下划线__开头命名，则改变变量或方法为私用，私有的变量和方法，只能在本类内部使用，类的外部以及子类都无法使用。
私有属性：
格式：__属性名=值 在类的外部不能使用（对象不能调用属性）
私用化封装后的限制：
（1）类可以访问
（2）类外/对象外 不可访问
（3）子类和子类对象 不可访问
#数据封装
class people():
def __init__(self,name,age):
self.name=name
self.age=age
#方法封装
class people1():
def __ init___(self,name,age):
封装就是指隐藏对象中一些不希望外部所访问到的属性或方法，即为了保证安全。
概念：指的是在设计类时，不对外提供，隐藏起来，提供公共方法以外边对其方法。（就是把属性和方法封装到一个抽象的类中）
封装的相当于一个黑盒子，我们将事物相关的属性和方法封装在一个类中，
在调用类创建实例，不用关心类内部代码的实现的细节，我们只要调用结果就可以
（2）封装的优点：
2.1封装数据可以很好的保护隐私，（将不需要对外提供的内容都隐藏起来）
2.2 封装方法主要原因是隔离复杂度
2.3 封装提高了代码的复用性。
2.4隐藏对象的属性和实现细节，提供公共方法对其访问
（3）python类的封装两种
3.1公用（共有）：类中的变量和方法公用；他们名称前都没有下划线，公有的变量和方法，在类的外部，内部，以及子类都可以使用
3.2私有：在类中的变量或方法下，下划线__开头命名，则改变变量或方法为私用，私有的变量和方法，只能在本类内部使用，类的外部以及子类都无法使用。
私有属性：
格式：__属性名=值 在类的外部不能使用（对象不能调用属性）
私用化封装后的限制：
（1）类可以访问
（2）类外/对象外 不可访问
（3）子类和子类对象 不可访问
#数据封装
class people():
def __init__(self,name,age):
self.name=name
self.age=age
#方法封装
class people1():
def __ init___(self,name,age):
self.name=name
self.age=age
def get_name(self):
returnself.name
（3）通过在变量前加一个下划线，
self.age=age
def get_name(self):
returnself.name
（3）通过在变量前加一个下划线，
class Test(object): #新式类 clss创建一个类 ，类名，英文：
name1='pl' #类变量
def __init__(self,name,age): #构建后函数，初始化
self.name=name #实例变量
self.__age=age #实例变量
def ff1(self): #一个函数就是方法
print(self.__name)
def __ff2(self): ##一个函数就是方法
print(self.age)
def ff3(self):
self.__ff2()
if __name__ == '__main__': # 主入口
dx=Test('xk','18') #创建一个类的对象 （实例）
print(dx.age)
print(dx.name)
(4)在方法前加上__, 外部无法调用私有方法，内部可以调用
class Test(object): #新式类 clss创建一个类 ，类名，英文：
name1='pl' #类变量
def __init__(self,name,age): #构建后函数，初始化
self.name=name #实例变量
self.age=age #实例变量
def ff1(self): #一个函数就是方法
print(self.name)
def __ff2(self): ##一个函数就是方法
print(self.age)
def ff3(self):
self.__ff2()
if __name__ == '__main__': # 主入口
dx=Test('xk','18') #创建一个类的对象 （实例）
dx.ff1() #通过对象调用方法
#dx.ff2() #通过对象调用方法
dx.ff3()
============================================
继承
1、继承：类的继承是面向对象程序设计的一个重要思想，继承时子类可以继承父类的内容，包括成员变量和成员函数。
2、在继承中一个类被另外一个类继承这个类称之为父类也称之为基类，则另外一个类则为子类也称之为派生类。
案例1：单个继承
class Father():#父类
def a(self):
print("豪车")
def b(self):
print("存款")
def c(self):
print("别墅")
class Son(Father):
def x(self):
print("无业游民")
def y(self):
print("桥洞")
def z(self):
print("负债")
if __name__ == '__main__':
# f=Father()
# f.a()
# f.b()
# f.c()
s=Son()
s.x()
s.y()
s.z()
s.a()
s.b()
s.c()
案例2：多个继承
class Father():#父类
def a(self):
print("豪车")
def b(self):
print("存款")
def c(self):
print("别墅")
class Mother():
def m(self):
print("上市公司")
def n(self):
print("地")
def p(self):
print("旷")
class Son(Father,Mother):
def x(self):
print("无业游民")
def y(self):
print("桥洞")
def z(self):
print("负债")
if __name__ == '__main__':
# f=Father()
# f.a()
# f.b()
# f.c()
s=Son()
s.x()
s.y()
s.z()
s.a()
s.b()
s.c()
s.m()
s.n()
s.p()
==============================================
多态
1、多态是以继承和重写父类方法为前提，对所有子类实例化产生的对象调用相同的方法，执行产生不同的执行结果。
2、例如同样是人，但是当问起一个人的职业时会有不同的结果，可能是软件测试工程师，可能是HR
3、一个对象的属性和行为不是由他所继承的父类决定的，而是由其本身包含的属性和方法决定
4、多条的优点：
（1）增加程序的灵活性
（2）增加程序的可拓展性
案例：多态可以传输数字，字母，中文等
class Nr(object):
def __init__(self,a,b):
self.a=a
self.b=b
def sj(self):
print(self.a+self.b)
if __name__ == '__main__':
n=Nr("多测师","牛逼")
n.sj()
案例2：
class Animal(object):
def talk(self):
print('我是动物')
class Cat(Animal):
def talk(self):
print('喵喵')
class Dog(Animal):
def talk(self):
print('汪汪')
c = Cat()
c.talk()
d=Dog()
d.talk()
a=Animal()
a.talk()
==================================================
拓展性
一、装饰器：
（1）定义：装饰器，本质是一个python函数，他可以让其他函数在不需要做任何代码改动的前提，增加额外的功能，装饰器的返回值也是一个函数对象。
（2）装饰器应用的场景：
插入日志，事务处理，缓存，权限等场景
（3）常见的装饰器：
内置装饰器，类装饰器，函数装饰器，带参数的装饰器
（4）案例：
#静态方法
@staticmethod
def func2():
print ('我是一个静态方法')
==================================================
