python面对对象

中间隔有python模块没有进行更新，是因为觉得模块的操作应用更应该记牢，再次先不更新

1,面对对象的作用: 能简化思路和代码

　　
2,面对对象的思路：
　　不着急直接去计算/操作代码获取结果
　　从一个大的问题中，要到要描述的角色
　　将角色的属性和行为抽象出来
　　形成一个模子
　　后期用到角色的时候，都围绕这个模子来操作。
3,类 ：一类抽象的事物，是描述了一类事物有哪些属性或者行为，但是不具体。
4,实例：就是一个依托于类的规范存在的，被赋予了具体属性值得实际存在的物体
5,对象 ：就是实例--给类中约束的属性赋了具体的值
实例化： 由一个类产生一个对象/实例的过程。 创建对象的过程 对象=类名（）
　　　　#1，创建一个对象 产生一些类对象指针
　　　　#2，调用init方法，将创造的对象传给self，执行init方法
　　　　#3，将self自动的返回给调用者
创造一个函数：用def（开头用小写）
创造一个类：用class(一般开头要用大写)

class Person: 这个整体就是类
　　country = ‘China’#静态属性
　　def func(self):
　　　　print(123)
　　def aaa(self):
Person 是一个类名Person()#这就是对象

Person 中可以放两个东西（类中可以定义的）：
　　静态属性:就是变量--是所有的对象共享的一个属性
　　动态属性（方法）:就是函数 自带一个叫做self的形参 特殊的__init__方法
类中写的所有的静态属性和动态属性都是所有对象共享的。
在self空间中或者是在实例化之后的对象的空间中定义的变量都是属于某个对象的
类名可以做两件事情：
　　查看静态属性和动态属性
　　创造一个对象 也就是实例化
对象：调用方法 查看对象命名空间中的属性

class Person:
    Country = ‘China‘
    def func(self):
        print(123)
    def __init__(self,name,sex,hp,ad):
        print()

print(Person.Country)  #通过.连接其中的元素
print(Person.func)
Person.func(0)   #使用Person调用方法的时候 self也是一个需要传的参数
print(Person.__dict__) #内置的一个字典  将变量和函数存进去

    #创造一个对象:对象 = 类名+（）
        #首先要创造一个对象
        #会自动的触发__init__函数，将创造出来的对象的地址创给self（self和obj是同一个东西）
        #执行init中的代码
        #将self指向的地址再返回给调用者
obj = Person（‘alex‘,None,10,1） #会自动化执行 def __init__(self):

对象名可以调用静态属性

class Person:
    Country = ‘China‘
    def __init__(self,name):
        self.name=name
    def attack(self):
        print(‘attack‘)

alex = Person(‘alex‘)
egon = Person(‘egon‘)
alex.Country = ‘印度‘ #往Alex的对象内存中存了一个印度（）
print(alex.Country)    #印度
print(egon.Country)    #China
print(Person.Country)  #China

class Person:
    Country = [‘China‘]
    def __init__(self,name):
        self.name=name

alex = Person(‘alex‘)
egon = Person(‘egon‘)

alex.Country[0] = ‘印度‘
print(alex.Country)  #印度
print(egon.Country)  #印度
print(Person.Country) #印度总结：如果是对静态属性赋值，那么会在对象空间里创造一个 如果是像列表一样更改 那么会先去找类空间找，找不到则再创造。

首先静态变量之所以出现：所有的对象都共享的值
调整静态变量的值：直接用类名去调整，是最准确的
对象对一个静态变量重新赋值的过程，实际上是在对象所在的内存空间中 添加一个个同名属性而已
方法并没有真正存储在对象的空间中，之所有能找到，是因为每一个对象在创建之初都有一个执行类的指针。

类名：
　　查看修改静态属性
　　实例化
对象名：
　　查看对象的属性
　　调用方法
对象使用名字的特点：自已有的时候用自己的，自己没有的时候用类的

静态属性和对象属性的区别是什么？
　　如果所有的对象的某一个值都是相同的，就用静态属性
　　如果所有的对象的某一个值都是不同，就用对象属性

