第五章---面向過程編程

阿新 • • 發佈：2018-04-26

lse 技術定義函數 utf list dict sch action .com 編寫

編程範式（流派）：
   面向對象編程，面向過程編程 各有用處！！
   編程：語法+數據結構(list dict)+算法(邏輯)

1.面向過程編程：核心是過程二字，過程指得是解決問題的步驟，相當於設計一條流水線，機械式的思維方式

優點：復雜的問題流程化，進而簡單化
缺點：可擴展性差
運用場景：系統監控腳本，自動部署腳本之類的，eg:軟件包解壓安裝（不再需要擴展了）就可以使用面向過程的思維編寫代碼

 1 ‘‘‘
 2 面向過程實例：用戶登錄註冊
 3 第一步：用戶輸入用戶名密碼
 4 第二步：檢查輸入的合法性
 5 第三步：註冊
 6 ‘‘‘
 7 
 8 import 
 json
 9 def interaction(): # 用戶交互函數，用戶用戶輸入用戶名密碼
10     name = input(‘name:‘).strip()
11     pwd = input(‘pwd:‘).strip()
12 
13     return {‘name‘:name,
14              ‘pwd‘:pwd
15             }
16 
17 def check(user_info): # 用戶校驗函數，用戶校驗用戶名密碼的合法性
18     is_legal = True
19 
20     if len(user_info[‘name 
‘]) == 0:
21         print(‘用戶姓名不能為空！‘)
22         is_legal = False
23 
24     if len(user_info[‘pwd‘]) < 6:
25         print(‘用戶密碼不能少於6位！‘)
26         is_legal = False
27     return {‘is_legal‘:is_legal,
28              ‘user_info‘:user_info
29             }
30 
31 def register(check_info): # 註冊
32 
     if check_info[‘is_legal‘]:
33         with open(‘db.json‘,‘w‘,encoding=‘utf-8‘) as f:
34             json.dump(check_info[‘user_info‘],f)
35 
36 def main():
37     user_info = interaction()
38     check_info = check(user_info)
39     register(check_info)
40 
41 if __name__ == ‘__main__‘:
42     main()

2.面向對象：核心就是對象二字，對象就是特征與技能的結合體

  優點：可擴展性強
  缺點：編程復雜度高
  應用場景：用戶需求經常變化，互聯網應用，遊戲，企業內部應用

技術分享圖片

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

在現實世界中：一定是先有對象，後又類
在程序中：一定先定義類，後調用類產生對象

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

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

    對象2：mumu
        特征：
            學校=‘luffycity‘
            名字=‘mumu‘
            性別=‘男‘
            年齡=1
        技能：
            學習
            吃飯
            睡覺

    對象3：zz
        特征：
            學校=‘luffycity‘
            名字=‘zz‘
            性別=‘男‘
            年齡=20
        技能：
            學習
            吃飯
            睡覺

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

        相似的技能
            學習
            吃飯
            睡覺

 1  1 # 先定義類：
 2  2 class LuffyStudengt:
 3  3     school = ‘luffycity‘
 4  4     def learn(self):
 5  5         print(‘is learning‘)
 6  6     def eat(self):
 7  7         print(‘is eating‘)
 8  8     def sleep(self):
 9  9         print(‘is sleepping‘)
10 10 
11 11 # 後產生對象
12 12 stu1 = LuffyStudengt()  # 實例化

3.如何使用類：

先定義類：
特征：變量 school
技能：函數

類和函數的區別：
定義函數只有調用函數名加（）才執行
定義類的時候類的內部代碼都會執行

類的用途：
1.操作它的屬性 增刪改查
2.實例化 產生對象

 1 class LuffyStudengt:
 2     school = ‘luffycity‘  # 數據屬性
 3     
 4     def learn(self):      # 函數屬性
 5         print(‘is learning‘)
 6     def eat(self):     # 函數屬性
 7         print(‘is eating‘)
 8     def sleep(self):    # 函數屬性
 9         print(‘is sleepping‘)
10 
11 # 查看類的名稱空間
12 print(LuffyStudengt.__dict__)
13 print(LuffyStudengt.__dict__[‘school‘])
14 
15 # 查:
16 print(LuffyStudengt.school) # == print(LuffyStudengt.__dict__[‘school‘])
17 
18 # 增：
19 LuffyStudengt.country = ‘China‘
20 print(LuffyStudengt.__dict__)
21 
22 # 刪
23 del LuffyStudengt.country
24 print(LuffyStudengt.__dict__)
25 
26 # 改
27 LuffyStudengt.school = ‘Luffycity‘
28 print(LuffyStudengt.__dict__)

4.__init__方法：

__init__方法用來為對象定制對象自己獨有的特征

