定義函數

def function(a,b): 函數名function，參數a和b
注意縮進

函數默認參數

• 一般使用情況：

def function(x,y,z):print(x+y+z)function(100,200,300) # 600

• 默認參數：

這時將x，y，z都設置默認參數：字符串1，2，3。 當然，如果不想使用默認參數，函數調用時重新賦值即可

def function(x='1',y='2',z='3'):print(x+y+z)function() #123 function('2','3','4') #234

• 注意：
  如果未提前定義的參數在已提前定義的參數后面，則會報錯：
  
  紅色的定義是提前默認的參數，y是沒有提前定義的參數
  所以會報錯：非默認參數緊跟在默認參數之后（non-default argument follows default argument）

想要默認定義的參數都放在后面

定義全局變量

global a : 定義一個全局變量a，但是不能直接global a=111

而是要

a=None def fun ():global aa=111print('past a :',a) fun() #經過函數內部賦值 print('new a :',a)

看似是在函數里面定義一個全局變量，其實是對函數里面的變量進行全局化（因為即使內部聲明了a，仍需要在全局先聲明）才能在外部使用。

安裝外部模塊

cmd中輸入pip install numpy
或者
pycharm中設置->Python解釋器->添加第三方庫

文件的讀寫

使用open( )函數：具體參數意義可見： https://www.runoob.com/python/python-func-open.html

創建文件

text='this is my first file\nthis is next line' my_file=open('my file.txt','w') #起名my file，僅寫入 my_file.write(text) #把上面的text寫入文件 my_file.close() #關閉文件

在我們存py文件的路徑下便有了

修改（追加）文件

append_text='\nappend contain' my_file=open('my file.txt','a') #append追加 my_file.write(append_text) my_file.close()

讀取文件

file=open('my file.txt','r') #read讀取文件到file content=file.read() #對file讀取，賦給content print(content)

讀取每一行存為list

file=open('my file.txt','r') #read讀取文件到file content=file.readlines() #用readlines()方法，把file的每一行放進列表list print(content)

把每一行存進list

當然，既然在list里面，那我們就可以用for-in將每句話輸出：

for i in content:print(i)

一行一行讀取

使用readline（）方法，對同一個文件：第一次使用時讀取第一行，第二次使用時讀取第二行。
且讀取的類型是str

file=open('my file.txt','r') #read讀取文件到file content1=file.readline() #把file的第一行，以字符串類型賦值給content1 content2=file.readline() #把file的第二行，以字符串類型賦值給content2 print(content1) print(content2) print(type(content1))

class類

class Abc: 聲明一個名為Abc的類(命名的首字母通常是大寫)

self是指向class實例的this指針，可以用來調用類的屬性或者方法。若類的內部要相互調用的話，也用self定位到class。

class Caculator:name='fly bird' #Caculator類的一個屬性，計算器的名稱price=18 #計算器的價格def add(self,x,y): #參數self，是指向Caculator的指針，可以調用Caculator的方法或屬性result=x+yprint(result)def minus(self,x,y): #如果類的內部要相互調用的話，用self定位到classresult=x-yprint(result)def times(self,x,y):result=x*yprint(result)def divide(self,x,y):result=x/yprint(result)cal=Caculator() #用對象cal獲得Caculator這個類 print(cal.name) cal.add(10,11)

init功能

初始化類的屬性，例如本例中Caculator固有的name和price是fly bird和18。

方法中有init()函數（這是class自帶的），則可以在調用時再次賦值，改變調用時c的屬性。當然，這不改變原來Caculator的屬性。而且，還可以在 init( ) 中初始化函數，做到：一調用這個class就執行某個函數

init（）函數中，用參數newname，賦值給Caculator的name：self.name=newname。

class Caculator:name='fly bird' #Caculator類的一個屬性，計算器的名稱price=18 #計算器的價格def __init__(self,newname,newprice):self.name=newnameself.price=newpriceself.add(1,2) #也可以在init中調用函數def add(self,x,y): #參數self，是指向Caculator的指針，可以調用Caculator的方法或屬性result=x+yprint(result)def minus(self,x,y): #如果類的內部要相互調用的話，用self定位到classresult=x-yprint(result)print(Caculator.name) #fly bird c=Caculator('fish',22) #調用時初始化 print(c.name) #fish print(c.price) #22 print(Caculator.price) #18 ，原Caculator仍是固有的

也可以用默認賦值def __init__(self,newname,newprice=29):這樣每次調用的時都自動重新賦上默認值price=29。
即：C.price 為 29，Caculator.price 為 18。

import 載入模塊

• 用最基本語法

import time print(time.localtime())

• 類似宏定義簡化模塊名

import time as t print(t.localtime())

• 只使用模塊的少數功能（不用前綴time）

