文章目錄

• 尚硅谷Python自學筆記
• • 計算基礎知識
  • • 進制
    • 文本文件和字符集
  • Python介紹
  • Python入門
  • • Pytho基本語法
    • 數值
    • 字符串
    • 對象（Object）
    • 對象的結構
    • 算數運算符
  • 條件判斷語句
  • • if語句
    • input()函數
    • break和continue
    • 質數練習
  • 游戲練習 唐僧大戰白骨精
  • 列表
  • • 切片
    • 通用操作
    • 序列
    • 修改元素
    • 列表的方法
    • rang
    • 元組
    • ==和!= is和is not
  • EMS員工管理系統練習
  • 字典
  • 集合
  • 函數
  • • 實參的傳遞方式
    • 不定長參數
    • 參數的解包
    • 返回值
    • 文檔字符串
    • 作用域和命名空間
    • 遞歸
    • 高級函數和匿名函數
    • 閉包
    • 裝飾器
  • 對象（Object）
  • • 類（class）
    • 類的定義
    • 對象的初始化
    • 封裝
    • 模塊、包
  • 異常和文件

尚硅谷Python自學筆記

03_尚硅谷_命令行簡介_嗶哩嗶哩_bilibili

計算基礎知識

win+R 打開命令窗

常用DOS命令

cd Desktop //進入桌面目錄. //表示本目錄.. //表示上一級目錄 d: //更改盤符 dir //查看當前目錄下所有文件 md hello //創建一個目錄（文件夾） rd hello //刪除一個目錄 del abc.txt //刪除文件 cls //清除命令行

path環境變量

保存的是一個一個路徑

當我們在命令行輸入一個命令（或訪問一個文件時）

系統會首先在當前目錄下尋找，如果找到了則直接執行或者打開，如果沒有找到，則會依次去path環境變量的路徑中去尋找，直到找到為止。如果path環境變量中的路徑都沒有找到，則報錯。

可以將經常訪問的文件或者程序的路徑添加到path環境變量中，這樣我們就可以在任意的位置訪問這些文件了。

進制

十進制

二進制

內存中每一個小格子，我們成為1bit（位）

bit是計算機中的最小單位

byte是我們最小的可操作的單位

8bit=1byte（字節）

1024byte=1kb（千字節）

1024kb=1mb（兆字節）

1024mb=1gb（吉字節）

1024gb=1tb（太字節）

八進制

十六進制

滿十六進一

0 1 2 3…9 a b c d e f

我們在查看二進制時，一般顯示未十六進制

文本文件和字符集

文本分為兩種，純文本和富文本

純文本中只能保存單一的文本內容，無法保存內容無關的東西（字體、顏色、圖片等）

富文本可以保存文本以外的內容（word文檔）

開發時，編寫程序使用的全都是純文本

純文本在計算機底層也會轉換為二進制保存，

將字符轉換為二進制碼的過程，稱為編碼

將二進制轉換為字符的過程，稱為解碼

編碼和解碼時所采用的規則，稱為字符集

常見的字符集

ASCII 美國人編碼，使用7位對美國常用的字符編碼 128字符

ISO-8859-1 歐洲的編碼，使用8位 256字符

GB2312 國標編碼，

GBK 國標編碼

Unicode 萬國編碼，包含世界上所有的語言和符號編寫程序時一般都是用Unicode 包含UTF-8、UTF-16、UTF-32

編寫程序時，如果程序代碼出現亂碼的情況，就要馬上去檢查字符集是否正確

Python介紹

計算機語言發展

機器語言→匯編語言→高級語言

根據轉換時機的不同，語言分成兩大類:

編譯型語言

C語言

會在代碼執行前將代碼編譯為機器碼，然后將機器碼交由計算機執行

特點：執行速度快 跨平臺能力差

解釋型語言

Python Java

執行的同時一邊執行一邊解釋

特點：執行速度慢 跨平臺能力好

Python 的用途

Web應用 爬蟲程序 科學計算 自動化運維 大數據 云計算 桌面軟件 人工智能

語言使用排名TIOBE Index - TIOBE

