python学习之路---day16--面向对象

                                   面向对象及成员的基本总结复习
一：先用一个实际例子说明类：

class 类名：
    class Car:
    #__init__ ：使我们在具体构造一个对象时，使这个对象有具体的属性，像有名字啊，价格等等这样的属性
    #self ：就是这个构造方法在执行这个类时候，将对象传递给self ，self：是谁调用的，谁就是self，
    #像上面车的例子，如果是c2调用的，那么self就是c2。c掉调用的，self就是c
        def __init__(self,user,color,price):   #将Car 这个类的基本属性进行封装。
            self.user=user
            self.color=color
            self.price=price

        def Drive(self,a):   #表示车的一个方法
            print("这辆车很赞！",a)

        #调用方法和属性遇到的问题：我们在调用属性( 价格， 颜色)的时候是不要写 括号的（）直接 c1.color  ，
        #调用方法才需要写括号（）   ,c1.Drive()
        c1=Car("旺财","red","88RMB")  #Car()  类加上括号后是将类进行实例化，实例化到具体的一辆车，然后
        这个车有基本的属性：所有者，颜色，价格等。。。

        print(c1.color)   #我们在调用属性( 价格， 颜色)的时候是不要写 括号的（）  ，，
        print(c1)  #打印的是一个内存地址
        c1.Drive("")  #对象调用这个具体的方法     #调用方法才需要写括号（）

二：我们在写类的时候一定会遇到 类里面的 方法：我们用  def __init__(self,属性一，属性二....) （这个是固定写法） 来给我们要创建
    的具体对象构造基本的属性，使其具有具体的属性，（面向对象是以具体的对象为主）
    构造方法和 函数有点相同

　　函数：
        def num():  #定义函数名字
            print("")
        num()    #打印：123    #调用这个函数,然后执行print 语句
        print(num())   #打印：123  None   (num函数被调用，然后执行print语句，但是因为没有返回值，所以再次输出的时候，没有返回值返回回来
                                    所以输出的就是 None )

    构造方法：（需要结合类来理解）
    class Name:
        def __init__(self,changduan,yuyan):  #里面放名字的属性，进行封装。（比如名字有的是英文，有的长，有的短。。。）
            self.changdu=changduan   #这些属性我们也称之为属性变量
            self.yuyan=yuyan

    def shuo(self):  #名字的作用我们也成为 一个方法
        print("说明一个人！")
        #return  "111"

    mz=Name("四个字","中文")  #Name()  实例化到具体一个名字，他又具体的属性是  几个字  和 是中文表达。
    print(mz.changdu)#调用属性   #调用具体对象的属性的时候，是不需要加括号的，直接   mz.cahgndu  然后打印就可以了
    mz.shuo()  #打印：说明一个人！
    print(mz.shuo())  #打印：说明一个人！    None    （方法被调用时，先执行 print语句 ，这个和函数的返回值一样，当执行完调用后，
                                        #如果有返回值则返回需要返回的值，如果没有返回值，则返回None # ）

    总结：函数和方法的其中一个区别：方法比函数多了一个 self  。

    主要是调用的时候会经常脑袋浆糊啊：.......
    函数调用：  函数名（）   然后执行函数体，有返回值则返回，没有则print （函数名 （））返回None
    方法调用：在将类实例化后  例如   mz=Name("四个字","中文") ,
    调用属性：   mz.price 就可以了
    调用方法时需要加括号：mz.shuo()

三：面向对象的三大特征：

　　 001：封装
    002：继承 ：分为单继承（只继承一个父类的特性，那么只有一个父类的全部非私有特性）和多继承（继承多个父类的特性，具有多个父类全部
            非私有的特性）
    003：多态：同一个对象有多个形态    持续  懵b中...需要实际例子再加深理解下

四：类的成员：
    类的成员：在类中写的什么，就是成员
    例子：

　　class Person:
        #方法
        def __init__(self,参数1，参数2.....):
            #属性变量
                self.属性1=参数1
                self.属性2=参数2
                ....
                #方法
                def method(self):
                    pass

