小学生绞尽脑汁也学不会的python(初识面对对象)

小学生绞尽脑汁也学不会的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(“请输入邮箱:”)

1. while循环提示用户输入：用户名、密码、邮箱
2. 为每个用户创建一个对象，并添加到列表中。

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()