Python开发之路-面向对象

1.三大范式

（1）面向过程编程

（2）函数式编程

（3）面向对象

 2.定义

定义：如果我们把数据和动作内嵌到一个结构（函数或类）里面，那么我们就有了一个'对象系统'（对象就是数据与函数整合到一起的产物）

首次面向对象设计：

def menghuanxiyou(name,gender):
    def datang(person):
        print('%s拜师程咬金' %person['name'])
    def fangcun(person):
        print('%s拜师金蝉大师' %person['name'])
    def init(name,gender):
        player = {
            'name':name,
            'gender':gender,
            '门派':datang
        }
        return player
    return init(name,gender)
player1 = menghuanxiyou('独白','男')
player1['门派'](player1)

此时输出的值为：独白拜师程咬金

3.面向对象设计（Object Oriented Design）

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

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

面向对象设计：将一类具体事物的数据和动作整合到一起，既面向对象设计

4.面向对象编程（Object-oriented Programming）

方法：就是用定义类加实例 / 对象的方式去实现面向对象的设计

实例化：由类生产对象的过程叫实例化，类实例化的结果就是一个对象，或者叫一个实例（实例=对象）

规范：声明类的时候首字母要大写

类的分类(python2中，python3中都是新式类)：

（1）经典类：

　　class Chinese:

　　　　pass

（2）新式类：

　　class Chinese(object):

　　　　pass

属性：（1）数据属性（2）函数属性

类和对象都有属性，都用点来访问自己的属性

查看类的属性：  print(dir(Chinese))

查看类的属性字典：__dict__ 里面存放着类的数据属性和函数属性

5.类的特殊属性

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

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

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

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

类名.__dict__# 类的字典属性

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

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

6.实例化

class Chinese:
    '这是一个中国人的类'  #---->文档
    pifu = '黄色'
    def __init__(self,name,age,gender):  #--> self就是p1实例本身
        print('开始初始化啦')
        self.mingzi = name #--> p1.mingzi = name
        self.nianling = age
        self.xingbie = gender
        #结尾自动return 封装完后的p1
    def chadui(self):
        print('%s又在插队' %self.mingzi)
person1 = Chinese('唐浩','21','男')
print(person1.mingzi,person1.pifu)
person1.chadui()  #——> 内部会将person1传入进去
Chinese.chadui(person1)
print(Chinese.__dict__)

实例只有数据属性没有函数属性，能调用函数是因为从class这个类的作用域里调用的

7.类属性

函数属性的命名一般是动词加名词

（1）查看类属性

　　print(Chinese.pifu)

（2）修改类属性

　　Chinese.pifu = '黄棕色'

　　print(Chinese.pifu)

（3）增加类属性

　　Chinese.toufa = '黑色' #---->直接增加即可

　　print(Chinese.toufa)

（4）删除类属性

　　del Chinese.pifu

函数属性：

（1）增加类的函数属性

def xizao(self,shijian):
    print('%s 洗了%s分钟' %(self.mingzi,shijian))
Chinese.xi_zao = xizao
person1.xi_zao('十')

此时输出结果为： 唐昊洗了十分钟

（2）修改类的函数属性

　　直接定义一个函数，然后覆盖即可

8.实例属性的增删改查

（1）查看数据属性

　　print(person1.mingzi)

　　print(person1.xizao)  #-->此处是绑定了类的函数属性

（2）增加实例属性

　　person1.faxing = '爆炸头'  ##只会增加实例内部的字典  不会加入到类里

（3）增加实例的函数属性

　　def test(self):

　　　　print('aaaa')  ###---->  这里的函数属性加入到了实例那个作用域里！！！

　　person1.test = test

　　person1.test(person1)  -->这里的参数可以随便改 ###很少这么用！！！  直接加入到类里的函数属性是最好的 要不然要做重复工作

###不要轻易去改类属性里底层结构的属性字典！！！

（4）修改实例的数据属性！！结构不要改

　　person1.mingzi = 'joe'

（5）删除实例的数据属性

　　del person1.mingzi

