函數

封裝好，進行某種功能

del 函數名(參數)：函數體return 返回值（可以沒有return語句）

作用域

在函數內定義的變量，僅能在函數內部使用，這是局部變量
函數之外的定義與賦值的變量，可以再任何地方使用，這是全局變量
global語句，可以將局部變量變成全局變量global 函數名

函數參數

位置參數：參數的順序和個數和函數定義中一致

sum=0
def math(a,b,c):sum=a+b+creturn sum
a=1;b=2;c=3	
math(a,b,c)#a,b,c 依次傳入math函數

默認參數：必須放在位置參數后面

def menu(hamburger,drinl,snacks='蛋撻'):print(('漢堡選擇：' + hamburger)print('飲料選擇：' + drink)print('小食選擇：' + snacks + '\n')
menu('香辣雞腿堡','可樂')
#打印結果：香辣雞腿堡，可樂，蛋撻
menu('香辣雞腿堡','可樂','薯條')
#打印結果：香辣雞腿堡，可樂，薯條（給了3個參數。第3個參數被更新）	

不定長參數：*參數名，當傳入參數數量不確定時使用，數據類型是元組（tuple），可以用for來循環遍歷

def math(a,*b,c=1):print('a'=a)print('c'=c)for i in b:print(b)
math(123,11,22,33,c=2)

關鍵參數：使用偽參數（形參）的名字來指定其對應的實參（傳入的變量）

def math(a,b):x=a-breturn x
y=math(b=3,a=7)

字典傳參
1.關鍵參數作為字典接收

def dic(**args):for s,t in args.items():print(s,':',t)
dic(a=20,b=30,c=50)
#a:20
#b:30
#c:50 args變成一個字典

2.將字典展開并接收

def dic(a,b,c):print(a,b,c)
d={'a':20,'b':30,'c':50}
dic(**d)
#20 30 50
#字典d被展開到偽參數a，b，c上

函數對象

在函數名末尾不加括號，只寫名稱的格式所表示的是函數本身，我們將其稱之為函數對象，可以像值一樣將其帶入到變量中去

def printHello(name):print('hello',name)
func=printHello#func是函數對象
func('siri')
#打印結果是hello siri
#將函數printHello帶入到func，func可以作為函數使用	

無名函數

進行簡單處理的函數，可以使用關鍵字“lambda"來記述，這種寫法稱為無名函數（）

#函數
def lo(a):return a.lower()
#無名函數
lo=lambda s:s.lower()
print(lo('HELLO'))#輸出 hello	

回調函數

函數可以將別的函數作為參數使用，被作為參數使用的函數被稱為回調函數

def calcdisp(a,b,callback):print(callback(a,b))
def calllback(a,b):return (a+b)
calcdisp(3,5,callback)#輸出值是8
#簡化寫法
calcdisp(3,5,lambda a,b : a + b)#callback被無名函數替代

函數嵌套

可以定義函數中的函數，內部函數稱為本地函數

def func1():def func2():print(1)print(2)func2()#調用內部函數
func1()#調用外部函數
#在這里不能調用func2，func2是func1的內部函數，作用域在func1內

類

類的創建

類的創建：class 類名（類名首字母大寫）：
類的屬性創建：賦值語句
類的方法創建：def 方法名（self）：
其中，self代表著實例化對象，是所有實例的替身

class Math:type_1=int_true#創建屬性def plus(self):#定義方法print(a+b)

類的調用

類的實例化：例如coke=water（），表明water這個類創建了一個叫做coke的實例，這個實例可以調用water類中的屬性和方法

class Food:drink = '可口可樂'def hambage(self):print('香辣鱈魚堡')
KFC=Food()#實例化類math，number為實例化對象，即self=number
print(Food.drink)#調用實例化對象的屬性type_1
Food.hambage()#調用了實例化對象的方法plus

注意：用def創建方法時，第一個參數位置要留給self，不需要傳參
在類的方法內部想要調用類屬性和其他方法，用self.屬性或self.方法

class Food:drink = '可口可樂'def hambage(self):print('香辣鱈魚堡')def menu(self):self.hambage()print(self.drink,'\n''蛋撻')
KFC = Food()
KFC.menu()

初始化方法

當每個實例對象被創建時，該方法內的代碼無須調用，自動運行
可以在初始化方法內部完成類屬性的創建，并設定初始值，方便隨時調用

class Musician:	def__int__(self):print('這是初始化方法')
lisi=Musician（）

那么調用屬性的代碼就發生了改變

class Pre:def __init__(self,name,age):self.name=nameself.age=agedef prin(self):print('%s的年齡是%d'%(self.name,self.age))
liu=Pre('劉劉',20)#作為name和age的值傳到Pre中
liu.prin()

類的繼承

子類有父類的屬性和方法，子類屬于父類，父類屬于object類

class X():name=1
class Y(X):pass #占位

class Car:wheel=4def run(self):print('有%d個輪子'%self.wheel)
class BMW(Car):pass
BMW320=BMW() #子類BMW實例化，BMW320
print(BMW320.wheel)#有4個輪子

類的多層繼承：
子類可以繼承父類，父類的父類，父類的父類的父類，語法同單層繼承
類的多重繼承：
一個子類可以繼承多個父類，和子類相關性更強的父類會放在更左側，先在左側父類找，找不到再去右側父類（就近原則）

類的定制

子類可以再繼承的基礎上進行個性化定制，如創建新屬性、新方法；修改繼承的屬性和方法
屬性方法名不同時創建，相同名字時修改

#音樂人
class Musician():loveMusic = True3     def intr(self):print("我喜歡音樂")print("我來自音樂界")def sing(self):print("我在唱歌")
# Rapper繼承音樂人
class Rapper(Musician): #類的繼承garrulous = True    #類的定制 ， 增加屬性def composition(self):  #類的定制， 增加方法print("我可以創作簡單的歌詞")def sing(self): #類的定制，更改方法print("我以說的方式進行唱歌")csunYuk = Rapper()
print(csunYuk.loveMusic) 
print(csunYuk.garrulous)
csunYuk.composition()
csunYuk.sing()
#True
#True
#我可以創作簡單的歌詞
#我以說的方式進行唱歌

也可以對實例化屬性進行修改

模塊

模塊，是一個將代碼封裝起來方便使用的py文件。里面可以有類、函數、變量。

a=10;b=1#變量print(a)#函數def math(a,b):#自定義函數    c=0c=a+breturn c#math函數返回cclass Math:#類num='1'#屬性def __init__(self,a):#初始化函數self.a=adef plus(self):#方法print(self.num)import test.py#調用模塊

使用模塊

1、import 語句
?法：import 模塊名
例?：import time;import csv

如何調?模塊中的函數，變量
?法：模塊名.函數；模塊名.變量
2、from…import語句
?法： 從模塊中導??個指定的部分到當前模塊（函數、變量、類名）
例?：from csv import *，默認將CSV模塊中的所有函數、變量進?全部導?
3、if __name__=='__main__'
?法：當運?的?件是程序的??時，則會執?if name=='main’下的語句，相反，當運?的?件作為模塊是被其他程序導?時，代碼if name=='main’下的代碼則不會執?

#不使用if __name__=='__main__'
#A.py
name = '小劉'
def fun_A():print('調用方法A')
def print_name():print('__name__的值是',__name__)
print_name()
fun_A()#做腳本運行時：__name__的值是__main__,調用方法A
#B.py
import A#B運行，輸出：__name__的值是A(值變成了模塊名)，調用方法A

#使用if __name__=='__main__'
#A.py
name = '小劉'
def fun_A():print('調用方法A')
def print_name():print('__name__的值是',__name__)
if __name__=='__main__'print_name()fun_A()#做腳本運行時：__name__的值是__main__,調用方法A
#B.py
import A
print_name()#B運行，輸出：__name__的值是A,不會調用fun_A函數了