怎樣理解python中的函數(shù),用戶自定義函數(shù)有什么意義?

函數(shù)是什么？

壺關網(wǎng)站建設公司創(chuàng)新互聯(lián),壺關網(wǎng)站設計制作，有大型網(wǎng)站制作公司豐富經(jīng)驗。已為壺關近千家提供企業(yè)網(wǎng)站建設服務。企業(yè)網(wǎng)站搭建\成都外貿(mào)網(wǎng)站建設要多少錢，請找那個售后服務好的壺關做網(wǎng)站的公司定做！

定義：函數(shù)是組織好的，可重復使用的，用來實現(xiàn)單一，或相關聯(lián)功能的代碼段。

作用：函數(shù)能提高應用的模塊性和代碼的重復利用率。你已經(jīng)知道Python提供了許多內(nèi)建函數(shù)，比如print()。但你也可以自己創(chuàng)建函數(shù)，這被叫做用戶自定義函數(shù)。

函數(shù)是 python 的一等公民，函數(shù)也是對象。

使用函數(shù)有兩個步驟：

1、定義函數(shù)?def 函數(shù)名(): 函數(shù)體

2、調(diào)用函數(shù)?函數(shù)名()

什么是python中的自省

自省就是程序運行時能夠知道對象的類型，比如type()/isinstance()/hasattr()這種函數(shù)

Python中定義函數(shù)的使用方法？

4.6. 定義函數(shù)

我們可以創(chuàng)建一個用來生成指定邊界的斐波那契數(shù)列的函數(shù):

def fib(n): # write Fibonacci series up to n

... """Print a Fibonacci series up to n."""

... a, b = 0, 1

... while a n:

... print(a, end=' ')

... a, b = b, a+b

... print()

...

# Now call the function we just defined:

... fib(2000)

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

關鍵字 def 引入了一個函數(shù) 定義。在其后必須跟有函數(shù)名和包括形式參數(shù)的圓括號。函數(shù)體語句從下一行開始，必須是縮進的。

函數(shù)體的第一行語句可以是可選的字符串文本，這個字符串是函數(shù)的文檔字符串，或者稱為 docstring。（更多關于 docstrings 的信息請參考 文檔字符串） 有些工具通過 docstrings 自動生成在線的或可打印的文檔，或者讓用戶通過代碼交互瀏覽；在你的代碼中包含 docstrings 是一個好的實踐，讓它成為習慣吧。

函數(shù) 調(diào)用 會為函數(shù)局部變量生成一個新的符號表。確切的說，所有函數(shù)中的變量賦值都是將值存儲在局部符號表。變量引用首先在局部符號表中查找，然后是包含函數(shù)的局部符號表，然后是全局符號表，最后是內(nèi)置名字表。因此，全局變量不能在函數(shù)中直接賦值（除非用 global 語句命名），盡管他們可以被引用。

函數(shù)引用的實際參數(shù)在函數(shù)調(diào)用時引入局部符號表，因此，實參總是 傳值調(diào)用 （這里的 值 總是一個對象 引用 ，而不是該對象的值）。[1] 一個函數(shù)被另一個函數(shù)調(diào)用時，一個新的局部符號表在調(diào)用過程中被創(chuàng)建。

一個函數(shù)定義會在當前符號表內(nèi)引入函數(shù)名。函數(shù)名指代的值（即函數(shù)體）有一個被 Python 解釋器認定為 用戶自定義函數(shù) 的類型。 這個值可以賦予其他的名字（即變量名），然后它也可以被當作函數(shù)使用。這可以作為通用的重命名機制:

fib

f = fib

f(100)

0 1 1 2 3 5 8 13 21 34 55 89

如果你使用過其他語言，你可能會反對說：fib 不是一個函數(shù)，而是一個方法，因為它并不返回任何值。事實上，沒有 return 語句的函數(shù)確實會返回一個值，雖然是一個相當令人厭煩的值（指 None ）。這個值被稱為 None （這是一個內(nèi)建名稱）。如果 None 值是唯一被書寫的值，那么在寫的時候通常會被解釋器忽略（即不輸出任何內(nèi)容）。如果你確實想看到這個值的輸出內(nèi)容，請使用 print() 函數(shù):

python語言中的內(nèi)建函數(shù)dir()是干啥用的?。?/h2>

dir() 函數(shù)

