- 面向过程
- 函数式编程
- 面向对象
面向过程
所谓过程就是我们解决问题的一个步骤，一步步的按照流程走，有先后之分。
它呢，整个设计就好比流水线，思维上比较机械化。
优缺点:
-
优点
- 复杂的问题流程化，将问题简化。
-
缺点
- 拓展性不好，
面向对象
核心是对象。
正式的来说
- 对象是一个数据以及相关行为的集合
- 面向对象是功能上指向建模对象
通过数据和行为方式来描述交互对象的集合。
在python中，一切皆为对象
面向对象的优缺点
-
优点
- 解决程序的拓展性
-
缺点
- 就是复杂度远高于面向过程
- 交互式解决问题，无法准确预测结果，
在现实世界中，以我们为例
object1:
tom
特征：
school = zucc
name = tom
age = 20
sex = male
技能：
study
sleep
eat
object2:
jack
特征：
school = zucc
name = jack
age = 21
sex = male
技能：
study
sleep
eat
sing
类就是类别、种类
对象就是特征和技能的统一体。
类则是着一些相似对象的特征和技能的结合。
对于现实世界，现有个体（即对象），才有类别；但对于程序，必须先有类，然后才有对象的。
面向对象编程
oop（object oritented programming）
其是一种程序设计思想。00p把对象作为程序的一个基本单元，一个对象就包含了数据和操作数据的函数。
在python中，所有数据类型都可以视为对象，同时，我们也可以自定义对象。
自定义的对象的数据的类型就是面向对象中类（class）的概念
demo：
假如要处理我们的成绩。为了表示学生的成绩：
-
面向过程的方式
stu1 = {"name":"tom","score":99} sruguotu2 = {"name":"jack","score"82}利用函数来实现
def find_score(stu): print(stu["name"],":",stu["score"])如果是面向对象
class student: def __init__(self,name,score,age,sex): self.name = name self.score = score self.age = age self.sex = sex def find_score(self): print(self.name,":",self.score) def find_age(self): print(self.name,":",self.age) def find_sex(self): print(self.name,":",self.sex) stu1 = student("tom",80,25,"男") stu1.find_age() >>>tom:25
面向对象技术简介
- 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
- **方法：**类中定义的函数。
- **类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
- **数据成员：**类变量或者实例变量用于处理类及其实例对象的相关的数据。
- **方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
- **局部变量：**定义在方法中的变量，只作用于当前实例的类。
- **实例变量：**在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
- **继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
- **实例化：**创建一个类的实例，类的具体对象。
- **对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
常见的概念
类的定义和使用
面向对象设计的思想，先抽象出类，再根据类创建实例。
类的定义
类的命名，大驼峰式
所谓大驼峰就是变量名称的单词的首字母大写。
创建一个类
class MyFirstClass:
pass
类的作用是一个模板。我们可以在创建实例的时候，把一些我们认为必须要绑定的属性填写进去。这时就通过特殊的__init__方法。在创建实例的时候，绑定相关属性。
class student:
school = 'zucc'
def __init__(self, name, age):
self.name = name
self.age = age
stu1 = student("tom",99) #实例化
print((stu1.name,stu1.age,stu1.school))
>>>('tom', 99, 'zucc')
和普通函数相比，在类中定义方法时，第一个参数必须是self。除第一个参数外，其他的和普通函数没有什么区别
self代表的是实例，而非类。
__init__方法
- 1.为对象初始化自己独有的特征
- 2.该方法中可以有任意的代码，但是一定不可以有返回值。
数据封装
class student:
def __init__(self,name,score,age,sex):
self.name = name
self.score = score
def find_score(self):
print(self.name,":",self.score)
我们通过__init__()让stu1实例本身就拥有了相关的数据，如果要访问这些数据，我们可以直接在student类的内部定义相关的函数来访问数据以此“封装”数据。
这些封装数据的函数和student类本身是关联起来的，他们被称之为方法。
类的两个作用：
-
属性引用
类名·属性
-
实例化
- 类名加上一个括号就是实例化，他能够自动触发
__init__函数的运行，进而为每个实例定制自己的特征。
- 类名加上一个括号就是实例化，他能够自动触发
类属性的查看
-
1.dir(类名)
- 返回一个列表
-
类名.
__dict__- 返回一个字典，key为属性名，value是属性值
特殊的类属性
类名.__name__ #返回类的名字
类名.__doc__ #类的文档字符串
类名.__base__ #类的第一个父类
类名.__bases__#类的所有父类构成的元组
类名.__module__#类定义所在的模块
类名.__class__ #实例所对应的类
类名.__dict__ #类的字典属性
总结：
class ClassName:
def__init__(self,para1,para2,...):
self.对象属性1 = 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。
class 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.aggressivity
class dog:
def __init__(self,name,breed,aggressivity,life_value):
self.name = name
self.breed = breed
self.aggressivity = aggressivity
self.life_value = life_value
def bite(self,people):
people.life_value -= self.aggressivity
per = person("jack",10,1000)
dog = dog("jeorry","husky",8,1000)
print(dog.life_value)
per.attack(dog)
print(dog.life_value)
>>>1000 990
类命名空间与对象、实例的空间
创建一个类就会创建一个类的名称空间，用来存储我们定义的所有的变量名。这些名字就是属性。
类的属性有两种：
- 静态属性
- 直接在类中定义的变量
- 动态属性
- 在类中定义的方法
静态属性是不能共享给所有对象的
动态属性是绑定到所有对象的
class student:
school = 'zucc'
def __init__(self, name, age):
self.name = name
self.age = age
def find_score(self):
print(self.name,":",self.score)
stu1 = student("tom",99)
stu2 = student("jack",89)
print(id(stu1.school))
print(id(stu2.school))
print(stu1.find_score)
print(stu2.find_score)
print(student.find_score)
>>>2517933892136
2517933892136
<bound method student.find_score of <__main__.student object at 0x0000024A409858D0>>
<bound method student.find_score of <__main__.student object at 0x0000024A40985908>>
<function student.find_score at 0x0000024A409889D8>
函数的三大特性
- 继承
- 多态
- 封装
继承
在面向对象编程中，当我们定义一个新类的时候，可以从某个现有的类继承，新的类就被称为子类（SubClass），而被继承的类则被称为基类，父类，超类（Base Class,Father Class,Super Class)
比如，我们定义一个动物类（animal），其有一个run（）方法如下：
class Animal(object): #定义父类
def run(self):
print("Animal is runing")
class dog(Animal): #单继承
pass
class cat(Animal): #单继承
pass
class husky(animal,dog): #多继承，用逗号分隔开
pass
dog = dog()
cat = cat()
print(dog.run())
print(cat.run())
继承的查看
ClassName.__bases__
多态
当子类和父类存在相同的方法时，子类的方法会覆盖父类的方法，再运行代码时，
总会调用子类和父类同名的方法
这样，就是继承的另外一个好处，多态。
理解多态，首先要对数据类型再进行说明。定义一个类的时候实际上就是定义了一种数据类型。我们自定义的数据类型和python自带的数据类型，比如str,list,dict,没什么区别
用isinstance()来判断某个变量是否是某个类型
对于一个变量，我们只要知道他的父类型，无需确切知道子类型，就可以放心调用相关的方法。运行时具体的方法是作用在子类型上还是父类型上，由我们运行的对象决定。
也就是说，调用时只管调用，不管细节。
当我们新增一个子类时，只要保证相关的方法编写正确，就不用管原来的代码是如何调用的。
---->"开闭“原则
- 对拓展开放：允许新增子类
- 对修改封闭：不需要修改依赖父类类型的函数。
总结：
继承可以一级一级的继承下来，类比肉类，就好比，爷爷奶奶到父母，再到子女
任何类都可以追溯到根类object。
私有属性
在类的内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据。这样，隐藏内部的复杂逻辑。
比如student类：
class student:
school = 'zucc'
def __init__(self, name, score):
self.name = name
self.score = score
def find_score(self):
print(self.name,":",self.score)
stu1 = student("tom",99)
print(stu1.score)
stu1.score = 97
print(stu1.score) >>>99 97
从这可以看出，外部代码可以自由修改一个实例的属性（name，score）
如果要让内部属性不被外部访问，我们可以在属性名称前加两个下划线。
在python中，实例的变量名如果以双下划线开头，就变成了一个私有变量，只有内部可以访问，外部不能访问。
可以，我们可以改一下student类。
封装
隐藏对象的属性和实现细节，仅对外提供公共访问的方式。
这样做的优点在于：
1.可以将变化隔离；
2.便于使用；
3.提高安全性；
4.提供复用性。
封装的原则是：
- 将不需要对外提供的内容隐藏起来；
- 隐藏属性，提供公共方法对其进行访问。
----> 私有方法，私有变量---->私有属性
用双下划线开头的方式将属性隐藏，设置为私有的。
┌───────────────┐
│ object │
└───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ Animal │ │ Plant │
└─────────────┘ └─────────────┘
│ │
┌─────┴──────┐ ┌─────┴──────┐
│ │ │ │
▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Dog │ │ Cat │ │ Tree │ │ Flower │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
鸭子类型：
如果要编写现有对象的自定义版本，可以继承该对象，也可以创建一个外观和行为像的，但与其无任何关系的全新对象。比方说，利用标准库中定义的各种“与文件类似的”的对象，尽管这些对象的工作方式像文件，但他们并没有继承内置文件对象的方法。
class Duck():
def walk(self):
print('I walk like a duck')
def swim(self):
print('i swim like a duck')
class Person():
def walk(self):
print('this one walk like a duck')
def swim(self):
print('this man swim like a duck')
可以很明显的看出，Person类拥有跟Duck类一样的方法，当有一个函数调用Duck类，并利用到了两个方法walk()和swim()。我们传入Person类也一样可以运行，函数并不会检查对象的类型是不是Duck，只要他拥有walk()和swim()方法，就可以正确的被调用。
总结：鸭子类型的特点是：
1、变量绑定的类型具有不确定性
2、函数可以接收任意类型的参数
3、调用方法时不检查提供的参数类型
4、调用是否成功由参数的方法和属性确定
5、调用不成功抛出错误（也就是对象中没有实现该功能的方法）
扫一扫
1171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
