面向对象

• 面向过程
• 函数式编程
• 面向对象

面向过程

所谓过程就是我们解决问题的步骤，一步步的按照过程走，有先后之分。

它呢，整个设计好比流水线，思维上比较机械化。

优缺点：

• 优点：
  • 复杂的问题流程化，将问题分解简化。
• 缺点：
  • 拓展性不好

面向对象

核心是对象。

正式的来说

• 对象是一个数据以及相关行为的集合
• 面向对象是功能上指向建模对象

通数据和行为方式来描述交换对象的集合。

在python中，一切皆为对象。

面向对象的优缺点：

• 优点

  ​ 解决程序的拓展性

• 缺点

  ​ 就是复杂度远高与面向过程

  ​ 交互式解决问题，无法准确预测结果

类就是类别，种类

对象就是特征和技能的统一体

类则是这一些列相思对象的特征和技能的结合。

对于现实世界，现有个体（即对象），才有类别，但对于程序，必须现有类，然后才有对象。

面向对象编程

OOP(object oriented programming)

其实一种程序设计思想.oop把对象作为程序的一个基本单元,一个对象就包括数据和操作数据的函数,

在python中,所有数据类型都可以视为对象,同时,我们也可以自定义对象.

自定义对象的数据类型就是面向对象中累(class)的概念.

Demo:假如要处理我们的成绩.为了表示学生的成绩:

• 面向过程的方式

python
stu1 = {"name":"tom","score":99}
stu2 = {"name":"jack","score":82}

利用函数来实现

def find_score(stu):
    print(stu["name"],":",stu["score"])

如果是面向对象

类的定义和使用

面向对象设计的思想,先抽像出类,再根据类创建实例

类的定义

class ClassName(object):
     class_statement

类的命名,大驼峰式所谓大驼峰就是变量名称的单词的首字母大写

创建一个类

class MyFirstClass:
	pass

类的作用是一个模板,我们可以在创建实例的时候,把一些我们认为必须要绑定的属性填进去.这时就通过特殊的’_init_'方法.在创建实例的时候,绑定相关的属性.比如在前面的name,score

和普通函数相比,在类中定义方法时,第一个参数必须是self.除第一个参数外,其他的和普通函数没有区别

self 代表的是实例,而非类

'_init_'方法

• 1.为对象出事化自己独有的特征
• 2.该方法中可以有任意的代码,但是一定不可以有返回值.

数据封装

我们通过_init_()让stu1 实例本身就拥有了相关数据,如果要访问这些数据,我们可以直接在student类的内部定义相关的函数来访问数据,一次"封装"数据.

这些封装数据的函数和stduent类本身是关联起来的,他们被称之为方法.

类的两个作用:

• 属性引用
  • ’ 类名.属性 ’
• 实例化
  • 类名加上一个括号就是实例化,他能够自动触发’_init_'函数的运行,进而为每个实例定制自己的特征.

类属性的补充

类属性的查看

• 1.dir(类名)
  • 返回一个列表
• 2.类名._dict_
  • 返回一个字典,key为属性名,value是属性值

特殊的类属性

类名.__name__ # 返回类的名字
类名.__doc__ # 类的文档字符
类名.__base__ #类的第一个父类
类名.__bases__ # 类的所有父类构成的元祖
类名,__module__ # 类定义所在的模块
类名.__class__ # 实例所对应的类
类名.__dict__ # 类的字典属性 

总结:

class ClassName:
	def __init__(self,para1,para2,...):
		self.对象属性 = para1
		self.对象属性2 = para2
		
	def 方法名1(self):
		pass
	def 方法名2(self):
		pass

obj = ClassName(para1,para2)
# 对象的实例化,代表具体的东西
# ClassName():调用__init__
# 括号内传参,无需传入self,参数一一对应
# 结果是返回对象obj

obj.对象属性1 # 查看对象的属性
obj.方法名1 # 调用类的方法

对象之间的交互

假如说现在定义两个类,Person,Dog.

类命名空间UI对象,实例的空间

创建一个类就会创建一个类的名称空间,用来存储我们定义的所有的变量名.这些名字就是属性.

类的属性有两种:

• 静态属性
  • 直接在类中定义变量
