面向过程 && 面向对象
(oop:object oriented programming)
面向过程：—侧重于怎么做？
1.把完成某一个需求的 所有步骤 从头到尾 逐步实现
2.根据开发要求，将某些功能独立的代码封装成一个又一个函数
3.最后完成的代码，就是顺序的调用不同的函数
特点：
1.注重步骤和过程，不注重职责分工
2.如果需求复杂，代码变得非常复杂
3.开发复杂的项目的时候，没有固定的套路，开发难度很大
面向对象：—-侧重于谁来做？
OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。
相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
1.在完成某一个需求前，首先确定职责–要做的事(方法)
2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)
3.最后完成代码，就是顺序的让不同的对象调用不同的方法
特点：
1.注重对象和职责，不同的对象承担不同的职责
2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供固定的套路
3.需要在面向过程的基础上，再学习一些面向对象的语法
面向对象有两个核心的概念
类：是一类具有相同特征或行为的事物的一个统称
对象：由类创建出来的一个具体的存在
类和对象的关系：先有类再有对象
类是模板 对象是根据这个模板创建出来的
类只需要有一个 对象可以有多个
类：属性(这一类事务的共同信息) 和 方法(你能完成的动作)
1.类名：这类事物的名字
大驼峰命名法：
1.每个单词的首字母大写
2.单词与单词之间没有下划线
2.属性:这个类创建出来的对象有什么特征
3.方法:这个类创建出来的对象有什么行为
实例
1.使用面向对象开发，第一步是设计类
2.使用 类名() 创建对象，创建对象的动作有两步
在内存中为对象分配空间
调用初始化方法__init___ 为对象初始化
3.对象创建后，内存中就有了一个对象的实实在在的存在–实例
因此：
1.创建出来的对象叫做类的实例
2.创建对象的动作叫做实例化
3.对象的属性叫做实例属性
4.对象调用的方法叫做实例方法
在程序执行时：
1.对象各自拥有自己的实例属性
2.调用对象的方法，可以通过self访问自己的属性，调用自己的方法
结论:
1.每一个对象都有自己独立的内存空间，保存各自不同的属性
2.多个对象的方法，在内存中之有一份，在调用方法时，需要把对象的引用传递到方法内部
self:
哪一个对象调用的方法，self就是哪一个对象的引用
在封装的方法内部，self就表示当前调用方法对象自己
在调用方法的时候，程序员不需要传递self参赛(定义的时候，第一个参数必须是self)
# 定义一个猫类
class Cat:
def eat(self):
print('%s 爱吃鱼' %(self.name))
def drink(self):
print('小猫要喝水')
# 创建猫对象
print(Cat())
tom = Cat()
tom.name = 'Tom'
print(tom.name)
print(tom)
tom.drink()
tom.eat()
fentiao = Cat()
fentiao.name='Cos'
print(fentiao)
fentiao.eat()
<__main__.Cat object at 0x7fc28fdb0160>
Tom
<__main__.Cat object at 0x7fc28fdb0160>
小猫要喝水
Tom 爱吃鱼
<__main__.Cat object at 0x7fc28fdb0198>
Cos 爱吃鱼
init：
类名( ) 就可以创建一个对象
类名( ) 创建对象的时候，python解释器会自动执行以下操作
1.为对象在内存中分配空间–创建对象
2.调用初始化方法为对象的属性设置初始值
这个初始化方法是内置方法，是专门用来定义一个类中有哪些属性和方法的
注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去。
如果希望在创建对象的同时，就设置对象的属性，可以对__init__方法进行改造
1.把希望设置的属性值，定义成__init__方法的参数
2.在方法内部使用self.属性名 = 形参 接收外部传递的参数
3.在创建对象的时候，使用类名(属性)调用
class Cat:
def __init__(self, new_name):
# print('这是一个初始化方法')
self.name = new_name
def eat(self):
print('%s爱吃鱼' % (self.name))
def drink(self):
print('%s要喝水' % (self.name))
hello_kitty = Cat('hello_kitty')
print(hello_kitty)
hello_kitty.eat()
hello_kitty.drink()
tom = Cat('蓝猫')
tom.drink()
tom.eat()
<__main__.Cat object at 0x7f7cc7899048>
hello_kitty爱吃鱼
hello_kitty要喝水
蓝猫要喝水
蓝猫爱吃鱼
str：
在python中 使用print输出对象变量时候，默认情况下
会输出这个变量引用的对象是由哪一个类创建的对象以及在内存中的地址
如果在开发中，希望使用print输出变量的时候，能够打印自定义内容
就可以利用__str__这个内置的方法了
class Cat:
def __init__(self,name):
self.name = name
# def __str__(self):
# # 返回必须是一个字符串
# return '我是 %s' %(self.name)
tom = Cat('tom')
print(tom)
addr = id(tom)
print(addr)
print('%x' %(addr))
print('%d' %(addr))
fentiao = Cat('粉条')
print(fentiao)
我是 tom
140443807584328
7fbb9f431048
140443807584328
我是 粉条
del：
如果希望在对象被销毁之前，再做一些事情，可以考虑一下__del__
当一个对象被从内存中销毁前(把这个对象从内存中删除掉)，
会自动调用 __del__方法
class Cat:
def __init__(self,name):
self.name = name
print('%s 来了' %(self.name))
def __del__(self):
print('%s 走了' %(self.name))
tom = Cat('tom')
print(tom.name)
del tom
print('*' * 50)
print(tom.name)
tom 来了
tom
tom 走了
**************************************************
NameError: name 'tom' is not defined
——————练习———————
“””
栈：先进后出 入栈(push) 出栈(pop) 取栈顶元素 判断栈是否为空 显示栈元素 列表
队列：先进先出
“””
class Stack:
def __init__(self):
self.stack = []
def push(self,value):
"""
:param value:入栈元素
:return:
"""
self.stack.append(value)
return True
def pop(self):
# 判断栈是否为空
if self.stack:
# 获取出栈元素 并返回
item = self.stack.pop()
return item
else:
return False
def top(self):
if self.stack:
return self.stack[-1]
else:
return False
def length(self):
return len(self.stack)
def view(self):
return ','.join(self.stack)
s = Stack()
s.push('1')
s.push('2')
s.push('3')
item = s.pop()
print(s.view())
1,2