Python入門

Pytho基本語法

嚴格區分大小寫

每一行就是一條語句，以換行結束（區別于Java的；）

一條語句多行可加‘\’

嚴格縮進

用‘#’單行注釋

使用變量不需要申明，直接賦值

數值

整數、浮點數（小數）、復數

整數沒有大小限制，如果數字過長可用__分開

十進制不能以0開頭

二進制 0b開頭

八進制 0o開頭

十六進制 0x開頭

對浮點數運算時，結果可能不精確

字符串

相同引號之間不能嵌套

單雙引號不能跨行使用

三重引號表示一個長字符，可以跨行使用，并保留引號內格式

轉義字符

可以使用‘\’作為轉義字符

‘表示’

\n表示換行

\uxxxx 表示Unicode編碼

可用type（）檢查字符類型

對象（Object）

Python是一門面向對象的語言

程序運行當中，所有數據都是存儲到內存當中然后在運行的

對象就是內存中專門用來存儲指定數據的區域

對象實際上就是一個容器，專門用來存儲數據

對象的結構

每個對象中都要保存三種數據

id

用來標識對象的唯一性可通過id（）函數查看對象的id

type

用來標識當前對象的類型類型決定對象有哪些功能Python是一門強類型的語言，對象一旦創建類型便不能修改

value

值就是對象中存儲的具體數據對于有些對象值可以改變對象分為兩大類 可變對象 不可變對象

算數運算符

//整除

**冪運算

%取模

條件判斷語句

邏輯詞

and or

條件可以連寫（Python特有）

if 10<num<20:print(11)

if語句

默認情況下if語句只會控制緊隨其后的那條語句，如果希望if控制多條語句，則可以在if后跟著一個代碼塊

if num > 10:print('num比10大')

代碼塊中保存著一組代碼，同一個代碼塊中的代碼，要么都執行要么都不執行

代碼塊就是一種為代碼分組的機制

如果要編寫代碼塊，語句就不能緊隨：后面，而要寫在下一行

代碼塊以縮進開始，直到代碼恢復到之前的縮進級別時結束

if True:print(11)print(22) elis ***:pass else:pass print(結束)

input()函數

函數調用后，程序會立即暫停，等待用戶輸入

用戶輸入完內容以后，點擊回車程序才會繼續向下執行

用戶輸入完成以后，其所輸入的內容會以返回值的形式返回

input（）的返回值是一個字符串

input（）函數中可以設置一個字符串作為參數，這個字符串會作為提示文字顯示

a = input('請輸入內容：‘) print('用戶輸入的內容為：’,a)

input()也可用于暫時阻止程序結束

break和continue

break可以用來立即退出循環語句（包括else）

continue可以用來跳出當次循環

兩者都是只對最近的循環起作用

質數練習

i = 2 while i <= 100:flag = Truej = 2while j < 1:if i % j == 0:flag = Falsej += 1if flag:print(i)i += 1

第一次優化（使用break）

from time import * begin = time()i = 2 while i <= 100:flag = Truej = 2while j < 1:if i % j == 0:flag = Falsebreak#一旦進入判斷，則證明i一定不是質數，此時內層循環沒有繼續執行的必要#使用break來退出內層循環j += 1if flag:print(i)i += 1end = time() print("程序花費了：",end - begin,"秒")

第二次優化（優化計算范圍）

from time import * begin = time()i = 2 while i <= 100:flag = Truej = 2while j <= 1 ** 0.5: #只需要計算到根號i #因數成對出現，前面沒有后面也沒有if i % j == 0:flag = Falsebreakj += 1if flag:print(i)i += 1end = time() print("程序花費了：",end - begin,"秒")

游戲練習 唐僧大戰白骨精

