函数：
def login():
user = input('请输入用户名：')
pwd = input('请输入密码：')
if user == 'alex' and pwd == 'sb':
print('登录成功')
else:
print('登录失败')
面向对象：
class Account:
def login(self):
user = input('请输入用户名：')
pwd = input('请输入密码：')
if user == 'alex' and pwd == 'sb':
print('登录成功')
else:
print('登陆失败')
obj = Account()
obj.login()
对比：
函数：定义简单/调用简单。
面向对象：定义复杂/调用复杂。 好处：归类，将某些类似的函数写在一起。
总结：
1、函数式编程可能会比面向对象编程易于操作。
2、python中支持两种编程方式。
3、面向对象编程方式格式：
定义：
class 类名： — 定义了一个类
def 函数名（self): — 在类中编写了一个【方法】
pass
调用：
变量名 = 类名() — 创建了一个对象/实例化一个对象，变量名为一个实例化的对象。
变量名.函数名() — 通过对象调用其中一个方法。
4、示例：
class Account:
def login(self):
user = input('请输入用户名：')
pwd = input('请输入密码：')
if user == 'alex' and pwd == 'sb':
print('登录成功'）
else:
print('登录失败‘）
obj = Account()
obj.login()
===============================================================================================
完成以下功能：
零零/20岁/女/喜欢下河洗澡
零零/20岁/女/喜欢上山采药
零零/20岁/女/喜欢在家做饭
函数编程方式示例2：
def xz(name,age,gender):
data = "%s,今年%s岁,性别%s,喜欢下河洗澡" %(name,age,gender)
print(data)
def cy(name,age,gender):
data = "%s,今年%s岁,性别%s,喜欢上山采药" %(name,age,gender)
print(data)
def zf(name,age,gender):
data = "%s,今年%s岁,性别%s,喜欢在家做饭" %(name,age,gender)
print(data)
xz('零零',20,'女')
cy('零零',20,'女')
zf('零零',20,'女')
面向对象编程方式示例2：
class LingLing:
def __init__(self,name,age,gender): #特殊的方法，如果 类名() ,则该方法会被自动执行
self.name = name
self.age = age
self.gender = gender
def xz(self):
data = "%s,今年%s岁,性别%s,喜欢下河洗澡" %(self.name,self.age,self.gender)
print(data)
def cy(self):
data = "%s,今年%s岁,性别%s,喜欢上山采药" %(self.name,self.age,self.gender)
print(data)
def zf(self):
data = "%s,今年%s岁,性别%s,喜欢在家做饭" %(self.name,self.age,self.gender)
print(data)
obj = LingLing('零零',20,'女')
obj.xz()
obj.cy()
obj.zf()
总结：
1.构造方法
示例一：
class Foo：
def __init__(self,name): 构造方法，目的进行数据初始化。
self.name = name
self.age = 10
obj = Foo("韩寒") 【self既是obj】
通过构造方法，可以将数据进行打包，以后使用时，去其中获取即可。
示例二：
class Bar:
pass
obj = Bar()
2.应用
a.将数据封装到对象中，以供自己在方法中调用
b.将数据封装到对象中以供其他函数调用
class Foo:
def __inti__(self,k1,k2,k3):
self.k1 = k1
self.k2 = k2
self.k3 = k3
obj = Foo(111,222,333)
def new_func(arg):
arg.k1
arg.k2
arg.k3
new_func(obj)
3.面向对象的三大特性：封装/继承/多态
【封装】：===================================
将相关功能封装到一个类中：
class Message:
def email(self):pass
def msg(self):pass
def wechat(self):pass
将数据封装到一个对象中：
class Person:
def __init__(self,name,age,gender):
self.name = name
self.age = age
self.gender = gender
obj = person('孙莉莉',18,'女')
【继承】：===================================
基本使用：
class SuperBase:
def f3(self):
print('f3')
class Baes(SuperBase): # 父类，基类
def f2(self):
print('f2')
class Foo(Base): # 子类，派生类
def f1(self):
print('f1')
obj = Foo()
obj.f1()
obj.f2()
obj.f3()
#原则：先在自己类中找，没有就去找父类。【继承的作用是为了提高代码的重用性】
calss Base: # 父类，基类
def f1(self):
pass
class Foo(Base): # 子类，派生类，继承Base类中的f1方法
def f2(self):
pass
class Bar(Base): # 子类，派生类，继承Base类中的f1方法
def f3(self):
pass
【多继承】：==================================
calss Base1:
def show(self):
print("Base1.show")
calss Base2:
def show(self):
print("Base2.show")
calss Foo(Base1,Base2):
pass
obj = Foo()
obj.show()
==================【练习题1】========================
class Base:
def f1(self):
print('base.f1')
class Foo(Base):
def f2(self):
print('foo.f2')
# 1、是否执行
obj = Foo()
obj.f2()
obj.f1()
#执行，先打印foo.f2后打印base.f1
# 2、是否执行
obj = Base()
obj.f1() # f1可执行
obj.f2() # f2非Base类的父级，无法执行操作，会报错
=======================【练习题2】========================
class Base:
def f1(self):
print('base.f1')
class Foo(Base):
def f3(self):
print('foo.f3')
def f2(self):
print('foo.f2')
self.f3() #obj是哪一个类(Foo),那么执行方法时，就从该类开始找。
obj = Foo()
obj.f2() # obj是哪一个类(Foo),那么执行方法时，就从该类开始找。
==============================================================
# 总结：
#1. self是哪个类的对象，那么就从该类开始找（自己没有就找父类）
#2. 多继承先找左边的参数对应的父类。
==============================================================
总结：
1、继承的编写
class Foo(父类)：
pass
2、支持多继承（先找左/再找右）
3、为什么要有多继承？提高代码重用性
【多态】：=====================================================
多种形态或多种状态。
鸭子模型，只要可以呷呷叫就是鸭子。
# 由于python原生支持多态，所以没有特殊性。
class Foo1:
def f1(self):
pass
class Foo2:
def f1(self):
pass
class Foo3:
def f1(self):
pass
def func(arg):
arg.f1()
obj = Foo1() #obj = Foo2() obj = Foo3()
func(obj)
====================================================
重点：
1、编写方式执行流程
2、如何归类？
反向：归类+提取公共值
正向：类相关的功能+提取公共值
3、三大特性：封装/继承/多态