python基础之面向对象(14)

装饰器是什么？
定义:装饰器是用于拓展原函数功能的一种语法,返回新函数替换旧函数
作用:在不更改原函数代码的前提下,拓展出新功能
@语法:加上@符 系统会自动把下面的函数当成参数传递到装饰器中,从下到上.
@符又被称作语法糖
装饰器：

1.普通装饰器

def decor(func):
def inner():
print(“财务拿钱买货”)
func()
print(“卖货的钱还回来”)
return inner
@decor #效果等同于sell=decor(sell)
def sell():
print(“买到货出去卖”)
sell()

2.装饰带有参数的函数
def decor(func):
def inner(*val1,**val2):
print(“财务拿钱买货”)
func(*val1,**val2)
print(“卖货的钱还回来”)
return inner
@decor
def sell(*val1,**val2):
for i,j in val2.items():
print(“卖的货里面有{}”.format(val1),‘它们的类型有{}’.format(i),“价格在{}”.format(j))
sell(“布娃娃”,“洋娃娃”,“金刚芭比”,可爱型=“100元”,冷酷型=“200元”)

3.装饰带有返回值的函数

def decor(func):
def inner():
print(“财务拿钱买货”)
res=func()#接收sell函数里的返回值"卖布娃娃"
print(“卖货的钱还回来”)
return res #将"卖布娃娃""作为返回值
return inner

@decor #效果等同于sell=decor(sell)
def sell():
print(“买到货出去卖”)
return “卖布娃娃”
res=sell()
print(res)#打印返回值

4.带有参数的装饰器（不同函数不同效果）

def out(name): # 这个只是一个接收name参数的壳子,因为decor(func)已经有一个参数了
def decor(func):
def inner():
func()
if name == ‘屌丝’:
print(“老娘没空鸟你”)
if name == “富帅”:
print(“在的呢,有空有空”)
return inner
return decor
@out(“屌丝”)
def diaosi():
print(“女神有空吗”)
diaosi()

@out(“富帅”)
def fushuai():
print(“有空吗”)
fushuai()

多个装饰器同时出现的情况，执行顺序是什么样的呢？
多个装饰器的调用顺序是自下往上，但是运行时的执行顺序是自上往下

def decor1(func):
def inner():
print(“一号技师”)
func()
print(“一号技师结束”)
return inner

def decor2(func):
def inner():
print(“二号技师”)
func()
print(“二号技师结束”)
return inner
@decor1
@decor2
def mashaji():
print(“马杀鸡真舒服”)
mashaji()

#结果为
一号技师
二号技师
马杀鸡真舒服
二号技师结束
一号技师结束
#自下而上,mashaji函数先被decor2装饰器装饰成新的函数即(decor2中的inner函数),新的函数再被传到decor1装饰器装饰成更新的函数.

def decor1(func):
def inner(func2):
print(“一号技师”)
res=func(func2)
print(“一号技师结束”)
return(res)
return inner
@decor1
def decor2(func):
print(“一号技师技术真好”)
def inner2():
print(“二号技师”)
func()
print(“二号技师结束”)
return inner2
@decor2
def mashaji():
print(“马杀鸡真舒服”)
mashaji()

#结果
一号技师
一号技师技术真好
一号技师结束
二号技师
马杀鸡真舒服
二号技师结束
#1.代码怎么样不报错:decor2先被decor1修饰器修饰,decor2(func)作为参数传入decor1的func中,将decor2(func)视作普通的有参数的被装饰函数,则decor1中的inner()和func()需要补对应的参数进去.又decor2(func)在decor1的func(func2)中被执行,返回值为inner2,在decor1中用res去接收返回值并作为decor1中的返回值.
2.执行顺序问题,因decor2调入decor1时inner2只是一个返回值未输出.所以只有等mashaji()调入decor2时才会输出.

5.把类作为装饰器（后面讲）

6.装饰类（后面讲）
面向过程: Procedure Oriented
一种以过程为中心的编程思想。
就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
面向对象：Object Oriented 简称OO
一种以事物为中心的编程思想。
是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
换句话来说，面向对象是以功能来划分问题，而不是步骤。

