在Python中，函式是一級（First-class）公民，也就是說，在Python中，函式是物件，為function的實例。如果你要定義一個函式，基本上是使用def來定義，如同 def 陳述句 中所說明過的，例如你要定義一個最大值的函式：
def max(m, n):
return m if m > n else n
print(max(10, 3)) # 顯示 10你可以用lambda運算式來定義函式，執行運算式時將會產生函式物件。 例如，上面的max函式，可以用以下的方式定義：
max = lambda m, n: m if m > n else n
print(max(10, 3)) # 顯示 10
lambda的語法是：
lambda arg1, arg2, ....: expression
lambda中arg1、arg2等就相當於定義函式時的參數，之後你可以在expression中使用這些參數。注意！lambda是運算式，不是陳述句，你在:之後的也必須是運算式，lambda中也不能有區塊，這表示一些小的運算任務你可以使用lambda，而較複雜的邏輯你可以使用def來定義。
基本上，lambda會產生function的實例，所以在def 陳述句 中所提到的參數定義與引數指定方式，對於lambda所產生的function實例都是適用的。
在Python中缺少其它語言中的switch陳述句，以下結合字典物件與lambda模擬switch的示範：
score = int(input('請輸入分數：'))
level = score // 10
{
10 : lambda: print('Perfect'),
9 : lambda: print('A'),
8 : lambda: print('B'),
7 : lambda: print('C'),
6 : lambda: print('D')
}.get(level, lambda: print('E'))()
在上例中，字典物件中的值的部份是lambda所建立的函式物件，你使用get()方法指定鍵，如果有符合的鍵，就傳回對應的函式物件並執行，否則就傳回get()第二個引數所指定的函式並執行，這模擬了switch中default的陳述。
在Python中，函式是function的實例，所以你可以自由傳遞，將一個函式中所定義的函式傳回也是常見的應用。例如：
def add(n1):
def func(n2):
return n1 + n2
return func
print(add(1)(2)) # 顯示 3
從一個函式中呼叫另一個函式，這是函式程設中鞣制（Curry）的概念。所謂鞣製，是指將接受多個參數的函式，改為接受單一參數的函式，在函式執行過後傳回一個函式物件再套用剩下的參數，就像是將兩個函式鞣製在一起。
另一個值得注意的是，n1參數的存活期間，本應跟隨著add()函式呼叫完成就結束，不過因為n1被綁定在func()函式之中，形成了一個閉包（Closure）。
閉包（Closure）是擁有閒置變數（Free variable）的運算式。閒置變數真正扮演的角色依當時語彙環境（Lexical environment）而定。支援閉包的程式語言通常具有一級函式（First-class function）。建立函式不等於建立閉包。如果函式的閒置變數與當時語彙環境綁定，該函式才稱為閉包。
在Python中，確實支援閉包的概念。例如：
>>> def outer():
... x = 10
... def inner():
... print(x)
... inner()
... x = 20
... return inner
...
>>> f = outer()
10
>>> f()
20
>>>
... x = 10
... def inner():
... print(x)
... inner()
... x = 20
... return inner
...
>>> f = outer()
10
>>> f()
20
>>>
在上例中，inner()確實綁定了區域變數x，在outer()內部呼叫inner()時顯示的是10，而後改變了x為20，由於inner()綁定了x，所以傳回的函式執行時，顯示x的值為20。
不過實際上在應用時，還是得小心一點。例如：
>>> def func():
... x = 10
... def getX():
... return x
... def setX(n):
... x = n
... return (getX, setX)
...
>>> getX, setX = func()
>>> getX()
10
>>> setX(20)
>>> getX()
10
>>>
... x = 10
... def getX():
... return x
... def setX(n):
... x = n
... return (getX, setX)
...
>>> getX, setX = func()
>>> getX()
10
>>> setX(20)
>>> getX()
10
>>>
在上例中，func()中的setX()宣告的x，其實是setX()中的區域變數x，其覆蓋了外部func()的x，所以你的n是指定給區域變數x。
回到鞣製的討論，實際上其應用，在於先針對既有的資料先行作運算並傳回未運算的函式，待後續資料備妥後再完成整個所需的運算結果。一個例子像是 因 式分解，可以先準備好一定長度的質數表，之後利用該質數表來進行因式分解。例如：
import math
def prepare_factor(max):
prime = [1] * max
for i in range(2, int(math.sqrt(max))):
if prime[i] == 1:
for j in range(2 * i, max):
if j % i == 0:
prime[j] = 0
primes = [i for i in range(2, max) if prime[i] == 1] # 質數表
def factor(num):
list = []
i = 0
while primes[i] ** 2 <= num:
if num % primes[i] == 0:
list.append(primes[i])
num //= primes[i]
else:
i += 1
list.append(num)
f = [0] * len(list)
for i in range(len(f)):
f[i] = list[i]
return f
return factor
factor = prepare_factor(1000)
print(factor(100)) # 顯示 [2, 2, 5, 5]
print(factor(500)) # 顯示 [2, 2, 5, 5, 5]
print(factor(800)) # 顯示 [2, 2, 2, 2, 2, 5, 5]