初識面向對象（理論1）

一：類和對象

類就是一類事物

對象：具體的事物

好比人是一類，而具體叫某某名字的是對象

在python中，用變量表示特徵，用函數表示技能，於是具備相同特徵和技能的一類事物就是‘類’，對象是則是這一類事物中具體的一個。

一：初識

聲明一個類  class小寫。類名大寫加：，（）可寫可不寫

class Person:   #定義一我的類      Person是類名
    role = 'person'  #人的角色屬性都是人
    def walk(self):  #人均可以走路，也就是有一個走路方法，也叫動態屬性
        print("person is walking...")

類的兩種做用：屬性引用和實例化

一：屬性引用（類名.屬性）

class Person:  # 定義一我的類
    role = 'person'  # 人的角色屬性都是人

    def walk(self):  # 人均可以走路，也就是有一個走路方法
        print("person is walking...")

print(Person.role)  # 查看人的role屬性
print(Person.walk)  # 引用人的走路方法，注意，這裏不是在調用

二：增強版（類做用，理論知識）

class Person:    # 類名 Person
    role = '人'  # 類的靜態變量 是全部的對象共享的一個屬性
    def attack(self):pass
print(Person.role)   # 類提供給咱們的調用方式
print(Person.attack)
Person.role = '中國人'
print(Person.role)
Person.attack()   # 報錯
print(Person.__dict__) # 存儲方式
print(Person.__dict__['role'])
print(Person.__dict__['attack'])
Person.__dict__['role'] = '人'

類只有兩個做用:
    1.使用類中的名字
        查看類中的名字:
        類名.變量名                # 能夠修改變量的值
        類名.__dict__['變量名']   # 不能修改
    2.創造對象  實例化對象
        對象就是實例,一個實際的例子
        對象 = 類名()
class Person:    # 類名 Person
    role = '人'  # 類的靜態變量 是全部的對象共享的一個屬性
    def __init__(self,name,sex,aggr,hp):  #{}
        self.name = name
        self.sex = sex
        self.aggr = aggr
        self.hp = hp
    def attack(self):
        print(self.name)
        print(self.sex)

obj1 = Person('alex','female',250,1)
obj2 = Person('egon','male',500,2)
print(obj1.name,obj1.sex,obj1.aggr,obj1.hp)
print(obj2.name,obj2.sex,obj2.aggr,obj2.hp)
print(obj1.__dict__)
print(obj2.__dict__)
print(obj1)
Person.attack(obj1)  # 調用一個類中的方法了
obj1.attack()
對象的具體:
    內存地址的不一致
    不一樣的對象 屬性的值應該不一樣

類名(參數)
    創造一個空對象 : self
    調用__init__方法 : 初始化方法
    把參數傳給__init__方法
    完成init方法中的代碼
    自動將self返回給實例化的地方

self就是對象

調用類中的方法 :
    類名.方法名(對象)
    對象名.方法名()

三：總結

