面向对象、类和对象

1.面向对象设计
面向过程的程序设计：核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么…面向过程的设计就好比精心设计好一条流水线，是一种机械式的思维方式。
优点是：复杂度的问题流程化，进而简单化（一个复杂的问题，分成一个个小的步骤去实现，实现小的步骤将会非常简单）
缺点是：一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，即便是能，也得是大改，改一个组件，牵一发而动全身。
应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。
面向对象的程序设计：（OOD），将一类具体事物的数据和动作整合到一起，即面向对象设计
核心是对象二字，（要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来想了想解决这个问题需要四个人：唐僧，沙和尚，猪八戒，孙悟空，每个人都有各自的特征和技能（这就是对象的概念，特征和技能分别对应对象的数据属性和方法属性），然而这并不好玩，于是如来又安排了一群妖魔鬼怪，为了防止师徒四人在取经路上被搞死，又安排了一群神仙保驾护航，这些都是对象。然后取经开始，师徒四人与妖魔鬼怪神仙交互着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取),对象是特征与技能的结合体，基于面向对象设计程序就好比在创造一个世界，你就是这个世界的上帝，存在的皆为对象，不存在的也可以创造出来，与面向过程机械式的思维方式形成鲜明对比，面向对象更加注重对现实世界的模拟，是一种“上帝式”的思维方式。
优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。
缺点：
编程的复杂度远高于面向过程，不了解面向对象而立即上手基于它设计程序，极容易出现过度设计的问题。一些扩展性要求低的场景使用面向对象会徒增编程难度，比如管理linux系统的shell脚本就不适合用面向对象去设计，面向过程反而更加适合。
无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法准确地预测最终结果。于是我们经常看到对战类游戏，新增一个游戏人物，在对战的过程中极容易出现阴霸的技能，一刀砍死3个人，这种情况是无法准确预知的，只有对象之间交互才能准确地知道最终的结果。
应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方
面向对象的程序设计并不是全部。对于一个软件质量来说，面向对象的程序设计只是用来解决扩展性
**用函数进行面向对象设计：**用面向对象语言写程序，和一个程序的设计是面向对象的，两者是八竿子打不着的

def school(name,addr,type):
    def init(name, addr, type):
        sch = {
            'name': name,
            'addr': addr,
            'type': type,
            'kao_shi': kao_shi,
            'zhao_sheng': zhao_sheng,
        }
        return sch
    def kao_shi(school):
        print('%s 学校正在考试' %school['name'])
    def zhao_sheng(school):
        print('%s %s 正在招生' %(school['type'],school['name']))
    return  init(name,addr,type)
s1=school('oldboy','沙河','私立学校')
print(s1)
print(s1['name'])
s1['zhao_sheng'](s1)
s2=school('清华','北京','公立学校')
print(s2)
print(s2['name'],s2['addr'],s2['type'])
s2['zhao_sheng'](s2)

{'name': 'oldboy', 'addr': '沙河', 'type': '私立学校', 'kao_shi': <function school.<locals>.kao_shi at 0x00000220068BFE18>, 'zhao_sheng': <function school.<locals>.zhao_sheng at 0x00000220068BFEA0>}
oldboy
私立学校 oldboy 正在招生
{'name': '清华', 'addr': '北京', 'type': '公立学校', 'kao_shi': <function school.<locals>.kao_shi at 0x00000220068BFF28>, 'zhao_sheng': <function school.<locals>.zhao_sheng at 0x00000220068C4048>}
清华 北京 公立学校
公立学校 清华 正在招生

用面向对象编程独有的语法class去实现面向对象设计
面向对象编程（OOP）：用定义类+实例/对象的方式去实现面向对象的设计
如果我们把数据和动作内嵌到一个结构（函数和类）里面，那么我们就有了一个对象系统（对象就是数据与函数整合到一起的产物）

class Dog:
    def __init__(self,name,gender,type):
        self.name=name
        self.gender=gender
        self.type=type
    def bark(self):
        print('一条名字为[%s]的[%s],狂吠不止' %(self.name,self.type))
    def yao_ren(self):
        print('[%s]正在咬人' %(self.name))
    def chi_shi(self):
        print('[%s]正在吃屎' %(self.type))
dog1=Dog('alex','female','京巴')
print(dog1.__dict__)
dog2=Dog('wupeiqi','female','腊肠')
dog3=Dog('yuanhao','female','藏獒')
dog1.bark()
dog2.yao_ren()
dog3.chi_shi()

{'name': 'alex', 'gender': 'female', 'type': '京巴'}
一条名字为[alex]的[京巴],狂吠不止
[wupeiqi]正在咬人
[藏獒]正在吃屎

2.类和对象
类：一种数据结构，类似一个模型，用来表述一类事物（数据和动作的结合体），用来生产真是的物体（实例）
对象：一个具体的事物，数据和动作的结合体
关系：对象由类产生，由类产生对象的过程叫实例化，类实例化的结果就是一个对象。
属性：数据属性，即是变量；函数属性，就是函数，在面向对象里通常称为方法
注意：类和对象均用点的方式来访问自己

