一、什么是面向对象的程序设计

1、面向过程的程序设计　　

　　面向过程：核心是过程二字，过程即解决问题的步骤，就是先干什么，再干什么。基于该思想写程序就好比在设计一条流水线，是一种机械式的思维方式。
　　优点：复杂的过程流程化，进而简单化
　　缺点：扩展性差

2、面向对象的程序设计

　　面向对象：核心是对象二字，对象是特征与技能的结合体。基于该思想编写程序就好比在创造一个世界，世界是由一个个对象组成，是一种“上帝式”的思维方式
　　优点：可扩展性强
　　缺点：编程复杂度高，容易出现过度设计问题

二、类与对象

　　对象是特征和技能的结合体，类就是一系列对象相似的特征与技能的结合体。

• 现实世界中：一定是现有的一个个具体存在的对象，后总结出的类
• 在程序中：一定保证先定义类，后产生对象

    对象1：
        特征：
            学校=清华
            名字=lionel
            性别=男
            年龄=18
        技能：
            学习
            选课

    对象2：
        特征：
            学校=清华
            名字=xiaohong
            性别=女
            年龄=28
        技能：
            学习
            选课

    对象3：
        特征：
            学校=清华
            名字=daming
            性别=男
            年龄=38
        技能：
            学习
            选课

现实世界中站在学校的角度

程序中的学校学生类：
    清华学生类
        相似的特征
            学校=清华
        相似的技能
            学习
            选课

程序中的学校学生类

# 类体代码在类的定义阶段就会立刻执行
class Student:
    school=‘oldboy‘
    def learn(self):
        print(‘is learning‘)
    def choose_course(self):
        print(‘choose course‘)
    print(‘=====run‘)
print(Student.__dict__)

python中类与对象

三、属性查找

1、类属性：数据属性、函数属性

• 类的数据属性是所有对象共享的，id都是一样的。
• 类的函数属性是绑定给对象用的，称为绑定方法，内存地址都不一样。

2、实例属性：数据属性

3、类属性的增删改查

class Student:
    school=‘清华‘
    def learn(self):
        print(‘is learning‘)
    def choose_course(self):
        print(‘choose course‘)
    print(‘=====run‘)

# 查看类属性
print(Student.school) # 数据属性
print(Student.learn) # 函数属性
"""
=====run
清华
<function Student.learn at 0x101a60488>
"""

# 增加类属性
Student.country=‘China‘
print(Student.country)
"""
=====run
China
"""

# 修改类属性
Student.school=‘北大‘
print(Student.school)
"""
=====run
北大
"""

# 删除类属性
del Student.country
print(Student.country)

类属性的增删改查

4、类与对象练习

class Student:
    school=‘oldboy‘
    def __init__(self,name,age,sex,course):
        self.name=name
        self.age=age
        self.sex=sex
        self.course=course
    def xue_xi():
        print(‘学习使我快乐‘)
    def xuan_ke(self):
        print(‘我叫%s,选择学习%s‘ %(self.name,self.course))

s1=Student(‘lionel‘,18,‘male‘,‘python‘)

print(s1.school)
print(Student.__dict__)
print(s1.__dict__)
Student.xue_xi()
Student.xuan_ke(s1)
s1.xuan_ke()

"""
清华
{‘__module__‘: ‘__main__‘, ‘school‘: ‘清华‘, ‘__init__‘: <function Student.__init__ at 0x101c60488>, ‘xue_xi‘: <function Student.xue_xi at 0x101c60598>, ‘xuan_ke‘: <function Student.xuan_ke at 0x101c60620>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Student‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Student‘ objects>, ‘__doc__‘: None}
{‘name‘: ‘lionel‘, ‘age‘: 18, ‘sex‘: ‘male‘, ‘course‘: ‘python‘}
学习使我快乐
我叫lionel,选择学习python
我叫lionel,选择学习python
"""

练习

四、类的三大特性

1、静态属性：既能访问到类属性也能访问到实例属性

class Room:
    def __init__(self,name,owner,width,length,heigh):
        self.name=name
        self.owner=owner
        self.width=width
        self.length=length
        self.heigh=heigh
    @property # 既能访问到类属性也能访问到实例属性
    def cal_area(self):
        # print(‘%s 住的 %s 总面积是 %s‘ %(self.owner,self.name,self.length*self.width))
        return self.length*self.width

r1=Room(‘学区房‘,‘lionel‘,100,100,100)
print(r1.cal_area)

静态属性

2、类方法：只能访问到类属性，不能访问到实例属性

class Room:
    tag=1
    def __init__(self,name,owner,width,length,heigh):
        self.name=name
        self.owner=owner
        self.width=width
        self.length=length
        self.heigh=heigh

    @property # 既能访问到类属性也能访问到实例属性
    def cal_area(self):
        return self.length*self.width

    @classmethod #只能访问到类属性，不能访问到实例属性
    def tell_info(cls,x):
        print(‘--->‘,cls.tag,x)
Room.tell_info(10)
"""
---> 1 10
"""

类方法

3、静态方法：既不能访问到类属性，也不能访问到实例属性

class Room:
    tag = 1
    def __init__(self, name, owner, width, length, heigh):
        self.name = name
        self.owner = owner
        self.width = width
        self.length = length
        self.heigh = heigh

    @property # 既能访问到类属性也能访问到实例属性
    def cal_area(self):
        return self.length * self.width

    @classmethod # 只能访问到类属性，不能访问到实例属性
    def tell_info(cls, x):
        print(‘--->‘, cls.tag, x)

    @staticmethod # 既不能访问到类属性，也不能访问到实例属性
    def student(a,b,c):
        print(‘%s %s %s正在学习‘ %(a,b,c))

Room.student(‘daming‘,‘xiaohong‘,‘lionel‘)
r1=Room(‘学区房‘,‘lionel‘,100,100,100)
r1.student(‘alex‘,‘egon‘,‘lionel‘)
"""
daming xiaohong lionel正在学习
daming xiaohong lionel正在学习
"""

静态方法

　　注意：静态方法和类方法虽然是给类准备的，但是如果实例去用，也是可以用的，只不过实例去调用的时候容易让人混淆，不知道你要干啥。

五、组合

什么是组合？

　　组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合。

class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
    def zhao_sheng(self):
        print(‘%s 正在招生‘ %self.name)

class Course:
    def __init__(self,name,price,period,school):
        self.name=name
        self.price=price
        self.period=period
        self.school=school
s1=School(‘oldboy‘,‘北京‘)
s2=School(‘oldboy‘,‘南京‘)
s3=School(‘oldboy‘,‘上海‘)

msg="""
1 老男孩 北京校区
2 老男孩 南京校区
3 老男孩 上海校区
"""
while True:
    print(msg)
    menu={
        ‘1‘:s1,
        ‘2‘:s2,
        ‘3‘:s3
    }
    choice=input(‘选择学校>>: ‘)
    school_obj=menu[choice]
    name=input(‘课程名>>: ‘)
    price=input(‘课程费用>>: ‘)
    period=input(‘课程周期>>: ‘)
    new_course=Course(name,price,period,school_obj)
    print(‘课程【%s】属于【%s】【%s】学校‘ %(new_course.name,new_course.school.name,new_course.school.addr))

组合

原文地址：https://www.cnblogs.com/wangzhiwei10/p/8976224.html