編程范式（流派）：
面向對象編程，面向過程編程 各有用處！！
編程：語法+數據結構(list dict)+算法(邏輯)
-----------------------------------
1.面向過程編程：核心是過程二字，過程指的是解決問題的步驟，設計一條流水線，機械式的思維方式

優點：復雜的問題流程化，進而簡單化---系統監控腳本，自動部署腳本之類的，eg:軟件包解壓安裝（不再需要擴展了）就可以使用面向過程的思維編寫代碼
缺點：可擴展性差，牽一發而動全身 1 # 注冊 2 import json 3 import re 4 5 def interative(): 6 name = input('>>:').strip() 7 password = input(">>").strip() 8 email = input('>>').strip() 9 return { 10 'name': name, 11 'password': password, 12 'email': email 13 } 14 15 16 def check(user_info): 17 is_valid = True 18 19 if len(user_info['name']) == 0: 20 print('用戶名不能為空') 21 is_valid = False 22 23 if len(user_info['password']) < 6: 24 print('密碼不能少于6位') 25 is_valid = False 26 27 if not re.search(r'@.*\.com$', user_info['email']): 28 print('郵箱格式不合法') 29 is_valid = False 30 31 return { 32 'is_valid': is_valid, 33 'user_info': user_info 34 } 35 36 37 def register(check_info): 38 if check_info['is_valid']: 39 with open('db.json', 'w', encoding='utf-8') as f: 40 json.dump(check_info['user_info'], f) 41 42 43 def main(): 44 user_info = interative() 45 46 check_info = check(user_info) 47 48 register(check_info) 49 50 51 if __name__ == '__main__': 52 main()
2.面向對象編程：核心就是對象二字，對象就是特征與技能的結合體 --站在上帝的角度想問題，一切事物都是對象！ 優點：可擴展性強
缺點：編程復雜度高
應用場景：用戶需求經常變化，互聯網應用，游戲，企業內部應用

類就是一系列對象相似的特征與技能的結合體
強調：站在不同的角度，得到的分類是不一樣的

在現實世界中：一定先有對象，后有類
在程序中：一定得先定義類，后調用類來產生對象

站在路飛學院的角度，大家都是學生

在現實世界中：
對象1：王二丫
特征：
學校='luffycity'
名字='王二丫'
性別='女'
年齡=18
技能：
學習
吃飯
睡覺

對象2：李三炮
特征：
學校='luffycity'
名字='李三炮'
性別='男'
年齡=38
技能：
學習
吃飯
睡覺

對象3：張鐵蛋
特征：
學校='luffycity'
名字='張鐵蛋'
性別='男'
年齡=48
技能：
學習
吃飯
睡覺

總結現實中路飛學院的學生類：
相似的特征
學校='luffycity'

相似的技能
學習
吃飯
睡覺 1 # 先定義類： 2 class LuffyStudent: 3 school = 'luffycity' 4 5 def learn(self): 6 print('is learning') 7 8 def eat(self): 9 print('is eatting') 10 11 # 后產生對象 12 stu1 = LuffyStudent 13 stu2 = LuffyStudent() 14 stu3 = LuffyStudent() 15 16 print(stu1) 17 print(stu2) 18 print(stu3) 3.如何使用類
類是定義就運行
函數是調用才運行

