python三大特性:封装,多态,继承
一、封装：
1、封装：封装就是隐藏对象一些不希望外部所访问到的属性和方法，保证安全
2、概念:指的是在设计时，不对外提供，隐藏起来，提供公共方法以外对其方法就是把属性和方法封装到一个抽象的类中，
3、封装相当于一个黑盒子，我们将事务相关的属性和方法封装在一个类中，在调用类创建实例，不用关注内部代码的实现细节，我们只要调用结果就可以。
4、封装的优点：
（1）封装数据可以很好的保护隐私、
（2）封装方法主要原因是隔离复杂度
（3）封装提高了代码的复用性
（4）隐藏对象的属性和实现细节，提供公共方法对其访问
5、python中类的封装分为两种：
（1）公用（共用）
类中变量和方法公用，他们名称前没有下滑线，共有的变量和方法，在类的外部，内部以及子类都可以调用
数据封装
方法封装
（2）私用
在类中变量和方法中,___下滑线开头命名，则改变变量或方法为私用，私有的变量和方法，只能在内部使用，类的尾部以及子类都无法使用。
私有属性：格式 ___属性名 =值 在类的外部不能使用（对象不能调用属性）
私有化封装后的限制：
a、类可以访问
b、类外，对象外 不可访问
c、子类和子类的对象 可访问
案例一:
代码:
class Lei(object):
a=20 #类变量
def init(self,a,b): #构造函数,初始化作用
self.__a=a #实例变量
self.b=b #实例变量
def fs1(self): #方法1
print(self.a+1) #
def __fs(self): #方法2
print(self.b+2)
def fs3(self): # 方法2
print(self.__fs())
if name == 'main':
dx=Lei(1,2) # 创建类的而对象 ,1,2就是一个实例
# dx.fs() ##通过类的对象.调用方法2
dx.fs3()
dx.fs1() #通过类的对象.调用方法
print(dx.a) #通过对象调实例变量
print(dx.b) #通过对象调实例变量
案例二:
class People(object):
def init(self,name):
self.__name = name
def setName(self,newname):
self.__name = newname
def getName(self):
return self.__name
if name == 'main':
p = People("xiaowang")
# print(p.__name) #报错
p.setName("xiaoming")
print(p.getName())
二、继承：
1、继承：类的继承是面向对象程序设计的一个重要思想，继承时子类可以继承父类的内容，包括成员变量和成员函数。
2、在继承中一个类被另外一个类继承这个类称之为父类也称之为基类，则另外一个类则为子类也称之为派生类
案例1：
class F(object):
def fh(self):
print("富豪")
def fang(self):
print("房")
def che(self):
print("车")
class M():
def fp(self):
print("富婆")
def qian(self):
print("qian")
def kuang(self):
print("kuang")
class s():
def qg(self):
print("乞丐")
if name == 'main':
fdx=F()
fdx.che()
fdx.fang()
fdx.fh()
mdx=M()
mdx.fp()
mdx.kuang()
mdx.qian()
sdx=s()
sdx.qg()
继承:
案例:单继承(继承一个类)
class F(object):
def fh(self):
print("富豪")
def fang(self):
print("房")
def che(self):
print("车")
class M():
def fp(self):
print("富婆")
def qian(self):
print("qian")
def kuang(self):
print("kuang")
class s(F):
def qg(self):
print("乞丐")
if name == 'main':
fdx=F()
fdx.che()
fdx.fang()
fdx.fh()
mdx=M()
mdx.fp()
mdx.kuang()
mdx.qian()
sdx=s()
sdx.qg()
sdx.fh()
sdx.fh()
sdx.che()
sdx.fang()
案例:多个类继承
class F(object):
def fh(self):
print("富豪")
def fang(self):
print("房")
def che(self):
print("车")
class M():
def fp(self):
print("富婆")
def qian(self):
print("qian")
def kuang(self):
print("kuang")
class s(F,M):
def qg(self):
print("乞丐")
if name == 'main':
fdx=F()
fdx.che()
fdx.fang()
fdx.fh()
mdx=M()
mdx.fp()
mdx.kuang()
mdx.qian()
sdx=s()
sdx.qg()
sdx.fh()
sdx.fh()
sdx.che()
sdx.fang()
sdx.kuang()
三.多态
1、多态是以继承和重写父类方法为前提，对所有子类实例化产生的对象调用相同的方法，执行产生不同的执行结果。
2、例如同样是人，但是当问起一个人的职业时会有不同的结果，可能是软件测试工程师，可能是HR
3、一个对象的属性和行为不是由他所继承的父类决定的，而是由其本身包含的属性和方法决定的
案例1：
class Cc(object):
def cs(self,x,y):
print(x+y)
if name == 'main':
c=Cc()
c.cs(1,2) #数值
c.cs("1","2") #字符
c.cs(" 杭州","多测师") # 汉字
案例2:
class A(object):
def talk(self):print("我是动物")
class Cat(A):
def talk(self):print("喵喵")
class Dog(A):
def talk(self):print("汪汪")
if name == 'main':
c=Cat()c.talk()d=Dog()d.talk()
