面向对象介绍
何为编程？
程序员按照特定的语法、数据结构及算法组织代码，以此来告诉计算机如何执行任务的过程；
编程范式[Programming paradigm]
从不同编程方式中归纳总结出来的编程方式类别，包含面向过程，面向对象，函数式编程等；
面向过程[Procedure Oriented]
通过一组指令，一步步告诉电脑怎么做，依赖Procedure[过程]；
核心思想：大问题->小问题->更小的问题->(可以在一个小范围内解决)；
问 题：从上到下，逐步依赖，改一个位置，相关依赖均要修改；
使用场景：面向过程比较适合简单脚本，一次性任务等场景使用，效率较高；
面向对象[OOP-Object Oriented Programming]
通过类与对象创建各种模型来实现对真实世界的描述；世界万物，皆可分类；世界万物，皆为对象；
只要是对象，就肯定属于某个品类；
只要是对象，就肯定有属性<静态属性，动态属性>；
在描述现实世界时，需要按照现实世界的规则来，所以需要搭建一个框架，才能够对某个事物进行描述；
优 势：易维护，易扩展，编程效率高，使别人更易理解，是团队开发变得从容；
语法
包含：属性、方法、构造函数、析构函数、私有方法、私有属性、类变量、实例变量。
class Dog: # 定义一个类 Dog 类名
n = 123 # 类变量<存在类的内存中>
# 类变量，所有实例公用的属性，可以修改，节省开销
name = "Class name"
name_list = ['11', '22', '33']
# 在实例化时，需要赋予的属性
# 构造函数:
# 作用：在实例化时，做一些类的初始化的工作<实例赋名字，传参数之类>
def __init__(dog_var, name): # dog_var用来接收实例名，如dog1, dog2,dog3
dog_var.name = name # dog_var.name属于实例变量<静态属性>，作用域是实例本身
# 实例变量用来描述类的不同实例的不同属性
dog_var.__owner = "Bruce" # 私有属性
# 私有方法同理,def __siyou(self): pass
# 类的方法，功能<动态属性>
def bulk(dog_var1): # dog_var1也是用来接收实例名，如dog1,dog2,dog3
print("%s Wang wang wang!!!" % dog_var1.name)
def get_owner(self):
print(self.__owner)
def __del__(self): # 析构函数
#print("%s was dead!!" % self.name)
#print("I miss you %s." % self.name)
pass
# 生成对象dog1-3
# 实例化(初始化一个类，造了一个对象)，把一个类变为一个实例的过程；
# 对象又称为Dog类的一个实例
dog1 = Dog('Xilou')
dog2 = Dog("QiuQiu") # 生成了一具体的狗狗
dog3 = Dog("Buck")
# 让狗叫
dog1.bulk() # 等价于Dog.bulk(dog1)
Dog.bulk(dog1) # 等价于dog1.bulk()
del dog1 # 删除实例<摘门牌号>，删除时调用析构函数__del__(self):
dog2.bulk()
dog3.bulk()
#### 类变量与实例变量的介绍与区别
print(Dog.n) # 类变量=>未实例化即可调用
print(Dog.name)
dog4 = Dog("Mengmeng")
print(dog4.n)
print(dog4.name) # 变量先找实例本身，如果没有则找类变量的；
dog5 = Dog("Doudou")
dog5.name = "豆豆" # 实例属性可以修改
dog5.kind = 'little dog' # 为实例新增属性
del dog5.name # 删除实例属性
print(dog5.name, dog5.kind)
dog4.n = 10 # 由结果推断，实例类变量的修改，实际是在实例内存内新建dog4.n=10这个变量；
dog6 = Dog("NianNian")
print(dog4.n, dog5.n, dog6.n) # dog4实例的类变量变更，dog5及dog6未做变更；
dog4.name_list.append('55')
print(dog4.name_list)
dog4.name_list = [333]
dog4.name_list.append(222)
print(dog4.name_list)
Dog.n = "类修改" #
# dog4不受影响，原因之前修改在实例中新建了同名的实例变量
# dog5及dog6调用类变量，所以修改类变量，返回值跟着修改
print(dog4.n, dog5.n, dog6.n)
print(dog5.name_list)
dog5.get_owner()
#####
# 析构函数：在实例释放、销毁的时候自动执行的，通常用于做一些收尾工作<关闭一些数据库链接，打开的临时文件等>；
# python判断变量是否在用-->变量名在则在用，变量不在则不再用-->不在用则从内存中回收；
#####
# 私有方法，私有属性:外部<实例之外>无法访问，只能内部访问<实例内部的方法>；
# 用于类的封装；
dog10 = Dog('XiLou Lee')
print(dog10.__owner) # 直接访问无法访问
dog10.get_owner() # 调用方法访问
#####
实例的生成过程
特性
类[class]
即分类，对一类拥有相同属性<静态属性，动态属性-即方法>的对象的抽象；
对象[object]
即是一个类实例化后的实例；类是对象的抽象，对象是类的特例；
封装[Encapsulation]
封装就是把抽象的数据和对数据进行的操作封装在一起，数据被保存在内部，程序的其他部分只有通过授权的操作（成员方法等）才能对数据进行操作；
继承[Interitance]
一个类可以派生出特殊的子类，则原有类为父类，而父类的属性及方法可以被子类继承；
# 父类-人类 class People: #经典类 #标准写法 class People(object): # 新式类<多继承的方法变了> def __init__(self, name, age): self.name = name self.age = age def eat(self): print("%s is eating." % self.name) def sleep(self): print("%s is sleeping" % self.name) def talk(self): print("%s is talking" % self.name) # 子类1-男人 class Man(People): def __init__(self, name, age, size): # 对构造函数进行重构，实例化时，实际的调用 People.__init__(self,name, age) # 所以，需要获取将父类构造函数的变量 # 并调用父类的构造函数 # People.是经典类的写法 # super(Man, self).__init__(name.age) 等价于上面的调用，作用在父类<People>的名称变更时，不需要更改 # super是新式类的写法,用的更多； self.size = size def piao(self): print("%s is piaoing....20s...done." %self.name) def sleep(self): People.sleep(self) print("%s is shout." % self.name) def get_size(self): print("%s's size is %s." % (self.name, self.size)) # 子类2-女人 class Woman(People): def get_birth(self): print("%s can born a baby...." % self.name) m1 = Man("Bruce", "22", "200") m1.eat() # 继承父类的方法 m1.piao() # 子类新增的方法 m1.sleep() # 重构父类的方法 m1.get_size() w1 = Woman("Ling", '35') w1.get_birth() ##### # 新式类及经典类，对于我们有影响的，主要体现在继承上； #####
多继承方式:
# 父类-人类 class People(object): def __init__(self, name, age): self.name = name self.age = age self.friends = [] def eat(self): print("%s is eating." % self.name) def sleep(self): print("%s is sleeping" % self.name) def talk(self): print("%s is talking" % self.name) # 父类-关系 class Relation(object): def make_friends(self, obj): print('%s is making friends with %s' %(self.name, obj.name)) self.friends.append(obj) # 子类1-男人 class Man(People, Relation): def __init__(self, name, age, size): super(Man, self).__init__(name, age) self.size = size def piao(self): print("%s is piaoing....20s...done." %self.name) def sleep(self): People.sleep(self) print("%s is shout." % self.name) def get_size(self): print("%s's size is %s." % (self.name, self.size)) # 子类2-女人 class Woman(People, Relation): # 多继承顺序是从左到右 def get_birth(self): print("%s can born a baby...." % self.name) m1 = Man("Bruce", 22, 2000) w1 = Woman("Lee", 23) m1.make_friends(w1) # 为什么传obj，人只能跟人交朋友，不能和字符串呀！！！！ print(m1.friends) # m1的friends列表中有w1这个人 print(m1.friends[0].name) # 获取m1朋友w1的名字，如果用字符串，就没有联系了呀； ##### # 新式类及经典类，对于我们有影响的，主要体现在继承的多继承这方面； # 为什么要进行多继承: # 因为一样东西可能同时属于两个类；或者拥有该种特质； # 多继承顺序是从左到右，构造函数也是这么执行的；(广度优先<新式类>)，深度优先<经典类&Python2>；
#####
多态[Polymorphism]
即，一个接口多种实现；
指一个引用在不同情况下的多种状态；
指通过指向父类的指针，来调用在不同子类中实现的方法；
def animal_bulk(obj): # 统一的一个接口 obj.bulk() class Animal(object): def __init__(self, name, age): self.name = name self.age = age @staticmethod def all_bulk(obj): # 统一的一个接口 obj.bulk() class Dog(Animal): def __init__(self, name, age): super().__init__(name, age) def bulk(self): print("Woof Woof!!") class Goat(Animal): def __init__(self, name, age): super().__init__(name, age) def bulk(self): print("Mian......") dog1 = Dog("QiuQiu", 12) goat1 = Goat("ShanDa", 2) # 静态类方法写法 Animal.all_bulk(dog1) Animal.all_bulk(goat1) # 类外函数调用 animal_bulk(dog1) animal_bulk(goat1)
特性总结：
封装是为了隐藏实现细节，使得代码模块化；
继承可以扩展已存在在的代码模块(类)；
封装和继承均为了一个目的:代码的重用；
而多态为了实现另外一个目的-接口重用，为了类在继承和派生的时候，保证使用‘家谱’中任一类的实例和某一属性时的正确调用；
end