python中一切皆对象，类型的本质就是类。

在python中，用变量表示特征，用函数表示技能，因而具有相同特征和技能的一类事物就是‘类’，对象是则是这一类事物中具体的一个。

声明函数的方法：

deffunctionName(args):'函数文档字符串'函数体

声明类的方法：

'''class类名：

'类的文档字符串'

类体'''

#创建一个类

classData:pass

#创建一个描述人的类

class Person: #定义一个人类

role = 'person' #角色属性都是人

def work(self): #人都会走路，是一种方法，也叫动态属性

print("person is walking...")

类的两种作用和：属性引用和实例化

属性引用：

class Person: #定义一个人类

role = 'person' #人的角色属性都是人

def walk(self): #人都可以走路，也就是有一个走路方法

print("person is walking...")print(Person.role) #查看人的role属性

print(Person.walk) #引用人的走路方法，注意，这里不是在调用

实列化：类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每一个实例定制自己的特征

class Person: #定义一个人类

role = 'person' #人的角色属性都是人

def __init__(self, name):

self.name= name #每一个角色都有自己的昵称;

def walk(self): #人都可以走路，也就是有一个走路方法

print("person is walking...")

p= Person('wy') #实例化对象

print(p.name) #自定制的属性

输出：wy

实例化的过程就是  '类——>对象'  的过程

语法：对象名 = 类名(参数)

p = Person('wy') #类名()就等于在执行Person.__init__()#执行完__init__()就会返回一个对象。这个对象类似一个字典，存着属于这个人本身的一些属性和方法。

查看属性&调用方法

print(p.name) #查看属性直接 对象名.属性名

print(p.walk()) #调用方法，对象名.方法名()

关于self

self：在实例化时自动将对象/实例本身传给__init__的第一个参数，你也可以给他起个别的名字，但是正常人都不会这么做。

类属性的补充：

一：我们定义的类的属性到底存到哪里了？有两种方式查看

dir(类名)：查出的是一个名字列表

类名.__dict__: 查出的是一个字典，key为属性名，value为属性值

二：特殊的类属性

类名.__name__#类的名字(字符串)

类名.__doc__#类的文档字符串

类名.__base__#类的第一个父类(在讲继承时会讲)

类名.__bases__#类所有父类构成的元组(在讲继承时会讲)

类名.__dict__#类的字典属性

类名.__module__#类定义所在的模块

类名.__class__#实例对应的类(仅新式类中)

下面用一个例子来更清楚的了解类：

#定义一个类求圆的面积和周长

from math importpiclassCircle:'''定义了一个圆形类；

提供计算面积(area)和周长(perimeter)的方法'''

def __init__(self,radius):

self.radius=radiusdefarea(self):return pi * self.radius *self.radiusdefperimeter(self):return 2 * pi *self.radius

circle= Circle(10) #实例化一个圆,后面跟参数

area1 = circle.area() #计算圆面积

per1 = circle.perimeter() #计算圆周长

print(area1,per1) #打印圆面积和周长

类命名空间与对象、实例的命名空间

创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性

而类有两种属性：静态属性和动态属性

静态属性就是直接在类中定义的变量

动态属性就是定义在类中的方法

类的数据属性是共享给所有对象的，而类的动态属性是绑定到所有对象的。

创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性

属性的查找顺序

在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常。

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

在python中新建的类可以继承一个或多个父类，父类有称基类或超类，新建的类称为派生类或子类

继承

单继承和多继承：

class Father1: #定义父类

pass

class Father2: #定义父类

pass

class Son1(Father1): #单继承，基类是Father，派生类是Son1

pass

class Son2(Father1,Father2): #多继承，用逗号分隔

pass

查看继承的类用：

__base__  查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类

如果没有基类，python中会默认继承object类。

继承的重用性

在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时

我们不可能从头开始写一个类B，这就用到了类的继承的概念。

通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用

classAnimal:def __init__(self,name,life_value):

self.name=name

