一、函数式编程和面向对象的对比
面向过程：根据业务逻辑从上到下写垒代码；
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可；
面向对象：对函数进行分类和封装，让开发“更快更好更强...”；
面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。
round 1 请开发一个消息提醒的功能（邮件/短信/微信）
函数式 面向对象通过第一轮对比，我们发现：
函数式的特点是：定义简单，调用简单；
面向对象的特点是：定义复杂，调用复杂，其好处是进行了归类，将某些类似的函数写在了一起。
总结：1、函数式编程可能会比面向对象好；
2、python中支持两种编程方式；
3、面向对象编程方式格式如下：
定义：
class 类名: -- 定义了一个类
def 函数名(self): -- 在类中编写了一个"方法"
pass
调用：
x1 = 类名() -- 创建了一个对象/实例化一个对象
x1.函数名() -- 通过对象调用其中一个方法.
4、面向对象编程示例：
class Account:
def login(self):
user = input('请输入用户名:')
pwd = input('请输入密码:')
if user == 'alex' and pwd == 'sb':
print('登录成功')
else:
print('登录失败')
obj = Account()
obj.login()
round 2 打印：完成以下功能：
老狗/20岁/男/上山去砍柴
老狗/20岁/男/开车去东北
老狗/20岁/男/喜欢大宝剑
函数版本 面向对象版本总结：1、构造方法
# 示例一：
class Foo:
def __init__(self,name): # 构造方法,目的是进行数据初始化.
self.name = name
self.age = 18 # 也可以指定值，不一定非要传参
obj = Foo("alex")
# 通过构造方法,可以将数据进行打包,以后使用时,去其中获取即可.
# 示例二：
class Bar:
pass
obj = Bar()
2、面向对象编程应用：
2.1 将数据封装到对象中，以供自己在方法中调用，如下示例：
class FileHandler:
def __init__(self, file_path):
self.file_path = file_path
self.f = open(self.file_path, 'rb')
def read_first(self):
# self.f.read()
# ...
def read_last(self):
# self.f.read()
# ...
def read_second(self):
# self.f...
# ...
obj = FileHandler('C:/xx/xx.log')
obj.read_first()
obj.read_last()
obj.read_second()
obj.f.close()
2.2 将数据封装到对象中，以供其他函数调用，如下示例：
def new_func(arg):
arg.k1
arg.k2
arg.k6
class Foo:
def __init__(self,k1,k2,k6):
self.k1 = k1
self.k2 = k2
self.k6 = k6
obj = Foo(11,22,66)
new_func(obj)
注：Java和C#只支持面向对象编程，而python比较灵活既支持面向对象编程也支持函数式编程。
二、面向对象代码如何编写
1、面向对象代码语法规则，如下示例：
class Foo:
def __init__(self, name):
self.name = name
def detail(self, msg):
print(self.name, msg)
obj = Foo("alex")
obj.detail("hello world")
2、什么时候写面向对象代码？如何写？
2.1 反向：归类 + 提取公共值；
2.2 正向：在指定类中编写和当前类相关的所有代码 + 提取公共值；如下示例：
class Person:
def __init__(self, na, gen, age, fig):
self.name = na
self.gender = gen
self.age = age
self.fight = fig
def grassland(self):
self.fight = self.fight - 10
def practice(self):
self.fight = self.fight + 90
def incest(self):
self.fight = self.fight - 666
cang = Person('苍井井', '女', 18, 1000) # 创建苍井井角色
dong = Person('东尼木木', '男', 20, 1800) # 创建东尼木木角色
bo = Person('波多多', '女', 19, 2500) # 创建波多多角色
dong.grassland()
二、面向对象三大特征：封装、继承、多态
1、封装
1.1 将相关方法封装到一个类中，如下示例：
class Message:
def email(self):pass
def msg(self):pass
def wechat(self):pass
1.2 将数据封装到一个对象中，如下示例：
class Person:
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
obj = Person('alex', 18, '男')
2、继承（原则：先在自己类中找，没有就去父类中找），如下示例：
class SuperBase:
def f3(self):
print('f3')
class Base(SuperBase): # 父类, 也称基类
def f2(self):
print('f2')
class Foo(Base): # 子类,也称派生类
def f1(self):
print('f1')
obj = Foo()
obj.f1()
obj.f2()
obj.f3()
# 父类和子类都是相对的，此例中Base是SupperBase的子类，是Foo的父类
总结：1）继承编写规则，如下：
class Foo(父类名):
pass
2）支持多继承，即一个子类可以有多个父类（先找左边父类，再找右边）；
3）为什么要有继承和多继承？提高代码的可重用性；
继承的相关练习题：
class Base1:
def f1(self):
print('base1.f1')
def f2(self):
print('base1.f2')
class Base2:
def f1(self):
print('base2.f1')
def f2(self):
print('base2.f2')
def f3(self):
print('base2.f3')
self.f1()
class Foo(Base1,Base2):
def f0(self):
print('foo.f0')
self.f3()
obj = Foo() # 实例化Foo类的一个obj对象
obj.f0()
# 结果为：
# foo.f0
# base2.f3
# base1.f1
总结：1）多继承先找左边；
2）明确self到底是谁，self是哪个类的对象，那么就从该类开始找(自己没有就找父类)；
3、多态
鸭子模型，只要可以嘎嘎叫就是鸭子。由于Python函数传参时，无需指定类型。
def func(arg): # arg可以是多种类型,只要其中有send方法即可.
arg.send()
多态就是多种形态或多种状态，由于python原生支持多态，所以没有特殊性，如下是体现python原生多态的示例：
python原生多态示例