1. 如何理解python中的main函數
這個腳本被執行的時候，__name__ 值就是 __main__ ，才會執行 main()函數 如果這個腳本是被 import 的話，__name__的值不一樣。main()函數就不會被調用。 這個句子用來寫既能直接運行，又能給其他python程序import，提供庫調用的腳本
2. Python中的函數是什麼,什麼是主調函數和被調函數,二者之間關系是什麼
主調函數是本身固有的數，被調函數是通過其他數計算出來的
主調函數 調用別的函數實現功能
例如 A是主調函數 B是被調函數
void A（）
{
B();
}
3. python主函數問題
當你寫的代碼少感覺不到主函數的優勢，但如果一個項目程序大的話主函數＋其他的邏輯自定義的函數就體現出優勢了，你發現控制一部分有錯誤或者你想修改某一部分的邏輯控制就可以快速的找到對應的部分，當然你也可以完全不用函數來寫，不過我敢保證這是很蠢的辦法，非常不便於維護
4. 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
以上實例輸出結果：
5. python 定義主函數怎麼得到其他函數的參數，求代碼改錯
import
csv
def
values
():
reader
=
csv.reader(open("H:/python_study_data/1.txt",
"rb"),
delimiter
=
"\t")
for
row
in
reader:
chr,
start,
end
=
row[0],
int(row[1]),
int(row[2])
yield
(start,
end)
#return
改為yield生成器
def
main
():
for
start,
end
in
values():
aa
=
end-start
print
aa
if
__name__
==
'__main__':
main()
6. 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.
7. python主函數怎麼寫
一般來說，Python程序員可能是這樣寫main()函數的：
"""Mole docstring.
This serves as a long usage message.
"""import sysimport getoptdef main():
# parse command line options
try:
opts, args = getopt.getopt(sys.argv[1:], "h", ["help"]) except getopt.error, msg: print msg print "for help use --help"
sys.exit(2) # process options
for o, a in opts: if o in ("-h", "--help"): print __doc__
sys.exit(0) # process arguments
for arg in args:
process(arg) # process() is defined elsewhereif __name__ == "__main__":
main()
Guido也承認之前自己寫的main()函數也是類似的結構，但是這樣寫的靈活性還不夠高，尤其是需要解析復雜的命令行選項時。為此，他向大家提出了幾點建議。
添加可選的 argv 參數
首先，修改main()函數，使其接受一個可選參數 argv，支持在互動式shell中調用該函數：
def main(argv=None):
if argv is None:
argv = sys.argv # etc., replacing sys.argv with argv in the getopt() call.1234
這樣做，我們就可以動態地提供 argv 的值，這比下面這樣寫更加的靈活：
def main(argv=sys.argv):
# etc.12
這是因為在調用函數時，sys.argv 的值可能會發生變化；可選參數的默認值都是在定義main()函數時，就已經計算好的。
但是現在sys.exit()函數調用會產生問題：當main()函數調用sys.exit()時，互動式解釋器就會推出！解決辦法是讓main()函數的返回值指示退出狀態（exit status）。因此，最後面的那行代碼就變成了這樣：
if __name__ == "__main__":
sys.exit(main())12
並且，main()函數中的sys.exit(n)調用全部變成return n。
定義一個Usage()異常
另一個改進之處，就是定義一個Usage()異常，可以在main()函數最後的except子句捕捉該異常：
import sysimport getoptclass Usage(Exception):
def __init__(self, msg):
self.msg = msgdef main(argv=None):
if argv is None:
argv = sys.argv try: try:
opts, args = getopt.getopt(argv[1:], "h", ["help"]) except getopt.error, msg: raise Usage(msg) # more code, unchanged
except Usage, err: print >>sys.stderr, err.msg print >>sys.stderr, "for help use --help"
return 2if __name__ == "__main__":
sys.exit(main())
這樣main()函數就只有一個退出點（exit）了，這比之前兩個退出點的做法要好。而且，參數解析重構起來也更容易：在輔助函數中引發Usage的問題不大，但是使用return 2卻要求仔細處理返回值傳遞的問題。
8. python如何定義和調用函數
自定義函數用
def 函數名（參數）：
（縮進）寫具體的函數部分，和寫普通程序一樣，只不過用return來返回需要的結果。
主程序裡面和使用普通內置函數一樣，函數名（參數）。
9. python怎麼調用c的main函數
if
__name__=="__main__":
print
'main'
當腳本作為執行腳本時__name__的值為__main__當腳本作為模塊時__name__為模塊文件名。舉個例子，a.py作為執行腳本時__name__的值是__main__。有2個腳本，a.py和b.py，a中引入b,執行a.py時，在b中模塊的__name__就是b.py