#身份選擇 print("-"*20,"歡迎來到游戲《唐僧大戰白骨精》","-"*20) print("請選擇你的身份：") print(" 1、唐僧") print(" 2、白骨精") id = input("請選擇[1-2]:") print('-'*80) if id == '1':#input（）函數都為字符型，判斷需要加單引號pass elif id == '2':print("你居然選擇了白骨精！系統自動分配你以唐僧的身份游玩") else:print("系統自動分配唐僧的身份游戲")#游戲部分 player_life = 2 player_attack = 2boss_life = 10 boss_attack = 4 print("你的身份是唐僧,攻擊力為",player_attack,'生命力為',player_life) print('-'*80) while boss_life > 0 and player_life > 0:print('請選擇你要進行的操作：')print('\t1、練級')print('\t2、打Boss')print('\t3、逃跑')player_choose = input('請選擇[1-3]')if player_choose == '1':player_attack += 2player_life += 2print("你的身份是唐僧,攻擊力為",player_attack,'生命力為',player_life)print('-'*80)elif player_choose == '2':boss_life = boss_life - player_attackplayer_life = player_life - boss_attackprint("你的身份是唐僧,攻擊力為",player_attack,'生命力為',player_life)print('白骨精生命力為',boss_life)print('-'*80)elif player_choose == '3':breakelse:print('輸入錯誤，請重新選擇')print('-'*80)if boss_life <= 0:print('你打敗了白骨精') elif player_life <= 0:print('你被白骨精抓了') else:print('逃跑成功')

列表

通過[]創建列表

列表存儲的數據，稱之為元素

一個列表中可以存儲多個元素，也可以在創建列表時，來指定列表中的元素

列表中可以保存任意的對象

列表中的對象都會按照插入的順序存儲到列表中

可以通過索引index來獲取列表中的元素

索引是元素在列表中的位置，列表中每一個元素都有一個索引

索引是從0開始的整數

如果使用的索引超過了最大的范圍，會拋出異常

my_list = [10,'hello',True,None,[1,2],print]print(my_list[4])#索引#獲取長度 t = len(my_list)

切片

Python的索引可以是負數

如果索引是負數，則從后向前獲取元素，-1表示倒數第一個

通過切片來獲取指定的元素

語法：列表[起始:結束]

通過切片獲取指定元素時，會包括起始位置的元素，不包括結束位置的元素

做切片操作時，總會返回一個新的列表，不會影響原來的列表

起始和結束位置的索引都可以省略不寫

如果省略起始位置，則會從第一個元素開始截取

如果省略結束位置，則會一直截取到最后

如果起始和結束都省略，則相當于創建一個列表的副本

stus = ['孫悟空','豬八戒','沙和尚','唐僧'] print(stus[0:2])print(stus[:3]) print(stus[1:]) print(stus[:])

語法：列表[起始：結束：步長]

步長表示：每次獲取元素的間隔，默認值為1

步長不能為0，但是可為負數

如果是負數，則會從列表的后部向前獲取元素

通用操作

+和*

in和 not in

in可以用來檢查指定元素是否在列表中

如果存在返回True，否則返回False

not in相反

min()和max()

print('牛魔上' in stus)min() max() s.index() s.count()

方法

s.index(‘牛魔上’,3,7) 獲取指定元素在列表中第一次出現的索引

第二個參數’3’表示查找的起始位置 '7’表示查找的結束位置 包括起始，不包括結束

s.count() 統計指定元素在列表中出現的次數

方法和函數基本上是一樣的，只不過方法必須通過對象.方法（）的形式調用

序列

序列是Python中最基本的一種數據結構

分類：

可變序列（序列中的元素可以改變）列表（list）不可變序列（元素不可改變）字符串（str）元組（tuple）

修改元素

直接通過索引來修改元素

通過del來刪除元素

通過切片來修改列表（在給切片賦值時，只能使用序列）

stus[0:0] = '牛魔王' #向0位置前插入新元素

設置步長時，序列中元素個數要和切片中一致

只能修改可變序列中的元素

不可變序列只能通過其他列表轉換

列表的方法

s.append() 往列表最后插入新元素

s.insert(3,‘唐僧’) 往指定位置插入元素

s.extend() 往列表最后加入多個新元素 相當于+

for s in stus:print(s)

rang

rang()是一個函數，可以用來生成一個自然數序列

該函數需要三個參數

