欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

第十六天-面向对象02-成员

程序员文章站 2023-01-24 17:51:44
# 类的成员:类中写的内容就是成员# class 类名:# 方法# def __init__(self, 参数1, 参数2....):# 属性变量# self.属性1 = 参数1# self.属性2 = 参数2# ....# 方法# def method(self):# pass'''上面代码中__... ......

 

# 类的成员:类中写的内容就是成员

# class 类名:
# 方法
# def __init__(self, 参数1, 参数2....):
# 属性变量
# self.属性1 = 参数1
# self.属性2 = 参数2
# ....
# 方法
# def method(self):
# pass
'''
上面代码中__init__和method都属于类的成员方法.又称为实例方法.需用对象来访问.而上⽅的self.属性1 = 参数1
这个代码含义是给对象设置属性信息.这个对象的xxx属性是xxxx.被称为成员变量或实例变量或者字段,类中还存在其他成员
'''



# 类的成员——变量:
# 实例变量 每个实例都应该拥有的变量. 如实例人.⼈的名字,⼈的爱好,每个⼈的个⼈信息.
# 类变量 一类事物统一拥有的变量 如.各位都是中国⼈.那大家都拥有同一个国家
 1 class person:
 2     country = "中国"  # 类变量,表示所有的该类对象都共享这个变量
 3     def __init__(self,name,age):
 4         # 实例变量/成员变量/字段  表示你创建的每一个人都有这两个变量
 5         self.name = name
 6         self.age = age
 7 
 8 p1 = person("麻花藤",45)
 9 print(p1.name)
10 print(p1.country) # 中国
11 
12 p2 = person("流动墙",46)
13 print(p2.name)
14 print(p2.country) # 中国

# 如上对象p1 p2的name都是对象自己的,但是country是公用的类的
# person.country = "大明" # 通过类名修改类变量  后面都跟着改变
p1.country ="越国" # 通过对象名修改实例变量 只对这个对象有效
print(p1.name)
print(p1.country)
print(p2.name)
print(p2.country)
#  类变量,最好是用类名来访问.当然,通过对象名也可以访问.但只能看,不能改变.想要改它,需要用类名
# 总结:
# 实例变量,给对象用的
# 类变量,多个对象共享的,最好是用类名来访问,更规范

 

 

 

# 类的成员-方法

# 实例方法(成员方法)
# 作用于对象 用的最多
 1 class car:
 2     def run(self): # 实例方法
 3         print("音速走你")
 4 
 5     def fly(self): # 实例方法
 6         print("起飞走你")
 7 
 8 c = car()
 9 c.run() # 对象直接调用实例方法
10 c.fly()

 

# 类方法:
# 使用类方法需要在类方法前面添加一个 @classmethod
 1 class person:
 2     def chi(self): # 实例方法
 3         print("人在吃")
 4 
 5     @classmethod # 类方法
 6     def he(cls):  # cls 类
 7         # print(cls)  # <class '__main__.person'>
 8         print("我是喝")
 9 
10     @classmethod
11     def shui(cls,a,b):  # 类方法在被调用时也不需要传递实例对象.但系统会自动的把类传递给第一个参数
12         return a+b
13 
14 # print(person)  # <class '__main__.person'>
15 person.he()
16 print(person.shui(1,2))  # 此时会自动把类名传递给第一个参数
17 p = person()
18 p.he()  # 类也可以访问 但不推荐 不管是类还是对象访问类方法 默认传递(cls)的都是类

 

# 静态方法: 作用于类
# 不需要给方法传递self
# 使用静态方法需要在前面添加一个 @staticmethod
 1 class person:
 2     @staticmethod  # 静态方法 可理解成类里面的函数
 3     def shui():
 4         print("我是睡")
 5 
 6     @classmethod # 类方法
 7     def he(cls):  # cls 类
 8         # print(cls)  # <class '__main__.person'>
 9         print("我是喝")