盡管查找和導入模塊相對容易，但要記住每個模塊包含什么卻不是這么簡單。您并不希望總是必須查看源代碼來找出答案。幸運的是，Python 提供了一種方法，可以使用內(nèi)置的 dir() 函數(shù)來檢查模塊（以及其它對象）的內(nèi)容。

dir() 函數(shù)可能是 Python 自省機制中最著名的部分了。它返回傳遞給它的任何對象的屬性名稱經(jīng)過排序的列表。如果不指定對象，則 dir() 返回當前作用域中的名稱

python中的函數(shù)和類的區(qū)別

類，class，用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。

函數(shù)，是組織好的，可重復使用的，用來實現(xiàn)單一，或相關聯(lián)功能的代碼段。

函數(shù)能提高應用的模塊性，和代碼的重復利用率。你已經(jīng)知道python提供了許多內(nèi)建函數(shù)，比如print()。但你也可以自己創(chuàng)建函數(shù)，這被叫做用戶自定義函數(shù)。

python語言中類和函數(shù)的區(qū)別是什么?

1、規(guī)則不同

類是一種引用數(shù)據(jù)類型，類似于byte、short、int(char)、long、float、double等基本數(shù)據(jù)類型;

函數(shù)必須聲明后才可以被調(diào)用，調(diào)用格式為：函數(shù)名(實參)調(diào)用時函數(shù)名后的小括號中的實參必須和聲明函數(shù)時的函數(shù)括號中的形參個數(shù)相同。

2、主體不同

類是面向?qū)ο蟪绦蛟O計實現(xiàn)信息封裝的基礎;

函數(shù)是指一段在一起的、可以做某一件事的子程序。

3、特點不同

類是一種用戶定義的引用數(shù)據(jù)類型，也稱類類型，每個類包含數(shù)據(jù)說明和一組操作數(shù)據(jù)或者傳遞消息的函數(shù)，類的實例稱為對象;

函數(shù)分為全局函數(shù)、全局靜態(tài)函數(shù)，在類中還可以定義構造函數(shù)、析構函數(shù)、拷貝構造函數(shù)、成員函數(shù)、友元函數(shù)、運算符重載函數(shù)、內(nèi)聯(lián)函數(shù)等。

Python 有哪些新手不會了解的深入細節(jié)