面向对象的学习： 面向对象的语法的学习 面对对象的思想的学习

面向对象的优势： 能够实现良好程序结构，方便程序的开发和管理维护！

效率：

运行效率：计算机 面向对象效率不如过程化的快
开发效率：程序员 面向对象比过程话开发要方便的多。 方便了程序员！

面向对象和面过程开发的区别：
【面向过程】：
吃饭 -> 自己做饭吃（调用做饭函数）
喝水 -> 自己倒水喝（调用了倒水函数）
洗衣服-> 自己洗衣服（调用了洗衣服函数）
睡觉 -> 自己拿睡衣（调用了拿睡衣的函数）

去公司-> 走路去（调用走路函数）
去海南-> 走路去（调用走路函数）
送礼  -> 带着礼物走去（调用走路运货函数）
....

【面向对象】：
女朋友：
做饭功能
倒水功能
洗衣服功能
拿睡衣功能

吃饭了->  女朋友，你给我做饭，谢谢
渴了  ->  女朋友，你给我倒一杯水，谢谢
洗衣服->  女朋友，帮我把衣服洗一洗
....

汽车：
    运动功能
    运货功能
    兜风功能
    ...

去公司-> 汽车的运动功能…
去海南-> 汽车的运动功能或者兜风功能
送礼 -> 汽车的运货功能
…

面向对象的结构特色：
高内聚（具有关联的功能，总结在一个结构当中）
低耦合（没有关联的功能，放在不同的结构中）

面向的对象的单词：
OO 面向对象
OOP 面向对象的开发 Object Oriented Programming
OOA 面向对象的分析 Object Oriented Analysis
OOD 面向对象的设计 Object Oriented Design
OOI 面向对象的实现 Object Oriented Implementation

OOA->OOD->OOI 面向对象程序开发的顺序（OOP）

学习面向对象离不开两个概念：类和对象

类:【类就是抽象的概念而已，（唯心主义）】
男人就是一个类
女人也是一个类
人类也是一个类
鸟类也是一个类
瓶子也是一个类
凳子也是一个类
…
以上内容都是一个简单的名词概念（语文）
【1.类是一个实物特征的集合，是一个抽象的名词概念。】

开车是一个类 （打火,挂挡，离合，加油门,走你~）
打人也是一个类 （脱掉上衣，拿起砖头，扔，赶快跑~）
做蛋糕是一个类 （和面，发酵，烘烤,切形状…抹奶油,放水果,打包~）
…
以上内容都是一个动词（语文）
【2.没有具体实施的行为也是一个类，抽象的概念，存在与脑海中】
对象：【对象是具体的实物或者行为，（唯物主义）】
明星林志玲这个美女 就是一个对象
小猪佩奇这个角色 也是一个对象
我手上这台电脑 也是一个对象
我现在坐着的这个凳子 也是一个对象
…
【1.对象是真真正正存在的实物，你看得见摸得着，不需要想象。】

我昨天开车去菜市场 就是一个对象
刚刚去做了个拉皮 也是一个对象
我给姐姐做了的生日蛋糕 这是一个对象

【2.真实发生过的行为就是对象，不需要想像，因为真的做了】
类和对象的关系：
都是面向对象开发中必不可少的内容。
1.类是由对象总结而来的。这个过程叫做抽象化
2.对象是由类具体实施而来。这个过程叫做实例化

创建文件：
习惯使用小写字母当作文件名，可以使用下划线进行分割。

类名的书写规范：
使用驼峰命名法，
大驼峰： MyCar XiaoBaiTu…
小驼峰： myCar xiaoBaiTu…

类的组成：
女朋友：(类)
特征：性别女，肤白，貌美，大长腿…
sex = “女”
color = “皮肤白”
face = “貌美”
leg = “大长腿”
…

功能：洗衣，做饭，打扫卫生，陪…
def wash():
洗衣功能

def cook():
    做饭功能

def clean():
    打扫卫生功能
...

类中内容只有2个：属性和方法
属性：用于描述特征的变量->成员属性
方法：用于描述功能的函数->成员方法
也有一种说法：类中只有属性

