小学生绞尽脑汁也学不会的python(初识面对对象)
一. 面向对象思想
1. 面向过程. 重点在"过程". 按照实物的发展流程. 先干嘛,后干嘛, 最后干嘛....
优点: 简单. 流水线式的工作
缺点: 可扩展性差.
2. 面向对象. 什么是对象? 对象是属性和动作的集合体. 对象是一个抽象的概念.
重点在"对象" : 属性和动作.类似上帝式的思维
优点: 可扩展性强(多态)
缺点: 编写相对比较复杂. 上手比较难.
面向对象和面向过程各有千秋. 各有各的好.
二. 面向对象如何编写
在代码中定义一个类,就相当于画图纸
class 类名:
pass
创建对象: 类名()
1. 构造方法:
def __init__(self, 属性):
self.属性 = 属性
2. 普通方法
def 方法名(self, 参数列表):
pass
self: 表示当前类的对象. 当前正在执行这个动作的对象.
对象.方法()
类名.方法(对象, 参数)
# 定义一辆车
class Car:
# 出厂设置.(__init__) 构造方法
def __init__(self, color, pai, pailiang, own): # self 表示当前类的对象
# print("我在造车")
# print(self)
# 绑定属性.
self.color = color
self.pai = pai
self.pailiang = pailiang
self.own = own
# 车能跑. 跑是一个动作. 要写函数(方法)
def run(self): # self: 当前类的对象
print("%s颜色的车在疯狂的跑" % self.color) # self就是你当前正在执行这个动作的对象.
print(self)
def tiaogao(self):
print("有一台%s色的车在疯狂跳高" % self.color)
c1 = Car("红", "京A66666", "2.0T", "alex") # 自动的调用__init__函数(方法)
c1.run() # 对象.方法()
c1.tiaogao()
print(c1)
# print(c1.__dict__)
# c1.color = "绿色"
# 字典.
# print(c1.color)
c2 = Car("黑色", "京B22222", "1.5L", "小猪佩奇") # 没有参数
c2.run()
print(c2)
# print(c2.color) # ????
# # 创造一辆车
# c = Car() # 类名()
#
# c.color = "黑色" # 对象.属性
# c.pai = "京A66666"
# c.pailiang = "2.0t"
# c.own = "alex"
# print(c.pai)
#
# c1 = Car() # 创建新对象. 又叫做实例化 # 类是一个概念. 对象:具体的实例
# c1.color = "白色"
# c1.pai = "京B22222"
# c1.pailiang = "1.6T"
# c1.own = "小猪佩奇"
# print(id(c), id(c1))
# print(c1.pai)
# print(c.own)
# print(type(c))
三. 面向对象和面向过程的对比(代码, 思想).
结论: 根据不同的业务逻辑, 来决定用那种思想.
# 装大象, 脚本
# print("打开冰箱门")
# print("装大象")
# print("关上冰箱门")
# 函数式编程
# def kaimen():
# print("打开冰箱门")
# def zhuangdaxiang():
# print("装大象")
# def guanmen():
# print("关门")
# kaimen()
# zhuangdaxiang()
# guanmen()
# 面向对象
# class Elphant:
#
# def open(self):
# print("大象会开门")
# def zhuang(self):
# print("把自己装进去")
# def close(self):
# print("把门关上")
#
# # 创建大象
# e = Elphant()
# e.open()
# e.zhuang()
# e.close()
# 第一回合. 面向过程赢
# 第二回合. 小猪佩奇(name, age, 技能)大战奥特曼, 蜘蛛侠, 蝙蝠侠
# 函数式
# def da_ao_te_man(name, age, jineng):
# print("%s, %s岁了, 用技能%s 打奥特曼" % (name, age, jineng))
# def da_zhi_zhu_xia(name, age, jineng):
# print("%s, %s岁了, 用技能%s 打蜘蛛侠" % (name, age, jineng))
# def da_bian_fu_xia(name, age, jineng):
# print("%s, %s岁了, 用技能%s 打蝙蝠侠" % (name, age, jineng))
#
# da_ao_te_man("小猪佩奇", 40, "嘴巴嘟嘟")
# da_zhi_zhu_xia("小猪佩奇", 40, "嘴巴嘟嘟")
# da_bian_fu_xia("小猪佩奇", 40, "嘴巴嘟嘟")
# 面向对象
# class Pig:
#
# def __init__(self, name, age, jineng):
# self.name = name
# self.age = age
# self.jineng = jineng
#
# def da_ao_te_man(self):
# print("%s, %s岁了, 用技能%s 打奥特曼" % (self.name, self.age, self.jineng))
# def da_zhi_zhu_xia(self):
# print("%s, %s岁了, 用技能%s 打蜘蛛侠" % (self.name, self.age, self.jineng))
# def da_bian_fu_xia(self):
# print("%s, %s岁了, 用技能%s 打蝙蝠侠" % (self.name, self.age, self.jineng))
#
# peiqi = Pig("小猪佩奇", 40, "嘴巴嘟嘟") # 把这三个属性封装到了一个对象里.
# peiqi.da_ao_te_man()
# peiqi.da_zhi_zhu_xia()
# peiqi.da_bian_fu_xia()
# 平手. 当属性和方法非常多的时候, 才能感觉到面向对象的好.
# 你要知道. 面向对象和面向过程都是思想. 用哪一个取决于业务逻辑.
# class Foo:
# def play(self):
# print("Foo中的play")
# def func(self):
# print("我是爹")
#
# class Foo2:
# def money(self):
# print("干爹给钱")
#
# def play(self):
# print("Foo2中的play")
#
# class Bar(Foo, Foo2): # 继承 子类, MRO算法. C3算法
# pass
#
# obj = Bar()
# # obj.money()
# # obj.func()
# obj.play()
# class Pet:
# def __init__(self, name):
# self.name = name
#
# def chi(self):
# print("吃,.....")
# def sleep(self):
# print("睡")
#
# class Cat(Pet):
# def catchMouse(self):
# print("%s喜欢抓老鼠" % self.name)
#
# class Dog(Pet):
# def chaijia(self):
# print("狗会拆家")
#
# class Snake(Pet): # 蛇是一种宠物, x是一种y的时候. x继承y
# pass
# c = Cat("佩奇")
# c.chi()
# c.sleep()
# c.catchMouse()
# class Car:
# def run(self):
# print("车会跑")
#
#
# class BMWCar(Car):
# pass
# class Animal:
# def dong(self):
# pass
#
# class Cat(Animal):
# def catchMaouse(self):
# pass
#
#
# # 变量 = 类名()
# c = Cat() # 猫类型的
# c.catchMaouse()
# c.dong()
#
# c = "alex"
# python本来就是多态. 里面没有所谓的类型.
# class Animal:
# def chi(self):
# print("所有的动物都会吃")
#
# class Haski(Animal):
# def chi(self):
# print("疯了一样的吃")
#
# class Monkey(Animal):
# def chi(self):
# print("龇牙咧嘴的吃")
#
# class Tiger(Animal):
# def chi(self):
# print("跟猫一样的吃")
#
# class Elphant(Animal):
# def chi(self):
# print("大象用鼻子卷着吃")
#
# class YingWu(Animal):
# def chi(self):
# print("xxxxx")
#
#
# class SiYangYuan:
# def wei(self, ani): # 多态性. 超强的可扩展性. 不论传递进来的是什么. 都统一当成动物来对待.
# ani.chi()
#
# syy = SiYangYuan()
#
# # 造动物
# hou = Monkey()
# ha = Haski()
# lao = Tiger()
# yw = YingWu()
#
# syy.wei(ha)
# syy.wei(hou)
# syy.wei(lao)
# syy.wei(yw)
class Car:
def run(self, speed):
print("车能跑%s迈" % speed)
c = Car() # 实例化一个对象
# Car.run(c, 50)
c.run(50)
四. 面向对象的三个特征(记下来).
1. 封装: 把具有相同属性和功能的内容封装在一个对象中
2. 继承: 子类可以自动拥有父类中除了私有属性外的其他所有内容
3. 多态: 同一个对象. 可以拥有多种形态. python原生自带多态性
特效练习题:
一.补充代码实现：
user_list = []
while True:
user = input(“请输入用户名:”)
pwd = input(“请输入密码:”)
email = input(“请输入邮箱:”)
- while循环提示用户输入：用户名、密码、邮箱
- 为每个用户创建一个对象，并添加到列表中。
3.当列表中的添加了3个对象后，跳出循环并以此循环打印所有用户的姓名和邮箱。如：
class User:
# def __init__(self, username, password, email):
# self.username = username
# self.password = password
# self.email = email
#
#
# user_list = []
# for i in range(3):
# user = input("请输入用户名:")
# pwd = input("请输入密码:")
# email = input("请输入邮箱:")
# u = User(user, pwd, email)
# user_list.append(u)
# else:
# for u in user_list:
# print("我叫%s, 邮箱是:%s" % (u.username, u.email))
#
二.补充代码：实现用户注册和登录
class User:
def __init__(self, name, pwd):
self.name = name
self.pwd = pwd
class Account:
def __init__(self):
self.user_list = [] # 数据源
def login(self):
print("欢迎来到登录环节")
username = input("请输入用户名: ")
password = input("请输入密码:")
for u in self.user_list:
if u.name == username and u.pwd == password:
print("登录成功")
return
else:
print("登录失败")
def register(self):
print("欢迎来到注册环节")
uname = input("请输入用户名")
pwd = input("请输入密码")
u = User(uname, pwd)
self.user_list.append(u)
def run(self):
while 1:
print("1. 注册")
print("2. 登录")
num = input("请输入你要执行的操作(Q退出):")
if num == "1":
self.register()
elif num == "2":
self.login()
elif num.upper() == "Q":
print("退出")
break
else:
print("你是不是傻")
obj = Account()
obj.run()