從開始看Python到現(xiàn)在也有半個多月了，前后看了Python核心編程和DiveintoPython兩本書。話說半個月看兩本，是個人都知道有多囫圇吞棗，這也是因為我暫時沒有需求拿這個做大型開發(fā)，主要是平時的小程序test用一用。所以我的策略是，整體瀏覽，用到時候現(xiàn)查。話說這核心編程第一版太古老了，老在講2.2之前的東西，我看的翻譯電子版，翻譯得也不好，很晦澀?？赐赀@個后還有點云里霧里，看網(wǎng)上人家說DIP好，啄木鳥還有免費電子文檔，就找來看這個。怎么說呢，講的比核心編程好，但不適合第一次看的初學者。我之所以覺得講得好，是因為看核心編程，有些概念還有些模糊，看了這本書就明白不少了。要是初學者上來就看這本，保證不好理解。下面就是在學習的過程中，在翻閱資料的過程中，總結(jié)的一些C和python比較明顯的不同之處，有大方向的，也有細節(jié)的?？隙]有總結(jié)完，比如動態(tài)函數(shù)，lambda這些，我都懶得往上寫了。實際上，作為兩種完全不同的語言，下面這些差異只是冰山一角而已。權當拋磚引玉吧，至少應該對和我有相同研究興趣，正在考慮是否學習另一門語言的朋友有點幫助。此文也算是DIP的學習筆記吧。順帶說一句，要是有朋友了解，可以幫忙推薦一下實戰(zhàn)性強的Python教材，語言這東西，不多練手，光比劃，是不可能學好的。學習目的我的以后的研究方向是嵌入式，顯然，C語言是我的主要語言。我不是一個語言愛好者，我以前覺得，對于做研究而不是應用的人來說，了解多門語言，不如精通一門語言。之所以去看python，主要還是因為python更有利于快速開發(fā)一些程序，也是因為現(xiàn)在認識到，研究和應用是不能分離的。個人以為，要想在計算機工程的競爭中立足，必須懂C語言。因為真正要做高性能編程,不可能將機器的體系架構拋到腦后讓Python虛擬機（或Java虛擬機等）幫你搞定所有底層。越來越多的CPUcore，越來越恐怖的內(nèi)存性能瓶頸，對于上層開發(fā)人員來說，無所謂，但是對高性能程序開發(fā)人員來說，這些是無法透明的。很多應用，還是自己掌控比較有效。這些場合中，匯編和C還是不可替代的。但是，光知道C是不夠的，掌握一門面向?qū)ο笳Z言，相對更高層的語言，不僅對以后的個人發(fā)展有利，也會對自己的技術認識產(chǎn)生幫助。如果要問對我來說誰更重要，我覺得還是C更重要。C的學習曲線更陡，貌似簡單，實際上到處都是陷阱，看上去比較簡單低效的程序，也不是學1，2個月就能搞定的。談到優(yōu)化的深層次和難度嘛，需要的功底是按年算的。但是一旦你C語言的基礎打好了，對計算機的理解，對其他語言的理解都是大有裨益的。比如，如果你有C基礎，可以說，學過1天python，就能寫的出來一些不短的程序。后面的優(yōu)化也不是什么大不了的算法，都是非?；镜恼Z句換來換去。當然這里不是說Python不好，實際上，上層應用，Python比C方便的不是一個層次。很多人覺得，既然懂C了，那么進一步掌握C＋＋應該是水到渠成，但C++不是C的超集，而我又不喜歡C＋＋的繁瑣和巨大，所以才決定看一看Python。我很喜歡Python的優(yōu)雅與快捷。語言類型和C不一樣，Python是一種動態(tài)類型語言，又是強類型語言。這個分類怎么理解呢？大概是可以按照下列說明來分類的：靜態(tài)類型語言一種在編譯期間就確定數(shù)據(jù)類型的語言。大多數(shù)靜態(tài)類型語言是通過要求在使用任一變量之前聲明其數(shù)據(jù)類型來保證這一點的。Java和C是靜態(tài)類型語言。動態(tài)類型語言一種在運行期間才去確定數(shù)據(jù)類型的語言，與靜態(tài)類型相反。Python是動態(tài)類型的，因為它們確定一個變量的類型是在您第一次給它賦值的時候。強類型語言一種總是強制類型定義的語言。Java和Python是強制類型定義的。您有一個整數(shù)，如果不明確地進行轉(zhuǎn)換，不能將把它當成一個字符串。弱類型語言一種類型可以被忽略的語言，與強類型相反。VBScript是弱類型的。在VBScript中，您可以將字符串‘12′和整數(shù)3進行連接得到字符串’123′，然后可以把它看成整數(shù)123，所有這些都不需要任何的顯示轉(zhuǎn)換。對象機制具體怎么來理解這個“動態(tài)確定變量類型”，就要從Python的Object對象機制說起了。Objects（以下稱對象）是Python對于數(shù)據(jù)的抽象，Python中所有的數(shù)據(jù)，都是由對象或者對象之間的關系表示的，函數(shù)是對象，字符串是對象，每個東西都是對象的概念。每一個對象都有三種屬性：實體，類型和值。理解實體是理解對象中很重要的一步，實體一旦被創(chuàng)建，那么就一直不會改變，也不會被顯式摧毀，同時通常意義來講，決定對象所支持的操作方式的類型（type，包括number，string，tuple及其他）也不會改變，改變的只可能是它的值。如果要找一個具體點的說明，實體就相當于對象在內(nèi)存中的地址，是本質(zhì)存在。而類型和值都只是實體的外在呈現(xiàn)。然后Python提供一些接口讓使用者和對象交互，比如id(）函數(shù)用來獲得對象實體的整形表示（實際在這里就是地址），type()函數(shù)獲取其類型。這個object機制，就是c所不具備的，主要體現(xiàn)在下面幾點：1剛才說了，c是一個靜態(tài)類型語言，我們可以定義inta,charb等等，但必須是在源代碼里面事先規(guī)定。比如我們可以在Python里面任意一處直接規(guī)定a=“l(fā)k”，這樣，a的類型就是string，這是在其賦值的時候才決定的，我們無須在代碼中明確寫出。而在C里面，我們必須顯式規(guī)定char*a=“l(fā)k”，也就是人工事先規(guī)定好a的類型2由于在C中，沒有對象這個概念，只有“數(shù)據(jù)的表示”，比如說，如果有兩個int變量a和b，我們想比較大小，可以用a＝＝b來判斷，但是如果是兩個字符串變量a和b，我們就不得不用strcmp來比較了，因為此時，a和b本質(zhì)上是指向字符串的指針，如果直接還是用＝＝比較，那比較的實際是指針中存儲的值——地址。在Java中呢，我們通過使用str1==str2可以確定兩個字符串變量是否指向同一塊物理內(nèi)存位置，這叫做“對象同一性”。在Java中要比較兩個字符串值，你要使用str1.equals(str2)。然后在Python中，和前兩者都不一樣，由于對象的引入，我們可以用“is”這個運算符來比較兩個對象的實體，和具體對象的type就沒有關系了，比如你的對象是tuple也好，string也好，甚至class也好，都可以用”is”來比較，本質(zhì)上就是“對象同一性”的比較，和Java中的＝＝類似，和C中的pointer比較類似。Python中也有＝＝比較，這個就是值比較了。3由于對象機制的引入，讓Python的使用非常靈活，比如我們可以用自省方法來查看內(nèi)存中以對象形式存在的其它模塊和函數(shù)，獲取它們的信息，并對它們進行操作。用這種方法，你可以定義沒有名稱的函數(shù)，不按函數(shù)聲明的參數(shù)順序調(diào)用函數(shù)，甚至引用事先并不知道名稱的函數(shù)。這些操作在C中都是不可想象的。4還有一個很有意思的細節(jié)，就是類型對對象行為的影響是各方面的，比如說，a=1;b=1這個語句中，在Python里面引發(fā)的，可能是a，b同時指向一個值為1的對象，也可能是分別指向兩個值為1的對象。而例如這個語句，c=[];d=[]，那么c和d是肯定指向不同的，新創(chuàng)建的空list的。沒完，如果是”c=d=[]“這個語句呢？此時，c和d又指向了相同的list對象了。這些區(qū)別，都是在c中沒有的。最后，我們來說說為什么python慢。主要原因就是functioncalloverhead比較大。因為所有東西現(xiàn)在都是對象了，contruct和destroy花費也大。連1+1都是functioncall，像’12′+’45′這樣的要createathirdstringobject,thencallsthestringobj’s__add。可想而知，速度如何能快起來？列表和數(shù)組分析Python中的list和C中的數(shù)組總是很有趣的。相信可能一些朋友和一樣，初學列表的時候，都是把它當作是數(shù)組來學的。最初對于list和數(shù)組區(qū)別的定性，主要是集中在兩點。首先，list可以包含很多不同的數(shù)據(jù)類型，比如["this",1,"is","an","array"]這個List，如果放在C中，其實是一個字符串數(shù)組，相當于二維的了。其次呢，list有很多方法，其本身就是一個對象，這個和C的單純數(shù)組是不同的。對于List的操作很多樣，因為有方法也有重載的運算符。也帶來一些問題，比如下面這個例子：加入我們要產(chǎn)生一個多維列表，用下面這個語句A=[[None]*2]*3結(jié)果，A的值會是[[None,None],[None,None],[None,None]]初一看沒問題，典型的二維數(shù)組形式的列表。好，現(xiàn)在我們想修改第一個None的值，用語句A[0][0]=5現(xiàn)在我們再來看看A的值：[[5,None],[5,None],[5,None]]發(fā)現(xiàn)問題沒有？這是因為用*來復制時，只是創(chuàng)建了對這個對象的引用，而不是真正的創(chuàng)建了它。*3創(chuàng)建了一個包含三個引用的列表，這三個引用都指向同一個長度為2的列表。其中一個行的改變會顯示在所有行中，這當然不是你想要的。解決方法當然有，我們這樣來創(chuàng)建A=[None]*3foriinrange(3):A[i]=[None]*2這樣創(chuàng)建了一個包含三個不同的長度為2的列表。所以，還是一直強調(diào)的，越復雜的東西，越靈活，也越容易出錯。代碼優(yōu)化C是一個很簡單的語言，當我們考慮優(yōu)化的時候，通常想得也很簡單，比如系統(tǒng)級調(diào)用越少越好（緩沖區(qū)機制），消除循環(huán)的低效率和不必要的系統(tǒng)引用，等等，其實主要都是基于系統(tǒng)和硬件細節(jié)考慮的。而Python就完全不一樣了，當然上面說的這些優(yōu)化形式，對于Python仍然是實用的，但由于Python的語法形式千差萬別，庫和模塊多種多樣，所以對于語言本身而言，就有很多值得注意的優(yōu)化要點，舉幾個例子吧。比如我們有一個listL1，想要構建一個新的listL2，L2包括L1的頭4個元素。按照最直接的想法，代碼應該是L2=[]foriinrange[3]:L2.append(L1[i])而更加優(yōu)化和優(yōu)美的版本是L2=L1[:3]再比如，如果s1..s7是大字符串(10K+)，那么join([s1,s2,s3,s4,s5,s6,s7])就會比s1+s2+s3+s4+s5+s6+s7快得多,因為后者會計算很多次子表達式，而join()則在一次過程中完成所有的復制。還有，對于字符串操作，對字符串對象使用replace()方法。僅當在沒有固定字符串模式時才使用正則表達式。所以說，以優(yōu)化為評判標準，如果說C是短小精悍，Python就是博大精深。include和import在C語言中的include非常簡單，因為形式單一，意義明確，當你需要用到外部函數(shù)等資源時，就用include。而Python中有一個相似的機制，就是import。乍一看，這兩個家伙挺像的，不都是我們要用外部資源（最常見的就是函數(shù)或者模塊（Python））時就用這個來指明么？其實不然，兩者的處理機制本質(zhì)區(qū)別在于，C中的include是用于告訴預處理器，這個include指定的文件的內(nèi)容，你都給我當作在本地源文件中出現(xiàn)過。而import呢，不是簡單的將后面的內(nèi)容*直接*插入到本地里面去，這玩意更加靈活。事實上，幾乎所有類似的機制，Python都比C靈活。這里不是說C不好，C很簡練，我其實更喜歡C。簡單說說這個靈活性。import在python中有三種形式，importX,fromXimport*(ora,b,c……),X=__import__(’x')。最常用的是第二種，因為比較方便，不像第一種那樣老是用X.module來調(diào)用模塊。fromXimport*只是import那些public的module(一般都是不以__命名的模塊)，也可以指定a,b,c來import。什么時候用哪一種形式呢？應該說，在大多數(shù)的模塊文檔里，都會明確告訴你應該用哪種形式。如果需要用到很多對象，那么fromXimport*可能更合適一些，但是，就目前來看，大多數(shù)第三方Python庫都不推薦使用frommodulenameimport*這種格式。這樣做會使引入者的namespace混亂。很多人甚至對于那些專門設計用于這種模式的模塊（包括Tkinter,threading和matplot）都不采用這種方式。而如果你僅僅需要某個對象類a，那么用fromXimporta比用importX.a更好，因為以后你調(diào)用a的函數(shù)直接用a.function()既可以了，不用加X。如果你連自己希望import的模塊都不知道怎么？請注意，此時Python的優(yōu)勢就體現(xiàn)出來了，我們可以用__import__(module)來調(diào)用module，其中這個module是字符串，這樣，可以在運行時再決定，你到底要調(diào)用什么module。舉個例子：defclassFromModule(module,Name):mod=__import__(module)returngetattr(mod,Name)這里，定義了一個函數(shù)classFromModule，你可以在代碼的任何時候調(diào)用它，o=classFromModule(ModuleOfTheClass,NameOfTheAttribute)()只需要傳入字符串形式的你希望import的模塊ModuleOfTheClass和其中屬性的名字NameOfTheAttribute（當然可以是數(shù)據(jù)也可以是方法），就能調(diào)用了，這個名字字符串不用事先指定，而是根據(jù)當時運行的情況來判斷。順帶說一句，Python中import的順序也有默認規(guī)定，這個和C中的include有點類似，因為我們一般都是先include系統(tǒng)文件，再include自己的頭文件（而且還有和“”的區(qū)別）。Python中呢，一般應該按照以下順序import模塊：1.標準庫模塊—如sys,os,getopt等2.第三方模塊3.本地實現(xiàn)的模塊。全局變量這里談全局變量呢，倒不是說Python和c的全局變量概念不同，他們的概念是相同的。只是在使用機制上，是有一些差異的。舉個例子：–module.py–globalvar=1deffunc():printglobalvar#Thismakessomeglobalreadonly,#anyattempttowritetosomeglobal#wouldcreateanewlocalvariable.deffunc2():globalglobalvarglobalvar=2#thisallowsyoutomanipulatetheglobal#variable在func這個函數(shù)中，globalvar是只讀的。如果你使用了globalvar=xxx這種賦值語句，Python會重新創(chuàng)造一個新的本地對象并將新值賦給它，原來的對象值不變。而在func2函數(shù)中，由于我們事先申明了globalvar是global的，那么此時的更改就直接在全局變量上生效。