#初始面向對象
'''
class Person:
    role = '人'   # 類的靜態變量 是全部的對象共享的一個屬性
    def __init__(self):
       pass
    def attack(self):
1.類：一類事務，如人，電腦等
 對象：一個具體的事務，如小明，小明的手機
2.定義一個類：class Person(): 類名 Person 首字母要大寫 （）可寫可不寫
              在類中添加共用屬性  role = '人'  類的靜態變量 是全部的對象共享的一個屬性
在調用時用 print(Person.role)
3.查看類中的名字：
3.1 print(Person.role) 類提供給咱們的調用方式  能夠進行修改 如Person.role = '中國人'
3.2 print(Person.__dict__) 類提供的存儲方式 會將類中的全部名字和方法均顯示出來
print(Person.__dict__['role'])
4.類只有兩個做用:
4.1.使用類中的名字
    查看類中的名字:1. 類名.變量名 # 能夠修改變量的值
                  2.類名.__dict__['變量名']   # 不能修改
4.2.創造對象  實例化對象
    對象就是實例,一個實際的例子
    對象 = 類名()  #obj1=person()
5.實例化：
1.obj1 = Person('alex','female',1,250)  # 實例化 先創造對象 再初始化
print(obj1.name,obj1.sex,obj1.aggr,obj1.hp)
print(obj2.name,obj2.sex,obj2.aggr,obj2.hp)
print(obj1.__dict__)
2.調用__init__方法 : 初始化方法
    def __init__(self,name,sex,aggr,hp):  #方法 動態屬性  內置的雙下方法 self就是對象
        self.name = name    self理解爲等於一個空字典，self={} self.name中name爲key值，等號右邊的爲value值
        self.sex = sex    name，sex等均爲屬性
        self.aggr = aggr
        self.hp = hp
6.對象的具體:
print(obj1) #object at 0x000001B8F1378A90>
print(obj2) #object at 0x000001B8F1378AC8>
    1.內存地址的不一致
    2.不一樣的對象 屬性的值應該不一樣
7.類名(參數)
    1.創造一個空對象 : self(即obj1）
    2.調用__init__方法 : 初始化方法
    3.把參數傳給__init__方法
    4.完成init方法中的代碼
    5.自動將self返回給實例化的地方 self就是對象
8.調用類中的方法 :
 def attack(self):  # 自定義方法
        print(self.name)
1.類名.方法名(對象) Person.attack(obj1）
2.對象名.方法名() obj1.attack()  def attack(self):self就是obj1
9.使用面向對象的步驟：
1.完成類
首先分析一下角色和類 類裏面有哪些屬性 init方法
再分析這個類中能有哪些行爲 定義爲方法
2.實例化
傳參數獲取實例化以後的對象
    1.首先創造對象,
    2.執行init方法
3.對象的調用：使用對象調用對象屬性和類中的方法
對象名的做用:
    1.使用變量 對象名.屬性名 obj1.name
    2.調用方法 對象名.方法名() obj1.attack()
'''
####人狗大戰
class Person:    # 類名 Person
    role = '人'  # 類的靜態變量 是全部的對象共享的一個屬性
    def __init__(self,name,sex,aggr,hp):  #方法 動態屬性  內置的雙下方法
        self.name = name    # 對象屬性 實例屬性
        self.sex = sex
        self.aggr = aggr
        self.hp = hp
    def attack(self,dog):  # 自定義方法
        print('%s打了%s'%(self.name,dog.name))
        dog.hp -= self.aggr

class Dog:
    def __init__(self,name,kind,aggr,hp):
        self.name = name   # 對象屬性
        self.kind = kind
        self.aggr = aggr
        self.hp = hp
    def bite(self,person):
        print('%s咬了%s'%(self.name,person.name))
        person.hp -= self.aggr
hei = Dog('小黑','teddy',260,10000)  # 實例化: 先創造對象 再初始化
alex = Person('alex','female',1,250)  # 實例化
egon = Person('egon','male',2,500)  # 實例化
alex.attack(hei)   # Person.attack(alex,hei)
egon.attack(hei)   # Person.attack(alex,hei)
print(hei.hp)
hei.bite(alex)
print(alex.hp)
#
# ##根據半徑求圓面積##
# from math import pi
# class Circle:
#     def __init__(self,r):
#         self.r=r
#     def area(self):
#        return self.r**2*pi
#     def  perimeter(self):
#        return self.r*2*pi
# circle=Circle(5)
# print(circle.area())
# print(circle. perimeter())
# ###小明，老王###
# '''
# 小明,男,10歲,上山去砍柴
# # 小明,男,10歲,開車去東北
# # 小明,男,10歲,最愛大保健
# # 老張,男,90歲,上山去砍柴
# # 老張,男,90歲,開車去東北
# # 老張,男,90歲,最愛大保健
# # 老王,男,70歲,上山去砍柴
# '''
# class Person:
#     def __init__(self,name,sex,aggr):
#         self.name=name
#         self.sex = sex
#         self.aggr = aggr
#     def attack(self):
#         print("%s%s%s上山去砍柴"%(self.name,self.sex,self.aggr ))
#         print("%s%s%s開車去東北" % (self.name, self.sex, self.aggr))
#         print("%s%s%s最愛大保健" % (self.name, self.sex, self.aggr))
# obj1=Person("小明","男",10)
# obj1.attack()
# obj2=Person("老王","男",90)
# obj2.attack()
# obj3=Person("老張","男",75)
# ###方法二###
# class Person:
#     def __init__(self,name,sex,age):
#         self.name = name
#         self.age = age
#         self.sex = sex
#     def dirve(self):
#         print('%s,%s,%s歲,開車去東北'%(self.name,self.sex,self.age))
#     def climb(self):
#         print('%s,%s,%s歲,上山去砍柴'%(self.name,self.sex,self.age))
#     def hobby(self):
#         print('%s,%s,%s歲,最愛大保健'%(self.name,self.sex,self.age))
# ming = Person('小明','男',10)
# ming.dirve()
# ming.climb()
# ming.hobby()
# zhang = Person('老張','男',90)
# zhang.dirve()
# zhang.climb()
# zhang.hobby()