self.life_value=life_valuedefeat(self):return '%s吃饭'%(self.name)classDog(Animal):'''狗类，继承Animal类'''

def __init__(self,name,life_value,bite):

super().__init__(name,life_value)

self.bite=bitedefeat(self):return '%s吃shi'%(self.name)classPerson(Animal):'''人，继承Animal'''

def __init__(self,name,life_value,bite):

super().__init__(name,life_value)

self.bite=bite

Ani= Animal('wy',100)

d= Dog('dog',100,10)

p= Person('wy',120,15)print(d.eat())print(p.eat())

# dog自身和父类都有eat的方法，调用自身

# person没有定义eat方法，往父类去找

抽象类与接口类

接口类：

继承有两种用途：

一：继承基类的方法，并且做出自己的改变或者扩展(代码重用)

二：声明某个子类兼容于某个基类，定义一个接口类interface，接口类中定义一些接口(就是函数名)，且并未实现接口的功能，子类继承接口，并且实现接口中的功能

classAlipay:'''支付宝支付'''

defpay(self,money):print('支付宝支付了%s元'%money)classApplepay:'''apple pay支付'''

defpay(self,money):print('apple pay支付了%s元'%money)defpay(payment,money):'''支付函数，总体负责支付

对应支付的对象和要支付的金额'''payment.pay(money)

p=Alipay()

a=Applepay()

pay(p,200)

pay(a,200)

抽象类：

什么是抽象类

与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化

为什么要有抽象类

如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。

比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。

从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。

从实现角度来看，抽象类与普通类的不同之处在于：抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的。

在python中实现抽象类：

#一切皆文件

import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):

all_type='file'@abc.abstractmethod#定义抽象方法，无需实现功能

defread(self):'子类必须定义读功能'

pass@abc.abstractmethod#定义抽象方法，无需实现功能

defwrite(self):'子类必须定义写功能'

pass

#class Txt(All_file):#pass#

#t1=Txt() #报错,子类没有定义抽象方法

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法

defread(self):print('文本数据的读取方法')defwrite(self):print('文本数据的读取方法')class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法

defread(self):print('硬盘数据的读取方法')defwrite(self):print('硬盘数据的读取方法')class Process(All_file): #子类继承抽象类，但是必须定义read和write方法

defread(self):print('进程数据的读取方法')defwrite(self):print('进程数据的读取方法')

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()#这样大家都是被归一化了,也就是一切皆文件的思想

wenbenwenjian.read()

yingpanwenjian.write()

jinchengwenjian.read()print(wenbenwenjian.all_type)print(yingpanwenjian.all_type)print(jinchengwenjian.all_type)

继承的作用：

减少代码的重用

提高代码可读性

规范编程模式

几个名词

抽象：抽象即抽取类似或者说比较像的部分。是一个从具题到抽象的过程。

继承：子类继承了父类的方法和属性

派生：子类在父类方法和属性的基础上产生了新的方法和属性

抽象类与接口类

1.多继承问题

在继承抽象类的过程中，我们应该尽量避免多继承；

而在继承接口的时候，我们反而鼓励你来多继承接口

2.方法的实现

在抽象类中，我们可以对一些抽象方法做出基础实现；

而在接口类中，任何方法都只是一种规范，具体的功能需要子类实现

钻石继承

新式类：广度优先

经典类：深度优先

多态

多态指的是一类事物有多种形态，动物有多种形态：人，狗，猪

importabcclass Animal(metaclass=abc.ABCMeta): #同一类事物:动物

@abc.abstractmethoddeftalk(self):pass

class People(Animal): #动物的形态之一:人

deftalk(self):print('say hello')class Dog(Animal): #动物的形态之二:狗

deftalk(self):print('say wangwang')class Pig(Animal): #动物的形态之三:猪

deftalk(self):print('say aoao')

一 什么是多态动态绑定(在继承的背景下使用时，有时也称为多态性)

多态性是指在不考虑实例类型的情况下使用实例

peo=People()

dog=Dog()

pig=Pig()#peo、dog、pig都是动物,只要是动物肯定有talk方法#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用

