Ⅰ python裡面的函數是什麼意思
1、Python中的函數是什麼意思？
如果你需要實現一個功能，那麼你需要用代碼來實現。
那麼Python中為你設置了一些固定功能的代碼，實現一個功能的這些代碼就是一個函數。
簡而言之，函數就是實現特有的功能，你可以直接調用的內建函數。
2、函數舉例
Python內置了許多函數，我們可以直接調用。
比如：abs函數，是用來求絕對值的。
如下圖所示，a就是輸入，b就是經過函數處理後得到的輸出。
具體如何求絕對值？我們不管，abs幫我們做好了，我們只要把他需要的值給他就行了
Ⅱ Python的函數都有哪些
Python 函數
函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。
函數能提高應用的模塊性，和代碼的重復利用率。你已經知道Python提供了許多內建函數，比如print()。但你也可以自己創建函數，這被叫做用戶自定義函數。
定義一個函數
你可以定義一個由自己想要功能的函數，以下是簡單的規則：
函數代碼塊以def關鍵詞開頭，後接函數標識符名稱和圓括弧()。
任何傳入參數和自變數必須放在圓括弧中間。圓括弧之間可以用於定義參數。
函數的第一行語句可以選擇性地使用文檔字元串—用於存放函數說明。
函數內容以冒號起始，並且縮進。
return [表達式]結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當於返回 None。
語法
def functionname( parameters ): "函數_文檔字元串"
function_suite
return [expression]
默認情況下，參數值和參數名稱是按函數聲明中定義的順序匹配起來的。
實例
以下為一個簡單的Python函數，它將一個字元串作為傳入參數，再列印到標准顯示設備上。
實例(Python 2.0+)
def printme( str ): "列印傳入的字元串到標准顯示設備上"
print str
return
函數調用
定義一個函數只給了函數一個名稱，指定了函數里包含的參數，和代碼塊結構。
這個函數的基本結構完成以後，你可以通過另一個函數調用執行，也可以直接從Python提示符執行。
如下實例調用了printme（）函數：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 定義函數def printme( str ): "列印任何傳入的字元串"
print str
return
# 調用函數printme("我要調用用戶自定義函數!")printme("再次調用同一函數")
以上實例輸出結果：
參數傳遞
在 python 中，類型屬於對象，變數是沒有類型的：
a=[1,2,3]
a="Runoob"
以上代碼中，[1,2,3]是 List 類型，"Runoob"是 String 類型，而變數 a 是沒有類型，她僅僅是一個對象的引用（一個指針），可以是 List 類型對象，也可以指向 String 類型對象。
可更改(mutable)與不可更改(immutable)對象
在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是可以修改的對象。
不可變類型：變數賦值a=5後再賦值a=10，這里實際是新生成一個 int 值對象 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當於新生成了a。
可變類型：變數賦值la=[1,2,3,4]後再賦值la[2]=5則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。
python 函數的參數傳遞：
不可變類型：類似 c++ 的值傳遞，如 整數、字元串、元組。如fun（a），傳遞的只是a的值，沒有影響a對象本身。比如在 fun（a）內部修改 a 的值，只是修改另一個復制的對象，不會影響 a 本身。
可變類型：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改後fun外部的la也會受影響
python 中一切都是對象，嚴格意義我們不能說值傳遞還是引用傳遞，我們應該說傳不可變對象和傳可變對象。
python 傳不可變對象實例
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
def ChangeInt( a ): a = 10
b = 2ChangeInt(b)print b # 結果是 2
實例中有 int 對象 2，指向它的變數是 b，在傳遞給 ChangeInt 函數時，按傳值的方式復制了變數 b，a 和 b 都指向了同一個 Int 對象，在 a=10 時，則新生成一個 int 值對象 10，並讓 a 指向它。
傳可變對象實例
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數說明def changeme( mylist ): "修改傳入的列表"
mylist.append([1,2,3,4])
print "函數內取值: ", mylist
return
# 調用changeme函數mylist = [10,20,30]changeme( mylist )print "函數外取值: ", mylist
實例中傳入函數的和在末尾添加新內容的對象用的是同一個引用，故輸出結果如下：
參數
以下是調用函數時可使用的正式參數類型：
必備參數
關鍵字參數
默認參數
不定長參數
必備參數
必備參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。
調用printme()函數，你必須傳入一個參數，不然會出現語法錯誤：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數說明def printme( str ): "列印任何傳入的字元串"
print str
return
#調用printme函數printme()
以上實例輸出結果：
關鍵字參數
關鍵字參數和函數調用關系緊密，函數調用使用關鍵字參數來確定傳入的參數值。
使用關鍵字參數允許函數調用時參數的順序與聲明時不一致，因為 Python 解釋器能夠用參數名匹配參數值。
以下實例在函數 printme() 調用時使用參數名：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數說明def printme( str ): "列印任何傳入的字元串"
print str
return
#調用printme函數printme( str = "My string")
以上實例輸出結果：
下例能將關鍵字參數順序不重要展示得更清楚：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數說明def printinfo( name, age ): "列印任何傳入的字元串"
print "Name: ", name
print "Age ", age
return
#調用printinfo函數printinfo( age=50, name="miki" )
以上實例輸出結果：
默認參數
調用函數時，默認參數的值如果沒有傳入，則被認為是默認值。下例會列印默認的age，如果age沒有被傳入：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數說明def printinfo( name, age = 35 ): "列印任何傳入的字元串"
print "Name: ", name
print "Age ", age
return
#調用printinfo函數printinfo( age=50, name="miki" )printinfo( name="miki" )
以上實例輸出結果：
不定長參數
你可能需要一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數，和上述2種參數不同，聲明時不會命名。基本語法如下：
def functionname([formal_args,] *var_args_tuple ): "函數_文檔字元串"
function_suite
return [expression]
加了星號（*）的變數名會存放所有未命名的變數參數。不定長參數實例如下：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數說明def printinfo( arg1, *vartuple ): "列印任何傳入的參數"
print "輸出: "
print arg1
for var in vartuple: print var
return
# 調用printinfo 函數printinfo( 10 )printinfo( 70, 60, 50 )
以上實例輸出結果：
匿名函數
python 使用 lambda 來創建匿名函數。
lambda只是一個表達式，函數體比def簡單很多。
lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
lambda函數擁有自己的命名空間，且不能訪問自有參數列表之外或全局命名空間里的參數。
雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，後者的目的是調用小函數時不佔用棧內存從而增加運行效率。
語法
lambda函數的語法只包含一個語句，如下：
如下實例：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數說明sum = lambda arg1, arg2: arg1 + arg2
# 調用sum函數print "相加後的值為 : ", sum( 10, 20 )print "相加後的值為 : ", sum( 20, 20 )
以上實例輸出結果：
return 語句
return語句[表達式]退出函數，選擇性地向調用方返回一個表達式。不帶參數值的return語句返回None。之前的例子都沒有示範如何返回數值，下例便告訴你怎麼做：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數說明def sum( arg1, arg2 ): # 返回2個參數的和."
total = arg1 + arg2
print "函數內 : ", total
return total
# 調用sum函數total = sum( 10, 20 )
以上實例輸出結果：
變數作用域
一個程序的所有的變數並不是在哪個位置都可以訪問的。訪問許可權決定於這個變數是在哪裡賦值的。
全局變數
局部變數
全局變數和局部變數
定義在函數內部的變數擁有一個局部作用域，定義在函數外的擁有全局作用域。
局部變數只能在其被聲明的函數內部訪問，而全局變數可以在整個程序范圍內訪問。調用函數時，所有在函數內聲明的變數名稱都將被加入到作用域中。如下實例：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
total = 0 # 這是一個全局變數# 可寫函數說明def sum( arg1, arg2 ): #返回2個參數的和."
total = arg1 + arg2 # total在這里是局部變數.
print "函數內是局部變數 : ", total
return total
#調用sum函數sum( 10, 20 )print "函數外是全局變數 : ", total
以上實例輸出結果：
Ⅲ python 定義函數
python 定義函數：
在Python中，可以定義包含若干參數的函數，這里有幾種可用的形式，也可以混合使用：
1. 默認參數
最常用的一種形式是為一個或多個參數指定默認值。
>>> def ask_ok(prompt,retries=4,complaint='Yes or no Please!'):
while True:
ok=input(prompt)
if ok in ('y','ye','yes'):
return True
if ok in ('n','no','nop','nope'):
return False
retries=retries-1
if retries<0:
raise IOError('refusenik user')
print(complaint)
這個函數可以通過幾種方式調用：
只提供強制參數
>>> ask_ok('Do you really want to quit?')
Do you really want to quit?yes
True
提供一個可選參數
>>> ask_ok('OK to overwrite the file',2)
OK to overwrite the fileNo
Yes or no Please!
OK to overwrite the fileno
False
提供所有的參數
>>> ask_ok('OK to overwrite the file?',2,'Come on, only yes or no!')
OK to overwrite the file? test
Come on, only yes or no!
OK to overwrite the file?yes
True
2. 關鍵字參數
函數同樣可以使用keyword=value形式通過關鍵字參數調用
>>> def parrot(voltage,state='a stiff',action='voom',type='Norwegian Blue'):
print("--This parrot wouldn't", action, end=' ')
print("if you put",voltage,"volts through it.")
print("--Lovely plumage, the",type)
print("--It's",state,"!")
>>> parrot(1000)
--This parrot wouldn't voom if you put 1000 volts through it.
--Lovely plumage, the Norwegian Blue
--It's a stiff !
>>> parrot(action="vooooom",voltage=1000000)
--This parrot wouldn't vooooom if you put 1000000 volts through it.
--Lovely plumage, the Norwegian Blue
--It's a stiff !
>>> parrot('a thousand',state='pushing up the daisies')
--This parrot wouldn't voom if you put a thousand volts through it.
--Lovely plumage, the Norwegian Blue
--It's pushing up the daisies !
但是以下的調用方式是錯誤的：
>>> parrot(voltage=5, 'dead')
SyntaxError: non-keyword arg after keyword arg
>>> parrot()
Traceback (most recent call last):
File "<pyshell#57>", line 1, in <mole>
parrot()
TypeError: parrot() missing 1 required positional argument: 'voltage'
>>> parrot(110, voltage=220)
Traceback (most recent call last):
File "<pyshell#58>", line 1, in <mole>
parrot(110, voltage=220)
TypeError: parrot() got multiple values for argument 'voltage'
>>> parrot(actor='John')
Traceback (most recent call last):
File "<pyshell#59>", line 1, in <mole>
parrot(actor='John')
TypeError: parrot() got an unexpected keyword argument 'actor'
>>> parrot(voltage=100,action='voom',action='voooooom')
SyntaxError: keyword argument repeated
Python的函數定義中有兩種特殊的情況，即出現*，**的形式。
*用來傳遞任意個無名字參數，這些參數會以一個元組的形式訪問
**用來傳遞任意個有名字的參數，這些參數用字典來訪問
（*name必須出現在**name之前）
>>> def cheeseshop1(kind,*arguments,**keywords):
print("--Do you have any",kind,"?")
print("--I'm sorry, we're all out of",kind)
for arg in arguments:
print(arg)
print("-"*40)
keys=sorted(keywords.keys())
for kw in keys:
print(kw,":",keywords[kw])
>>> cheeseshop1("Limbuger","It's very runny, sir.","It's really very, very runny, sir.",shopkeeper="Michael Palin",client="John",sketch="Cheese Shop Sketch")
--Do you have any Limbuger ?
--I'm sorry, we're all out of Limbuger
It's very runny, sir.
It's really very, very runny, sir.
----------------------------------------
client : John
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch
>>>
3. 可變參數列表
最常用的選擇是指明一個函數可以使用任意數目的參數調用。這些參數被包裝進一個元組，在可變數目的參數前，可以有零個或多個普通的參數
通常，這些可變的參數在形參列表的最後定義，因為他們會收集傳遞給函數的所有剩下的輸入參數。任何出現在*args參數之後的形參只能是「關鍵字參數」
>>> def contact(*args,sep='/'):
return sep.join(args)
>>> contact("earth","mars","venus")
'earth/mars/venus'
4. 拆分參數列表
當參數是一個列表或元組，但函數需要分開的位置參數時，就需要拆分參數
調用函數時使用*操作符將參數從列表或元組中拆分出來
>>> list(range(3,6))
[3, 4, 5]
>>> args=[3,6]
>>> list(range(*args))
[3, 4, 5]
>>>
以此類推，字典可以使用**操作符拆分成關鍵字參數
>>> def parrot(voltage,state='a stiff',action='voom'):
print("--This parrot wouldn't", action,end=' ')
print("if you put",voltage,"volts through it.",end=' ')
print("E's", state,"!")
>>> d={"voltage":"four million","state":"bleedin' demised","action":"VOOM"}
>>> parrot(**d)
--This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !
5. Lambda
在Python中使用lambda來創建匿名函數，而用def創建的是有名稱的。
python lambda會創建一個函數對象，但不會把這個函數對象賦給一個標識符，而def則會把函數對象賦值給一個變數
python lambda它只是一個表達式，而def則是一個語句
>>> def make_incrementor(n):
return lambda x:x+n
>>> f=make_incrementor(42)
>>> f(0)
42
>>> f(2)
44
>>> g=lambda x:x*2
>>> print(g(3))
6
>>> m=lambda x,y,z:(x-y)*z
>>> print(m(3,1,2))
4
6. 文檔字元串
關於文檔字元串內容和格式的約定：
第一行應該總是關於對象用途的摘要，以大寫字母開頭，並且以句號結束
如果文檔字元串包含多行，第二行應該是空行
>>> def my_function():
"""Do nothing, but document it.
No, really, it doesn't do anything.
"""
pass
>>> print(my_function.__doc__)
Do nothing, but document it.
No, really, it doesn't do anything.
Ⅳ python中的 for f in sorted(set(basket)):中的set()是什麼函數呢
dict
Python內置了字典：dict的支持，dict全稱dictionary，在其他語言中也稱為map，使用鍵-值（key-value）存儲，具有極快的查找速度。
舉個例子，假設要根據同學的名字查找對應的成績，給定一個名字，要查找對應的成績，如果用dict實現，只需要一個「名字」-「成績」的對照表，直接根據名字查找成績，無論這個表有多大，查找速度都不會變慢。
用Python寫一個dict如下：
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
set
set和dict類似，也是一組key的集合，但不存儲value。由於key不能重復，所以，在set中，沒有重復的key。
要創建一個set，需要提供一個list作為輸入集合：
>>> s = set([1, 2, 3])
>>> s
set([1, 2, 3])
注意，傳入的參數[1, 2, 3]是一個list，而顯示的set([1, 2, 3])只是告訴你這個set內部有1，2，3這3個元素，顯示的[]不表示這是一個list。
重復元素在set中自動被過濾：
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
set([1, 2, 3])
Ⅳ 如何用Quartz Signal快速實現Worldquant 101 Alpha
優礦的500萬實盤在如火如荼地進行中，我們已經看到有礦友利用經典的機器學習演算法和新的Quartz Signal模塊對於優礦上現有因子的利用進行探索，但是對於大多數信號/因子研究者來說，尋找新的Alpha依然是其孜孜以求的目標。
如何去尋找新的Alpha因子的靈感成為擺在量化研究者面前無法迴避的問題。
我們注意到，Zura Kakushadze 等人最新發表的論文101 Formulaic Alpha(…) 里提到了很多基於價量數據構建的"Alpha"因子，為我們提供了很多新的靈感。
本文將先簡單介紹論文中提到的Alpha因子表達式語法以及含義，之後會介紹如何用Quartz Signal便捷地實現這些Alpha，最後會提供2個在論文中出現並且效果不錯的Alpha因子供大家參考。
Formulaic Alpha簡介
研讀過上文提到的論文，我們發現，論文中提到的Formulaic Alpha就是用一個表達式來表示一個Alpha因子：
· 寫出的表達式是在每一個調倉日對每一支按照該表達式進行計算
· 例如：1/close; 對universe中每一支，計算1/closePrice，然後此向量被標准化，即除以其數值的總和（所有數值相加的結果為 1）。這將為所有創建了一個基於「權重」的向量，每個權重代表投資組合中投資於該的資金比例
· 其支持的數據有：open(開盤價)/close(收盤價)/high(最高價)/low(最低價)/vwap(日內交易量加權價格)/returns(單日收益率)等等
我們認為這種Formulaic Alpha的表達形式有以下特點：
· 表達簡潔，但隱藏了太多細節，用戶無法看到具體的調倉信息
· 受限於表達式表達能力的不足，提供了豐富的內置函數，幫助用戶完成了cross-sectional信息的處理
內置函數
· 可分為橫截面函數和時間序列函數兩大類，其中時間序列函數名多為以ts_開頭
· 大部分函數命名方式較為直觀
· abs(x) log(x)分別表示x的絕對值和x的自然對數
· rank(x)表示某x值在橫截面上的升序排名序號，並將排名歸一到[0,1]的閉區間
· delay(x,d)表示x值在d天前的值
· delta(x,d)表示x值的最新值減去x值在d天前的值
· correlation(x,y,d) covariance(x,y,d)分別表示x和y在長度為d的時間窗口上的Pearson相關系數和協方差
· ts_min(x,d) ts_max(x,d) ts_argmax(x,d) ts_argmin(x,d) ts_rank(x) sum(x,d) stddev(x,d)等均可以通過函數名稱了解其作用
· 更多地函數解釋可以參考論文的附錄
Quartz Signal模塊簡介
正如API幫助文檔中提到的，Signal模塊是優礦為方便因子/信號研究者提供的工具，將用戶從與信號研究無關的數據獲取、下單邏輯中抽離出來，用戶可以將精力集中於按照自己的思路開發新的信號。
使用Signal自定義信號的通用實現過程如下：
def foo(data, dependencies=['PE&# 39;], max_window=4):
return data['PE&# 39;].mean()
# in initialize(account)
a = Signal("signal_a", foo)
account.signal_generator = SignalGenerator(a)
# in handle_data(account)
account.signal_result['signal_a']
我們可以將Quartz Signal的使用過程分為四個步驟：
定義實現信號邏輯的函數（在上例中即為foo函數）
在initialize函數中定義Signal，在實例化Signal類時將信號名字和描述函數作為參數傳入
在initialize函數中將需要使用的信號注冊到account.signal_generator中，可以注冊多個信號
在handle_data中通過account.signal_result獲取計算好的信號值
我們重點介紹一下用戶需要完成的信號描述函數：
信號描述函數實際上是用戶在每一個調倉日對於可以獲得數據的處理邏輯
信號描述函數名可以按照Python函數的命名規范任意定義，但其參數必須為一個非關鍵字參數data，兩個關鍵字參數dependencies和max_window
dependencies的參數格式必須為str構成的list，list的元素為該函數中需要使用的因子名稱，具體支持因子列表參考幫助文檔
max_window的參數格式為int，表示用戶希望用到過去max_window天的因子數據
data則是根據dependencies和max_window，Quartz Signal模塊幫助用戶取到的數據，其格式為一個dict，key為因子名稱，value為max_window*universe_length的Pandas DataFrame
信號描述函數的返回值必須為一個長度與data中每一元素列數相同的Pandas Series
如下圖所示：
上圖描述的就是data的結構，其中data只有一個元素，其key為"PE"，value就是上圖表格所示的Pandas DataFrame，具體地，其columns為universe的secID，其index為%Y%m%d格式的日期字元串
Quartz Signal v.s. Formulaic Alpha
由上述描述可見，使用Quartz Signal模塊可以便捷地實現Formulaic Alpha，同時相比Formulaic Alpha表達式有以下優勢：
更加直觀：
o用戶在預先定義信號描述函數時，就可以明晰地定義自己需要的因子數據和時間窗口
o用戶可以在Quartz框架中靈活定義自己的調倉頻率和下單邏輯，並可以直觀地看到每次調倉的列表
更加靈活：
oFormulaic Alpha限制了表達式的計算結果必須代表相應在投資組合中的權重，而Quartz Signal並沒有此限制，用戶可以在handle_data中按照自己的想法任意處理信號值
o信號描述函數的data是以Pandas DataFrame的格式傳入的，這樣用戶就可以在函數中同時看到橫截面數據和時間序列數據，為用戶提供了更多可能
更加強大：信號描述函數的data是以Pandas DataFrame的格式傳入的，Pandas豐富的內置函數可以幫助我們完成較復雜Formulaic Alpha表達式才能完成的任務（見最後一個示例）
更多數據：Quartz Signal不僅支持openPrice/closePrice/highPrice/lowPrice/turnoverVol等價量信息，還支持PE、RSI等更豐富的因子
下面我們就用Quartz Signal模塊實現了一個論文中提到的Formulaic Alpha:
用Quartz Signal實現一個Formulaic Alpha
以WebSim論文中alpha 53為例，其原始表達式為:
(−1∗delta((((close−low)−(high−close))/(close−low)),9))
化簡可得，((close - low) - (high - close)) / (close - low)的9日之前值-當前值
繼續化簡可得：(2∗close−low−high)/(close−low)
我們深入研究該因子可以發現：
(2∗close−low−high)/(close−low)=1−(high−close)/(close−low)
前面的常數1可以通過delta消掉，其實可以簡化為(high−close)/(close−low)的現值-9天之前的值
而(high−close)/(close−low)本身則代表了收盤價在日內波動中的位置，可以看做是買入意願的一種體現
我們強烈建議大家在實現這些Formulaic Alpha因子之前先花一些精力去理解其經濟含義，不僅可以加深對其原理的理解，在某些時候還可以簡化實現。
我們以論文中的Alpha 26為例，其原始表達式為：
−1∗ts_max(correlation(ts_rank(volume,5),ts_rank(high,5),5),3)
我們當然可以按照其原始表達式一步步地先對過去5天的成交量和最高價進行排名，再取相關系數；但是較熟悉Pandas DataFrame內置函數或者統計知識較豐富的研究者可以發現，correlation(ts_rank(volume,5),ts_rank(high,5),5) 其實就是在計算Spearman Rank Correlation Coefficient，使用DataFrame內置的corr(method="spearman")函數就可以完成計算，可以大大提高開發效率。
在我們的模擬的過程中發現，如果按照原公式進行計算，無論是long還是short的結果都跑不贏大盤，同時對於成交量和最高價相關性較高的將會是市場追逐的熱點，應該分配更大的權重。
所以在上述代碼中我們將原Formulaic Alpha前面的負號去掉。
當然，對於論文中出現的某些因子可能較難於理解其經濟學意義，我們鼓勵大家用Quartz Signal將其實現之後發到社區上與大家一起討論。
對於Quartz Signal模塊有哪些不盡如人意的地方也可以反饋給我們，幫助我們持續改進。
Ⅵ python函數與方法的區別總結
1、函數的分類：
內置函數：python內嵌的一些函數。
匿名函數：一行代碼實現一個函數功能。
遞歸函數
自定義函數：根據自己的需求，來進行定義函數。
2、方法的分類：
普通方法：直接用self調用的方法。
私有方法：__函數名，只能在類中被調用的方法。
屬性方法：@property，將方法偽裝成為屬性，讓代碼看起來更合理。
特殊方法(雙下劃線方法)：以__init__為例，是用來封裝實例化對象的屬性，只要是實例化對象就一定會執行__init方法，如果對象子類中沒有則會尋找父類（超類），如果父類（超類）也沒有，則直接繼承object（python 3.x）類，執行類中的__init__方法。類方法：通過類名的調用去操作公共模板中的屬性和方法。
靜態方法：不用傳入類空間、對象的方法， 作用是保證代碼的一致性，規范性，可以完全獨立類外的一個方法，但是為了代碼的一致性統一的放到某個模塊（py文件）中。
其次，從作用域的角度來分析：
（1）函數作用域：從函數調用開始至函數執行完成，返回給調用者後，在執行過程中開辟的空間會自動釋放，也就是說函數執行完成後，函數體內部通過賦值等方式修改變數的值不會保留，會隨著返回給調用者後，開辟的空間會自動釋放。
（2）方法作用域：通過實例化的對象進行方法的調用，調用後開辟的空間不會釋放，也就是說調用方法中對變數的修改值會一直保留。
最後，調用的方式不同。
（1）函數：通過「函數名（）」的方式進行調用。
（2）方法：通過「對象.方法名」的方式進行調用。
Ⅶ python裡面有哪些自帶函數
python系統提供了下面常用的函數：
1. 數學庫模塊（math）提供了很多數學運算函數；
2.復數模塊（cmath）提供了用於復數運算的函數；
3.隨機數模塊（random）提供了用來生成隨機數的函數；
4.時間（time）和日歷（calendar）模塊提供了能處理日期和時間的函數。
注意：在調用系統函數之前，先要使用import 語句導入 相應的模塊
該語句將模塊中定義的函數代碼復制到自己的程 序中，然後就可以訪問模塊中的任何函數，其方 法是在函數名前面加上「模塊名.」。
希望能幫到你。
Ⅷ 簡述python函數中參數的幾種形態
在調用函數時，通常會傳遞參數，函數內部的代碼保持不變，針對 不同的參數處理不同的數據。
有位置傳參、關鍵字傳參、默認值參數、多值參數等。
1、參數傳遞
形參和實參：
形參：定義 函數時的 參數變數
實參：調用 函數時，使用的參數變數
參數傳遞的過程，就是 把實參的引用 傳遞給 形參 ，使用實參的值來執行函數體的過程。
在 Python 中，函數的 實參/返回值 都是是靠 引用 來傳遞來的
2、位置實參
按照參數位置，依次傳遞參數，這是最普通的方式。