起始位置（可以省略，默認是0）

結束位置

步長（可以省略，默認為1）

通過rang（）可以創建一個指定執行次數的for循環

r = rang(5) #生成序列[0,1,2,3,4]

for i in rang(20):print(i)

元組

元組是一個不可變序列

操作基本和列表一致

當希望數據不改變時，一般使用元組

當元組不是空元組時，括號可以省略

my_tuple = () my_tuple = 10,20,30

交換a、b的值可以利用元組的解包

區別于其他語言，不需要利用第三方變量

在對一個元組解包時，變量的數量必須和元組中元素數量一致

也可以在變量前邊添加一個*，這樣變量將會獲取元組中所有剩余元素

不能同時出現兩個及以上的*變量

a,b = b,amy_tuple = 10,20,30,40 a,*b,c = my_tuple

==和!= is和is not

==和！= 比較的是對象的值是否相等

is和is not 比較的是對象的id是否相等

EMS員工管理系統練習

做命令行版本的員工管理系統

功能

1、查詢顯示當前系統中所有員工2、添加將員工添加到當前系統中3、刪除將員工從系統中刪除4、退出退出系統 from time import *#歡迎界面 print('='*20,'歡迎來到EMS員工管理系統','='*20) begin_time = time() print('開始時間為：',begin_time,'秒') #創建用戶列表 emps = [] while True:#功能界面print('功能：')print('\t1、查看員工信息')print('\t2、添加員工信息')print('\t3、刪除員工信息')print('\t4、退出系統')play_choose = input('請選擇[1-4]：')if play_choose == '1':#查看員工信息print('\t序號\t姓名\t年齡\t性別\t住址')#顯示信息n = 1for emp in emps:print(f'\t{n}\t{emp}')n += 1elif play_choose == '2':#添加員工信息name = input('請輸入員工姓名：')age = input('請輸入員工年齡：')sex = input('請輸入員工性別：')address = input('請輸入員工住址：')#用戶確認print('您將添加員工：',name,' ',age,' ',sex,' ',address)judge = input('確認添加請按[Y]:')if judge == 'Y' or judge == 'y':emp = f'{name}\t{age}\t{sex}\t{address}'emps.append(emp)print('添加成功')else:print('添加失敗')elif play_choose == '3':#刪除員工信息del_num = int(input('請輸入要刪除的員工序號：'))#判斷if del_num <= len(emps):#顯示被刪員工信息del_index = del_num -1print('以下員工將被刪除')print('\t序號\t姓名\t年齡\t性別\t住址')print(f'\t{del_num}\t{emps[del_index]}')judge = input('確認刪除請輸入[Y]')if judge == 'Y' or judge == 'y':emps.pop(del_index)print('刪除成功')else:print('刪除失敗')else:print('序號輸入錯誤')elif play_choose == '4':#退出print('感謝您的使用！')end_time = time()print('程序運行時間為：',begin_time - end_time,'秒')input('點擊回車確認退出')breakelse:#用戶選擇錯誤print('選擇錯誤，請重新選擇')end_time = time()print('程序運行時間為：',begin_time - end_time,'秒')print('='*90)

字典

字典屬于新的數據結構，稱之為映射（mapping）

字典的作用和列表類似，都是用來存儲對象的容器

列表存儲數據的性能很好，但是查詢數據的性能很差

在字典中每一個元素都有一個唯一的名字，通過這個唯一的名字可以快速的查找指定元素

在查詢元素時，字典的效率非常高

在字典中可以保存多個對象，每個對象都有唯一一個名字

這個唯一的名字，我們稱之為鍵（key），通過key可以快速查詢value

這個對象，我們稱其為值（value）

所以字典，我們也稱為鍵值對（key-value）結構

每個字典中可以有多個鍵值對，每一個鍵值對稱為項（item）

d = {'name':'孫悟空','age':18}

使用{}來創建字典

字典的值可以是任意對象

字典的鍵必須是不可變對象(int、str、bool、tuple等)

字典的鍵不能重復，如果重復后邊就會替換前面的

