python面向对象

一、面向对象编程

面向对象编程（英语：Object­oriented 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)