python 面向對象公有屬性

阿新 • • 發佈：2018-06-11

pre charm pychar .com one most In 本地 name

公有屬性定義公有屬性也叫作類變量

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 面向對象公有屬性

pre charm pychar .com one most In 本地 name 公有屬性定義公有屬性也叫作類變量 class role(): # 傳參數 # 公有屬性都在這裏定義 # 在類裏直接定義的屬性即是公有屬性 natio

python面向對象——類屬性和實例屬性

python#coding:utf-8 #描述橘子對象的類 class Orange: def __init__(self, weight): self.weight = weight #實例屬性 def get_weight(self): print(

Python面向對象—類屬性和實例屬性

%d 元素 self 分享圖片 def elf 類方法技術分享 __init__ 屬性：就是屬於一個對象的數據或函數元素類有類方法、實例方法、靜態方法、類數據屬性（類變量）和實例數據屬性（實例變量）。類屬性：包括類方法和類變量，可以通過類或實例來訪問，只能通過類來修改

Python 面向對象 --- 私有屬性和私有方法

處理 %d com 私有訪問 class 無法 self. inf 01，應用場景及定義方式應用場景在實際開發中，對象的某些屬性或方法可能只希望在對象的內部被使用，而不希望被外部訪問到私有屬性就是對象不希望公開的屬性私有方法就是對象不希望

python面向對象——屬性

python#coding:utf-8 #描述橘子對象的類 class Orange: def __init__(self, weight): self.weight = weight def get_weight(self): print(self.w

Python學習：17.Python面向對象（四、屬性（特性），成員修飾符，類的特殊成員）

介紹 col 寫代碼被調用表示 1.5 emp 成員 object 一、屬性（特性）普通方法去執行的時候，後面需要加括號，特性方法執行的時候和靜態字段一樣不需要不需要加括號. 特性方法不和字段同名. 特性方法不能傳參數. 在我們定義數據庫字段類的時候,往往需要

【17】有關python面向對象編程的提高【多繼承、多態、類屬性、動態添加與限制添加屬性與方法、@property】

爸爸 mce turn object get 寫法 pri import sel 一、多繼承案例1：小孩繼承自爸爸，媽媽。在程序入口模塊再創建實例調用執行 #father模塊 class Father(object): def __init__(self,mon

python面向對象之靜態屬性/靜態方法/類方法/組合

int html pan 定義都是 itl 接口繼承操作 icm #!/usr/bin/env python # coding:utf-8 class Campus: def __init__(self,name,addr,type): s

Python面向對象4：類的相關函數與屬性

rop 面向對象進行 let class fde 如果 fse doc 1 類相關函數- issubclass:檢測一個類是否是另一個類的子類- isinstance:檢測一個對象是否是一個類的實例- hasattr:檢測一個對象是否由成員xxx- getattr: ge

python入門（十四）：面向對象（屬性、方法、繼承）

mage eat div 實例變量統一 object 地址面向對象實例方法任何東西1）屬性（特征：通常可以用數據來描述）（類變量和實例變量）2）可以做一些動作（方法）類來管理對象的數據。屬性：類變量和實例變量（私有變量）方法： 1）實例方法 2）類方法

python面向對象開發的自我理解

div cpn fmt 打開 ptp 以數據為中心 bsp 規則構造 ?詳細代碼理解可以參考笨鳥教程博客：http://www.runoob.com/python3/python3-class.html 面向對象經常被提起，那到底什麽是面向對象呢？它的基本概念

python面向對象-4類的繼承與方法的重載

== pin pan 父類 class 分享 ima rop failure 1.類的繼承與方法的重載上面就是先定義了一個類A，然後由定義了一個類B，B繼承了類A，這樣B就有了A的非私有屬性和方法。 1 class Washer: 2 com

Python-面向對象之類的特殊成員方法

神奇 key 是什麽 logs self. family local utf-8 操作類的特殊成員方法 1、__doc__ 說明：表示類的描述信息 class Foo: """ 描述類信息，這是用於看片的神奇 """ def func(self):

Python面向對象

self. 面向對象 init self foo pri cat cnblogs 執行面向對象三大特性一、封裝 #1.將內容封裝到某處 #創建類 class Foo: def __init__(self,name,age): #稱為構造方法，根據類創建對象

Python面向對象編程（一）

過程函數名 err 沒有什麽是概念 end 流程三個參數 1.什麽是面向對象面向對象（oop）是一種抽象的方法來理解這個世界，世間萬物都可以抽象成一個對象，一切事物都是由對象構成的。應用在編程中，是一種開發程序的方法，它將對象作為程序的基本單元。 2.面向對象與面

python面向對象類

type peer git 包含 ron 產生其他 code ttr 面向對象變成介紹面向過程編程核心是過程（流水線式思維），過程即解決問題的步驟，面向過程的設計就好比精心設計好一條流水線，考慮周全什麽時候處理什麽東西。主要應用在一旦完成很少修改的地方，如linux內

python 面向對象

num count 外部引用計數器 urn sel eth most option Python 面向對象 Python從設計之初就已經是一門面向對象的語言，正因為如此，在Python中創建一個類和對象是很容易的。本章節我們將詳細介紹Python的面向對象編程。如果你

Python 面向對象的補充

pan -- article 添加 alt bsp copy 無需 tle isinstance(obj,cls)和issubclass(sub,super) isinstance(obj,cls)檢查是否obj是否是類 cls 的對象 1 class Foo(objec

python面向對象進階

參數 tar pri 析構 getattr 實例初始化 pan bsp clas isinstance(obj,cls)檢查是否obj是否是類 cls 的對象。 isinstance(obj,cls)檢查是否obj是否是類 cls 的對象。反射 python面向對象中的反

python面向對象基礎

實例對象 env log style class cnblogs set 實例 pre #! /usr/bin/env python #! -*- cording:utf-8 -*- class Turtle: def __init__(self,x):

python 面向對象 公有屬性

相關推薦

python 面向對象公有屬性