************************************组合**************************************
组合：两个类的事儿
关系：一个类有另一个类 比如人有武器
　　一个类的对象作为另一个类对象的属性
武器类的对象作为人类对象的一个属性

class Person:
    def __init__(self,name,sex,hp,ad):
        self.name = name
        self.sex=sex
        self.hp=hp
        self.ad=ad
    def attack(self,dog):
        dog.hp -= self.ad

class Dog:
    def __init__(self,name,kind,hp,ad):
        self.name = name
        self.kind=kind
        self.hp=hp
        self.ad=ad
    def bite(self,person):
        person.hp -= self.ad

class Weapon:
    def __init__(self,name,price,ad=0,hp=0):
        self.name = name
        self.price = price
        self.ad = ad
        self.hp = hp
        self.ad_total = self.ad #人和武器的攻击力总和

    def Kill(self,dog):
        dog.hp -= self.ad_total

alex = Person(‘alex‘,None,50,1)
taibai = Dog(‘哮天犬‘,‘teddy‘,200,30)
alex.attack(taibai)
print(taibai.hp)

板儿砖 =Weapon(‘打狗砖‘,998,190)
print(板儿砖.__dict__)
alex.weapon = 板儿砖
alex.weapon.Kill(taibai)
print(taibai.hp)

学生与课程组合

课程类的对象作为学生对象的一个属性

class Student:
    def __init__(self,name,sex,age,number,course):
        self.name = name
        self.sex = sex
        self.age = age
        self.number = number
        self.course = course

class Course:
    def __init__(self,name,period,price):
        self.name = name
        self.period = period
        self.price = price

python = Course(‘python‘,‘6 months‘,20000)

xiaoming = Student(‘小明‘,‘male‘,18,10086,python)
xiaoming.course.name
print(xiaoming.course.name)
print(xiaoming.course.period)
print(xiaoming.course.__dict__)

圆和圆环组合：圆形类的对象作为圆环对象的一个属性

from math import pi
print(pi)
class Circle: #目的是规范一个圆
    def __init__(self,r):
        self.r = r
    def perimeter(self):
        return pi*2*self.r
    def area(self):
        return pi*self.r**2

class Ring:
    def __init__(self,out_r,in_r):
        self.out_circle = Circle(out_r)
        self.in_circle = Circle(in_r)
    def peri(self):
        return self.out_circle.perimeter() + self.in_circle.perimeter()
    def are(self):
        return self.out_circle.area() - self.in_circle.area()

r = Ring(10,5)
print(r.peri())
print(r.are())

圆的创建

*************面对对象的三大特性***************
python重要的是继承和封装
　　　　继承
　　　　多态
　　　　封装

#继承的作用：
#代码的重用性以及两种继承方法：

class Role:
    def __init__(self,name,hp,ad):
        print(‘in Role init‘)
        self.name = name
        self.hp=hp
        self.ad=ad
class Person(Role):
    def __init__(self,name,sex,hp,ad):
        self.sex = sex           #派生属性（父类没有）
        #Role.__init__(self,name,hp,ad)  #指名道姓--继承
        #super().__init__(name,hp,ad)  #super()直接代表父类,不用传self
        super(Person,self).__init__(name,hp,ad) #super中有默认参数写不写都可以

    def attack(self,dog):        #派生方法（父类没有）
        dog.hp -= self.ad
class Dog(Role):
    def bite(self,person):
        person.hp -= self.ad
alex = Person(‘alex‘,None,100,1)
print(alex.__dict__)

#如果我自己的类里面也有一个init 先执行类里面的init
#继承的语法：在子类定义的时候括号里加上父类的名字
#对象在寻找名字的时候，先找自己对象空间里的-->再找自己的类的空间里的-->再找父类空间的
#在自己的类中调用父类中的同名方法:

　　　　　　　　　　1）指名道姓（需要自己传self参数）

　　　　　　　　　　2）super方法（不需要自己传self参数）

检测继承关系学的怎么样d的一个方法：

class Foo:
    def __init__(self):   #父类中的self是下面Foo类中的self，可以这样理解
        self.func()
    def func(self):
        print(‘in foo‘)

