1，類和對象

python中一切皆為對象，類型的本質就是類。

>>> dict #類型dict就是類dict
<class ‘dict‘>
>>> d=dict(name=‘eva‘) #實例化
>>> d.pop(‘name‘) #向d發一條消息，執行d的方法pop
‘eva‘

在python中,用變量表示特征，用函數表示技能（方法），因而具有相同特征和技能的一類事物就是‘類‘,對象則是這一類事物中具體的一個。

1.1類

class 類名：

#創建一個類
class Preson：
    pass


class Preson：
    role 
 
=“peron”    #靜態屬性
    def walk（self）:     #方法，動態屬性
        print（"person is walking..."）

類的兩種作用：屬性引用，實例化

# class Person:                 # 類名
#     country = ‘China‘         # 創造了一個只要是這個類就一定有的屬性
#                                # 類屬性 靜態屬性
#     def __init__(self,*args):  # 初始化方法，self是對象，是一個必須傳的參數
#
 
         # self就是一個可以存儲很多屬性的大字典
#         self.name = args[0]   # 往字典裏添加屬性的方式發生了一些變化
#         self.hp = args[1]
#         self.aggr = args[2]
#         self.sex = args[3]
#
#     def walk(self,n):         # 方法，一般情況下必須傳self參數，且必須寫在第一個
#                               # 後面還可以傳其他參數，是自由的
#         print(‘%s走走走,走了%s步‘%(self.name,n))
 

#
# # print(Person.country)        # 類名 可以查看類中的屬性，不需要實例化就可以查看
# alex = Person(‘狗剩兒‘,100,1,‘不詳‘)  # 類名還可以實例化對象，alex對象   # 實例化
# # print(alex.__dict__) # 查看所有屬性
# print(alex.name)  # 查看屬性值
# # print(alex.hp)  # 查看屬性值
# alex.walk(5)    # Person.walk(alex，5)  # 調用方法 類名.方法名(對象名)

關於self：在實例化是自動講對象/實例本身傳給__init__的第一個參數，可以換名字。

1.2對象

對象=類名（）

對象是關於類而實際存在的一個例子，對象/實例只有一種作用：屬性引用

調用的固定模式：

class 類名:
    def __init__(self,參數1,參數2):
        self.對象的屬性1 = 參數1
        self.對象的屬性2 = 參數2

    def 方法名(self):pass

    def 方法名2(self):pass

對象名 = 類名(1,2)  #對象就是實例，代表一個具體的東西
                  #類名() : 類名+括號就是實例化一個類，相當於調用了__init__方法
                  #括號裏傳參數，參數不需要傳self，其他與init中的形參一一對應
                  #結果返回一個對象
對象名.對象的屬性1   #查看對象的屬性，直接用 對象名.屬性名 即可
對象名.方法名()     #調用類中的方法，直接用 對象名.方法名() 即可

1.3對象之間的交互

# class Dog:
#     def __init__(self,name,blood,aggr,kind):
#         self.name = name
#         self.hp = blood
#         self.aggr = aggr
#         self.kind = kind
#     def bite(self,person):
#         # 狗咬人，人掉血
#         person.blood -= self.aggr
# class Person:
#     def __init__(self,name,blood,aggr,sex):
#         self.name = name
#         self.blood = blood
#         self.aggr = aggr
#         self.sex = sex
#     def attack(self,dog):
#         dog.hp -= self.aggr
#         if dog.hp <= 0:
#             print(‘%s打了%s,%s被打死了，撲街~~~‘%(self.name,dog.name,dog.name))
#         else:
#             print(‘%s打了%s,掉了%s血‘%(self.name,dog.name,self.aggr))
# jin = Dog(‘金老板‘,100,20,‘teddy‘)
# # print(jin.name)
# alex = Person(‘alex‘,999,998,‘不詳‘)
# jin.bite(alex)   # Dog.bite(jin,alex)
# print(alex.blood)
# # alex attack
# alex.attack(jin)  # Person.attack(alex,jin)
# print(jin.hp)

2，類和對象命名空間

類裏可以定義兩種屬性：靜態屬性。動態屬性

創建一個類就會創建一個類的名稱空間，用來存儲類中定義的名字，這些名字稱為類的屬性

創建一個對象就會創建一個對象的名稱空間。存放對象/實例的名字，稱為對象/實例的屬性

類中的靜態變量可以被對象和類調用

對於不可變數據類型來說，類變量最好用類名操作，

對於可變數據類型來說，對象名的修改是共享的，重新賦值是獨立的

# 類裏的名字有 類變量（靜態屬性量）+ 方法名（動態屬性）
# 對象裏的名字 對象屬性
# 對象 —— > 類
# 對象找名字 ： 先找自己的 找類的 再找不到就報錯
# 對象修改靜態屬性的值
    # 對於不可變數據類型來說，類變量最好用類名操作
    # 對於可變數據類型來說，對象名的修改是共享的，重新賦值是獨立的

class Course:
    language=["Chinese"]                                              #language="Chinese"
    def __init__(self,teacher,course_name,period,price):
        self.teacher=teacher
        self.course_name=course_name
        self.period=period
        self.price=price
    def func(self):
        pass
Course.language[0]="df"                                           #Course.language="df"  
linux=Course("egon","py","6 months",20000)            #print(linux.language)
print(linux.language)                                                   #print(Course.language)
print(Course.language)
linux.language[0]="hu"                                              #linux.language="hu"
print(linux.language)                                                  #print(linux.language)
print(Course.language)                                                #print(Course.language)   
#  [‘df‘]                                                                     #df
[‘df‘]                                                                           df             
 ["hu"]                                                                         du             
 ["hu"]                                                                          df            
                                                                                                   

2.2綁定方法

# def func():pass
# print(func)
#
# class Foo:
#     def func(self):
#         print(‘func‘)
#     def fun1(self):
#         pass
# f1 = Foo()
# print(Foo.func)
# print(f1.func)
# print(f1.fun1)
#<bound method Foo.func of f1

# 包 —— __init__
# import package —— 類的實例化的過程
# import time
# time.time()

2.3組合

組合：一個對象的屬性值是另外一個類的對象（在一個類中以另外一個類的對象作為數據屬性，稱為類的組合）

什麽時候用：當類之間有顯著不同，並且較小的類是較大類所需要的組件時，用組合。（什麽是什麽）

#圓環的面積
# 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 2*pi*self.r
# class Ring:
#     def __init__(self,out_r,ins_r):
#         self.out_c=Circle(out_r)
#         self.ins_c=Circle(ins_r)
#     def area(self):
#         return self.out_c.area()-self.ins_c.area()
#     def perimerter(self):
#         return self.out_c.perimeter()+self.ins_c.perimeter()
# ring=Ring(20,10)
# print(ring.area())
# print(ring.perimerter())

# class Birthday:
#     def __init__(self,year,month,day):
#         self.year=year
#         self.month=month
#         self.day=day
# class Course:
#     def __init__(self,cou_name,period,piric):
#         self.name=cou_name
#         self.period=period
#         self.piric=piric
# class Teacher:
#     def __init__(self,name,age,sex,birthday):
#         self.name=name
#         self.age=age
#         self.sex=sex
#         self.birthday=birthday
#         self.course = Course(‘python‘, ‘6 month‘, 2000)
# b=Birthday(2020,2,13)
# egg=Teacher("egon",0,"女",b)
# print(egg.name)
# print(egg.sex)
# print(egg.birthday.day)
# print(egg.course.piric)

面向對象1