巨蟒python全棧開發-第17天 核能來襲-成員

一.今日主要內容

    1.成員
        在類中你能寫的全部內容都是類的成員
    2.變量
        (1)實例變量:昨天寫的就是實例變量,由對象去訪問的變量.
        (2)類變量(靜態變量):此時,這個變量屬於類,可是對象也能夠訪問

    3.方法
        (1)實例方法:昨天寫的就是實例方法,使用     對象.方法()    進行調用
            特色:在聲明的時候,須要給出self,self必須放在第一個位置
                 在調用的時候,自動的會把對象傳遞給形參的self

        (2)類方法(@classmethod):類方法是屬於類的.
            特色:在聲明的時候須要給出一個可以接收類名的參數,cls,也必須放在參數的第一個
                在調用的時候,自動的把xx對象的類傳遞給cls

        (3) 靜態方法(@staticmethod):靜態方法也是屬於類的,靜態方法就比如,咱們在類中定義了一個函數
            靜態方法通常和類方法差很少,使用類名去訪問

    4.屬性(這個是比較有用的)
            #爲了在難受的時候舒服一點
            在方法上添加一個@property,能夠把一個方法變成一個屬性,可是這個屬性不能夠被賦值
            當咱們某一個屬性必須通過計算才能獲得結果的時候
            #個人理解:本質是方法,可是能夠當成屬性來用
    5.私有
        全部已雙下劃綫開頭的方法,變量都是私有內容,外界沒法訪問//除非你主動暴露這些內容
        你想保護就把他私有化
    #總結:強化面向對象(今天量稍微大一些)

二.今日內容大綱
1.實例化變量
2.實例方法
3.類變量
4.類方法
5.靜態方法
6.屬性
7.私有

三.今日內容詳解

1.實例變量

class Person:
    def __init__(self,name,id,gender,birth):
        self.name=name      #實例變量   對象裏的變量
        self.id=id
        self.gender=gender
        self.birth=birth

p=Person('wusir','10086','不詳','1900-12-15')


print(p.birth)
p.birth='1840-5-6'      #實例變量能夠進行修改
print(p.birth)

#實例變量通常使用       對象.屬性

print(p.name)

2.實例方法
(1)

class Computer(object):
    #實例方法
    def play(self):
        print('電腦能夠掃雷')

        #在定義實例方法的時候,必須給出一個參數 self
        #形參的第一個參數,自動的把對象給傳遞進來
    def work(self):     #self 就是個形參,隨便寫,中文也行
        print(self)     #self 是當前類的對象
        print('電腦用來工做')

c=Computer()
c.work()            #調用的時候不須要手動給出self
print(c)

(2)

回顧以前
字符串操做.  列表操做. 字典操做. 元組操做.....
s = "你好啊"
s.replace("你", "我")
以前講解的全部方法都是實例方法

3.類變量

class Person:
    # country='中國'        #類變量,  類變量是屬於類的
    country = '大清'          #類變量不是特別特別經常使用
    def __init__(self,name,gender):
        self.name=name
        self.gender=gender

p=Person('武sir','未知')
print(p.name)   #實例變量
print(p.gender)
print(p.country)    #類變量能夠給對象使用

p2=Person('太白','兩性')
print(p2.gender)
print(p2.country)

                    #大坑:沒有修改類變量
p.country='大清'  #沒有修改類變量,只是在本身的實例化空間內建立了一個country
p2.country='大明'
print(p.country)    #類變量能夠給對象使用
print(p2.country)

Person.country='大元'     #類變量最好是使用類名來訪問
print(p.country)
print(p2.country)

 4.類方法

class Person:
    #實例方法
    def chi(self):
        print('人會吃')

    @classmethod  #裝飾器,此時這個方法是一個類方法,固定方法
    def he(cls):    #此時接收到的cls是類名
        print(cls)
        print('人會喝')
#用對象訪問
p=Person()
p.he()          #解釋:在調用類方法的時候. 默認的把類名傳遞給類方法
                #<class '__main__.Person'>
                #人會喝
print(Person)   #<class '__main__.Person'>

# 類方法通常用類名去訪問
Person.he() # 類方法

# Person.chi()      #這句話就會報錯

# 總結:帶類的最好用類來訪問

5.靜態方法

class Person:

    @staticmethod   #靜態方法
    def yue():
        print('SKT')

#靜態方法可使用對象訪問,
# 也可使用類名訪問,
# 可是通常推薦使用類名訪問