只有用.点 去查找的时候会局限在类里，以下这个情况不会：

country = '中国'
class test:
    def __init__(self,name):
        print('%s' %name,country)
p1 = test('chris')

此时输出值为 chris 中国

以下这种情况拿的是全局变量：

country = '美国'
class test:
    country = '中国'
    def __init__(self,name):
        print('%s' %name,country)
p1 = test('chris')

此时输出值为 chris  美国

以下这种情况是给类修改：（实例内部并没有列表）

country = '美国'
class test:
    country = '中国'
    l = [1,2]
    def __init__(self,name):
        print('%s' %name,country)
p1 = test('chris')
p1.l.append(5)
print(p1.__dict__)

此时p1的字典为空

9.静态属性 @property  可访问实例属性和类属性

@propert 来封装函数使其成为静态属性

class Fangjain:
    def __init__(self,owner,name,length,width,height):
        self.owner = owner
        self.name = name
        self.length = length
        self.width = width
        self.height = height
    @property
    def cal_mianji(self):
        return '%s 住的%s 面积为%s' %(self.owner,self.name,(self.length*self.width))
    @property
    def cal_体积(self):
        return '%s 住的%s 面积为%s' %(self.owner,self.name,(self.length*self.width*self.height))
p1 = Fangjain('chris','豪宅',100,50,20)
p1.cal_mianji #-->此时cal_mianji 函数被封装成了一个静态属性 可用点的方式调用查看
mianji = p1.cal_mianji ##-->这里调用不要再加括号 直接用点的方式调用
print(mianji)

10.类方法（与类捆绑 不需与实例捆绑） @classmethod 不可访问实例的属性

当只要操作与类相关的方法时使用，不能访问实例属性

@classmethod
    def class_info(cls):
        return cls.biaozhun
a = Fangjain.class_info() ##-->自动将Room类传递给class_info里的cls参数
print(a)

11.静态方法 类的工具包 主要做一些和类和实例无关的功能 实例和类都可以调用 实例不会将自己的参数传进去

    @staticmethod
    def maifang_xuqiu(money,chaoxiang):
        print('价格少于%s 朝向为%s' %(money,chaoxiang))
p1 = Fangjain('chris','豪宅',100,50,20)
p1.maifang_xuqiu(2444,'南') ##-->实例也可调用
Fangjain.maifang_xuqiu(3000,'北')

 此时输出值为：

价格少于2444 朝向为南
价格少于3000 朝向为北

12.组合 让类与类直接产生联系

class School:
    def __init__(self,addr,name):
        self.addr = addr
        self.name = name

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

class Teacher:
    def __init__(self,t_name,age,salary,course):
        self.t_name = t_name
        self.age = age
        self.salary = salary
        self.course = course

s1 = School('南山','同恩')
s2 = School('宝安','蓝袜')
s3 = School('蛇口','领先者')

t1 = Teacher('王尚峰',25,2500,'英语')
t2 = Teacher('许周堆',26,8000,'棒球')

info = '''
    1 -- > 同恩
    2 -- > 蓝袜
    3 -- > 领先
    以下是教师名单：
    1 -- > 王尚峰
    2 -- > 许周堆
'''

while True:
    print(info)
    club = input('请选择您要选择的俱乐部:')
    jiaoshi = input('请选择您要选择的老师:')
    class_obj = {
        '1':s1,
        '2':s2,
        '3':s3,
    }
    jiaoshi_obj = {
        '1':t1,
        '2':t2,
    }
    xuexiao = class_obj[club]
    laoshi = jiaoshi_obj[jiaoshi]
    name = input('请输入你要上的课程名：')
    price = input('请输入你的价位：')
    period = input('请输入你的课程时长：')
    course1 = Course(name,price,period,xuexiao,laoshi)
    print('感谢您选择【%s】 您选择的课程为【%s】由【%s】老师任教 您的课程价格为【%s】校区位于【%s】 ' 
          %(course1.school.name,course1.name,course1.teacher.t_name,course1.price,course1.school.addr))