• 动态属性
  • 在类中定义的方法

静态属性是共享给所有对象的

动态属性是绑定到所有对象的

函数的三大特性

• 继承
• 多态
• 封装

在面向对象编程中,当我们定义一个新类的时候,可以从某个现有的类继承,新的类就被称为子类

(Subclass),而被继承的类则被称为基类,父类,超类(Base Class,Father Class,Super Class)

比如

class Animal(object):
    def run(self):
        print("Animal is running")
class Dog(Animal):
    pass
class Cat(Animal):
    pass
dog = Dog()
cat = Cat()
print(dog.run())
print(cat.run())

继承的查看

` ClassName._bases_

多态

当子类和父类存在相同方法时,子类方法会覆盖父类方法,再运行代码时,总会调用子类和父类同名的方法.

这样,就是继承另外一个好处,多态

class Animal(object):
    def run(self):
        print("Animal is running")
class Animal2():
    pass
class Dog(Animal): #单继承
    def run(self):
        print("dog is running")

class Cat(Animal):  # 单继承
    def run(self):
        print("cat")
class Husky(Animal,Animal2): # 多继承,用逗号分隔开
    pass
dog = Dog()
cat = Cat()
print(dog.run())
print(cat.run())

husky = Husky()
#husky.run()

print(Dog.__bases__)
print(Husky.__bases__)
print(Animal.__bases__)
print(Animal2.__class__)
#如果不指定基类,Python类会默认继承object类
#object是所有python类的基类,提供一些常见方法的实现

理解多态,首先要对数据类型进行说明.定义一个类的时候世纪上就是定义了一种数据类型.我们自定义的数据类型和Python自带的数据类型,不如str,list,dict,没什么区别.

用isinstance()来判断某个变量是否是某个类型

对于一个变量,我们只要知道他的父类型,无需确切知道子类型,就可以放心调用相关的方法.运行时具体的方法时作用在子类型上还是父型上,由我们运行的对象决定.

也就是说,调用时只管调用,不管细节.

当我们新增一个子类时,只要保证相关的方法编写正确,就不用管原来的代码是如何调用的.

---->"开闭"原则

• 对拓展开放:允许新增子类
• 对修改封闭:不需要修改依赖父类类型的函数

私有属性

在类的内部,可以有属性和方法,而外部代码可以通过直接调用实例变量的方法

class Student:
    school = "zucc"
    def __init__(self,name,score):
        self.__name = name
        self.__score = score
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score
    def find_score(self):
        print(self.__name,":",self.__score)
stu1 = Student("Tom",99)
stu2 = Student("jack",98)
print(stu1.find_score())
stu1.score =97
print(stu1.score)
print(stu1.find_score())
#print(stu1.set_score(97))
print(stu1.find_score())

从这里可以看出,外部代码可以自由修改一个实例的属性(name,score)

如果要让内部属性不被外部访问,我们可以在属性名称前加两个下划线.

在python中,实例的变量名如果以下划线开头,就变成了一个私有量,只有内部可以访问,外部不能访问.

so,我们改下Student类.

封装

隐藏对象的属性和实现细节,仅对外提供公共访问的方式.

这样做的有点在于:

1.可以将变化隔离;

2.便于使用

3.提供安全性;

4.提高复用性.

封装的原则是;

• 将不需要对外提供的内容隐藏起来;
• 隐藏属性,提供公共方法对其进行访问.

---->私有方法,私有变量----->私有属性

class Test:
    def run(self):
        print("多态测试")
dog = Dog()
cat = Cat()
test = Test()
dog.run()
cat.run()
test.run()


def run_twice(animal):
    animal.run()
    animal.run()

run_twice(test)
#鸭子类型不要求有严格的继承关系,一个对象,只要看起来像鸭子,走起路来还是鸭子

#也就是说,如果要编写现有对象的自定义版本,可以继承该对象,也可以创建一个外观和行为像的对象,但与其无用的关系的全新对象.
#比方说,利用标准库中定义的各种"与文件类似的"的对象,尽管这些对象的工作方式向文件,但是他们并没有继承内置文件对象的方法.

class TestFile:
	def read(self):
		pass
	def write(self):
		pass
class OperFile:
	def read(self):
		pass
	def write(self):