面向对象编程基础

 三大编程范式：

函数式编程：函数接收的参数是一个函数名，返回值中包含函数（可读性差）

面向过程编程：把一个大的问题分成很多小的问题，一步一步地执行

面向对象设计/面向对象编程：通过class把数据属性和函数属性整合到一起形成一个类，然后通过这个类实例化出一个对象，就是面向对象设计

                                                面向对象设计的方法属于面向对象编程，而通过函数创建类的方式也属于面向对象编程

 

类的概念：

把一类事物的相同的特征和动作整合到一起就是类，类是一个抽象的概念

对象的概念：

就是基于类而创建的一个具体的事物（具体存在的），也就是特征和动作整合到一起

类属性：

数据属性（变量）

函数属性（函数）（在面向对象中叫作类）

#python为类内置的特殊属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

class Chinese:
    eyes='big'      #定义数据属性
    face='beautiful'
    CH='chinese'
    def movement():    #定义函数属性
        print('love to traval')
    def food(self):
        print('%s love to eatting' %Chinese.CH)

print(Chinese.eyes)                #big
# print(Chinese.__dict__)          #查看属性字典
print(Chinese.__dict__['eyes'])    #big
Chinese.movement()                 #love to traval
Chinese.__dict__['movement']()     #love to traval
Chinese.__dict__['food'](1)        #chinese love to eatting

 

实例化：

由类生成对象的过程叫实例化，类实例化的结果就是对象

实例=对象

通过定义初始化函数，返回一个字典，即可实例化生成对象

class Chinese:
    face = 'beautiful'
    def __init__(self,name,age,sex):     #self表示实例自己本身
        self.name=name
        self.age=age
        self.sex=sex
    def movement():
        print('love to traval')
    def food(self):
        print('%s love to eatting' %self.name)

p1=Chinese('pplee','35','female')   #相当于 p1=Chinese.__init__(p1,name,age,sex)  类实例化产生一个对象p1
print(p1.__dict__)      #{'sex': 'female', 'name': 'pplee', 'age': '35'}
print(p1.age)           #35
print(p1.face)          #beautiful
p1.food()               #pplee love to eatting
p1.movement()           #报错  movement()本身不需要传参数，而p1.movement()运行时，默认传入p1

 

 

函数创建类与class去实现面向对象设计的区别：

使用函数创建一个学校类：

特征：名字、地址、类型

动作：考试、招生、开除学生

#声明函数
def functionName(args):
    '函数文档字符串'
    函数体

#创建一个school的类
def school(name,addr,type):
    def init(name,addr,type):
        sch={
        'name':name,
        'addr':addr,
        'type':type,
        'kaixue':kaixue,
        'kaoshi':kaoshi
        }
        return sch
    def kaixue(school):
        print('%s 学校已开学' % school['name'])

    def kaoshi(school):
        print('这是一所%s,%s学校的学生在考试'%(school['type'],school['name']))
    return  init(name,addr,type)

#通过类生成具体的对象
s1=school('深圳第一中学','深圳市福田区','公立学校')
s2=school('宝安第一中学','深圳市宝安区','私立学校')

print(s1)
#{'addr': '深圳市福田区', 'kaoshi': <function school.<locals>.kaoshi at 0x0000024A6E2D4158>,
#  'type': '公立学校', 'kaixue': <function school.<locals>.kaixue at 0x0000024A6E2D40D0>, 'name': '深圳第一中学'}
print(s2)
#{'addr': '深圳市宝安区', 'kaoshi': <function school.<locals>.kaoshi at 0x0000024A6E2D4268>,
# 'type': '私立学校', 'kaixue': <function school.<locals>.kaixue at 0x0000024A6E2D41E0>, 'name': '宝安第一中学'}

s1['kaoshi'](s1)    #这是一所公立学校,深圳第一中学学校的学生在考试
s2['kaixue'](s2)    #宝安第一中学 学校已开学

 

使用面向对象编程独有的语法class去实现面向对象设计

class 类名：
       '类的文档字符串'
       类体