class Son(Foo):
    def func(self):
        print(‘in son‘)

Son()

继承：什么是什么的关系
　　节省两个类之间共有的方法或者代码
　　如果子类和父类一样 那么可以省略子类的 用父类的
　　如果是子类特有的，用子类的---派生
　　如果两个方法，子类也有父类也有，用子类的
　　如果两个方法，子类也有父类也有，想用父类的：指名道姓，super

#抽象类和接口类---了解
#钻石继承--新式类 和 经典类--（python程序员需要了解的）。
主要就是维持了一种规范
python中 一切皆对象

dic = {‘k‘:‘v‘}
lst = [1,2,3]
len(dic)
print(dic.__len__()) #len是个对象 先这样理解吧

def len(dic):
    return dic.__len__()

********************************************抽象类**********************************************

from abc import ABCMeta,abstractmethod  #记住这个

class Pay(metaclass=ABCMeta):
    @abstractmethod
    def pay(self,money):pass  #目的是为了规范
#抽象类：
    #在类的位置指定metaclass 是ABCMeta
    #在指定的方法上面添加@abstractmethod 装饰器
#目的：规范所有继承这个类的子类，必须实现被@abstractmethod 装饰器 装饰的这个方法
#特点：抽象类和接口类不能被实例化
class Wechatpay:
    def pay(self,money):
        print(‘微信支付了%s元‘ %money)

class Alipay:
    def pay(self,money):
        print(‘支付宝支付了%s元‘ %money)

class Applepay:
    def fuqian(self,money):  #里面的fuqian必须是pay才行
        print(‘apple支付了%s元‘ %money)

def payment(obj,money):
    obj.pay(money)

wp = Wechatpay()
#wp.pay(100)
payment(wp,100)        #编程习惯---归一化设计
ap = Alipay()
#ap.pay(100)
payment(ap,100)    

app = Applepay()   #会报错 因为Applepay里面的方法是fuqian 不是pay
payment(app,100)  

****************************************************接口类*****************************************************
接口类：python天生支持多继承 java语言是不支持多继承的
python支持多继承，对于python来说抽象类和接口类没有区别
接口类是python特有的，因为python直接用类就可以实现接口的效果
python没有‘接口’这种数据类型，Java中有

from abc import ABCMeta,abstractmethod
class Walk_Animal(metaclass=ABCMeta):  #接口隔离：使用多个专门的接口，而不使用单一的总接口，即客户端不应该用那些不需要的接口
    @abstractmethod
    def walk(self):pass
class Fly_Animal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):pass
class Swim_Animal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self):pass

class Tiger(Walk_Animal,Swim_Animal):#老虎只会走和游泳，所以用不着飞的规范
    def walk(self):
        print(‘walk‘)
    def swim(self):
        print(‘swim‘)

class Parrot:
    def walk(self):
        print(‘walk‘)
    def fly(self):
        print(‘fly‘)

class Swan:
    def walk(self):
        print(‘walk‘)
    def fly(self):
        print(‘fly‘)
    def swim(self):
        print(‘swim‘)

依赖倒置原则：
高层 模块不应该依赖底层模块，二者 都应该依赖其抽象，抽象不应该依赖细节，细节应该依赖抽象，换言之，要针对接口编程，而不是针对实现编程。

#钻石继承 ：4个类图形（也可以增加）就是形状像钻石 其实就是多继承
#D-B-C-A
#找一个名字，如果这个名字在子类不存在，就会遵循一个顺序往上找
#继承关系会形成一张图，每一个类都是这个图中的节点，寻找顺序会把图中的每个节点都找一遍且只找一次
------遍历算法
python3里面的所有类都是新式类
新式类的遍历算法遵循---广度优先规律

class A:
    def func(self):print(‘in a‘)
class B(A):pass
    #def func(self):print(‘in b‘)
class C(A):
    def func(self):print(‘in c‘)
class D(B,C):pass
    #def func(self):print(‘in d‘)

d = D()
d.func()

原文地址：https://www.cnblogs.com/xiao-xuan-feng/p/12228316.html