dict() #創建字典 in() #判斷元素是否在字典中 d.update() #將其他字典中的鍵值對添加到當前字典 del d[] #刪除 d.popitem() #一般刪除最后一個鍵值對 會將刪除的鍵值對以元組返回 d.pop() #根據key刪除鍵值對 有返回值 d.clear() #清除字典 d.copy() #對字典淺復制 復制以后的對象和原對象使獨立的 如果值是一個可變對象 這個對象則不會被復制

字典的遍歷

key() 該方法返回字典的所有key

values（） 該方法返回一個序列，序列中保存字典的值

iteams（） 該方法返回字典中所有的項 會返回一個序列 序列中包含雙值子序列

for k in d.keys():print(k,d[k])for v in d.values():print(v)for k,v in d.items():print(k,'=',v)

集合

集合只能存儲不可變對象

集合中存儲的對象是無序的（不是按照元素的插入順序保存）

集合中不能出現重復的元素

result = s1 & s2 //集合的交集 result = s1 | s2 //并集 result = s1 - s2 //差集 只在s1有，s2沒有 result = s1 ^ s2 //異或集 result = s1 <= s2 //檢查s1是否是s2的子集

函數

函數也是一個對象

對象是內存中專門存儲數據的一塊區域

函數可以用來保存一些可執行的代碼，并且可以在需要時，對這些語句進行多次的調用

創建函數

def 函數名（）：

代碼塊

函數名必須要符合標識符的規范（不能以數字開頭）

函數中保存的代碼不會立即執行，需要調用函數代碼才會執行

定義函數一般都是要實行某種功能

函數的參數

在定義函數時，可以在函數（）中定義數量不等的形參

形參–定義形參就相當于在函數內部聲明了變量，但是并不賦值

實參–如果函數定義時，指定了形參，那么在調用函數時也必須傳遞實參

實參將會賦值給相應的形參

定義形參時可以指定默認值，如果用戶傳遞實參則默認值無效，否則默認值生效

def fn(a,b=20):print('a+b=',a+b)fn(2,3)

實參的傳遞方式

實參可以傳遞任意類型

位置參數

位置參數就是將對應位置的實參賦值給對應的形參

關鍵字參數

可以不按照形參定義的順序去傳遞，而根據參數名去傳遞參數

位置參數和關鍵字參數可以混合使用,位置參數須寫在前面

fn(1,c=20,b=11)

在函數中對形參進行重新賦值，不會影響其他變量

如果形參執行的是一個對象，當我們通過形參去修改對象時會影響到所有指向該對象的變量

若想使函數內外可變對象獨立，可傳遞對象副本（copy或者切片）

不定長參數

在定義函數時，可以在形參前邊加上*，這樣這個形參將會獲取到所有實參

它將會保存所有實參到一個元組中

eg：定義一個函數，可以求任意個數字的和

def sum(*a):result = 0for n in a:result += nprint('和為：',result)sum(123,321)

帶*的形參只能有一個，且只能接受位置參數

可以和其他參數配合使用

可變參數不一定要寫在最后，但后面的所有參數，必須以關鍵字參數的形式傳遞

def fn(a,*b,c):print(a)print(b)print(c)fn(1,2,3,4,c=5)

**形參可以接收其他的關鍵字參數，它會將這些參數統一保存到一個字典中

字典的key就是參數的名字，字典的value就是參數的值

**形參只能有一個，必須寫在所有參數的最后

def fn(a,b,**c)passfn(b=3,a=2,c=4,d=5)

參數的解包

傳遞實參時，可以在序列類型的參數前添加*，這樣會自動將序列中的元素依次作為參數傳遞

這里要求序列中元素的個數必須和形參的個數一致

#創建一個元組 t = (10,2,20,30)fn(*t)#創建一個字典 d = {'a':100,'b':200,'c':300}fn(**d)

返回值

return后面跟什么值，函數就會返回什么值

后面可以跟任意的對象，返回值甚至可以是一個函數

def fn(*a):result = 0for n in a:result += nruturn resultprint(result)

文檔字符串

通過help()函數可以查詢Python中函數的用法

