0

Hàm trong Python

Hàm trong Python

1. Khái niệm hàm trong Python

Trong lập trình, để thực hiện một công việc nào đó, và công việc này lặp đi lặp lại, chúng ta sử dụng hàm sẽ tiết kiệm được công sức. Chính bạn đã sử dụng một số hàm đã được xây dựng sẵn trong Python, ví dụ như hàm print(), type()

Chẳng hạn, trong chương trình chúng ta có một nhiệm vụ là giải phương trình bậc hai năm lần, thì mỗi lần người dùng sẽ nhập vào các hệ số a, b, c từ bàn phím, chương trình sẽ giải phương trình với các hệ số đó và trả lại kết quả là vô nghiệm, có nghiệm kép hay hai nghiệm phân biệt và in các nghiệm đó. Nếu không sử dụng hàm ta phải đánh máy đoạn chương trình sau 5 lần!

from math import sqrt

a = int(input("a = "))
b = int(input("b = "))
c = int(input("c = "))
d = b**2 – 4*a*c
if d < 0:
      print("Phương trình vô nghiệm.")
elif d == 0:
      print("Phương trình có nghiệm kép x = ", -b /(2*a))
else:
      print("Phương trình có hai nghiệm ", (-b + sqrt(d))/(2*a), " và ",\   (-b - sqrt(d))/(2*a))

Khi đó, chương trình trông sẽ dài dòng phức tạp, hơn nữa, mỗi lần giải một phương trình mới ta lại phải gõ lại đoạn mã  này, tính tái sử dụng không[1] có. Lúc này, chúng ta cần sử dụng đến hàm.

2. Khai báo hàm trong Python

Để khai báo một hàm trong Python chúng ta sử dụng từ khóa def với cú pháp:

def name([arg,... arg=value,... *arg, **arg]):
    """Mô tả về hàm nếu (nên) có (phần này thường gọi là docstring)"""
    <khối lệnh>
    return [giá trị trả về]

Trong đó name là tên của hàm, được đặt tên theo đúng quy tắc đặt tên và theo sau phải là cặp ngoặc tròn (). Bên trong cặp ngoặc tròn, ta có arg là các tham số nếu có, value là giá trị mặc định của tham số – nếu người dùng không cung cấp một giá trị cho tham số khi gọi hàm thì giá trị mặc định này sẽ được sử dụng, *arg**arg là các tham số kiểu tuple, tức một bộ các tham số.

Một hàm trong Python có thể có tham số hoặc không. Cần lưu ý rằng, nếu hàm có tham số nhận các giá trị mặc định, thì các tham số này phải được khai báo sau các tham số không nhận giá trị mặc định. Chẳng hạn, khai báo hàm bậc hai y=a*x**2+b*x+c thì thường giá trị mặc định là a=1, nhưng ta không thể khai báo tham số a lên trước, mà bắt buộc phải khai báo tham số a cuối cùng, chẳng hạn

def ham_bac_hai(b, c, a = 1):
    <khối lệnh thực thi hàm>

Tiếp theo là dấu hai chấm : và xuống dòng để bắt đầu vào phần thân của hàm. Phần này có thể gồm chú thích mô tả về hàm để giúp cho các lập trình viên khác, và chính bản thân chúng ta sau này, hiểu rõ hơn về hàm và khối lệnh chính của hàm để thực hiện nhiệm vụ đề ra.

Cuối cùng là từ khóa return để thoát khỏi hàm và trở về chương trình chính, hoặc trả về giá trị của hàm đối với hàm có giá trị trả về; phần này không bắt buộc phải có.

Một hàm nếu được khai báo trong một lớp thì còn được gọi là một phương thức method của lớp.

3. Lời gọi đến hàm trong Python

Để gọi một hàm có tên là name đã được định nghĩa, ta sử dụng câu lệnh name(). Hãy quay trở lại ví dụ giải phương trình bậc hai để hiểu rõ hơn.

from math import sqrt
def giai_pt():
      a = int(input("a = "))
      b = int(input("b = "))
      c = int(input("c = "))
      d = b**2 – 4*a*c
      if d < 0:
            print("Phương trình vô nghiệm.")
      elif d == 0:
            print("Phương trình có nghiệm kép x = ", -b /(2*a))
      else:
            print("Phương trình có hai nghiệm ", (-b + sqrt(d))/(2*a),
            " và ", (-b – sqrt(d))/(2*a))

Như vậy, hàm giai_pt ở trên không có tham số truyền vào và cũng không có kết quả trả về, bởi bản thân các lệnh trong hàm đã in ra nghiệm của phương trình rồi. Để gọi hàm này ta chỉ đơn giản là dùng câu lệnh giai_pt().

Ở cách làm này, trong bản thân hàm đã có các câu lệnh để người dùng nhập vào giá trị của các hệ số a, b, c của phương trình. Nếu muốn truyền các hệ số khi gọi hàm giai_pt() ta có thể viết lại như sau:

