面向物件程式設計

面向過程的概念

面向過程核心即過程二字,解決問題的流程,即先幹什麼,在幹什麼,最後幹什麼

# 例如:
1.洗衣服
2.把大象放進冰箱需要幾步?
"""
	1.把冰箱門開啟
	2.把大象大象放進去
	3.關上冰箱門
"""
3.流水線生產飲料

優點:複雜的問題流程化,進而簡單化
缺點:牽一髮而動全身,擴充套件性差,可維護性差
應用場景:對擴充套件性要求不高的地方,eg:安裝包的使用

# 註冊的功能
"""
	1.使用者輸入使用者名稱和密碼
	2.驗證引數
	3.寫入檔案,註冊成功
"""

面向物件的概率

面向物件核心即物件二字

什麼是物件?

	1.程式中:
		函式:盛放資料的容器
		物件:盛放資料和函式的容器
	2.現實生活中:
		一切皆物件
		物件:特徵與技能的結合體
優點:擴充套件性強,可維護性強
缺點:程式設計難度高
應用場景:對擴充套件性要求較高的地方 eg:微信,qq

# 舉例:
	以學生選課系統為例
# 版本三
def choose_course(stu_dict,course):
    stu_dict['course'].append(course)
    print('%s選課成功 %s'%(stu_dict['name'],stu_dict['course']))

stu1 ={
    'name':'jason',
    'age':'15',
    'gender':'male',
    'course':[],
    'choose_course':choose_course}

stu2 ={
    'name':'ly',
    'age':'18',
    'gender':'male',
    'course':[],
    'choose_course':choose_course}

stu1['choose_course'](stu1,'python')  # jason選課成功 ['python']
stu2['choose_course'](stu2,'python')  # ly選課成功 ['python']
 

類的定義和物件的產生

物件:特徵與技能的結合體
類:一系列物件相似的特徵與相似的技能的結合體

強調:站在不同的分類,劃分的分類不一定一樣

# 問題來了:
	到底是先有類還是先有物件?
	1.程式中:
		必須先定義類,然後呼叫類產生物件
        2.現實生活中:
                先有物件,再有人類

"""
使用專業的語法定義類:
    1.定義函式:
        def 函式名():
            pass
    2.定義類:
        class 類名():
            pass
"""

定義類:
"""
    發生了什麼事?
        1.立即執行類體程式碼
        2.產生一個類的名稱空間,把類體裡面執行的名字都扔到名稱空間中(大字典)
        3.把類的名稱空間繫結給__dict__,類名.__dict__
"""
# 類名一般情況下首字母都大寫
class Student():
    # 定義一個屬性
    school = 'SH'

    # 定義一個技能(函式)
    def choose_course(stu_dict,course):
        stu_dict['course'].append(course)
        print('%s選課成功 %s' % (stu_dict['name'],stu_dict['course']))

# 檢視類的名稱空間
print(Student.__dict__)

# 產生物件
#呼叫類產生物件,預設產生的是一個空物件{}

stu1 = Student()
stu2 = Student()
stu3 = Student()

print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
 

對物件定製自己獨有的屬性

class Student():
  # 定義一個屬性
  school = 'SH'
  # 初始化方法
  # 呼叫類自動觸發的函式
  # 該方法不是一定要定義,需要用到就定義,不需要可以不定義
  def __init__(stu_obj,name,age,gender):
  # 空物件.name = name
  # 空物件.age = age
  # 空物件.gender = gender
  stu_obj.name = name # stu1.__dict__['name'] = 'jason' 
  stu_obj.age = age # stu1.__dict__['age'] = 18
  stu_obj.gender = gender # stu1.__dict__['gender'] = 'male'
  # return None # 這個方法中不能有返回值
# 定義一個技能(函式)
def choose_course(stu_dict,course):
    stu_dict['course'].append(course)
    print('%s選課成功 %s' % (stu_dict['name'],stu_dict['course']))

# 呼叫類發生了幾件事?
"""
  1.得到一個空物件
  2.呼叫了Student.__dict__(空物件,'ly',18,'male')
  3.得到一個初始化結果
"""
stu1 = Student('ly',18,'male')
stu2 = Student('jason',18,'male')
# stu1 = Student()
# print(stu1.__dict__)
# print(stu2.__dict__)

# print(stu1.name)
# print(stu2.name)

# 屬性的查詢:先從自己的物件中查詢,然後再去產生物件的類中尋找

stu1.school = 'aaaa' # 在stu1名稱空間產生一個school = aaaa
print(stu1.school)
 

屬性的查詢順序

class Student():
    # 定義一個屬性
    school = 'SH'

    def __init__(self,name,age,gender,course=None)
        if course is None:
            course = []
        self.name = name # stu1.__dict__['name'] = 'jason'
        self.age = age  # stu1.__dict__['age']  = 18
        self.gender = gender  # stu1.__dict__['gender']  = 'male'
        self.course =course
    def choose_course(self,course)
    # stu_dict => stu
    self.course.append(course)
    print('%s選課成功 %s' % (self.name,self.course))

   def func(self,name,age):
       pass
# 屬性的查詢:
# 1.類屬性: 在類中寫的屬性就稱之為類屬性
# 2.物件屬性: 在物件自己的名稱空間中的屬性就是物件屬性

# 類屬性的查詢
# 1.查
# print(Student.school)

# 2.增加
# Student.country = 'China'

# 3.改
Student.school = 'BJ'

# 4.刪除
del Student.school
print(Student.__dict__)
{}
stu = Student('ly',18,'male')  # 例項化物件:stu就是一個例項

# 物件屬性
# 1.查
# print(stu.name)
# print(stu.age)
# print(stu.gender)

# 2.增
# stu.aaa = 'aaa'

# 改
# stu.name = 'zzy'

# 4.刪除
# del stu.name
# print(syu.__dict__)


# 類中的方法,類可以呼叫,物件也可以呼叫
# 類呼叫方法
# Student.choose_course(stu,'python') # 類來呼叫,函式的引數有幾個就要傳幾個
print(Student.choose_course)

# 物件的呼叫方法
# 類中的方法,類可以呼叫,物件也可以呼叫,但是,推薦物件來呼叫,因為物件來呼叫,會把自己當做第一個引數傳遞給函式
stu.choose_course('python') # stu.choose_course(stu,'python')

class Teacher():
    pass
print(isinstance(123,int))  # True
print(isinstance(syt,Teacher))  # Flase