一、面向对象编程
面向对象编程（英语：Objectoriented programming，缩写：OOP）是一种编 程理念，这种编程理念更符合我们人的逻辑思维。使用面向对象编程可以提高我 们的开发速度和代码的重用率。面向对象的开发非常适合大型程序开发，开发速 度和后期维护都比过程化开发要好很多。
二、面向对象和面向过程理解
面向过程和面向对象都是用来解决问题的，只是解决问题的思路不同。 面向过程可以理解亲力亲为，面向对象可以理解为坐享其成。
例如炒菜
面向过程: 1)菜市场买菜，2)讨价还价，3)洗菜，4)切菜，5)炒菜，6)吃
面向对象: 1) 点开APP，2).下订单 3).吃
面向过程： 在生活中就是亲力亲为，在程序中面向过程编程就是函数之间的一个相互调用。 以函数为基本结构使用。 面向对象在生活中是坐享其成，别人做好的东西为我所用。在程序中面向对象编 程是以对象为基本结构使用。 那什么是对象呢?
三、对象和类的相关概念
1.类
类:是对一群具有相同特征或者行为的事物的统称，是抽象的，不能直接使用。
例如：人类
描述一个类通过行为和特征
行为：吃饭，睡觉
特征：白种人，黄种人
类可以理解为一种事物的模板
2.对象
对象: 是由类创造出来的具体实体，可以直接使用的。例如：小明，丹尼
3.类和对象之间的关系
1. 先有类后有对象
2. 类只有一个对象可以有多个
4.类的设计
在程序中设计一个类，通常需要满足一下3个要素：
类名：大驼峰命名法。
属性：描述这类事物的特征。
方法：描述这类事物的具体行为。
四、定义一个简单的类(只包含方法)
class Person:
def eat(self):
print('吃饭')
def sleep(self):
print('睡觉')
xiaoming = Person()
xiaoming.eat()
xiaoming.sleep()
self 变量
self：哪个对象调用方法或者属性，self就是那个变量。 练习查看 self和 对象的内存id值是否相同。
class Person:
def eat(self):
print(id(self))
def sleep(self):
print(id(self))
per = Person()
per.eat()
per.sleep()
init()方法
init()内置方法在创建对象的时候自动执行。
在init()方法中做一些初始化操作。
class Cat:
def __init__(self):
print('我是初始化方法')
self.name = 'tom'
tom = Cat()
print(tom.name)
str()方法
打印对象的名称时默认调用的是str()方法，此方法默认返回的是对象的内存地 址。
重写str()方法打印对象的信息
class Msg:
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return '{}的年龄是：{}'.format(self.name,self.age)
a = Msg('张三',20)
print(a)
#张三的年龄是：20
面向对象的三大特性：封装、继承、多态
封装：封装将类中的某些部分（属性或者方法）隐藏起来，使对象不能直接使用，具有保护功能。
class Person:
def set_name(self,new_name):
self.__new_name = new_name
def get_name(self):
return self.__new_name #私有化属性在类的外部不能使用（对象不能调用私有属性）
def set_age(self,new_age):
if new_age > 150 or new_age < 0:
print('年龄超出正常人的年龄')
self.__new_age = 0
else:
self.__new_age = new_age
def get_age(self):
return self.__new_age
def __str__(self):
return '姓名：{}，年龄：{}'.format(self.__new_name,self.__new_age)
p = Person()
p.set_name('张三')
p.set_age(18)
print(p)
p._Person__new_name = '李四'# 私有属性可以通过对象名.类名__方法名或类名.类名__方法名访问到(一般不用)
print(p)
闭包函数：
有三个概念：
闭包函数必须有内嵌函数。
内嵌函数必须要引用外层函数的变量。
闭包函数返回内嵌函数的地址（函数名）
写一个闭包函数:
def outer():
a = 1
def inner():
print(a)
return inner
outer()
装饰器：
在闭包的基础上使它具备更强大的功能
概念：在不修改原函数及其调用方式的情况下对原函数功能进行扩展
再在需要装饰的函数上面
写一个装饰器：
def outer(f):
def inner():
print('上行装饰')
f()
print('下行装饰')
return inner
@outer
def func():
print('原函数')
func()
上行装饰
原函数
下行装饰
继承：子项继承父项的某些功能，在程序中表现某种联系
写个继承类：
#写个父类
class Person(object):
def run(self):
print('父类方法')
#再创建一个子类
class Liming(Person):
def s(self):
print('子类方法')
l = Liming()
l.s()
l.run()
子类方法
父类方法
多态：一个函数有多种表现形式，调用一个方法有多种形式，但是表现出的方法是不一样的。
概念：
class Pay(object):
def pay(self, money): pass
class Alipay(Pay):
'''支付宝支付'''
def pay(self, money):
print('支付宝支付了%s元' % money)
class Applepay(Pay):
'''apple pay支付'''
def pay(self, money):
print('apple pay支付了%s元' % money)
class Person(object):
def consumption(self, pay, money):
pay. pay(money)
alipay = Alipay()
apply_pay = Applepay()
person = Person( )
#使用支付宝支付
person. consumption(alipay, 100)
#使用苹果支付
person. consumption(apply_pay, 200)