from math import sqrt
def giai_pt(a, b, c):
      d = b**2 – 4*a*c
      if d < 0:
            print("Phương trình vô nghiệm.")
      elif d == 0:
            print("Phương trình có nghiệm kép x = ", -b /(2*a))
      else:
            print("Phương trình có hai nghiệm ", (-b + sqrt(d))/(2*a),\
            " và ", (-b – sqrt(d))/(2*a))

Lúc này, để giải phương trình bậc hai với các hệ số a = 1, b = -3, c = 5 ta chỉ việc gọi hàm bằng cách sử dụng câu lệnh giai_pt(1, -3, 5).

4. Giá trị trả về của hàm

Hàm trong Python có thể có hoặc không có giá trị trả về. Điều này khác với các hàm số trong toán học bắt buộc phải nhận một giá trị trả về, thì hàm trong Python có thể chỉ thực hiện một nhiệm vụ nào đó như in ra màn hình một chuỗi, xóa hết các phần tử của một tập hợp…

Trong trường hợp hàm có kết quả trả về ta sử dụng từ khóa return, theo sau là giá trị trả về của hàm. Khi đó hàm có thể được sử dụng như một biến để tính toán. Hãy xét một hàm đơn giản, tên là cong để cộng hai số nguyên ab, giá trị trả về chính là tổng của hái số đó, định nghĩa như sau:

def cong(a, b):
      return a + b

Chúng ta sẽ thử gọi hàm này với các tham số truyền vào  a = 3, b =7.

>>> cong(3, 7)
10
>>> cong(3, 7) + 5
15

Nếu ta thực hiện chương trình này trong trình thông dịch Python, thì ở lần gọi hàm thứ nhất kết quả trả về là 10, ở lần gọi thứ hai, bản thân hàm được sử dụng như một biến số để thực hiện tiếp phép cộng, và kết quả trả về là 10.

Tuy nhiên, nếu các bạn soạn một script có nội dung như sau

def cong(a, b):
      return a + b

cong(3, 7)
cong(4, 7) + 5

và lưu lại với tên có phần mở rộng .py rồi chạy script này thì kết quả là không xuất hiện gì cả trên màn hình! Lí do là chương trình vẫn tính a + b, và vẫn trả về kết quả này và được sử dụng để tính toán tiếp nhưng không được in ra màn hình. Lúc này, muốn in kết quả ra chúng ta phải sử dụng đến hàm print() của Python.

def cong(a, b):
      return a + b

print(cong(3, 7))
print(cong(4, 7) + 5)

Theo sau từ khóa return là một giá trị, một biểu thức, một câu lệnh, thậm chí lại là một hàm[2] hoặc không có gì cả. Nếu không có gì, thì chương trình chỉ đơn giản là thoát khỏi hàm mà thôi và trả về giá trị None. Mỗi khi gặp từ khóa return thì hàm sẽ kết thúc, chương trình sẽ thoát khỏi hàm và thực hiện câu lệnh tiếp theo. Hãy xem ví dụ sau để hiểu rõ hơn:

def test():
      print(1)
      return
      print(2)

Chúng ta sẽ chạy thử.

>>> test()
1
>>> print(test())
1
None

Ta thấy ngay, câu lệnh print(2) không được thực thi vì trước đó chương trình đã thực hiện lệnh return rồi. Hơn nữa, lệnh return này không trả về gì cả, nên nếu ta dùng lệnh print(test()) thì chương trình sẽ trả về kết quả None. Còn số 1 kia được in ra là do bản thân trong hàm có câu lệnh print(1) mà thôi.

Bài tập

  • Viết hàm giải hệ phương trình bậc nhất hai ẩn, sử dụng định thức cấp hai.
  • Viết chương trình kiểm tra xem số tự nhiên n có phải là số nguyên tố không.
  • Viết chương trình tìm ước chung lớn nhất của hai số tự nhiên.

5. Tham số của hàm trong Python

Như đã nói, một hàm có thể có tham số hoặc không. Đối với hàm có tham số thì nếu số lượng tham số xác định, chúng ta có thể khai báo hết các tham số/đối số đó. Nhưng đối với các hàm có số lượng tham số chưa biết, ví dụ như tính tổng của một dãy số mà chưa biết dãy đó có bao nhiêu phần tử, thì chúng ta phải cần đến các tham số đặc biệt, khai báo với các dấu sao * trước danh sách tham số/đối số.

Phần này có tham khảo từ blog https://icewolf-blog.herokuapp.com/post/8

 5.1. Cách truyền tham số dạng *args**kwargs trong python (abittrary arguments)