__init__實例化對象時會自動調

 1 class LuffyStudengt:
 2     school = ‘luffycity‘
 3 
 4     # stu1,‘mm‘,‘女‘,18
 5     def __init__(self,name,sex,age):
 6         self.Name = name
 7         self.Sex = sex
 8         self.Age = age
 9 
10     def learn(self):
11         print(‘is learning‘)
12     def eat(self):
13         print(‘is eating‘)
14     def sleep(self):
15         print(‘is sleepping‘)
16 
17 # 後產生對象
18 stu1 = LuffyStudengt(‘mm‘,‘女‘,18)  # 實例化
19 
20 # 加上__init__方法後實例化的步驟
21 # 1.先產生一個空對象stu1
22 # 2.LuffyStudent.__init__(stu1,‘mm‘,‘女‘,18)
23 
24 # 查
25 print(stu1.__dict__)
26 print(stu1.Name)
27 
28 # 改：
29 stu1.Name = ‘夢夢‘
30 print(stu1.__dict__)
31 print(stu1.Name)
32 
33 # 刪除：
34 del stu1.Name
35 print(stu1.__dict__)
36 
37 # 增：
38 stu1.classname = ‘python全站開發‘
39 print(stu1.__dict__)
40 
41 stu2=LuffyStudent(‘mumu‘,‘男‘,1) #Luffycity.__init__(stu2,‘mumu‘,‘男‘，1)
42 print(stu2.__dict__)
43 print(stu2.Name)

5.屬性查找與綁定方法：

 1 class LuffyStudengt:
 2     school = ‘luffycity‘
 3 
 4     # stu1,‘mm‘,‘女‘,18
 5     def __init__(self,name,sex,age):
 6         self.Name = name
 7         self.Sex = sex
 8         self.Age = age
 9 
10     def learn(self):
11         print(‘%s is learning‘% self.Name)
12     def eat(self):
13         print(‘%s is eating‘% self.Name)
14     def sleep(self):
15         print(‘%s is sleepping‘% self.Name)
16 
17 # 後產生對象
18 stu1 = LuffyStudengt(‘mm‘,‘女‘,18)  # 實例化
19 stu2 = LuffyStudengt(‘mumu‘,‘男‘,1)
20 stu3 = LuffyStudengt(‘zz‘,‘男‘,20)
21 
22 # 對象：特征和技能的結合體
23 # 類：類是一系列對象相似的特征與相似的技能的結合體
24 
25 # 類中的數據屬性:是所有對象共有的
26 # print(stu1.school,id(stu1.school))
27 # print(stu2.school,id(stu2.school))
28 # print(stu3.school,id(stu3.school))
29 #
30 # # luffycity 6854800
31 # # luffycity 6854800
32 # # luffycity 6854800
33 # 類中的函數屬性:是綁定給對象使用的，綁定到不同的對象是不同的綁定方法
34 # 對象調用綁定方法時，會把對象本身當做第一個參數傳入，傳給self
35 # print(LuffyStudengt.learn)
36 # LuffyStudengt.learn(stu1)
37 
38 # print(stu1.learn)
39 # stu1.learn()
40 # print(stu2.learn)
41 # print(stu3.learn)
42 
43 # 變量查找順序：首先會在對象的名稱空間中找，找不到在去類的名稱空間找，然後去父類的名稱空間找，還找不到就不會去全局找了
44 stu1.x = ‘from stu1‘
45 LuffyStudengt.x = ‘from LuffyStudent‘
46 
47 print(stu1.x)
48 # from stu1

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()

第五章---面向過程編程

lse 技術定義函數 utf list dict sch action .com 編寫編程範式（流派）：面向對象編程，面向過程編程各有用處！！編程：語法+數據結構(list dict)+算法(邏輯)1.面向過程編程：核心是過程二字，過程指得是解決問題的步驟

第五章面向對象編程設計與開發——續