p=Person()
p.yue()

Person.yue()
#知識點回顧:
#fromkeys共用value,返回新字典,不是原來的字典

6.屬性

(1)引子

#怎麼解決,每過一年都要加一年,把age 替換成 birth
class Person:
    def __init__(self,name,gender,birth):
        self.name=name
        self.gender=gender
        self.birth=birth     #2000  2018
    #年齡這一項,原本就應該是算出來的,而不是直接存儲的
p1=Person('武sir','未知',2000)
age=2018-p1.birth       #每一個人都有年齡這個屬性,可是又沒辦法存儲
print(age)

(2)@property

class Person:
    def __init__(self,name,gender,birth):
        self.name=name
        self.gender=gender
        self.birth=birth     #2000  2018
    #年齡這一項,原本就應該是算出來的,而不是直接存儲的
    @property   #把一個方法更改爲一個屬性,每次拿屬性的時候都會自動的去執行這個方法
                #方法的返回值就是屬性值
    def age(self):      #實例方法
        print('我是方法')
        return 2018-self.birth
#注意:這裏的屬性是不能賦值的,方法不是變量
p1=Person('武sir','未知',2000)
print(p1.age)       #看着像一個變量同樣使用,實際上這裏是調用的一個方法
print(p1.age)

# p1.age=99          #不能夠修改的,由於age是一個方法,不是一個變量
                    #這句話修改會報錯

7.私有     __

class Person:
    __qie='潘潘'    #私有類變量(或者叫作私有靜態變量)
    def __init__(self,name,mimi):
        self.name=name
        self.__mimi=mimi    #__mimi表明的是 私有內容  實例變量
    def gaosu(self):
        print(f'把祕密告訴了太白,次日全部人都知道了"{self.__mimi}"')
        print(Person.__qie) #私有的類變量只能在類中調用,能夠用類名調用
        print(self.__qie) #私有的類變量只能在類中調用,能夠用對象名調用

    def __yue(self):    #私有的實例方法
        print('我要和寶寶約')

    @staticmethod
    def __koujiao():
        print('韓志遠但願和嫂子一塊兒摳腳')

p=Person('wusir','和嫂子的故事')
p.gaosu()

# print(p.__mimi) #私有的內容只能在類裏面調用,這裏寫會報錯
#除非主動暴露本身的祕密,不然,不會
# print(Person.__qie)   #這句話也會報錯
# p.__koujiao()         #也會報錯
# Person.__koujiao()         #也會報錯

做業:

1. 簡述⾯面向對象三⼤大特性並⽤用示例例解釋說明？【背寫】 

封裝:對屬性和方法的封裝,以便隨時調用

繼承:子類除了自己以外還可使用父類的方法和屬性

多態:鴨子模型,同一個對象擁有多種形態

2.⾯向對象中的變量分爲哪幾種？並用示例說明區別？【背寫】

(1)實例變量: 說白了,就是每一個實例變量都應該擁有的變量,好比,人的名字,人的愛好
     每一個人的我的信息都屬於實例變量..給對象用的

(2) 類變量(靜態變量): 直接寫在類中的變量就是類變量,須要用類名來訪問,能夠改變,多個對象共享的

3.⾯向對象中方法有哪幾種？並用示例說明區別？【背寫】 

1. 類方法         類名.方法   調用
2. 實例方法       對象.方法   調用
3. 靜態方法       類名.方法   調用

4.面向對象中的屬性有什麼？並⽤用示例例說明？ 

重點記憶(這個 沒有理解好)

(1)@property  把方法轉換成屬性
(2)對象.屬性(self.name)

5.簡述靜態方法和類方法的區別？ 

記憶!!!
靜態方法: 不用傳遞參數,沒有繼承
類方法:  須要傳遞參數,能夠繼承;訪問類方法,默認傳遞的是類;

6.⾯向對象的⽅法中哪一個無需傳參數？ 

記憶!!!

靜態方法

7.面向對象中公有和私有成員，在編寫和調用時有哪些不一樣？ 

記憶!!!

編寫,公有成員編寫時,沒有什麼特別的要求,私有成員在成員名字前面須要加上__,雙下劃線,
公有成員在內部和外部均可以調用,私有成員只能在內部使用

網友:
公有使用: __xx__   兩端使用__
私有使用__xx       左端使用

8.

class Foo(object):
    a1=11
    a2=12
    def __init__(self):
        self.a1=1
