目錄

• python-面向過程、面向對象、類
• 面向過程編程
• 面向對象
  • 類和對象
    • 二者區別
    • 定義格式：
    • 定義類發生的事情
    • 定義類的標准格式
    • 屬性的查找順序

python-面向過程、面向對象、類

面向過程編程

前言：編程不就編程嗎？怎么還有這么多的洋氣詞后綴？？今天主要介紹一下面向過程和面向對象是什么。

大白話版本：面向過程編程可以比作是做一道菜，那么做一道菜分為幾步呢？？

1. 准備食材
2. 起鍋燒油
3. 放輔料
4. 炒菜
5. 出鍋

最高端的食材往往只需要最簡單的烹飪方式，呸，撤回來昂。這個過程，分步來，按部就班的，一步一步的過程為面向過程。

如果還不理解的話，那么想一想，把大象裝進冰箱需要幾步？😢😢😢，顯然是三步了，打開冰箱把大象塞進去，關上冰箱！

• 面向過程編程其實也是一樣的，將編程要實現的目標，按步驟實現，每一步就是一個過程！
  

實例一：

# 做菜的步驟，通過面向過程編程實現
def step1():
    print('第一步，准備食材')
def step2():
    print('第二步，起鍋燒油')
def step3():
    print('第一步，放輔料')
def step4():
    print('第一步，炒菜')
def step5():
    print('第一步，出鍋')

def mainstep():
    step1()
    step2()
    step3()
    step4()
    step5()
    print('感謝老板祝老板生八個兒子')

mainstep()

#結果
第一步，准備食材
第二步，起鍋燒油
第一步，放輔料
第一步，炒菜
第一步，出鍋
感謝老板祝老板生八個兒子

實例二：

# 用戶注冊功能
'''
1.獲取用戶名和密碼
2.組織成固定的格式
3.文件操作寫入文件
'''

# 定義獲取用戶信息函數
def get_info():
    username = input('please input your name>>>:').strip()
    pwd = input('please input your pwd>>>:').strip()
    if len(username) == 0 or len(pwd) == 0:
        print('your username or name is empty,please try again!')
        return
    else:
        user_id = {
            '1': 'admin',
            '2': 'user'
        }
        print(user_id)
        choice = input('please choice your position:')
        if choice == '1':
            id = user_id[choice]
            print('you are admin!')
        elif choice == '2':
            id = user_id[choice]
            print('you are user!')
    return make_info(username, pwd, id)

# 處理信息格式
def make_info(username, pwd, id):
    data = f'{username}|{pwd}|{id}\n'
    return save_info(data)

# 存儲到文件
def save_info(data):
    with open(r'user_info.txt', 'a', encoding='utf8') as f:
        f.write(data)
    print('sign success!')

# 調用主體函數
get_info()

# 結果
please input your name>>>:hammer
please input your pwd>>>:123
{'1': 'admin', '2': 'user'}
please choice your position:1
you are admin!
sign success!

---

牛逼定義：面向過程的程序設計把計算機程序視為一系列的命令集合，即一組函數的順序執行。為了簡化程序設計，面向過程把函數繼續切分為子函數，即把大塊函數通過切割成小塊函數來降低系統的復雜度

---

面向對象

前言：面向對象，此對象非彼對象，面向對象的核心在於“對象”二字。

大白話版本：面向對象可以理解為，做菜的過程我們創造了一個機器人，把食材准備好和步驟寫入機器人，那么可以理解為食材是我們需要的“數據”，如何做菜的步驟理解為“功能”，這個就是面向對象，總的來說就是定義出一系列的功能來對數據進行操作

• 

• 程序中對象：對象是把數據和功能整合到一起的產物，或對象就是盛放數據與功能的容器
• 現實生活中：對象就是特征和技能的結合體

示例如下：

# 未學習面向對象前，所有數據和功能都是散開的
# 數據
name = 'HammerZe'
course = []
# 功能
def add_course(name,course):
    course.append('python')
    print(f"學生{name}選課{course}")
add_course(name,course)

# 結果
學生HammerZe選課['python']

這樣我們發現，如果有100個學生需要和格式化輸出結果怎么辦？寫100次嗎？是不是非常的麻煩

# 升級版
def add_course(user_info,course):
    user_info['course'].append(course)
    print(f"學生{user_info['name']}選課{user_info['course']}")


user_info = {
    'name': 'HammerZe',
    'course':[],
    'add_course':add_course,
}

user_info['add_course'](user_info,'python')
# 結果
學生HammerZe選課['python']
'''通過整合，把數據和功能寫在一起，結果是一樣的'''

類和對象

二者區別