from time import time,localtime #從time模塊引入time和localtime兩個功能 print(time()) #不需要寫time.time print(localtime()) #不需要寫time.localtime

• 使用模塊的所有功能（不用前綴time）

from time import * print(localtime()) print(gmtime()) print(time())

自定義模塊

不同的函數在不同文件中，在Python文件之間的相互調用。前提是兩個文件在同一個目錄下（同一個文件夾里）

被調用文件formula.py中：

def function():print('ss')

調用文件Python.py中：

import formulaformula.function()

也可以把自己做好的模塊放在電腦中存放所有外部模塊的目錄下，這樣就不用把被調用模塊和調用模塊放在一個文件夾，就可以隨時調用了。

用try-except捕捉報錯

使本來報錯的程序不中斷報錯，而是用變量捕捉到，然后可以把報錯輸出查看。

例如：打開一個不存在的文件

file=open('asdasd','r')

會報錯：

捕獲報錯：

try:file=open('asdasd','r') except Exception as e: #Exception類型的報錯，存進eprint(e)

捕獲報錯且代碼編譯不報錯：

至于except為什么選擇Exception？這只是一個類型，同樣還有很多別的錯誤類型 。

更多參數可以看這個: https://www.runoob.com/python/python-exceptions.html

一個處理報錯例子

在文件中查找名為“asdasd.txt”的文件，若沒有找到則詢問是否新建，若找到則在文件中添加一句話：i am coming

try:file=open('asdasd.txt','r+') #只讀+寫入方式 except Exception as e:print('there is no file named asdasd')respone=input('do you want to creat a new file?')if respone=='y':file=open('asdasd.txt','w')else:pass else: #此else對應上面exceptfile.write('i am coming')file.close()

若報錯，則輸出：there is no file named asdasd。并詢問是否要新建，若輸入y，則open名為asdasd的新文件。
若沒有報錯（找到asdasd文件），則給文件寫入:i am coming，最后關上文件。

zip，lambda，map

zip 合并列表

zip英文是拉鏈，即把多個列表合并起來，形成元組

a=[1,2,3] b=[2,3,4] s=list(zip(a,b)) #如果不轉換為list則只能獲得object print(s) #[(1, 2), (2, 3), (3, 4)]

每個列表有三個元素，所以最終zip出了三個元組

若要輸出：

for i,j in s: #i和j自動獲取s每個元組中的第一個，第二個值print(i*2,j*3)

lambda 定義簡單函數

相對def一個函數，lambda定義簡單函數更為方便，只需寫出參數和算式即可。

def fun1(x,y):print(x+y) fun1(2,3)fun2=lambda x,y:x+y #不用括號包住參數，直接寫運算，自動return print(fun2(2,3))

用map包裝函數及參數

list(map(fun1,[1,3],[2,5])) 即包裹函數fun1且,第一個方括號內是參數x的值，第二個是y的值。最后使用list轉換，使輸出為列表形式

def fun1(x,y):print(x+y)list(map(fun1,[1,2],[3,5]))

輸出：4和7 分別是1+3 和 2+5
但是其輸出機制我還沒有搞清楚：不轉換list時候輸出為object，轉換后自動print并換行輸出結果

淺復制copy和深復制deepcopy

在復制出克隆體之前，若a=c，則兩個變量的id相同，改變a的任意值，c的值也會變化。

淺復制

import copy庫，然后用c=copy.copy(a)，將a拷貝到克隆體c上，就可以做到修改c不影響a。

import copy a=[11,22,33] c=a print(id(a)) #2345350338368 print(id(c)) #2345350338368 c=copy.copy(a) print(id(c)) #2345349923968 地址發生變化 c[1]=9999 print(a) #[11, 22, 33] a不變 print(c) #[11, 9999, 33] 僅修改c中的22為9999

淺復制的缺點

b=[11,22,[33,44]] d=copy.copy(b) #使用淺copy print(d) print(id(b)==id(d)) #d和d的id不同 d[0]=0 #修改d[0]的值 print(d) #[0, 22, [33, 44]] print(b) #[11, 22, [33, 44]] b不發生修改 d[2][1]=999 print(d) #[0, 22, [33, 999]] print(b) #[0, 22, [33, 999]] b也發生了修改

淺拷貝只能做到拷貝父對象指針（指向b和d）
而子對象指針（指向b[2]列表）沒有被復制，所以修改d[2][1]也會影響b內的值

深復制deepcopy

完全賦值整個對象，任何部分都不會發生使用共用內存的情況。
語句：d=copy.deepcopy(b)

簡單引用

c=a就是兩者共用同一存儲，id相同，修改一個另一個也跟著修改。

總結

以上是生活随笔為你收集整理的B站莫烦Python基础学习笔记的全部內容，希望文章能夠幫你解決所遇到的問題。

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