一、初始面向对象
1.面向过程
核心：过程（流水线式思维）
优点：极大的降低了写程序的复杂度，只需顺着要执行的步骤，堆叠代码就可
缺点：代码牵一发而动全身
2.面向对象：
核心：对象
对象：特征（变量）和技能（函数）的结合体
优点：可扩展强，基于面向对象设计游戏
缺点：可控性差，一旦建立就是对象和对象之间的交互，我们无法预测，一个很好的例子就是打游戏
3.初始类和对象
python中一切皆对象，类型的本质就是类
在Python中，用变量表示特征，用函数表示技能，所以具有相同特征和技能的一类事物就是‘ 类’，（一系列对象共同的特征与技能的结合体）
class Chinese:#会执行里面的代码 特征与技能
country = 'China'
#技能
def __init__(self,name,color,age): #__init__初始化，只干初始化的活
# __init__方法一定不能有返回值
# if not isinstance(name,str):
# raise TypeError#触发异常 认为的造问题
self.name=name
self.color=color
self.age=age
def talk(self):
print('is talking')
def eat(self):
print('is eating')
def sleep(self):
print('is sleeping')
#程序中的对象
p1=Chinese('lb','red',21) #第一个对象
p2=Chinese('xiaoma','green',21) #实例化 触发__init__的执行
#p1:可以称为Chiese类的一个实例或对象
print(p1.name,p1.color,p1.age)
print(p2.name,p2.color,p2.age)
4.对象相关知识的总结
对象就是实例，代表一个具体的东西
类名（）：类名家括号就是实例化一个类，相当于调用了一个__init__方法
括号里传参数，不许要传self，其他与__init__中的形参一一对应
结果返回一个对象
查看对象的属性，直接用对象名，属性名即可
调用类中的方法，直接用对象名.对象方法名（）即可
5.对象之间的交互
用这个例子具体实现6.面向对象的组合
class BirthDate: def __init__(self,year,month,day): self.year=year self.month=month self.day=day class Couse: def __init__(self,name,price,period): self.name=name self.price=price self.period=period class Teacher: def __init__(self,name,gender,birth,course): self.name=name self.gender=gender self.birth=birth self.course=course def teach(self): print('teaching') p1=Teacher('egon','male', BirthDate('1995','1','27'), Couse('python','28000','4 months') ) print(p1.birth.year,p1.birth.month,p1.birth.day) print(p1.course.name,p1.course.price,p1.course.period) ''' 运行结果: 1 27 python 28000 4 months ''' 复制代码
from math import pi
class Circle:
'''
定义了一个圆形类；
提供计算面积(area)和周长(perimeter)的方法
'''
def __init__(self,radius):
self.radius = radius
def area(self):
return pi * self.radius * self.radius
def perimeter(self):
return 2 * pi *self.radius
circle = Circle(10) #实例化一个圆
area1 = circle.area() #计算圆面积
per1 = circle.perimeter() #计算圆周长
print(area1,per1) #打印圆面积和周长
class Ring:
'''
定义了一个圆环类
提供圆环的面积和周长的方法
'''
def __init__(self,radius_outside,radius_inside):
self.outsid_circle = Circle(radius_outside)
self.inside_circle = Circle(radius_inside)
def area(self):
return self.outsid_circle.area() - self.inside_circle.area()
def perimeter(self):
return self.outsid_circle.perimeter() + self.inside_circle.perimeter()
ring = Ring(10,5) #实例化一个环形
print(ring.perimeter()) #计算环形的周长
print(ring.area()) #计算环形的面积
二、面向对象三大特征
1.继承
继承是一种创建新类的方式，在Python中新建的类可以继承一个或多个类
父类：又称为基类或超类
新建的类：又称为派生类或子类
类的继承分为：单继承和多继承
class Animal: #父类，基类，超类 def __init__(self, name, life_value, aggr): self.name = name self.life_value = life_value self.aggr = aggr def eat(self): self.life_value+=10 class Person(Animal):#子类、派生类，会继承父类所有的方法 def __init__(self,name, life_value, aggr,money): super().__init__(name, life_value, aggr) self.money=money def attrack(self,enemy):#人的派生方法 enemy.life_value-=self.aggr class Dog(Animal): def __init__(self,breed,name,life_value,aggr): #Animal.__init__(self,name,life_value,aggr)#让子类执行父类的方法，就是父类名，方法名（参数），连self也得传 super().__init__(name, life_value, aggr) super(Dog,self).__init__(name,life_value,aggr) #super关键字，新式类中的 self.breed=breed def bite(self,peron):#狗的派生方法 peron.life_value-=self.aggr def eat(self): #父类方法的重写 super().eat() #在实现父类的方法的基础上实现自己的一些方法 print('dog is eating') h2=Dog('牛头梗','旺财',1000,500) # h2=Dog('旺财',1000,500,) h2.eat() print(h2.life_value) super(Dog,h2).eat()#调用父类的 print(h2.life_value) egg=Person('egon',200,1500,400) print('人的攻击力',egg.aggr) print('狗的攻击力',h2.aggr) egg.eat() print('吃了回血丸的人',egg.life_value) h2.eat() print('吃了回血丸的狗',h2.life_value) print('之前',egg.life_value) h2.bite(egg) print('之后',egg.life_value)
继承总结：
继承语法：class类名
想在子类中实现调用父类的方法
在类内----super(子类名，self)
在外面----super(子类名，对象名).方法名(0)
如果不指定继承的父类，默认继承object
子类可以使用父类的所有属性和方法
如果子类有自己的方法就执行自己的
如果是子类没有的方法名就执行自己父类的
继承 大范围到小范围
抽象：小范围到大范围
派生： 父类的基础上又产生了子类----派生类
派生方法：父类里没有的，但子类有的
派生属性：父类没有的，子类有
方法的重新；父类有的方法，在子类里重新实现
减少代码重用性
提高代码可读性
规范编程模式
2.接口类和抽象类
多继承：我们应该尽量避免多继承问题
接口类
from abc import ABCMeta,abstractclassmethod
class Payment(metaclass=ABCMeta):
#接口类，不能被实例化，规范所有支付功能必须实现pay方法
@abstractclassmethod
def pay(self,money):
pass
class Wxpay(Payment):#微信支付功能
def pay(self,money):
print('微信支付了%s元'%money)
class QQpay(Payment):
def pay(self,money):
print('QQ支付了%s元'%money)
#接口归一化，简化使用pay功能的成本，支付函数，总体负责支付，对应支付的对象的对象和金额
def pay(payment,money):
payment.pay(money)
l=Wxpay()
pay(l,300)
抽象类
from abc import ABCMeta,abstractclassmethod
class Animal:
@abstractclassmethod
def eat(self):
print('拿起来')
print('打开') #将猫和狗能做的事抽象出来
print('倒在碗里')
@abstractclassmethod
def sleep(self):
pass
class Dog(Animal):
def eat(self):
print('dog is eating')
class Cat(Animal):
def sleep(self):
print('cat is sleeping')
3.钻石继承
深度优先 经典类 py3中
广度优先 新式类 py2中
2.多态
多态指的是一类事物的多种状态
python自带多态
import abc class Animal(metaclass=abc.ABCMeta): #同一类事物:动物 @abc.abstractmethod def talk(self): pass class People(Animal): #动物的形态之一:人 def talk(self): print('say hello') class Dog(Animal): #动物的形态之二:狗 def talk(self): print('say wangwang') class Pig(Animal): #动物的形态之三:猪 def talk(self): print('say aoao')
文件有多种形态：文本文件，可执行文件
import abc class File(metaclass=abc.ABCMeta): #同一类事物:文件 @abc.abstractmethod def click(self): pass class Text(File): #文件的形态之一:文本文件 def click(self): print('open file') class ExeFile(File): #文件的形态之二:可执行文件 def click(self): print('execute file')
多态性
分为静态多态性和动态多态性
静态多态性：任何类型都可以用运算符进行运算符
动态多态性
peo=People() dog=Dog() pig=Pig() #peo、dog、pig都是动物,只要是动物肯定有talk方法 #于是我们可以不用考虑它们三者的具体是什么类型,而直接使用 peo.talk() dog.talk() pig.talk() #更进一步,我们可以定义一个统一的接口来使用 def func(obj): obj.talk()
Python中处处多态，Python中一切皆对象
就是在传递参数的时候，不需要知道参数的数据类型
因此，可以随意传递任意数据类型、y鸭子类型：对于某一些方法来说，可以无差别的对待的几个类型，就是鸭子类型
python不崇尚相似类型之间的继承关系
数据类型之间减少依赖关系，解耦
3.封装
隐藏对象的属性和实现细节，仅对外提供公共访问方式
好处：
a.将变化隔离;
b.便于使用
c.提高复用性
d.提高安全性
封装原则：
a.将不需要对外提供的内容都隐藏起来
b.把属性都隐藏，提高公共方法对其访问
私有变量和私有方法
在Python中用双下划线开头的方式将属性隐藏起来（设置成私有的）
a. 私有变量
#其实这仅仅这是一种变形操作
#类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：
class A:
__N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
def __init__(self):
self.__X=10 #变形为self._A__X
def __foo(self): #变形为_A__foo
print('from A')
def bar(self):
self.__foo() #只有在类内部才可以通过__foo的形式访问到.
#A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形
这种自动变形的特点：
1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。
这种变形需要注意的问题是：
1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N
2.变形的过程只在类的定义是发生一次,在定义后的赋值操作，不会变形
b.私有方法
在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
>>> class A: ... def fa(self): ... print('from A') ... def test(self): ... self.fa() ... >>> class B(A): ... def fa(self): ... print('from B') ... >>> b=B() >>> b.test() from B #把fa定义成私有的，即__fa >>> class A: ... def __fa(self): #在定义时就变形为_A__fa ... print('from A') ... def test(self): ... self.__fa() #只会与自己所在的类为准,即调用_A__fa ... >>> class B(A): ... def __fa(self): ... print('from B') ... >>> b=B() >>> b.test() from A
property属性
property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值
import math
class Circle:
def __init__(self,radius): #圆的半径radius
self.radius=radius
@property
def area(self):
return math.pi * self.radius**2 #计算面积
@property
def perimeter(self):
return 2*math.pi*self.radius #计算周长
c=Circle(10)
print(c.radius)
print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
print(c.perimeter) #同上
'''
输出结果:
314.1592653589793
62.83185307179586
'''
BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解） 成人的BMI数值： 过轻：低于18.5 正常：18.5-23.9 过重：24-27 肥胖：28-32 非常肥胖, 高于32 体质指数（BMI）=体重（kg）÷身高^2（m） EX：70kg÷（1.75×1.75）=22.86 import math class Circle: def __init__(self,radius): #圆的半径radius self.radius=radius @property def area(self): return math.pi * self.radius**2 #计算面积 @property def perimeter(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方法可以实现
class Foo: def __init__(self,val): self.__NAME=val #将所有的数据属性都隐藏起来 @property def name(self): return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置) @name.setter def name(self,value): if not isinstance(value,str): #在设定值之前进行类型检查 raise TypeError('%s must be str' %value) self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME @name.deleter def name(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三种方法
class Foo: @property def AAA(self): print('get的时候运行我啊') @AAA.setter def AAA(self,value): print('set的时候运行我啊') @AAA.deleter def AAA(self): print('delete的时候运行我啊') #只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter f1=Foo() f1.AAA f1.AAA='aaa' del f1.AAA
class Goods: def __init__(self): # 原价 self.original_price = 100 # 折扣 self.discount = 0.8 @property def price(self): # 实际价格 = 原价 * 折扣 new_price = self.original_price * self.discount return new_price @price.setter def price(self, value): self.original_price = value @price.deleter def price(self): del self.original_price obj = Goods() obj.price # 获取商品价格 obj.price = 200 # 修改商品原价 print(obj.price) del obj.price # 删除商品原价
classmethod
staticmethod
class Classmethod_Demo(): role = 'dog' @classmethod def func(cls): print(cls.role) Classmethod_Demo.func()
class Staticmethod_Demo():
role = 'dog'
@staticmethod
def func():
print("当普通方法用")
Staticmethod_Demo.func()
class Student:
f = open('student', encoding='utf-8')
def __init__(self):pass
@classmethod #类方法，默认参数cls,直接可以用类名调用
def show_student_info(cls):
for line in cls.f:
name,sex = line.strip().split(',')
print(name,sex)
# @staticmethod# 静态方法：让类里的方法直接被类调用，就像正常的函数
# def show_student_info():#这里本来需要传值，但是加上@staticmethod就不需要了
# f = open('student', encoding='utf-8') #文件句柄
# for line in f:
# name,sex=line.strip().split(',')
# print(name,sex)
# 海娇 =Student()
# 海娇.show_student_info() #
Student.show_student_info()
# @classmethod和@staticmethod
# 相同：直接被类调用，不同实例化
#
# 不同：
# classmethod必须有cls参数表示类，可以使用类属性
# @staticmethod不需要，不能直接使用类属性
# 绑定方法
# 非绑定方法
#
# 普通方法：默认有一个self方法穿进来，并且只能被对象调用---绑定到对象
# 类方法 默认有一个cls传进来表示本类，并且可以被类和对象调用-----绑定到类
# 静态方法：没有默认参数，并且可以被类和对象调用--没有绑定----非绑定