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))
选课系统低级版 组合的使用
原文地址:https://www.cnblogs.com/caixiaowu/p/12350632.html