面向对象初识

1.面向过程VS面向对象

面向过程: 过程(流水线式思维)
优点:极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。
缺点:流程就是用来解决一个问题，代码牵一发而动全身。

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。
--------------
函数式：将某功能代码封装到函数中，以后无需重复写代码，调用方便
--------------

面向对象: 对象(上帝式思维)

优点是：解决程序的扩展性。
对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：可控性差，无法像面向过程一样精准的预测问题的处理流程与结果，
面向对象的程序一旦开始就由对象之间的交互解决问题，无法预测最终结果。

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等
面向对象的程序设计并不是全部。对于一个软件质量来说，面向对象的程序设计只是用来解决扩展性。
---------------------------

类：具有相同特征的一类事物(人、狗、老虎)(人类 是一个类, )
对象／实例：具体的某一个事物（隔壁阿花、楼下旺财）(人类中,具体到某个人,这个具体的人就是一个具体的实例,也是一个对象)
实例化：类——>对象的过程
===================

2.初识类和对象

dict #字典类型 是个大类
{'age':18} #具体到某一个字典 就是字典的一个对象
****对象就是已经实实在在 存在的 某一个 具体 的 个体。

在python中，用变量表示特征，用函数表示技能，因而具有相同特征和技能的一类事物就是‘类’，对象是则是这一类事物中具体的一个。
==========

类

类的声明:

class Date: #类名大写
变量=值 #静态属性 (数据属性)
def __init__(self): #初始化方法 (给对象添加必要的属性) (self 就是对象本身)
pass
def func(self): #动态属性(self必须加) (函数属性,方法)(类里面的函数不叫函数,叫方法)

============

类的两种作用:

1.属性引用
2.实例化

属性引用:

class Person: #定义一个人类
role = 'person' #人的角色属性都是人 (类属性:声明的类 的属性)
def walk(self): #人都可以走路，也就是有一个走路方法
print("person is walking...")
 
 
print(Person.role) #查看人的role属性 (属性的获取: 类.属性 实例.属性)
print(Person.walk) #引用人的走路方法，注意，这里不是在调用
Person.country = ‘中国’ # 增加属性
del Person contry #删除属性
Person.role = 11 #修改属性 (role 本来就有,重新赋值)

================

实例化:
类名+() 就是实例化,会自动触发__init__函数,可以用它来为每个实例定制自己的特征

实例化过程:
构造方法:造对象
初始化:给新生对象添加一些属性

语法:

对象名 = 类名(参数)

p = Person('zhou') #类名()就等于在执行Person.__init__()
#执行完__init__()就会返回一个对象。这个对象类似一个字典，存着属于这个人本身的一些属性和方法。
#你可以偷偷的理解：p = {'name':'zhou','walk':walk}

查看属性&调用方法:

• 对象名.(对象的)属性名
• 对象名.(类的)方法名()

关于self:

self：在实例化时自动将对象/实例本身传给__init__的第一个参数，你也可以给他起个别的名字，但不建议这样做,(代码别人看不懂)

类属性的补充:

一：我们定义的类的属性到底存到哪里了？有两种方式查看

1. dir(类名)：查出的是一个名字列表
2. 类名.__dict__:查出的是一个字典，key为属性名(函数方法名)，value为属性值(函数方法内存地址)(__dict__是字典形式,但是不能修改,只能查看)

二：特殊的类属性

类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串 #功能说明字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

============================

对象的相关知识:

class Person:         # 定义一个人类
role = 'person'         # 人的角色属性都是人

def __init__(self, name, aggressivity, life_value):
self.name = name         # 每一个角色都有自己的昵称;
self.aggressivity = aggressivity     # 每一个角色都有自己的攻击力;
self.life_value = life_value     # 每一个角色都有自己的生命值;

def attack(self,dog): 
                    # 人可以攻击狗，这里的狗也是一个对象。
                    # 人攻击狗，那么狗的生命值就会根据人的攻击力而下降
dog.life_value -= self.aggressivit   

对象是关于类的实际存在的一个例子，即实例

对象/实例只有一种作用：属性引用

p = Person('zhou',10,1000) #传值,默认传进__init__函数 (默认调用__init__)
print(p.name)
print(p.aggressivity)
print(p.life_value)

# zhou
# 10
# 1000

也可以引用一个方法，因为方法也是一个属性，只不过是一个类似函数的属性，我们也管它叫动态属性。
引用动态属性并不是执行这个方法，要想调用方法和调用函数是一样的，都需要在后面加上括号

固定格式:(定义&调用)

定义:

class 类名:
def __init__(self,args1,args2):
self.attribute1 = args1         #attribute(对象的属性)
self.attribute2 = args2

def func1(self):pass         #method(方法名)

def func2(self):pass

调用:
对象名 = 类名(Kitty,18) 　　 #对象就是实例，代表一个具体的东西 obj.class_name(实参1,实参2...)
　　　　　　　　　　　　#类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法
　　　　　　　　　　　　#括号里传参数，参数不需要传self，其他与init中的形参一一对应
　　　　　　　　　　　　#结果返回一个对象 (对象的属性在__init__函数里面)
对象名.对象的属性1　　　　 #查看对象的属性，直接用 对象名.属性名 即可 obj.[attribute1]
对象名.方法名() 　　　　 #调用类中的方法，直接用 对象名.方法名() 即可 obj.method1.()