python 面向对象(一)初识面向对象

##################################总结####################

面向过程:一切以事物的发展流程为中心

面向对象:一切以对象为中心,一切皆为对向,具体的某个事物就是对象

优点:可维护性比原来好 缺点:编写相对比较复杂. 上手比较难.

面向过程: 应用程序相对比较小. 不需要大规模的设计
面向对象: 程序非常大. 项目管理 维护成本很高. 此时更适合用面向对象(结构)

打比方:
大象进冰箱
步骤: 第一步, 开门, 第二步, 装大象, 第三步, 关门

面向对象:大象, 你进冰箱.
此时主语是大象. 我操纵的是大象. 此时的大象就是对象

2. 类. 对象
类: 就是图纸. 创建对象的第一步. 先画图纸. 先写类.
对象: 对象就是车. 通过图纸造出来的具体的东西. 通过类来创建对象

class 类名:

　　def__init__(self):#初始化方法,又被称为构造方法

self.属性=值

　　def fangfa(self):

　　　　方法体(函数体, return)

变量 = 类()
变量.属性 # 操作属性
变量.方法 # 调用方法

class HeShang:
    def __init__(self, fh, name, miao):
        self.fahao = fh
        self.name = name
        self.miao = miao

    def nianjing(self):
        print("和尚会念经")

    def huayuan(self):
        print("和尚会化缘")

lzs = HeShang("花和尚", "鲁智深", "梁山水庙")

#不需要向原来一样传递一样的参数了
lzs.nianjing()
lzs.huayuan()

3.面向对象的三大特征

面向对象三大特征: 封装, 继承, 多态. 只要是面向对象编程语言. 都有这三个特征.

(1)封装:把很多数据封装到一个对象中,把固定功能的代码封装到一个代码块, 函数, 对象,打包成模块,这都属于封装的思想.

1. 对属性的封装(__init__())
self.xxx = xxx
2. 对方法和功能的封装

(2)继承: 子类可以自动拥有父类中除了私有属性外的其他所有内容.

class Animal:
    def dong(self):
        print("动物会动, 顾雍")

class Cat(Animal): # 子类其实是对父类的一种扩展
    def catchMouse(self):
        print("猫很皮, 抓老鼠")
c = Cat()
c.dong()
c.catchMouse()

a = Animal() # 父类的对象不能执行子类中的功能
a.dong()
# a.catchMouse() # 创建的是动物. 动物不能执行抓老鼠

支撑继承多个继承

# python支持多继承
class Foo1:
    def getMoney(self):
        print('给你个大嘴巴子')

    def play(self):
        print("玩儿")

class Foo2:
    def getMoney(self):
        print('给多点儿')

class Bar(Foo1, Foo2): # 离当前类最近的是亲爹, 后面的是干爹.
    pass

b = Bar()  # 就近原则, MRO的C3算法
b.getMoney() # Foo2里的

(3)多态:同一个对象多种形态.

class Animals:
    def eat(self):
        print("动物就知道吃")
class pig(Animals):
    def eat(self):
        print("猪在吃")
class tiger(Animals):
    def eat(self):
        print("大虫在吃")
class lion(Animals):
    def eat(self):
        print("西几在吃")
class feeder:
    def feed(self,Ani):
        Ani.eat() #传进来的东西要会吃就行
# 动物园
pig = pig()
tiger=tiger()
lion=lion()

alex = feeder()
alex.feed(pig)
alex.feed(tiger)
alex.feed(lion)

多态的好处: 程序具有超高的可扩展性,面向对象思想的核心与灵魂,python自带多态.

user_list = []
while True:
        user = input(“请输入用户名:”)
        pwd = input(“请输入密码:”)
        email = input(“请输入邮箱:”)
1. while循环提示用户输入：用户名、密码、邮箱
2. 为每个用户创建一个对象，并添加到列表中。
4. 当列表中的添加了3个对象后，跳出循环并以此循环打印所有用户的姓名和邮箱。如

user_list=[]

class UserInfo:
    def __init__(self,username,password,email):
        self.username=username
        self.password=password
        self.email=email
while True:
    user=input('请输入用户名:')
    pwd=input('请输入密码:')
    email=input('请输入邮箱:')

    u=UserInfo(user,pwd,email)#创建对象
    user_list.append(u)#把创建好的对象添加到列表中
    if len(user_list)==3:
        break

for i in user_list: #i是user_list中的对象
    print(f'用户名:{i.username},邮箱:{i.email}')

扩展在原有的基础上添加注册登陆功能注明:调用 2次注册一次登陆登陆只有3次机会

class User:
    def __init__(self,username,password):
        self.username=username
        self.password=password
class Account:
    def __init__(self):
        self.user_list=[]#目的是存储用户信息
    def login(self):
        for i in range(3):
            uname=input(">>请输入登陆名:")
            upwd=input('>>请输入密码:')
            for u in self.user_list:
                if uname == u.username and upwd == u.password:
                    print('登陆成功')
                    return
            else:
                print('登陆失败')
    def regist(self):
        user=input('请输入注册的用户名:')
        upwd=input('请输入注册的密码:')
        u=User(user,upwd)#创建用户
        self.user_list.append(u)#这样会出现重复的用户
    def run(self):
        self.regist()#自己类中的方法互相调用用self
        self.regist()
        self.login()
obj=Account()
obj.run()

在原有的基础上强行装一波文件

class User:
    def __init__(self, username, password):
        self.username = username
        self.password = password

class Account:
    def __init__(self):
        # self.user_list = [] # 目的是存储用户信息
        pass

    def login(self):
        for i in range(3):
            uname = input("登录用户名>>>")
            upwd = input("登录密码>>>")

            f = open("info", mode="r", encoding="utf-8")
            for line in f:
                lst = line.strip().split("_") # ["wusir", "123"]
                u = User(lst[0], lst[1])#把循环的文件第一个位子 第二个位子 赋值给第一个位子和第二个位子
                if uname == u.username and upwd == u.password:
                    print("登录成功")
                    return
            else:
                print("登录失败")

    def regist(self):
        uname = input("注册用户名>>>")
        upwd = input("注册密码>>>")
        u = User(uname, upwd) # 创建用户 把User的类强行赋值了一波
        # 把用户写入到文件中
        f = open("info", mode="a", encoding="utf-8")
        f.write(u.username+"_"+u.password+"
")
        f.flush()
        f.close()

    def run(self): # 运行
        # 调用两次注册
        self.regist() # 自己类中的方法互相调用. 用self调用
        # self.regist()  # 自己类中的方法互相调用. 用self调用
        # 一次登录
        # self.login()

# if __name__ == '__main__': # 当前py文件如果是启动文件. 执行这里的代码
obj = Account()
obj.run()

不怕大牛比自己牛，就怕大牛比自己更努力