五：类的成员：变量
    类的变量两大类：

　1：实例变量：（字段）
  2:类变量（静态变量）
    实例变量：就是具体的一个对象所具有的特性（像 大小啊 名字啊等等）。
    类变量：就是一大陀群体都具有的特特性

    实例变量和类变量的基本对比：
    类变量就是  这个特性是所有具体对象都拥有的，不管这个类的那一个具体对象是谁，
    它都有这个特性（像人类都拥有名字这个特性一样），当这个类变量发生变化时，那么
    这个类的所有具体对象都有的这个特性也就一起变了

001 类变量案例：

class Person: #一个Person 类
            country="中国"  #类变量, 表示所有的该类的对象都共享这个变量.
            def __init__(self,name,age):
                self.name=name
                self.age=age
        p1=Person("qw",34)
        p1.country="大清"   #对比我们之前写的  c=Car（） c.color()

        # p1.name()  #面向对象中，这样写是调用方法的，不是调用属性   #TypeError: 'str' object is not callable

        print(p1.name)
        print(p1.country)

        p2=Person("",56)
        print(p2.name)        #
        print(p2.country)     #

    002）：实例变量 ：当我们给当前这个对象添加一个实例变量的时候，那么这个类变量是不会改变的，
    改变的只是当前这个对象的实例变

    案例：

p1 = Person("alex", 18, "1840年06⽉01⽇")
    # # 在执行p1.country = "大清"的时候. 其实 并没有去改变类中的country,
    # 而是给对象添加了⼀个实例变量. 并且这个实例变量,只有当前的p1是存在的.
    # 在p2中是不存在的
    p1.country = "⼤清"  #给p1添加实例变量  ，p2 是没有的
    print(p1.name)
    print(p1.country) # ⼤清
    p2 = Person("wusir", 28, "1894年07⽉25⽇")
    print(p2.name)
    print(p2.country) # 中国

六：类的成员：方法

成员方法：对象直接访问这个方法（我们也称之实例方法）
    访问：直接是 对象访问 ----->   对象名.成员方法名()
    成员方法作用：待更新.......

    静态方法：需要在方法之前添加 @staticmethod  来表示这个方法是一个静态方法
    调用：直接是类名直接调用和访问 ---->   类名.静态方法名()    和静态变量一样
    调用的时候  对象也可以调用（--> 对象名.静态方法名() ），但是我们不会这么干，为了区分静态方法和实例方法
    静态方法作用：待更新.......

    类方法： 需要在方法之前添加 @classmethod   来表示这个方法是一个类方法，并且第一个值我们默认给第一个参数为cls
    调用和访问： 直接是类名调用 ----->  类名.类方法名字()
    类方法的作用：待更新.......

案例编写：
　　案例一

　　

class QiuGe:
        # def __init__(self,name,age,salary):
        #     self.name=name
        #     self.age=age
        #     self.salary=salary
        def salary(self):
            print("日进斗金")
        def gf(self):
            print("单身狗")
        def shenggao(self):
            print("东北人老高儿了")
        def sum(self,a,b):
            return a+b
    c=QiuGe()
    c.salary()  #类直接调用实例方法
    c.shenggao()
    print(c.sum(1,5))

　　案例二：

　　

class Car:

        @classmethod
        def red(cls):
            print("")

    c=Car()
    c.red() #用对象去调用类方法
    print(c.red())  # 为啥打印：  123  None  （c调用red  但是red方法没有返回值，所以打印NOne）
    总结： #不管用对象还是类去访问类方法，传递进去的都是类
    Car.red() #用类去调用类方法
    不建议用对象去调用类方法，调用属性不需要加括号，调用方法需要加括号

七：类的成员 - 属性
    属性其实就是通过⽅法改造过来的⼀种变量的写法, 在⽅法上添加⼀个 @ property就可以
    案例

