python是函數式編程嗎

python是函數編程

10年積累的做網站、網站制作經驗，可以快速應對客戶對網站的新想法和需求。提供各種問題對應的解決方案。讓選擇我們的客戶得到更好、更有力的網絡服務。我雖然不認識你，你也不認識我。但先做網站設計后付款的網站建設流程，更有肇慶免費網站建設讓你可以放心的選擇與我們合作。

函數編程定義:

1、"函數式編程"是一種"編程范式"（programming paradigm），也就是如何編寫程序的方法論。

2、它屬于"結構化編程"的一種，主要思想是把運算過程盡量寫成一系列嵌套的函數調用。[2]

Python魔法函數（特殊函數）

Python中如何實現運算符的重載，即實現例如a+b這樣的運算符操作呢？

在C++中可以使用 operator 關鍵字實現運算符的重載。但是在Python中沒有類似這樣的關鍵字，所以要實現運算符的重載，就要用到Python的魔法函數。Python魔法函數是以雙下劃線開頭，雙下劃線結尾的一組函數。我們在類定義中最常用到的 __init__ 函數就是這樣一個魔法函數，它在創建類對象時被自動調用。

下面我們來看個簡單的例子。

上述代碼示例了幾個魔法函數的用法。 __add__ 函數對應了二元運算符+，當執行a+b語句時，python就會自動調用a. add (b)。 對于上述例子中的v1+v2+v3，則相當于調用了(v1. add(v2)). add(v3)。

代碼中還有一個在Python類定義經常使用的 __str__ 函數，當使用 str() 時會被調用。print函數對傳入的參數都調用了str()將其轉換成易讀的字符串形式，便于打印輸出，因而會調用類定義的__str__函數打出自定義的字符串。

代碼中還有一個特殊的 __call__ 函數，該函數在將對象采用函數調用方式使用時被調用, 例如v1()相當于v1. call ()。

以上就是魔法函數的基本使用方法。常見的魔法函數我們可以使用 dir() 函數來查看。

輸出結果為：

上述結果中形式為‘__函數名__’的函數為魔法函數，注意有些對象也是這種形式，例如__class__, __module__等, 這些不是魔法函數。具體的魔法函數說明可以參考Python官方說明文檔。

以上代碼在Python3.6運行通過.

python是函數式編程語言嗎

函數式編程是使用一系列函數去解決問題，按照一般編程思維，面對問題時我們的思考方式是“怎么干”，而函數函數式編程的思考方式是我要“干什么”。 至于函數式編程的特點暫不總結，我們直接拿例子來體會什么是函數式編程。

lambda表達式（匿名函數）：

普通函數與匿名函數的定義方式：

#普通函數

def add(a,b):

return a + b

print add(2,3)

#匿名函數

add = lambda a,b : a + b

print add(2,3)

#========輸出===========

5

5

匿名函數的命名規則，用lamdba 關鍵字標識，冒號（：）左側表示函數接收的參數（a,b） ,冒號（：）右側表示函數的返回值（a+b）。

因為lamdba在創建時不需要命名，所以，叫匿名函數^_^

Map函數：

計算字符串長度

abc = ['com','fnng','cnblogs']

for i in range(len(abc)):

print len(abc[i])

#========輸出===========

3

4

7

定義abc字符串數組，計算abc長度然后循環輸出數組中每個字符串的長度。

來看看map()函數是如何來實現這個過程的。

abc_len = map(len,['hao','fnng','cnblogs'])

print abc_len

#========輸出===========

[3, 4, 7]

雖然，輸出的結果中是一樣的，但它們的形式不同，第一種是單純的數值了，map()函數的輸出仍然保持了數組的格式。

大小寫轉換；

python提供有了，upper() 和 lower() 來轉換大小寫。

#大小寫轉換

ss='hello WORLD!'

print ss.upper() #轉換成大寫

print ss.lower() #轉換成小寫

#========輸出===========

HELLO WORLD!

hello world!

通過map()函數轉換：

def to_lower(item):

return item.lower()

name = map(to_lower,['cOm','FNng','cnBLoGs'])

print name

#========輸出===========

['com', 'fnng', 'cnblogs']

這個例子中我們可以看到，我們寫義了一個函數toUpper，這個函數沒有改變傳進來的值，只是把傳進來的值做個簡單的操作，然后返回。然后，我們把其用在map函數中，就可以很清楚地描述出我們想要干什么。

再來看看普通的方式是如何實現字符串大小寫轉換的：

abc = ['cOm','FNng','cnBLoGs']

lowname = []

for i in range(len(abc)):

lowname.append(abc[i].lower())

print lowname

#========輸出===========

['hao', 'fnng', 'cnblogs']

map()函數加上lambda表達式(匿名函數)可以實現更強大的功能。

#求平方

#0*0,1*1,2*2,3*3,....8*8

squares = map(lambda x : x*x ,range(9))

print squares

#========輸出===========

[0, 1, 4, 9, 16, 25, 36, 49, 64]

Reduce函數：

def add(a,b):

return a+b

add = reduce(add,[2,3,4])

print add

#========輸出===========

9

對于Reduce函數每次是需要對兩個數據進行處理的，首選取2 和3 ，通過add函數相加之后得到5，接著拿5和4 ，再由add函數處理，最終得到9 。

在前面map函數例子中我們可以看到，map函數是每次只對一個數據進行處理。

然后，我們發現通過Reduce函數加lambda表達式式實現階乘是如何簡單：

#5階乘