Kiểu truyền tham số này thường được sử dụng khi định nghĩa những hàm không biết trước số lượng tham số truyền vào. Thực sự thì không nhất thiết phải là *args**kwargs, điều quan trọng là tham số có 1 dấu sao * hay là 2 dấu sao **. Đặt tên tham số là *var hay **vars hay bất cứ thứ gì bạn muốn. Nhưng để dễ hiểu thì nên dùng tên chuẩn là *args**kwargs

5.2. *args**kwargs dùng để làm gì?

Khi khai báo một hàm trong Python, sử dụng *args**kwargs cho phép bạn truyền vào nhiều tham số/đối số mà không cần biết trước số lượng.

#giả sử các tham số truyền vào đều là số

def sum(*args):
   total = 0
   for number in args:
     total += number
 return total

# gọi hàm
sum(1, 2, 3, 19)
sum(1, 100)

def myFun(*argv): 
    for arg in argv: 
        print (arg)
   
myFun('Hello', 'Welcome', 'to', 'GeeksforGeeks')

5.3. *args**kwargs khác gì nhau?

Khi gọi hàm trong Python, có 2 kiểu truyền tham số:

  • Truyền tham số theo tên.
  • Truyền tham số bình thường theo thứ tự khai báo đối số.

Ví dụ

def register(name, password):
 ....

#Truyền tham số theo kiểu thông thường, phải theo đúng thứ tự
register( 'Coulson', 'hail_Hydra')

#Truyền tham số theo tên, Không cần phải theo thứ tự khai báo thao số
register( password='cookHim', name='Skye')
  • *args nhận các tham số truyền bình thường, sử dụng args như một list.
  • **kwargs nhận tham số truyền theo tên, sử dụng kwargs như một dictionary.
def test_args(*args):
  for item in args:
     print item

>>>test_args('Hello', 'world!')
Hello
world!

def test_kwargs(*kwargs):
  for key, value in kwargs.iteritems():
     print '{0} = {1}'.format(key, value)

>>test_kwargs(name='Dzung', age=10)
age = 10
name = Dzung

5.4. Thứ tự sử dụng và truyền tham số *args, **kwargs và tham số bình thường

Khi sử dụng hàm, ta phải khai báo đối số theo thứ tự ưu tiên đối số/tham số xác đinh, tiếp theo là *args và cuối cùng là **kwargs.  Đây là thứ tự bắt buộc. Và khi truyền tham số bạn cũng phải truyền theo đúng thứ tự này. Không thể truyền lẫn lộn giữa 2 loại.

Khi sử dụng đồng thời *args**kwargs thì không thể truyền tham số bình thường theo tên

def show_detail(name, *args, **kwargs):
...

show_detail(name='Coulson', 'agent', age='40', level='A')
>>> Lỗi

def show_detail_2(name, **kwargs):
...