class User:
        def __init__(self,name,birthday,email):
            self.name=name
            self.birthday=birthday
            self.email=email
        @property    #作用是将一个方法变成一个属性（像名字啊，年龄啊，具体的东西）
        def age(self):#方法
            return 2018-self.birthday
    u=User("xu",1878,"123@email.con")
    print(u.age)  #我们调用属性的时候是不需要写 括号的的,在调用方法的时候才需要u.age()
    # print(u.age())

属性的总结：
    1. 方法参数只能有⼀个self
    2. 方法上方要写@property
    3. 调用的时候, 我们不需要写括号. 直接当成属性变量来⽤就可以了.
    4. 这种套路只能取值. 不能设置值

八：私有：python中以 __ 作为方法或则变量的前缀 ，表示这个方法或则变量是一个私有的
    私有变量例子：

class Person:
        def __init__(self,name,age):
            self.__name=name  #____name 私有变量，其他的对象user不能访问
            self.__age = age  #__age 私有变量，其他的对象user不能访问
    user=Person("旺财",23)
    # user.name() #这个是直接调用类里面的属性
    # print(user.name)  #个是直接调用类里面的属性
    print(user.__name)  #报错AttributeError: 'Person' object has no attribute '__name'

    ###私有的外部成员访问不到，但是内部的方法是可以访问的
    例子：
    class Person:
        def __init__(self,name,age):  #这个是构造方法
            self.name=name
            self.__age=age  #私有的变量
            print("构造方法")

        def __chi(self):
            print("私有方法__chi")

        def he(self):
            print("非私有方法")

        def wan(self):
            self.__chi() #内部调用私有方法__chi  --〉 -----内部调用的方法，很重要啊  记住-----
            print("我调用了内部的私有方法 __chi()")
    P=Person("xu",32)
    P.wan()
    打印：
    构造方法
    私有方法__chi
    我调用了内部的私有方法 __chi()

作业代表性题目代码：

　　

第一题：
1. while 循环提示用户输入：用户名、密码、邮箱
2.为每个用户创建一个对象，并添加到列表中。
3.当列表中的添加了 3 个对象后，跳出循环并以此循环打印所有用户的姓名和邮箱。

class UserInfo:
    def __init__(self,name,password,email):  #定义一个属性封装
        self.name=name
        self.password=password
        self.email=email
lst=[]
while len(lst)<3:
    Yname=input("请输入您的账号名字:")
    Ypwd=input("请输入密码：")
    youjian = input("请输入email：")
    user=UserInfo(Yname,Ypwd,youjian)
    lst.append(user)

print(lst)  #打印的是一个对象的内存地址组成的列表
for i in lst:  #i 代表每一个输入的成员对象
    print("我叫%s,我的邮箱是%s:" % (i.name,i.email))

第二题：
class User:  #用户
    def __init__(self,name,pwd):
        self.name=name
        self.pwd=pwd

class Account:  #账户
    def __init__(self):
        self.user_list=[]    #用户列表，数据格式[user对象，user对象，user对象]

    def login(self):
        '''
        用户登陆，用户输入用户名和密码并去self.user_list中检查用户是否合法
        :return:
        '''
        print("登陆界面")
        mingzi=input("请输入你的账号名：")
        mima=input("请输入你的密码：")
        for u in self.user_list:
            if u.name==mingzi and u.pwd==mima: #账号密码正确则返回True
                return True
        else:
            return False

    def register(self):  #注册
        print("注册界面")
        uname=input("请输入您的注册账号名字：")
        upwd=input("请输入您的注册密码：")
        u=User(uname,upwd)     #创建对象
        self.user_list.append(u)
        print(self.user_list)

    def run(self):
        '''
        主程序，先进行2次用户注册，在进行用户登陆（3次重试机会）

        :return:
        '''
        self.register()
        self.register()
        for i in range(3):
            ret=self.login()
            if ret==True:
                print("欢迎登陆！")
                break
        else:
            print("次数达到三次，已退出了！")

if __name__=="__main__": #如果用户名正确，则执行下面的语句。
    obj=Account()
    obj.run()