#5！=1*2*3*4*5

print reduce(lambda x,y: x*y, range(1,6))

#========輸出===========

120

Python中的除了map和reduce外，還有一些別的如filter, find, all, any的函數做輔助（其它函數式的語言也有），可以讓你的代碼更簡潔，更易讀。 我們再來看一個比較復雜的例子：

#計算數組中正整數的值

number =[2, -5, 9, -7, 2, 5, 4, -1, 0, -3, 8]

count = 0

sum = 0

for i in range(len(number)):

if number[i]0:

count += 1

sum += number[i]

print sum,count

if count0:

average = sum/count

print average

#========輸出===========

30 6

5

如果用函數式編程，這個例子可以寫成這樣：

number =[2, -5, 9, -7, 2, 5, 4, -1, 0, -3, 8]

sum = filter(lambda x: x0, number)

average = reduce(lambda x,y: x+y, sum)/len(sum)

print average

#========輸出===========

5

最后我們可以看到，函數式編程有如下好處：

1）代碼更簡單了。

2）數據集，操作，返回值都放到了一起。

3）你在讀代碼的時候，沒有了循環體，于是就可以少了些臨時變量，以及變量倒來倒去邏輯。

4）你的代碼變成了在描述你要干什么，而不是怎么去干。

python支持函數式編程嗎

python不是完全支持函數式編程，他支持部分函數式編程，函數式編程就是一種抽象程度很高的編程范式，純粹的函數式編程語言編寫的函數沒有變量，因此，任意一個函數，只要輸入是確定的，輸出就是確定的，這種純函數我們稱之為沒有副作用。而允許使用變量的程序設計語言，由于函數內部的變量狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函數是有副作用的。

Python對函數式編程提供部分支持。由于Python允許使用變量，因此，Python不是純函數式編程語言。

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

實例中傳入函數的和在末尾添加新內容的對象用的是同一個引用，故輸出結果如下：

函數內取值: ?[10, 20, 30, [1, 2, 3, 4]]函數外取值: ?[10, 20, 30, [1, 2, 3, 4]]

參數

以下是調用函數時可使用的正式參數類型：

必備參數

關鍵字參數

默認參數

不定長參數

必備參數

必備參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。

調用printme()函數，你必須傳入一個參數，不然會出現語法錯誤：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可寫函數說明def printme( str ): ? "打印任何傳入的字符串"

print str

return

#調用printme函數printme()

以上實例輸出結果：

Traceback (most recent call last):

File "test.py", line 11, in module

printme()TypeError: printme() takes exactly 1 argument (0 given)

關鍵字參數

關鍵字參數和函數調用關系緊密，函數調用使用關鍵字參數來確定傳入的參數值。

使用關鍵字參數允許函數調用時參數的順序與聲明時不一致，因為 Python 解釋器能夠用參數名匹配參數值。

以下實例在函數 printme() 調用時使用參數名：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可寫函數說明def printme( str ): ? "打印任何傳入的字符串"

print str

return

#調用printme函數printme( str = "My string")

以上實例輸出結果：

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" )

以上實例輸出結果：

Name: ?mikiAge ?50

默認參數

調用函數時，默認參數的值如果沒有傳入，則被認為是默認值。下例會打印默認的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" )

以上實例輸出結果：

Name: ?mikiAge ?50Name: ?mikiAge ?35

不定長參數

你可能需要一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數，和上述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 )

以上實例輸出結果：

輸出:10輸出:706050

匿名函數

python 使用 lambda 來創建匿名函數。

lambda只是一個表達式，函數體比def簡單很多。

lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。

lambda函數擁有自己的命名空間，且不能訪問自有參數列表之外或全局命名空間里的參數。

雖然lambda函數看起來只能寫一行，卻不等同于C或C++的內聯函數，后者的目的是調用小函數時不占用棧內存從而增加運行效率。

語法

lambda函數的語法只包含一個語句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

如下實例：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可寫函數說明sum = lambda arg1, arg2: arg1 + arg2

# 調用sum函數print "相加后的值為 : ", sum( 10, 20 )print "相加后的值為 : ", sum( 20, 20 )

以上實例輸出結果：

相加后的值為 : ?30相加后的值為 : ?40

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 )

以上實例輸出結果：

函數內 : ?30

變量作用域

一個程序的所有的變量并不是在哪個位置都可以訪問的。訪問權限決定于這個變量是在哪里賦值的。

變量的作用域決定了在哪一部分程序你可以訪問哪個特定的變量名稱。兩種最基本的變量作用域如下：

全局變量

局部變量

全局變量和局部變量

定義在函數內部的變量擁有一個局部作用域，定義在函數外的擁有全局作用域。

局部變量只能在其被聲明的函數內部訪問，而全局變量可以在整個程序范圍內訪問。調用函數時，所有在函數內聲明的變量名稱都將被加入到作用域中。如下實例：

實例(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

以上實例輸出結果：

函數內是局部變量 : ?30函數外是全局變量 : ?0

在python常說的函數式編程是什么意思

函數式編程相對應的是命令式編程

比方說你要定義一個方法

命令式編程如下：

def func1():

而同樣功能的函數式編程如下：

func1 = lambda :

新聞標題：python函數器,python生成器函數
文章鏈接：http://www.2m8n56k.cn/article30/hcecso.html

成都網站建設公司_創新互聯，為您提供全網營銷推廣、響應式網站、網站維護、關鍵詞優化、品牌網站制作、定制開發

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：[email protected]。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