show_detail_2(name=Coulson', age='40', level='A')
>>> Chạy OK

6. Lời gọi đệ quy đến hàm trong Python

Một hàm có thể gọi lại chính nó, lúc này ta gọi là các lời gọi đệ quy[3] recursion.

Ví dụ, cho cấp số cộng un với u1 = 5 và công sai d = 7 thì, chẳng hạn, muốn tìm số hạng thứ 20 ta lấy số hạng thứ 19 cộng thêm 7, nhưng muốn tính số hạng thứ 19 ta lại phải lấy số hạng thứ 18 cộng thêm 7 và cứ như thế cho đến số hạng thứ nhất thì đã có sẵn u1 = 5. Tổng quát, ta có công thức truy hồi như sau

Nếu ta viết hàm cap_so_cong(n) để tính số hạng thứ n thì trong bản thân hàm này sẽ gọi lại chính nó với tham số truyền vào là n - 1:

def cap_so_cong(n):
      if n == 1:
            return 5
      else:
            return cap_so_cong(n-1) + 7

Lúc này, để tìm số hạng thứ n ta chỉ việc gọi hàm và truyền vào tham số n, chẳng hạn tính số hạng thứ 50 thì gọi hàm và truyền vào cho nó tham số n = 50, cap_so_cong(50):

>>> cap_so_cong(50)
348

Một hàm có thể gọi lại chính nó nhiều lần, ví dụ, chúng ta xét dãy số Fibonacci

Chúng ta có chương trình như sau

def fibonacci(n):
      if n == 1 or n == 2:
            return 1
      else:
            return fibonacci(n-1) + fibonacci(n-2)

Khi chạy chương trình, thử tìm số Fibonacci thứ 30 ta được kết quả

>>> fibonacci(30)
832040

Tuy nhiên, trong lập trình, chúng ta nên hạn chế các lời gọi đệ quy, vì như thế chương trình sẽ cần rất nhiều bộ nhớ, chẳng hạn, ta tìm số Fibonacci thứ 100 thôi đã phải đợi rất lâu, vì bản thân mỗi lần gọi hàm, chương trình sẽ gọi lại chính nó hai lần và cứ như thế, do đó số lượng lời gọi hàm sẽ tăng lên rất nhiều với tốc độ cấp số nhân!

Bài tập

  • Viết hàm cap_so_nhan(n) để tìm số hạng thứ n của một cấp số nhân với số hạng đầu bằng 7 và công bội bằng 2.
  • Viết hàm giai_thua(n) để tính giai thừa[4] của số tự nhiên n, chẳng hạn giai_thua(6) trả về kết quả 720.
  • Tìm tất cả các số tự nhiên hai chữ số mà khi đảo trật tự của hai chữ số đó sẽ thu được một số nguyên tố cùng nhau với số đã cho.
  • Tìm các số tự nhiên lẻ có ba chữ số. Ba chữ số này, theo trật tự từ trái qua phải tạo thành một cấp số cộng.
  • Tìm các số tự nhiên có ba chữ số. Ba chữ số này, theo trật tự từ trái qua phải tạo thành một cấp số nhân với công bội là một số tự nhiên khác 0.

7. Biến toàn cục, biến cục bộ

Trong Python không có sự phân biệt giữa tham số và tham số giá trị như trong ngôn ngữ khác, Pascal chẳng hạn, nên tất cả các giá trị được truyền vào một hàm chúng ta đều gọi là tham số của hàm. Ở đây, chúng ta chỉ cần phân biệt khái niệm biến toàn cục global và biến cục bộ (biến địa phương) local mà thôi.

Một biến được định nghĩa bên trong một hàm chỉ có thể được sử dụng bên trong hàm đó và được gọi là biến cục bộ. Các tham số và biến cục bộ này chỉ được phép sử dụng bởi các lệnh nằm bên trong hàm. Khi hàm được thực thi thì biến sẽ tồn tại và sẽ bị hủy khi chúng ta thoát khỏi hàm.

a = 1
def bien_cuc_bo(a):
    a = 5
    print(a)

bien_cuc_bo(a) # chương trình  trả về kết quả là 5
print(a) #chương trình vẫn trả về kết quả là 1

Nhưng nếu như biến mà có kiểu dữ liệu là list thì những thay đổi bên trong hàm sẽ được giữ lại.

a = [0, 5, 10, 15]
def bien_cuc_bo(a):
    a[1] = 100
    print(a)

bien_cuc_bo(a) # chương trình  trả về kết quả là [0, 100, 10, 15]
print(a) #chương trình vẫn trả về kết quả là [0, 100, 10, 15]

Để ghi nhận lại những thay đổi giá trị của một biến do các câu lệnh bên trong hàm tạo nên, chúng ta có thể sử dụng từ khóaglobal (biến toàn cầu, biến toàn cục). Khi một biến được khai báo là global thì chúng ta có thể gọi và thay đổi giá trị của nó từ bất kỳ đâu trong chương trình, kể cả trong thân hàm. Lưu ý rằng biến toàn cục chỉ có thể khai báo bên trong hàm và nó không thể là tham số/đối số của hàm.

Như ví dụ sau, biến a lúc đầu có giá trị là 1, và trong hàm a được khai báo global đồng thời nhận giá trị mới là 5 thì ra bên ngoài hàm, giá trị mới này vẫn được ghi lại chứ không như ví dụ trước.

a = 1
def bien_toan_cuc():
   global a
   a = 5
   print(a)

bien_toan_cuc() # chương trình  trả về kết quả là 5
print(a) #chương trình vẫn trả về kết quả là 5

8. Hàm nặc danh

Chúng ta sử dụng từ khoá lambda được dùng để tạo một hàm số nặc danh (một hàm số không có tên). Nó là một hàm số trên một dòng và không có câu lệnh return. Nó chỉ bao gồm một biểu thức mà kết quả của biểu thức này chính là giá trị trả về của hàm. Ví dụ:

a = lambda x: x*2
for i in range(1,6):
      print(a(i))

Kết quả

2
4
6
8
10

Ở đây, chúng ta tạo ra một hàm số chỉ trong một dòng lệnh, nó được dùng để nhân đôi giá trị của đối số nhận vào, sử dụng câu lệnh lambda. Sau đó, chúng ta dùng hàm này để nhân đôi các giá trị của một danh sách các số nguyên từ 1 đến 5.

[1]Bạn chỉ có thể tái sử dụng bằng cách Copy – Paste mà thôi 🙂

[2]Xem phần đệ quy hàm để rõ hơn.

[3]Thực ra, thử tìm hiểu từ đệ quy thì thấy rất khó hiểu, ta cứ hiểu nôm na như là phép quy nạp trong Toán học.

[4]Giai thừa của một số tự nhiên n, kí hiệu là n!, được tính bởi công thức

hocbaicungcon

Leave a Reply

Your email address will not be published. Required fields are marked *