語法：help(函數對象)

文檔字符串（doc str）

在定義函數時，可以在函數內部編寫文檔字符串，文檔字符串就是函數的說明

在函數第一行寫一個字符串就是文檔字符串

def fn(a:int,b:str):'''這是一個文檔字符串的事例函數的作用：。。。。函數的參數：a,作用,類型。。。b，作用，類型。。。。'''return 10help(fn)

作用域和命名空間

在函數中為變量賦值時，默認都是為局部變量賦值

如果希望在函數內部修改全局變量，則需要使用global關鍵字，來聲明變量

命名空間（namespace）

指的是變量存儲的位置，每一個變量都需要存儲到指定的空間當中

每一個作用域都會有一個對應的命名空間

命名空間實際就是一個字典，是一個專門用來存儲變量的字典

locals（）用來獲取當前作用域的命名空間

遞歸

將一個大問題分解為一個個小問題，直到問題無法分解，再去解決問題

遞歸函數的兩個條件

1、基線條件問題可以被分解為的最小問題，當滿足基線條件時，遞歸就不再執行2、遞歸條件將問題繼續分解的條件 def factorial(n):if n == 1:return 1return n * factorial(n-1)

高級函數和匿名函數

filter（）

可以從序列中過濾出符合條件的元素，保存到一個新序列中

參數：

1、函數，根據該函數來過濾序列（可迭代的結構）2、需要過濾的序列（可迭代的結構）

返回值：

過濾后的新序列（可迭代結構）

匿名函數lambda（）函數表達式

專門用來創建一些簡單的函數，是函數創建的另一種方式語法：lambda 參數列表：返回值 def fn(i):return i%3 == 0 #等價于lambda i:i % 3 == 0l = [1,2,3,4,5,6,7,8,9] r = filter(lambda i:i % 3 == 0,l) print(list(r))

map()

可以對可迭代對象中的所有元素做指定的操作，然后將其添加到一個新的的對象中返回

l = [1,2,3,4,5,6,7,8,9] r = map(lambda i:i ** 2,l) print(list(r))

sort()

該方法用來對列表中的元素進行排序

默認直接比較列表中的元素的大小

可以接收一個關鍵字參數，key

key需要一個函數作為參數，當設置了函數作為參數每次都會以列表中的一個元素作為參數調用函數，并且使用函數的返回值來比較元素的大小

sorted（）

可以對任意的序列進行排序

不會影響原來的對象，而是返回一個新對象

閉包

形成閉包的要件

函數嵌套

將內部函數作為返回值返回

內部函數必須要使用到外部函數的變量

防止一些數據處于全局作用域被隨意修改，放到函數中保護起來，形成閉包

裝飾器

通過裝飾器，可以在不修改原來函數的情況下對函數進行擴展

在開發中，通常通過裝飾器來擴展函數的功能

def begin_end(old(*args,**kwargs)):def new_function(*args,**kwargs):print('開始執行')result = old(*args,**kwargs)print('執行結束')return resultreturn new_function#用法一 f = begin_end(fn) f()#用法二 @begin_end def fn():pass

對象（Object）

類（class）

• 內置對象并不能滿足所有需求，所以在開發中經常需要自定義一些對象

• 也稱對象為類的實例（instance）

• 如果多個對象是通過一個類創建的，我們稱這些對象是一類對象

• 如int（），float（），bool（）等這些都是類

• 自定義的類都需要使用大寫字母開頭，使用駝峰法命名

• 類也是一個對象

• 類就是用來創建對象的對象

• 類是type類型的對象，定義類實際就是定義了一個type類型的對象

語法：

class 類名（[父類]）:

公共屬性def \_\_init\__(self,....):pass方法

• 可以向對象中添加變量，對象中的變量稱為屬性

• 語法：對象.屬性名 = 屬性值

• 使用類創建對象的流程

  • 1、創建一個變量

  • 2、在內存中創建一個新對象

  • 3、給對象的id賦值給變量

class MyClass():passmc = MyClass() mc.name = '孫悟空'

類的定義