class Chinese:
    '这是一个中国人的类'
    dang='共产党'
    def sui_di_tu_tan():
        print('朝着墙上就是一口痰')
    def cha_dui(self):
        print('插到了前面')
# print(Chinese.dang)
# Chinese.sui_di_tu_tan()
# Chinese.cha_dui('元昊')

# # print(dir(Chinese))
# # print(Chinese.__dict__) #查看属性字典
# print(Chinese.__dict__['dang'])
# Chinese.__dict__['sui_di_tu_tan']()
# Chinese.__dict__['cha_dui'](1)

class Ball:
    def __init__(self,name):
        self.name = name
    def kick(self):
        print("我叫%s,该死的，谁踢我..." % self.name)
b=Ball("土豆")
print(b.kick())
#共有，私有。在python中定义私有变量只需要在变量名或函数名前加上“—”两个下划线，
那么这个函数或变量就会为私有的了。_类名__变量名形式来访问
class Person:
    __name="肖亮鹏"#如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线，
    在Python中，实例的变量名如果以开头，就变成了一个私有变量（private），
    只有内部可以访问，外部不能访问
    def getName(self):
        return self.__name
#print(Person(__name))    NameError: name '__name' is not defined的结果
p=Person()
print(p.getName())
print(p._Person__name)#python中的变量为伪私有，可以通过这种方式来访问

类的增删改查

class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name))
#查看
print(Chinese.country)
#修改
Chinese.country='Japan'
print(Chinese.country)
p1=Chinese('alex')
print(p1.__dict__)
print(p1.country)
#增加
Chinese.dang='共产党'
# print(Chinese.dang)
# print(p1.dang)
#删除
del Chinese.dang
del Chinese.country
print(Chinese.__dict__)
# print(Chinese.country)
def eat_food(self,food):
    print('%s 正在吃%s' %(self.name,food))
Chinese.eat=eat_food
print(Chinese.__dict__)
p1.eat('屎')
def test(self):
    print('test')
Chinese.play_ball=test
p1.play_ball()# Chinese.play_ball(p1)

Japan
{'__module__': '__main__', '__init__': <function Chinese.__init__ at 0x000002A19536FD08>, 'play_ball': <function Chinese.play_ball at 0x000002A19536FE18>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None}
{'__module__': '__main__', '__init__': <function Chinese.__init__ at 0x000002A19536FD08>, 'play_ball': <function Chinese.play_ball at 0x000002A19536FE18>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None, 'eat': <function eat_food at 0x000002A195361AE8>}
alex 正在吃屎
test

实例属性的增删改查

class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))
p1=Chinese('alex')
print(p1.__dict__)
#查看
print(p1.name)
print(p1.play_ball)
#增加
p1.age=18
print(p1.__dict__)
print(p1.age)
#不要修改底层的属性字典
# p1.__dict__['sex']='male'
# print(p1.__dict__)
# print(p1.sex)
#修改
p1.age=19
print(p1.__dict__)
print(p1.age)
#删除
del p1.age
print(p1.__dict__)

{'name': 'alex'}
alex
<bound method Chinese.play_ball of <__main__.Chinese object at 0x0000017C3999D4E0>>
{'name': 'alex', 'age': 18}
18
{'name': 'alex', 'age': 19}
19
{'name': 'alex'}

类与实例属性综合

class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name
    def play_ball(self,ball):
       print('%s 正在打 %s' %(self.name,ball))
p1=Chinese('alex')
print(p1.country)
p1.country='日本'
print('类的--->',Chinese.country)
print('实例的',p1.country)
》》》
China
类的---> China
实例的 日本

作用域问题

# country='中国'
# class Chinese:
#     def __init__(self,name):
#         self.name=name
#
#     def play_ball(self,ball):
#         print('%s 正在打 %s' %(self.name,ball))
# p1=Chinese('alex')
# # print(p1.country)

country='中国－－－－－－－－－－－－－－－－－－－'
class Chinese:
    country='中国'
    def __init__(self,name):
        self.name=name
        print('--->',country)#在实力属性里面定义的
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))
print(Chinese.__dict__)
print(Chinese.country)
p1=Chinese('alex')
print('实例--------》',p1.country)#有点调用就是从类内部调用

{'__module__': '__main__', 'country': '中国', '__init__': <function Chinese.__init__ at 0x0000021049E11AE8>, 'play_ball': <function Chinese.play_ball at 0x0000021049E1FD08>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None}
中国
---> 中国－－－－－－－－－－－－－－－－－－－
实例--------》 中国

class Chinese:
    country='China'
    l=['a','b']
    def __init__(self,name):
        self.name=name
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))
p1=Chinese('alex')
print(p1.l)
p1.l=[1,2,3]
print(Chinese.l)
print(p1.__dict__)
p1.l.append('c')
print(p1.__dict__)
print(Chinese.l)

['a', 'b']
['a', 'b']
{'name': 'alex', 'l': [1, 2, 3]}
{'name': 'alex', 'l': [1, 2, 3, 'c']}
['a', 'b']