#使用面向对象编程独有的语法class去实现面向对象设计创建一个school的类
class school:
    def __init__(self,name,addr,type):
        self.name=name
        self.addr=addr
        self.type=type

    def kaixue(self):
        print('%s 学校已开学' % self.name)

    def kaoshi(self):
        print('这是一所%s,%s学校的学生在考试'%(self.type,self.name))


#通过类生成具体的对象
s1=school('深圳第一中学','深圳市福田区','公立学校')
s2=school('宝安第一中学','深圳市宝安区','私立学校')

print(s1.__dict__)
#{'type': '公立学校', 'addr': '深圳市福田区', 'name': '深圳第一中学'}
print(s2.__dict__)
#{'type': '私立学校', 'addr': '深圳市宝安区', 'name': '宝安第一中学'}

s1.kaixue()
#深圳第一中学 学校已开学
s2.kaoshi()
#这是一所私立学校,宝安第一中学学校的学生在考试

 

 类属性增删改查

class people:
    country='chinese'
    def __init__(self,name,age,higth,wigth):
        self.name=name
        self.age=age
        self.higth=higth
        self.wigth=wigth

p1=people('pplee','18','153','85')

print(people.country)         #查看类属性
print(p1.country)             #实例具有类的属性

people.addr='shenzhen'        #类增加一个数据属性
print(p1.addr)                #实例也能读取到类新增的属性

people.country='japan'        #类修改数据属性
print(p1.country)             #实例也能读取到类修改后的属性

del people.country            #删除类属性

 

实例属性的增删改查

class people:
    country='chinese'
    def __init__(self,name,age,higth,wigth):
        self.name=name
        self.age=age
        self.higth=higth
        self.wigth=wigth

p1=people('alice','18','153','85')

print(p1.__dict__)     #查看实例字典
print(p1.name)         #查看实例属性
print(p1.country)      #可以访问自身的函数属性，也可以访问类的属性

p1.sex='femals'        #增加实例属性，类不会增加该属性
p1.country='japan'     #增加实例属性country,类自身的country属性不会改变
print(p1.country)      #--->japan
print(people.country)  #--->chinese

p1.name='tom'          #修改实例属性
print(p1.__dict__)     #-->{'country': 'japan', 'wigth': '85', 'name': 'tom', 'sex': 'femals', 'age': '18', 'higth': '153'}

del p1.country         #删除实例属性
del p1.sex
print(p1.__dict__)     #-->{'wigth': '85', 'age': '18', 'higth': '153', 'name': 'tom'}

 

静态属性、类方法、静态属性：

class people:
    country = 'chinese'

    def __init__(self, name, age, higth, wigth):
        self.name = name
        self.age = age
        self.higth = higth
        self.wigth = wigth

    @property         #静态属性
    def food(self):
        print('%s love to eat rice' % self.country)

    @classmethod      #类方法
    def hobby(cls):
        print('%s love to treval' % cls.country)

    @staticmethod     #静态方法 类的工具包：不能使用类变量和实例变量
    def fitness(a,b):
        print('%s and %s love to dance' %(a,b))

p1=people('alice','18','153','85')
p1.food               #food()定义为静态属性，调用时就不用再加()
people.hobby()        # 类方法：类直接调用类定义的函数
people.fitness('lilei','hanmeimei')

 

 继承

接口继承：定义一个基类，基类当中把自己的方法用装饰器的方式定义成接口函数，当子类继承基类时，子类必须实现基类的方法，不实现，就没办法进行实例化

import abc

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractclassmethod
    def Action(self):
        pass
    @abc.abstractclassmethod
    def Feature(self):
        pass

class Cat(Animal):   #实现了接口继承，可以进行实例化
    def Action(self):
        print('黑猫喵喵叫')

    def Feature(self):
        print('小猫很可爱')

class Dog(Animal):   #未实现基类中的方法，无法实例化
    def Action(self):
        print('小狗汪汪叫')


m1=Cat()  #实例化成功
m2=Dog()  #实例化成功

 

 

 

学习材料来源：

https://www.cnblogs.com/linhaifeng/articles/6182264.html