考慮問題系列 [] 有時變量將在說我人類相同 5.1 類、實例、屬性、方法詳解類的語法上面的代碼其實有問題，屬性名字和年齡都寫死了，想傳名字傳不進去。 class Person(object): def __init__(self, name

第五章面向對象編程設計與開發——續3

接口 known 情況 rom 不能新功能 area lse print 5.9——封裝如何隱藏在python中用雙下劃線開頭的方式將屬性隱藏起來（設置成私有的） #其實這僅僅是一種變形操作 #類中所有雙下劃線開頭的名稱如_x都會自動形成：_類名_x的形式： cl

python學習第四節叠代器生成器面向過程編程

break 對象 end 面向過程編程捕捉捕捉異常就會 python學習因此 1：什麽是叠代可以直接作用於for循環的對象統稱為可叠代對象(Iterable)。可以被next()函數調用並不斷返回下一個值的對象稱為叠代器(Iterator

面向過程編程(OPP) 和面向對象編程(OOP)的關系

方法 java 初始需要繼承面向過程 hot 之間以及面向過程編程(OPP) 和面向對象編程(OOP)的關系原文鏈接：http://blog.csdn.net/phphot/article/details/3985480 關於面向過程的編程(OPP)和

Day9：yield的表達式形式、面向過程編程（grep -rl 'root' /etc）

ear blog break 裝飾 sea end col 位置 append 一.yield的表達式 def foo(): print(‘starting‘) while True: x=yield None#return 2

yield的表達式形式、面向過程編程（grep -rl 'root' /etc）

pycha app spa 絕對路徑文件的 printer earch 判斷裝飾器一、yield的表達形式 def foo(): print(‘starting‘) while True: x=yield None#return 2

python基礎之生成器表達式形式、面向過程編程、內置函數部分

[] remove curd fsp mar send 最大限度 rabl ret 生成器表達式形式直接上代碼 1 # yield的表達式形式 2 def foo(): 3 print(‘starting‘) 4 while True: 5

python3 面向過程編程思想，函數綜合應用

return div char pytho user turn n) filepath end 應用：grep -rl ‘root‘ /etc　　實現過濾文件的功能 import os def init(func): def wrapper(*args,**kw

Python 面向過程編程

targe opener 不同 rac ron 協程 traceback 字符 path 一、解釋面向過程：核心是過程二字，過程即解決問題的步驟，基於面向過程去設計程序就像是在設計，流水線式的編程思想，在設計程序時，需要把整個流程設計出來，一條工業流水線，是一種機械式的

.NET第四章Windows窗體編程

bsp 鼠標 smd 示例委托 orm windows 設定 nta 2.創建MDI窗體應用MDI就是多文檔界面，這是因為Excel電子表格用戶有時需要同時操作多份表格，MDI正好為這種操作提供了很大方便要在主窗體上添加子窗體就要先把當前窗體設定為一個MDI窗體的容器（即

Day4 閉包、裝飾器decorator、叠代器與生成器、面向過程編程、三元表達式、列表解析與生成器表達式、序列化與反序列化

反序 bsp pic nbsp tor 序列 space 列表解析列表 http://pic.cnhubei.com/space.php?uid=1774&do=album&id=1362489http://pic.cnhubei.com/space.ph

十三、面向過程編程

思路 with 進入 dex function index bsp text .html 運用上次的 yiled 　　模擬 grep -rl ‘root‘ /etc （遞歸找etc下所有文件並打開，過濾有‘root‘的文件） # import os # g = os.wa

面向對象與面向過程編程

算法面向過程編程代碼底層面向高效率是把一個才會兩種思想的對比：面向過程是具體的東西，而且面向過程是面向對象的基礎。面向對象可以說是面向過程的抽象，比如汽車有開車，加減速和剎車，關於汽車的操作有好多，每一個都需要一個具體的過程來實現，把這些過程抽象的總結起

day5-python之面向過程編程

**kwargs http users 二階可擴展 send filepath with log 一、面向過程編程 #1、首先強調：面向過程編程絕對不是用函數編程這麽簡單，面向過程是一種編程思路、思想，而編程思路是不依賴於具體的語言或語法的。言外之意是即使我們不依賴

python--叠代器、生成器、面向過程編程

except ini fun 對象表達式函數 ood 機械 cat 一、叠代器叠代器的概念 #叠代器即叠代的工具，那什麽是叠代呢？ #叠代是一個重復的過程，每次重復即一次叠代，並且每次叠代的結果都是下一次叠代的初始值 while True： #只是單純的重復，

叠代器、生成器、面向過程編程

-s 返回 odin 解決問題要求元組因此對比 cat 閱讀目錄一叠代器二生成器三面向過程編程一叠代器一叠代的概念 #叠代器即叠代的工具，那什麽是叠代呢？#叠代是一個重復的過程，每次重復即一次叠代，並且每次叠代的結果都是下一

Python函數之面向過程編程

with bject 現在體系輸入機械 int python函數 clas 一、解釋面向過程：核心是過程二字，過程即解決問題的步驟，基於面向過程去設計程序就像是在設計，流水線式的編程思想，在設計程序時，需要把整個流程設計出來，一條工業流水線，是一種機械式的思

Python--面向過程編程

import 用戶註冊 not 復雜 col name 工廠用戶 imp 面向過程編程是Python兩種編程流派的其中一種，另外一種是面向對象編程，這篇博客只討論面向過程編程： 1、概念面向過程的核心是過程二字，過程就是解決問題的步驟，他就像是設計工廠的一條流水線，是一

叠代器和生成器，面向過程編程

ready 索引 tro 必須 bre OS 取值 for循環場景叠代器叠代的工具，叠代是一個重復的過程，並且每次重復都是基於上一次結果而來什麽是可叠代的對象和叠代器對象？在python中，但凡內置有__iter__方法的對象，都是可叠代對象可叠代對象執行__i

第五章---面向過程編程

相關推薦