python 面向对象 公有属性
公有属性定义 公有属性也叫作类变量 静态字段
class role(): # 传参数 # 公有属性都在这里定义
# 在类里直接定义的属性即是公有属性
nationality = 'JP' def __init__(self,name,role,weapon,life_value=100,moneny=15000):
# 构造函数
# 实例化过程中做一些类的初始化工作
# 成员属性
self.name = name
self.role = role
self.weapon = weapon
self.life_value = life_value
self.moneny = moneny
self.__heart = 'normal' # 私有属性 def shot(self): # 类的方法,功能(动态属性)
print("shotting") # 定义一个方法用来对外访问
def show_heart(self):
return self.__heart def got_shot(self):
print("on,%s got shoot..." % self.name) def buy_gun(self,gun_name):
print("%s just bought %s" %(self.name,gun_name))
self.weapon = gun_name b1 = role('mike','警察','AK47')
b2 = role('mike','警犬','B13') print(b1.weapon) # AK47 打印的是成员属性
# b2武器也是成员属性
# 想让 b1 b2 共享武器需要公有属性 print(b1.nationality) # JP
print(b2.nationality) # JP
修改公有属性
class role(): # 传参数 # 公有属性都在这里定义
# 在类里直接定义的属性即是公有属性
nationality = 'JP' def __init__(self,name,role,weapon,life_value=100,moneny=15000):
# 构造函数
# 实例化过程中做一些类的初始化工作
# 成员属性
self.name = name
self.role = role
self.weapon = weapon
self.life_value = life_value
self.moneny = moneny
self.__heart = 'normal' # 私有属性 def shot(self): # 类的方法,功能(动态属性)
print("shotting") # 定义一个方法用来对外访问
def show_heart(self):
return self.__heart def got_shot(self):
print("on,%s got shoot..." % self.name) def buy_gun(self,gun_name):
print("%s just bought %s" %(self.name,gun_name))
self.weapon = gun_name b1 = role('mike','警察','AK47')
b2 = role('mike','警犬','B13') print(b1.weapon) # AK47 打印的是成员属性
# b2武器也是成员属性
# 想让 b1 b2 共享武器需要公有属性 b1.nationality = 'Thailand'
print(b1.nationality) # Thailand
print(b2.nationality) # JP
更改类的公有属性
class role(): # 传参数 # 公有属性都在这里定义
# 在类里直接定义的属性即是公有属性
nationality = 'JP' def __init__(self,name,role,weapon,life_value=100,moneny=15000):
# 构造函数
# 实例化过程中做一些类的初始化工作
# 成员属性
self.name = name
self.role = role
self.weapon = weapon
self.life_value = life_value
self.moneny = moneny
self.__heart = 'normal' # 私有属性 def shot(self): # 类的方法,功能(动态属性)
print("shotting") # 定义一个方法用来对外访问
def show_heart(self):
return self.__heart def got_shot(self):
print("on,%s got shoot..." % self.name) def buy_gun(self,gun_name):
print("%s just bought %s" %(self.name,gun_name))
self.weapon = gun_name b1 = role('mike','警察','AK47')
b2 = role('mike','警犬','B13') print(b1.weapon) # AK47 打印的是成员属性
# b2武器也是成员属性
# 想让 b1 b2 共享武器需要公有属性 # 更改类的公有属性
role.nationality = 'Thailand' # 两个都改了
print(b1.nationality) # Thailand
print(b2.nationality) # Thailand
class role(): # 传参数 # 公有属性都在这里定义
# 在类里直接定义的属性即是公有属性
nationality = 'JP' def __init__(self,name,role,weapon,life_value=100,moneny=15000):
# 构造函数
# 实例化过程中做一些类的初始化工作
# 成员属性
self.name = name
self.role = role
self.weapon = weapon
self.life_value = life_value
self.moneny = moneny
self.__heart = 'normal' # 私有属性 def shot(self): # 类的方法,功能(动态属性)
print("shotting") # 定义一个方法用来对外访问
def show_heart(self):
return self.__heart def got_shot(self):
print("on,%s got shoot..." % self.name) def buy_gun(self,gun_name):
print("%s just bought %s" %(self.name,gun_name))
self.weapon = gun_name b1 = role('mike','警察','AK47')
b2 = role('mike','警犬','B13') print(b1.weapon) # AK47 打印的是成员属性
# b2武器也是成员属性
# 想让 b1 b2 共享武器需要公有属性 # 更改类的公有属性
role.nationality = 'Thailand' # 两个都改了
print(b1.nationality) # Thailand
print(b2.nationality) # Thailand print("-"*40)
b1.nationality = 'china'
print(b1.nationality)
print(b2.nationality) '''
AK47
Thailand
Thailand
----------------------------------------
china
Thailand
'''
还没有实例化之前 就存在定义公有属性 公有属性就存在内存里
公有属性存在类的内存里, 可以省内存 不用放在构造函数里 每次实例化都保存在每个对象内存里
class role(): # 传参数 # 公有属性都在这里定义
# 在类里直接定义的属性即是公有属性
nationality = 'JP' def __init__(self,name,role,weapon,life_value=100,moneny=15000):
# 构造函数
# 实例化过程中做一些类的初始化工作
# 成员属性
self.name = name
self.role = role
self.weapon = weapon
self.life_value = life_value
self.moneny = moneny
self.__heart = 'normal' # 私有属性 def shot(self): # 类的方法,功能(动态属性)
print("shotting") # 定义一个方法用来对外访问
def show_heart(self):
return self.__heart def got_shot(self):
print("on,%s got shoot..." % self.name) def buy_gun(self,gun_name):
print("%s just bought %s" %(self.name,gun_name))
self.weapon = gun_name print(role.nationality) # JP # b1 = role('mike','警察','AK47')
# b2 = role('mike','警犬','B13') # # 更改类的公有属性
# role.nationality = 'Thailand'
#
# # 两个都改了
# print(b1.nationality) # Thailand
# print(b2.nationality) # Thailand
#
#
# print("-"*40)
# b1.nationality = 'china'
# print(b1.nationality)
# print(b2.nationality)
class role(): # 传参数 # 公有属性都在这里定义
# 在类里直接定义的属性即是公有属性
nationality = 'JP' def __init__(self,name,role,weapon,life_value=100,moneny=15000):
# 构造函数
# 实例化过程中做一些类的初始化工作
# 成员属性
self.name = name
self.role = role
self.weapon = weapon
self.life_value = life_value
self.moneny = moneny
self.__heart = 'normal' # 私有属性 def shot(self): # 类的方法,功能(动态属性)
print("shotting") # 定义一个方法用来对外访问
def show_heart(self):
return self.__heart def got_shot(self):
print("on,%s got shoot..." % self.name) def buy_gun(self,gun_name):
print("%s just bought %s" %(self.name,gun_name))
self.weapon = gun_name b1 = role('mike','警察','AK47')
b2 = role('mike','警犬','B13') # 两个都改了
print(b1.nationality)
print(b2.nationality) # 更改类的公有属性
role.nationality = 'china'
print(b1.nationality, b2.nationality) '''
JP
JP
china china
'''
class role(): # 传参数 # 公有属性都在这里定义
# 在类里直接定义的属性即是公有属性
nationality = 'JP' def __init__(self,name,role,weapon,life_value=100,moneny=15000):
# 构造函数
# 实例化过程中做一些类的初始化工作
# 成员属性
self.name = name
self.role = role
self.weapon = weapon
self.life_value = life_value
self.moneny = moneny
self.__heart = 'normal' # 私有属性 def shot(self): # 类的方法,功能(动态属性)
print("shotting") # 定义一个方法用来对外访问
def show_heart(self):
return self.__heart def got_shot(self):
print("on,%s got shoot..." % self.name) def buy_gun(self,gun_name):
print("%s just bought %s" %(self.name,gun_name))
self.weapon = gun_name b1 = role('mike','警察','AK47')
b2 = role('mike','警犬','B13') # 两个都改了
print(b1.nationality)
print(b2.nationality) # 更改类的公有属性
role.nationality = 'china'
print(b1.nationality, b2.nationality) print("-"*40)
b1.nationality = "USA"
print(b1.nationality)
print(b2.nationality) '''
JP
JP
china china
----------------------------------------
USA
china
'''
在本地创建一个新的 r1.nationality = CN 与Role 没有半点关系
函数 方法也是公有属性
class role(): # 传参数 # 公有属性都在这里定义
# 在类里直接定义的属性即是公有属性
nationality = 'JP' def __init__(self,name,role,weapon,life_value=100,moneny=15000):
# 构造函数
# 实例化过程中做一些类的初始化工作
# 成员属性
self.name = name
self.role = role
self.weapon = weapon
self.life_value = life_value
self.moneny = moneny
self.__heart = 'normal' # 私有属性 # 这里的函数 方法 也是公有属性
def shot(self): # 类的方法,功能(动态属性)
print("shotting") # 定义一个方法用来对外访问
def show_heart(self):
return self.__heart def got_shot(self):
print("on,%s got shoot..." % self.name) def buy_gun(self,gun_name):
print("%s just bought %s" %(self.name,gun_name))
self.weapon = gun_name b1 = role('mike','警察','AK47')
b2 = role('mike','警犬','B13') def shot2(self):
print("my shot",self.name) b1.shot = shot2 b1.shot(b1) # 需要手动传参数
b2.shot() # 用原来对象方法 '''
my shot mike
shotting
'''
python 公有属性可以用类访问,也可以用对象访问
公有属性只能用类去访问
class po: country = "中国" def __init__(self, name):
self.name = name s1 = po("河南") # python 公有属性可以用类访问,也可以用对象访问
print(po.country)
print(s1.country) '''
中国
中国
'''
私有公有属性 对外不能访问
class Foo(object): __name = "mike" print(Foo.__name) '''
Traceback (most recent call last):
File "C:/Users/Administrator.QH-20170325TNQR/PycharmProjects/SSSSS/SS/day7/S13 面向对象/私有公有属性 .py", line 11, in <module>
print(Foo.__name)
AttributeError: type object 'Foo' has no attribute '__name'
'''
在内部普通方法可以访问
class Foo(object): __name = "mike" def __init__(self, name):
self.name = name def f1(self):
print(Foo.__name) obj = Foo("jack")
obj.f1() # mike
使用静态方法 不创建对象
class Foo(object): __name = "mike" def __init__(self, name):
self.name = name @staticmethod
def f1():
print(Foo.__name) Foo.f1() # mike
python 面向对象 公有属性的更多相关文章
- python 面向对象 公有属性 用在哪里
公有属性也可以叫做静态字段 如果每个对象都有一个共同的值 , 应该把它设置为公有属性 公有属性使用场景,每个对象中保存相同的东西时,可以使用公有属性 类找公有属性 过程
- python -- 面向对象编程(属性、方法)
一.属性 对象的属性(attribute)也叫做数据成员(data member). 如果想指向某个对象的属性,可以使用格式: object.attribute 属性又分为:私有属性和公有属性. 私有 ...
- python 面向对象 私有属性
__init__构造函数 self.name = name # 属性, 实例变量,成员变量,字段 def sayhi()# 方法, 动态属性 私有属性不对外看到 前面加上__ class role() ...
- python面向对象之类属性,实例属性
python中的属性分为类属性和实例属性,之前已经说过一些,这里主要是对类属性与实例属性的增删改查 首先是对类属性的增删改查,下面这个是对类属性的修改,在书写类时,已经对类属性occupation进行 ...
- python私有公有属性
python中,类内方法外的变量叫属性,类内方法内的变量叫字段.他们的私有公有访问方法类似. class C: __name="私有属性" def func(self): prin ...
- Python面向对象之类属性类方法静态方法
类的结构 实例 使用面向对象开发时,第一步是设计类: 当使用 类名() 创建对象时,会自动执行以下操作: 1.为对象在内存中分配空间--创建对象: 2.为对象的属性 设置初始值--初始化方法(init ...
- Python面向对象之属性
属性的定义和调用 1,定义时,在普通方法的基础上添加@property装饰器 2,定义时,属性仅有一个self参数 3,调用时,无需括号 vim day7-8.py #!/usr/bin/python ...
- Python面向对象 | 类属性
property property是一个装饰器函数,可以将一个方法伪装成属性,调用的时候可以不用加().@property被装饰的方法,是不能传参数的,因为它伪装成属性了. 装饰器的使用:在要装饰的函 ...
- Python面向对象—类属性和实例属性
属性:就是属于一个对象的数据或函数元素 类有类方法.实例方法.静态方法.类数据属性(类变量)和实例数据属性(实例变量). 类属性:包括类方法和类变量,可以通过类或实例来访问,只能通过类来修改. 实例属 ...
随机推荐
- MathType有哪些功能
随着寒流呼呼来临,期末考也不放过我们,不知道你们是在题海里遨游,还是已做好了挑战准备呢.不管你是哪种情况,现在就有一款玩转理工科的强大编辑公式强悍来袭,不管你是学生.教师,还是理科专业工作者,Math ...
- Asp.net 程序优化js,css合并与压缩
访问时将js和css压缩并且缓存在客户端,采用的是Yahoo.Yui.Compressor组件还完成的,从这里可下载 创建一个IHttpHandler来处理文件 ) }; ) ...
- Win10关闭自动更新
1.搜索栏输入“组策略”后回车 2.找到计算机配置→管理模板→Windows组件→Windows更新 3.在右侧双击“配置自动更新”,然后选择“已启用”,在左下方下拉菜单中选择“2 - 通知下载并通知 ...
- work,i/o最小线程设置
设置work i/o最小线程有两种方式1.通过配置文件设置,影响所有iis部署程序(待验证)2.通过程序代码设置,iis上部署的程序互不影响int minWorker, minIOC; //Get t ...
- opencascade读取iges并用vtk离散的一些问题
近期抽时间在弄iges文件内容读取的工作.然后将其离散化在vtk中能够显示处理以及兴许的一些工作.主要目的是识别CAD文件导出的模型,然后进行离散处理.方便兴许的处理.离散工作比較简单.opencas ...
- NodeJS-004-Oracle驱动编译
一.参考文章 https://community.oracle.com/docs/DOC-931127 http://www.cnblogs.com/stone_w/p/4794747.html ht ...
- jQUery中closest和parents的主要区别是
①,前者从当前元素开始匹配寻找,后者从父元素开始匹配寻找: ②,前者逐级向上查找,直到发现匹配的元素后就停止了,后者一直向上查找直到根元素,然后把这些元素放进一个临时集合中,再用给定的选择器表达式去过 ...
- 详解Integer.toString(int i)方法和String.valueOf(int i)方法
通过查看String类的源码: public static String valueOf(int i) { return Integer.toString(i); } 我们可以看到,String.va ...
- JS-提取字符串—>>普通方法VS正则表达式
如下:“23nr qreq2 34fq4 4454gsr 45” [将这一串字符中的数字挑出来,当然人家作伴的不能被分开]. 一.普通方法: <script type="text/ja ...
- PHP获取POST的原始数据的方法
一般我们都用$_POST或$_REQUEST两个预定义变量来接收POST提交的数据.但如果提交的数据没有变量名,而是直接的字符串,则需要使用其他的方式来接收. 方法一: 使用全局变量$GLOBALS[ ...