10 
11 person.shui() # 类名可直接访问
12 p = person()
13 p.shui() # 也能调用 但很少这样用 以便区分静态方法和实例方法

 

 

 

# 属性:
# 属性其实就是通过方法改造过来的一种变量的写法,在方法上添加一个 @property
 1 class user:
 2     def __init__(self,name,birthday,qq):
 3         self.name = name
 4         self.birthday = birthday
 5         self.qq = qq
 6 
 7     @property  # 可以把一个方法变成属性
 8     def age(self):
 9         return 2018 - self.birthday
10     @property
11     def email(self):
12         return "123@163.com"
13 
14 u = user("张三",1994,123485)
15 re = u.birthday # 调用属性不需要括号
16 print(re)
17 print(user.email)
# 注意:
# 1. 方法参数只能有一个self
# 2. 方法上方要写@property
# 3. 调用时,不需要写括号.直接当成属性变量来用
# 4. 这种套路只能取值.不能设置值




# 私有: (一般不用)
# 应用于某些不能公开、公共的对象,如...你老婆
# python中使用__作为方法或者变量的前缀 那么这个方法或者变量就是私有的
 1 # 私有变量:  实例变量 类变量
 2 class person:
 3     def __init__(self,wife,secret):
 4         self.__wife = wife
 5         self.__secret = secret
 6 
 7 wangnm = person("王尼美","嘘...")
 8 # print(wangnm.__wife) # 报错  'person' object has no attribute '__wife'
 9 # 程序报错 私有内容外部是不能直接访问到的
10 
11 # 但如果开辟外界访问通道(公用方法) 那就可以通过这个公用的方法来获取到私有内容 但只能看不能改
12 class person:
13     __zisi = "有些方面,谁都是自私的"  # 类变量也可以用 私有属性
14     def __init__(self,wife,secret):
15         self.__wife = wife # 私有
16         self.__secret = secret
17 
18     def tell(self):
19         print("大喇叭开播啦~~")
20         return self.__secret,self.__wife
21 
22 wangnm1 = person("王尼美","嘘...")
23 print(wangnm1.tell())  # 借助tell方法成功访问到秘密
24 # print(person.__zisi)  # 类变量同样报错

 

# 私有方法
# 私有方法,顾名思义,只能自己访问的方法.别人都不能随便调用.如: 你和你女朋友约会.你希望别⼈来调用么?
 1 class person:
 2     def __init__(self):
 3         pass
 4 
 5     def __yue(self):
 6         print("我们在约会")
 7 
 8     def work(self):
 9         print("努力搬砖中")
10 
11 p = person()
12 # p.yue() # 报错 __yue是一个私有的方法.只能在类中自己调用.类外不能直接访问.
13 p.work()
14 
15 # 同样,私有方法也是相对而言的.我们可以通过其他方法来访问到
16 class person:
17     def __init__(self):
18         pass
19 
20     def __yue(self):
21         print("我们在约会")
22 
23     def work(self):
24         print("努力搬砖中")
25         self.__yue()  # 在自己类中访问自己的其他方法.哪怕是私有的.也是自己在用
26 
27     # 类方法与静态方法也和实例方法一样
28     @classmethod
29     def __yue1(cls):
30         print("ta们在约会")
31 
32     @staticmethod
33     def __yue2():
34         print("ta们在约会")
35 
36     @property
37     def __yue3(self):
38         return "ta们在约会"
39 
40 
41 p = person()
42 p.work() # 努力搬砖中  我们在约会
43 # person.__yue1()  # 报错
44 # person.__yue2()
45 # person.yue3  # 报错 找不到

 

# 不过需要注意的是,对于私有内容而言,子类是无法继承的!
 1 class fu:
 2     def __init__(self):
 3         pass
 4     def __qingfu(self):
 5         print("情妇_如花...")
 6 
 7 class zi(fu):
 8     pass
 9 
10 re = zi()
11 # print(re.__qingfu)  # 报错 'zi' object has n