• 生活中

  • 對象：特征與技能的結合體

  • 類：具有相似的特征，相似的技能歸為一類，

  • 例如：西瓜和哈密瓜可以歸為一水果類，

    ​ 狗和貓可以歸為動物一類·····

  • 強調：站在不同的分類角度，划分的類可能不一樣，是先有對象，才有類的

• 程序中：

  • 對象：數據和功能的結合體
  • 類：具有相似數據，相似功能 的為一類
  • 強調：必須先定義類，再調用類產生對象

定義格式：

1. 定義函數

   def 函數名():

   ​ pass

2. 定義類：

   class 類名():

   ​ pass

   類比兩者記憶

定義類發生的事情

1. 立即執行類內代碼
2. 產生一個類的名稱空間，把類內執行的名字都丟到名稱空間中（丟到大字典中）
3. 把類的名稱空間綁定給__ dict __，類名 . __dict__查看名稱空間

示例如下：

class Student():
    def add_course(user_info, course):
        user_info['course'].append(course)
        print(f"學生{user_info['name']}選課{user_info['course']}")
    print('調用類就會執行我！！')

# 查看類的名稱空間
print(Student.__dict__)

# 產生對象：調用類的時候產生一個空對象{}
stu1 = Student()

# 查看對象的名稱空間
print(stu1.__dict__)  # {}

定義類的標准格式

用學生類舉例

class Student():
    # 初始化
    def __init__(self,name,age):
        self.name = name # stu.__dict__['name'] = 'Hammer'
        self.age = age

    '''注意：return 在這個方法中不能有返回值'''

    # 選課方法
    def choose_course(stu_dict,course):
        stu_dict['course'].append(course)
        print(f"學生{stu_dict['name']}選課{course}")


stu = Student('HammerZe',18)
'''1.調用類產生一個空對象
   2.調用了Student.__dict__(空對象,'HmmerZe',18)'''

# 查看類的名稱空間
print(Student.__dict__)
# 查看對象的名稱空間
print(stu.__dict__)# {'name': 'HammerZe', 'age': 18}
# 取值
print(stu.__dict__['name'])
print(stu.name)

屬性的查找順序

• 屬性的查找：
  • 類屬性：在類中的屬性就稱為類屬性
  • 對象屬性：在對象自己的名稱空間中屬性就是對象屬性
  • 注意：
    • 屬性的查找：先從自己的對象中查找，然后在去產生對象的類中取找
      如果使用dict從對象的名稱空間獲取值，找不到會報錯
      使用.獲取值，在自己的名稱空間找不到會取類的名稱空間查找

示例如下

class Student():
    # 初始化
    school = 'SH'

    def __init__(self, name, age,course = None):
        if course is None:
            course = []
        self.name = name  # stu.__dict__['name'] = 'Hammer'
        self.age = age
        self.course = course

    '''注意：return 在這個方法中不能有返回值'''

    # 選課方法
    def choose_course(self, course):
        self.course.append(course)
        print(f"學生{self.name}選課{self.course}")


stu = Student('HammerZe', 18)
'''1.調用類產生一個空對象
   2.調用了Student.__dict__(空對象,'HmmerZe',18)'''

''' 屬性的查找：先從自己的對象中查找，然后在去產生對象的類中取找
        如果使用__dict__從對象的名稱空間獲取值，找不到會報錯
        使用.獲取值，在自己的名稱空間找不到會取類的名稱空間查找
'''
# 類的查找
# 查看名稱空間
print(Student.__dict__)
# 查看值
print(Student.school)  # SH
# 查看方法
print(Student.choose_course)
# 類的增加
Student.country = 'China'
print(Student.__dict__['country']) # China
# 類的修改
Student.school = 'BJ'
print(Student.__dict__['school']) # BJ
# 類的刪除
del Student.school
print(Student.__dict__.get('school')) # None
''' 底層為字典可以用get '''

# 對象的增刪查改
# 查看名稱空間
print(stu.__dict__) # {'name': 'HammerZe', 'age': 18}
# 查看值
print(stu.name) # HammerZe

# 修改值
stu.name = 'Ze'
print(stu.name) # Ze

# 增加值
stu.gender = 'male'
print(stu.__dict__) # {'name': 'Ze', 'age': 18, 'gender': 'male'}

# 刪除值
del stu.gender
print(stu.__dict__) # {'name': 'Ze', 'age': 18}


# 方法的調用
# 類調用
Student.choose_course(stu,'python') # 學生Ze選課['python']
# 對象調用
stu.choose_course('java') # 學生Ze選課['python', 'java']

• 注意：類中的方法，類可以調用，對象也可以調用, 但是，推薦對象來調用，因為對象來調用，會把自己當成第一個參數傳遞給函數

---