python学习笔记-面向对象设计

前言

1、三大编程范式：

面向过程编程

函数式编程

面向对象编程

2、编程进化论

1.编程最开始就是无组织无结构，从简单控制流中按步写指令

2.从上述的指令中提取重复的代码块或逻辑，组织到一起，便实现了代码重用，且代码由无结构走向了结构化，创建程序的过程变得更具逻辑性

3.我们定义函数都是独立于函数外定义变量，然后作为参数传递给函数，这意味着：数据与动作是分离的

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

3、面向对象设计

面向对象设计（Object oriented design）：将一类具体事物的数据和动作整合到一起，即面向对象设计

面向对象编程（object-oriented programming）：用定义类+实例/对象的方式去实现面向对象的设计

4、类和对象定义

类：类是一种数据结构，就好比一个模型，该模型用来表述一类事物（事物即数据和动作的结合体），用它来生产真实的物体（实例）

对象：睁开眼，你看到的一切的事物就是一个个的对象，你可以把对象理解成一个具体的事物

类和对象的关系：对象都是由类产生的，上帝造人，上帝首先由一个造人的模板，这个模块即人的类，然后上帝根据类的定义来生产一个个的人

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

1、初识类

定义

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

#创建一个类
class Chinese:
    pass

#实例化出一个对象p1
p1=Chinese()

经典类和新式类

#经典类：
class 类名：
    pass

#新式类：
class 类名(父类): # class 类名(object)
    pass

大前提：

1、只有在python2中才分新式类和经典类，python3中统一都是新式类
2、新式类和经典类声明最大不同在于，所有新式类必须继承至少一个父类
3、所有类不管是否显式声明父类，都有一个默认继承object父类

2、类的属性

2.1划分

类是用来描述一类事物，类的对象是指这一类事物的一个个体。是事物就有属性，属性分为

1、数据属性：就是变量
2、函数属性：就是函数，就是在类中的方法

类和对象均用.来访问自己的属性

2.2访问方式

查看类属性有2种方式

dir(类名)：查出的是一个属性名字列表
类名.__dict__:查出的是一个字典

class Chinese:
    work = "程序员"

    def sleep():
        print("晚上12点睡觉")

    def eat(self):
        print("点好外卖，送餐中")

print(Chinese.work)  # 加点本质上就是查__dict__的属性字典。
Chinese.sleep()
Chinese.eat(1)

#原理如下
print(Chinese.__dict__)  # 查看类的属性字典
#结果为：{'__module__': '__main__', 'work': '程序员', 'sleep': <function Chinese.sleep at 0x0088E1E0>, 'eat': <function Chinese.eat at 0x0088E270>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None}
print(Chinese.__dict__["work"])
Chinese.__dict__["sleep"]()#通过属性字典找到该函数属性的内存地址，然后加()运行该函数
Chinese.__dict__["eat"](1)

# 类的其他属性
print(Chinese.__name__)  # Chinese               类Chinese的名字（字符串）
print(Chinese.__doc__)  #None                    文档字符串
print(Chinese.__module__)  #__main__             模块

print(Chinese.__base__)  #<class 'object'>       类的第一个父类
print(Chinese.__bases__)  # (<class 'object'>,)  类的所有父类构成的元组
print(Chinese.__dict__)  #                       类的属性
print(Chinese.__class__)  #<class 'type'>        实例对应的类（仅新式类中）

3、面向对象的程序设计

例1

def Chinese(name,age,sex):

    def init(name,age,sex):
        dic={"name":name,
             "age":age,
             "sex":sex,
             "sleep":sleep,
             "eat":eat
        }
        return dic

    def sleep():
        print("晚上12点睡觉")

    def eat(dic):
        print("%s点好外卖，送餐中" %dic["name"])

    return init(name,age,sex)

p1=Chinese("steven","","男")
p1["sleep"]() #晚上12点睡觉
p1["eat"](p1)#steven点好外卖，送餐中

例2

class Chinese:
    work = "程序员"

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def sleep():
        print("晚上12点睡觉")

    def eat(self):#self就是实例自己
        print("%s点好外卖，送餐中" %self.name)

p1=Chinese("steven","","男")#相当于p1=Chinese.__init__(p1,"袁浩","18","female")
#p1.sleep() 报错，不需要传参数却传了个参数。因为class自动处理相当于执行了p1.sleep(p1),因此，类中的方法在创建的时候要传一个参数self。如def sleep(self)
p1.eat()

print(p1.__dict__)      #显示实例的属性字典
print(Chinese.__dict__) #显示类的实例字典
# print(p1.name)
# print(p1.__dict__["name"])