类的书写规则：
1.声明一个类必须使用class关键字
2.类名的声明需要符合驼峰命名法（推荐）
3.类中只能存在两种内容：属性和方法，除此之外不允许出现其他内容
4.声明成员属性的时候，变量必须赋值
5.声明成员方法的时候，按照函数声明规范即可（参数中会自动添加self参数）

实例化对象：
对象变量 = 类名()

spl = GirlFriend()

python中有无数个数据类型，本质上所有的数据类型都是一个类

print(GirlFriend)
print(type(1))
print(type(GirlFriend()))
print(GirlFriend()) 只有这个输出的是对象

获取类和对象中所属成员的信息
类：类名.dict
对象:对象名.dict

类成员的操作：（少用）
成员属性:（和变量一样）
访问 类名.成员属性名
修改 类名.成员属性名 = 新值
删除 del 类名.成员属性名
添加 类名.成员属性名 = 值

class Car():
wheel = 4
car_door = 4
color = “多种多样”
def move(self):
print(“小汽车开起来，嘟嘟嘟”)
def load(self):
print(“一个车里有北京和上海的所有学员”)

car=Car() #实例化对象
print(Car.wheel) #使用类访问成员属性
print(Car.dict)#查看类的信息
Car.wheel=“黄色” #修改类的成员属性
print(Car.dict)
del Car.wheel #删除类的成员属性
print(Car.dict)
Car.name=“奔驰”
print(Car.dict)

成员方法
访问 类名.方法名(参数)
修改 类名.方法名 = 新的函数 （不要加括号）（注意：仅限了解，不推荐使用）
删除 del 类名.方法名 （不要加括号）
添加 类名.新方法名 = 函数（也可以是lambda表达式）（注意：仅限了解，不推荐使用）

class Car():
wheel = 4
car_door = 4
color = “多种多样”
def move(self):
print(“小汽车开起来，嘟嘟嘟”)
def load(self):
print(“一个车里有北京和上海的所有学员”)

Car.move(1)
print(Car.dict)
Car.move=lambda x:print(“我爱小汽车”)
print(Car.dict)
del Car.load
print(Car.dict)
Car.love=lambda x:print(“奔驰我要定了”)
print(Car.dict)

对象成员的操作：
成员属性：
访问 对象.成员属性名
修改 对象.新成员属性名 = 新值
添加 对象.成员属性名 = 值
删除 del 对象.成员属性名 （必须是属于当前对象的成员才可以）

class Car():
wheel = 4
car_door = 4
color = “多种多样”
def move(self):
print(“小汽车开起来，嘟嘟嘟”)
def load(self):
print(“一个车里有北京和上海的所有学员”)

car=Car()
print(car.wheel)
print(car.dict)
car.wheel=“黄色” #先给对象添加属性
print(car.dict)
car.wheel=“白色” #修改对象的属性
print(car.dict)
del car.wheel
print(car.dict)
car.name=“奔驰”
print(car.dict)

成员方法：
访问 对象.成员方法名()
修改 对象.成员方法名 = 新的函数（不要加括号）
添加 对象.成员方法名 = 函数 （不要加括号）
删除 del 对象.成员方法名 （不要加括号）

class Car():
wheel = 4
car_door = 4
color = “多种多样”
def move(self):
print(“小汽车开起来，嘟嘟嘟”)
def load(self):
print(“一个车里有北京和上海的所有学员”)
car=Car()
car.move()
print(car.dict)
car.move=lambda x:print(“我爱小汽车”) #添加对象方法
print(car.dict)
car.move=lambda x:print(“奔驰我要定了”) #修改对象方法
print(car.dict)
del car.move #删除对象方法
print(car.dict)

1.实例化对象的时候通常情况下类中的成员不会在对象中复制一份
2.访问对象成员的时候，只要没有该成员，对象会向实例化他的类查找。
3.对象成员的添加和修改，都只会影响当前对象本身，不会影响类和其他对象
4.删除对象成员时候，必须是该对象自身的成员才可以删除，不可以删除类和其他对象~