peo.talk()

dog.talk()

pig.talk()#更进一步,我们可以定义一个统一的接口来使用

deffunc(obj):

obj.talk()

鸭子类型：  如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用

classTxtFile:defread(self):pass

defwrite(self):pass

classDiskFile:defread(self):pass

defwrite(self):pass

封装

什么是封装：

隐藏对象的属性和实现细节，仅对外提供公共访问方式。

为什么要封装：

1. 将变化隔离；

2. 便于使用；

3. 提高复用性；

4. 提高安全性；

【封装原则】

1. 将不需要对外提供的内容都隐藏起来；

2. 把属性都隐藏，提供公共方法对其访问。

怎么用？

在python中用双下划线开头的方式将属性隐藏起来(设置成私有的)

#其实这仅仅这是一种变形操作#类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：

classA:__N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N

def __init__(self):

self.__X=10 #变形为self._A__X

def __foo(self): #变形为_A__foo

print('from A')defbar(self):

self.__foo() #只有在类内部才可以通过__foo的形式访问到.

#A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

这种自动变形的特点：

1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。

2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。

3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

#正常情况

>>> classA:

...deffa(self):

...print('from A')

...deftest(self):

... self.fa()

...>>> classB(A):

...deffa(self):

...print('from B')

...>>> b=B()>>>b.test()fromB#把fa定义成私有的，即__fa

>>> classA:

...def __fa(self): #在定义时就变形为_A__fa

... print('from A')

...deftest(self):

... self.__fa() #只会与自己所在的类为准,即调用_A__fa

...>>> classB(A):

...def __fa(self):

...print('from B')

...>>> b=B()>>>b.test()from A

property属性

property是一种特殊的属性，访问它时会执行一段功能(函数)然后返回值

importmathclassCircle:def __init__(self,radius): #圆的半径radius

self.radius=radius

@propertydefarea(self):return math.pi * self.radius**2 #计算面积

@propertydefperimeter(self):return 2*math.pi*self.radius #计算周长

c=Circle(10)print(c.radius)print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值

print(c.perimeter) #同上

'''输出结果:

314.1592653589793

62.83185307179586'''

python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法(接口)去设置和获取，在python中通过property方法可以实现

classFoo:def __init__(self,val):

self.__NAME=val #将所有的数据属性都隐藏起来

@propertydefname(self):return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)

@name.setterdefname(self,value):if not isinstance(value,str): #在设定值之前进行类型检查

raise TypeError('%s must be str' %value)

self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME

@name.deleterdefname(self):raise TypeError('Can not delete')

f=Foo('egon')print(f.name)#f.name=10 #抛出异常'TypeError: 10 must be str'

del f.name #抛出异常'TypeError: Can not delete'

一个静态属性property本质就是实现了get，set，delete三种方法

classFoo:

@propertydefAAA(self):print('get的时候运行我啊')

@AAA.setterdefAAA(self,value):print('set的时候运行我啊')

@AAA.deleterdefAAA(self):print('delete的时候运行我啊')#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter

f1=Foo()

f1.AAA

f1.AAA='aaa'

del f1.AAA

classGoods:def __init__(self):#原价

self.original_price = 100

#折扣

self.discount = 0.8@propertydefprice(self):#实际价格 = 原价 * 折扣

new_price = self.original_price *self.discountreturnnew_price

@price.setterdefprice(self, value):

self.original_price=value

@price.deleterdefprice(self):delself.original_price

obj=Goods()

obj.price#获取商品价格

obj.price = 200 #修改商品原价

print(obj.price)del obj.price #删除商品原价

classmethod : 在方法中调用类方法，self 是对象方法，这里要写 cls

classClassmethod_Demo():

role= 'dog'@classmethoddeffunc(cls):print(cls.role)

Classmethod_Demo.func()

staticmethod : 静态方法

classStaticmethod_Demo():

role= 'dog'@staticmethoddeffunc():print("当普通方法用")

Staticmethod_Demo.func()