#Chinese.sleep()     #运行表示是类调用方法，跟实例没关系
#Chinese.eat(p1)

执行结果为：

steven点好外卖，送餐中
{'name': 'steven', 'age': '25', 'sex': '男'}
{'__module__': '__main__', 'work': '程序员', '__init__': <function Chinese.__init__ at 0x00E3E1E0>, 'sleep': <function Chinese.sleep at 0x00E3E270>, 'eat': <function Chinese.eat at 0x00E3E2B8>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None｝　　

总结：

1、两个例子都应用了面向对象的思想。使用class定义类不代表一定是面向对象，用面向对象编程语言编程不一定就是面向对象，用非面向对象语言也能实现面向对象，面向对象是一种设计思想。

2、例2对比例1，使用__init__方法，相当于自动生成了属性字典并返回，就不需要return。实例化时会触发该函数运行。

3、实例就只有数据属性，没有函数属性

4、属性的增删改查

#====== 类属性的增删改查=====
class Chinese:
    work = "程序员"

    def __init__(self,name):
        self.name = name

    def play_ball(self,ball):
        print("%s 正在打 %s" % (self.name, ball))

# 查询
print(Chinese.work)
# 修改
Chinese.work = '复仇者'
print(Chinese.work)
# 增加
Chinese.country = "china"
print(Chinese.country)
# 删除
print(Chinese.__dict__)
del Chinese.country
print(Chinese.__dict__)

# 增加类的函数属性
def eat_foot(self, food):
    print("正在吃%s" % food)

Chinese.eat = eat_foot
print(Chinese.__dict__)

# 修改类的函数属性(重新增加一个属性，覆盖要修改的属性)
# 略

# =====实例属性的增删改查=====
p1 = Chinese("steven")
print(p1.__dict__)
# 查看
print(p1.name)
print(p1.play_ball)

# 增加实例的数据属性
p1.age = 18
print(p1.__dict__) #{'name': 'steven', 'age': 18}
print(p1.age)

# 增加实例的函数属性。（一般不这么用）
def test(self):
    print("来自实例的函数属性")
p1.test = test
print(p1.__dict__)
#p1.test()  # 这里会报错，提示缺少请求参数。实例只有在调用类的函数属性时才自动加上self参数。

# 修改
p1.age = 19
print(p1.__dict__)
print(p1.age)

# 删除
del p1.age
print(p1.__dict__)

5、作用域

#-----场景1-----
class Chinese:
    work = "程序员"

    def __init__(self, name):
        self.name = name

def play_ball(self, ball):
    print("%s 正在打 %s" % (self.name, ball))

p1 = Chinese("steven")
print(p1.work)

p1.work = "医生"
print(Chinese.work)  # "程序员"
print(p1.work)  # "医生"

#-----场景2-----
work = "程序员"
class Chinese:

    def __init__(self,name):
        self.name = name
        print("---->",work)

    def play_ball(self, ball):
        print("%s 正在打 %s" % (self.name, ball))

p1 = Chinese("steven")  # 执行结果为"----> 程序员"。如果类或实例加点进行访问，访问的只能是类或实例的作用域。这里没加点所以能输出。
#print(Chinese.work) 报错，只能访问类自己的作用域，不能访问到外部的work
#print(p1.work)报错

#------场景3-----
work = "程序员"
class Chinese:
    work= "律师"
    l = ["a", "b"]
    def __init__(self,name):
        self.name = name
        print("---->", work)

    def play_ball(self, ball):
        print("%s 正在打 %s" % (self.name, ball))

print(Chinese.__dict__)
print(Chinese.work)  # "律师"。
p1 = Chinese("steven")  # 结果为"----> 程序员"。因为在类里面定义的都跑到类的字典里去了，没有用点访问跟实例和类都没关系不会从类或实例的字典里去找，只是个普通变量
print("实例---》", p1.work)  # "实例---》 律师"。通过点的方式调用，就会从类内部去找

#-----场景四-----
work = "程序员"
class Chinese:
    work= "律师"
    l = ["a", "b"]
    def __init__(self,name):
        self.name = name
        print("---->", work)

    def play_ball(self, ball):
        print("%s 正在打 %s" % (self.name, ball))

p1 = Chinese("steven")
print(p1.l)
# p1.l=[1,2,3]
# print(Chinese.l)
# print(p1.__dict__)
p1.l.append("c")  # 这里p1没有l,这里拿到的l就是类的属性，改的也是类属性
print(p1.__dict__)  # {"name":"steven"}
print(Chinese.l)  # ["a","b","c"]