• 1、數據（屬性）

• 2、行為（方法）

• 在類的代碼塊中，我們可以定義變量和函數

  • 變量會成為該類實例的公共屬性，所有該類實例都可以通過對象.屬性名的形式訪問

  • 函數會成為該類實例的公共方法，所有該類實例都可以通過對象.方法名（）的形式調用

方法調用時，第一個參數由解析器自動傳遞，所以定義方法時，至少要定義一個形參

• 類中定義的屬性和方法都是公共的，任何該類實例都可以訪問

• • 屬性和方法查找的流程：

  • 當我們調用一個對象的屬性時，解析器會先在當前對象中尋找是否含有該屬性

  • 如果有則直接返回當前的對象的屬性值

  • 沒有則去當前對象的類對象中尋找

• 類對象和實例對象中都可以保存屬性（方法）

  • 如果這個屬性（方法）是所有實例共享的，則應該保存到類對象中

  • 如果這個屬性（方法）時某個實例獨有的，則應該保存到實例對象中

• 一般情況下，屬性保存到實例對象中，方法需要保存到類對象中

對象的初始化

• 在類中可以定義一些特殊方法（魔術方法）

  • 特殊方法都是以__開頭，__結尾的方法

  • 特殊方法不需要自己調用

• 學習特殊方法：

  • 1、特殊方法什么時候調用

    • 在對象創建以后立刻調用

  • 2、特殊方法有什么作用

    • 可以用來向新創建的對象中初始化屬性

封裝

封裝是面向對象的三大特性之一

指的是：隱藏對象中一些不希望被外部所訪問到的屬性和方法

• 如何隱藏一個對象中的屬性（防君子不防小人）

  • 將對象的屬性名，修改為一個外部不知道的名字

• 如何獲取（修改）對象中的屬性

  • 需要提供getter和setter方法使外部可以訪問到屬性

  • getter獲取對象中的指定屬性（get_屬性名）

  • setter用來設置對象的指定屬性（set_屬性名）

• 使用封裝，增加了類的定義的復雜程度，但是它也確保了數據的安全性

  • 1、隱藏了屬性名，使調用者無法隨意的修改對象中的屬性

  • 2、增加了getter和setter方法，很好的控制了屬性是否是只讀

    • 如果希望屬性是只讀的，則可以直接去掉setter方法

    • 如果希望屬性不能被外部訪問，則可以直接去掉getter方法

  • 3、使用setter方法設置屬性，可以增加數據的驗證，確保數據的值是正確的

  • 4、使用getter和setter方法可以在讀取（修改）屬性的同時做一些其他處理

• __開頭的屬性是隱藏屬性，無法通過對象訪問

• 使用__開頭的屬性實際上依然可以在外部訪問，所以這種方式我們一般不用

  • 一般會將私有屬性（不希望被外部訪問的屬性）以_開頭

模塊、包

• 在一個模塊中引入外部模塊

• 1、import 模塊名

• 2、import 模塊名 as 別名

  • 在每一個人模塊內部都有一個__name__屬性，通過這個屬性可以獲取到模塊名字

  • 當name屬性值為main時，該模塊為主模塊，一個程序只會有一個主模塊

異常和文件

try:

代碼塊（可能出錯的代碼）

except：

代碼塊（出錯后處理的方式）

else：

代碼塊（沒出錯時要執行的語句）

文件

• 調用open（）來打開一個文件，可以將文件分成兩種類型

  • 一種，是純文本文件（utf-8等）

  • 一種，是二進制文件（圖片、mp3等）

處理文本文件時，必須指定文件的編碼

• 通過read（）來讀取文件中的內容

• 如果直接調用read（）它會將文本文件的所有內容全部讀取出來

  • read（）可以接收一個size作為參數，默認值為-1

  • 每一次讀取都是從上次讀取到的位置開始讀取

read() readline() readlines()seek() #修改當前讀取位置 tell() #查看當前讀取位置

總結

以上是生活随笔為你收集整理的尚硅谷Python自学笔记的全部內容，希望文章能夠幫你解決所遇到的問題。

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