obj=Foo()
print(obj.a1)
print(obj.a2)


結果:
1
12
分析:應該先找__init__裏面的實例變量信息,再找類變量信息

9.

class Foo(object):
    a1=11

    def __init__(self,num):
        # self.a2=num
        self.a2=1
obj=Foo(999)
print(obj.a2)
print(obj.a1)

print(Foo.a1)
# print(Foo.a2)     #由於第四行裏是用類調用初始化方法裏的變量,天然調用不到
                #報錯緣由是,類中沒有屬性a2


結果:
999
11
11
第四行報錯

 

10.

class Foo(object):
    a1=1
    __a2=2
    a2=2

    def __init__(self,num):
        self.num=num
        self.__salary=1000
        # self.salary=1000
    def get_data(self):
        print(self.num+self.a1)
obj=Foo(666)
print(obj.num)
print(obj.a1)
# print(obj.__salary)     #結果:Foo' object has no attribute '__salary'
# print(obj.salary)         #本身測試結果:1000
# print(obj.__a2)
# print(obj.a2)             #本身測試結果:2
print(Foo.a1)             #結果:1
print(Foo.__a2)
# print(Foo.a2)               #本身測試結果:2


結果:
666
1
找不到
找不到
1
找不到

11.

# 沒問題,可是作這樣的題目必定要仔細
class Foo(object):
    a1=1
    __a2=2

    def __init__(self,num):
        self.num=num
        self.__salary=1000

    def get_data(self):
        print(self.num+self.a1)

obj1=Foo(666)
obj2=Foo(999)
print(obj1.num)     #666
print(obj1.a1)      #1

obj1.num=18
obj1.a1=99

print(obj1.num)     #18
print(obj1.a1)      #99

print(obj2.a1)                  #1
print(obj2.num+Foo.a1)          #1000
print(obj2.num+obj1.a1)         #1098

12.

#注意下面的四種玩法
class Foo(object):
    hobby='大保健'
    def __init__(self,num):
        self.num=num
        self.__salary=1000
    def f1(self):
        print(Foo.hobby)
    @staticmethod
    # def f2(self):
    def f2():       #注意這個靜態方法不能有self，有self不會調用
        print(Foo.hobby)
    @classmethod
    def f3(cls):
        print(cls.hobby)
    @property
    def f4(self):
        print(Foo.hobby)
        # print(self.hobby)
f=Foo(200)
f.f1()
f.f2()
f.f3()
f.f4

13.

class Foo(object):
    @classmethod
    def f3(cls):
        print(cls)
Foo.f3()            #結果:<class '__main__.Foo'>

14.

class Foo(object):
    @classmethod
    def f3(cls):
        print(cls)
obj=Foo()
obj.f3()            #結果:<class '__main__.Foo'>

15.

#我認爲是同樣的
#結果是同樣的,和我推測的同樣

class Foo(object):
    @classmethod
    def f3(cls):
        print(cls)
    def f2(self):
        self.f3()       #<class '__main__.Foo'>
        Foo.f3()        #<class '__main__.Foo'>
obj=Foo()
obj.f2()

16.

class Base(object):
    @classmethod
    def f3(cls):
        print(cls)
    def f1(self):
        print('base.f1')
        self.f3()           #子類中有的話,用子類的,沒有則用父類的
class Foo(Base):
    # def f3(self):
    #     print('123')
    def f2(self):
        print('foo.f2')
        self.f1()
obj=Foo()
obj.f2()

#結果:
foo.f2
base.f1
<class '__main__.Foo'>

17.請編寫一個私有的靜態方法，並經過代碼證實私有方法不能再外部方法但能夠在內部訪問。

#注意,咱們能夠在內部經過,本身的類和未私有化的方法來調用私有化的靜態方法
class Person:
    __qie='潘潘'    #私有類變量
    def __init__(self,name,mimi):
        self.name=name
        self.__mimi=mimi    #__mimi表明的是 私有方法
                        #
    @staticmethod
    def __donggua(self):
    # def donggua(self):
        print('你好啊!')
    def gaosu(self):
        # __donggua()
        Person.__donggua(self)
        print(f'把祕密告訴了太白,次日全部人都知道了"{self.__mimi}"')
p=Person('wusir','和嫂子的故事')
# print(p.__mimi) #私有的內容只能在類裏面調用
#除非主動暴露本身的祕密,不然,不會
p.gaosu()