面向对象及成员的基本总结复习
一：先用一个实际例子说明类：
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("123") #对象调用这个具体的方法 #调用方法才需要写括号（）
二：我们在写类的时候一定会遇到 类里面的 方法：我们用 def __init__(self,属性一，属性二....) （这个是固定写法） 来给我们要创建
的具体对象构造基本的属性，使其具有具体的属性，（面向对象是以具体的对象为主）
构造方法和 函数有点相同
函数：
def num(): #定义函数名字
print("123")
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("123",56)
print(p2.name) #123
print(p2.country) #56
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))
View Code
案例二：
class Car:
@classmethod
def red(cls):
print("123")
c=Car()
c.red() #用对象去调用类方法
print(c.red()) # 为啥打印： 123 None （c调用red 但是red方法没有返回值，所以打印NOne）
总结： #不管用对象还是类去访问类方法，传递进去的都是类
Car.red() #用类去调用类方法
不建议用对象去调用类方法，调用属性不需要加括号，调用方法需要加括号
View Code
七：类的成员 - 属性
属性其实就是通过⽅法改造过来的⼀种变量的写法, 在⽅法上添加⼀个 @ 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()
View Code