類的用途：
1.操作它的屬性 增刪改查
2.實例化 產生對象 1 class LuffyStudent: 2 school='luffycity' # 數據屬性 3 4 def learn(self): # 函數屬性 5 print('is learning') 6 7 def eat(self): # 函數屬性 8 print('is sleeping') 9 # print('---') # 類是定義，就運行 10 11 #查看類的名稱空間 12 # print(LuffyStudent.__dict__) 13 # print(LuffyStudent.__dict__['school']) 14 # print(LuffyStudent.__dict__['learn']) 15 16 #查 17 # print(LuffyStudent.school) 18 # print(LuffyStudent.learn) 19 20 #增 21 LuffyStudent.country = 'china' 22 print(LuffyStudent.__dict__) 23 # print(LuffyStudent.country) 24 25 #刪 26 del LuffyStudent.country 27 print(LuffyStudent.__dict__) 28 29 #改 30 LuffyStudent.school = 'LuffyCity' 31 print(LuffyStudent.__dict__)
4.__init__方法
__init__方法用來為對象定制對象自己獨有的特征
__init__實例化對象時會自動調 1 class LuffyStudent: 2 school = 'luffycity' 3 4 def __init__(self,name,sex,age): 5 self.Name=name 6 self.Sex=sex 7 self.Age=age 8 9 def learn(self): 10 print('is learning') 11 12 def eat(self): 13 print('is eatting') 14 15 # 后產生對象 16 stu1 = LuffyStudent('alice','女',18) 17 18 #加上__init__方法后，實例化的步驟 19 #1.先產生一個空對象stu1 20 #2.觸發函數 LuffyStudent.__init__(stu1,name,sex,age) 21 22 #查 23 # print(stu1.__dict__) 24 # print(stu1.Name) 25 # print(stu1.Age) 26 27 #改 28 stu1.Name = 'alex' 29 print(stu1.__dict__) 30 print(stu1.Name) 31 32 #刪 33 del stu1.Name 34 print(stu1.__dict__) 35 36 #增 37 stu1.class_name = 'python開發' 38 print(stu1.__dict__) 39 40 stu2 = LuffyStudent('lily','男',30) # Luffycity.__init__(stu2,'lily','男'，30) 41 print(stu2.__dict__) 42 print(stu2.Name) 5.屬性查找
1 # x = 'global' 2 class LuffyStudent: 3 school = 'luffycity' 4 5 def __init__(self,name,sex,age): 6 self.Name=name 7 self.Sex=sex 8 self.Age=age 9 10 def learn(self,x): 11 print('%s,%s is learning' % (self.Name,x)) 12 13 def eat(self): 14 print('%s is eatting' % self.Name) 15 16 # 后產生對象 17 stu1 = LuffyStudent('alice','女',18) 18 stu2 = LuffyStudent('alex','男',38) 19 stu3 = LuffyStudent('lily','男',40) 20 # print(stu1.__dict__) 21 # print(stu2.__dict__) 22 # print(stu3.__dict__) 23 24 # 對象：特征與技能的結合體 25 # 類：類是一系列對象相似的特征與相似的技能的結合體 26 27 # 類中的數據屬性：是所有對象共有的 28 # print(LuffyStudent.school) 29 # 30 # print(stu1.school,id(stu1.school)) 31 # print(stu2.school,id(stu2.school)) 32 # print(stu3.school,id(stu3.school)) 33 34 # 類中的函數屬性:是綁定給對象使用的，綁定到不同的對象是不同的綁定方法，對象調用綁定方法時,會把對象本身當作第一個傳入，傳給self 35 # print(LuffyStudent.learn) 36 # LuffyStudent.learn(stu1) 37 # LuffyStudent.learn(stu2) 38 # LuffyStudent.learn(stu3) 39 40 # print(stu1.learn) 41 # stu1.learn(1) #learn(stu1,4) 42 # print(stu2.learn) 43 # print(stu3.learn) 44 45 # stu2.learn(2) 46 # stu3.learn(3) 47 48 # 屬性查找，對象會在自己內部找 --》類中找--》父類找--》不會去全局找 49 # stu1.x = 'form stu1' 50 # LuffyStudent.x = 'from LuffyCity class ' 51 # print(LuffyStudent.__dict__) 52 # print(stu1.__dict__) 53 # print(stu1.x) 6.補充知識 1.站的角度不同，定義出的類是截然不同的；
2.現實中的類并不完全等于程序中的類，比如現實中的公司類，在程序中有時需要拆分成部門類，業務類等；
3.有時為了編程需求，程序中也可能會定義現實中不存在的類，比如策略類，現實中并不存在，但是在程序中卻是一個很常見的類。

4.python 一切皆對象，在python3里統一了類與類型（list dict）的概念 1 # print(type([1,2])) 2 # print(list) 3 class LuffyStudent: 4 school = 'luffycity' 5 6 def __init__(self,name,sex,age): 7 self.Name=name 8 self.Sex=sex 9 self.Age=age 10 11 def learn(self,x): 12 print('%s,%s is learning' % (self.Name,x)) 13 14 def eat(self): 15 print('%s is eatting' % self.Name) 16 # print(LuffyStudent) 17 18 li1 = [1,2,3] # li = list(1,2,3) # list 對象 19 li1.append(4) # 對象在調自己的綁定方法 # list.append(li1,4) 20 # list.append(li1,4) # 類中的方法 是給 對象用的 21 print(li1) 7.可擴展性高 1 class Chinese: 2 country = 'China' 3 def __init__(self,name,age,sex): 4 self.name=name 5 self.age=age 6 self.sex=sex 7 def eat(self): 8 print('%s is eating' % self.name) 9 10 p1 = Chinese('alice',19,'女') 11 p2 = Chinese('alex',22,'男') 12 13 print(p1.name,p1.country) 14 print(p2.name,p2.country) 15 p1.eat() 16 p2.eat()

轉載于:https://www.cnblogs.com/alice-bj/p/8530411.html

總結

以上是生活随笔為你收集整理的面向对象 - 1.面向过程/2.面向对象/3.如何使用类/4.__init__方法/5.属性查找/6.补充知识/7.可扩展性高...的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。