Toán tử dấu sao có nghĩa là gì trong một lệnh gọi hàm?

Không những gì *nhà điều hành có nghĩa là bằng Python, chẳng hạn như trong mã như zip(*x)hay f(**k)?

1. Nó được xử lý nội bộ như thế nào trong trình thông dịch?
2. Nó có ảnh hưởng đến hiệu suất không? Nó nhanh hay chậm?
3. Khi nào thì hữu ích và khi nào thì không?
4. Nó nên được sử dụng trong một khai báo hàm hoặc trong một cuộc gọi?

Dấu sao đơn *giải nén chuỗi / tập hợp thành các đối số vị trí, vì vậy bạn có thể làm điều này:

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

values = (1, 2)

s = sum(*values)

Thao tác này sẽ giải nén bộ tuple để nó thực sự thực thi như sau:

s = sum(1, 2)

Dấu sao đôi **cũng làm như vậy, chỉ sử dụng từ điển và do đó, các đối số được đặt tên:

values = { 'a': 1, 'b': 2 }
s = sum(**values)

Bạn cũng có thể kết hợp:

def sum(a, b, c, d):
    return a + b + c + d

values1 = (1, 2)
values2 = { 'c': 10, 'd': 15 }
s = sum(*values1, **values2)

sẽ thực thi như:

s = sum(1, 2, c=10, d=15)

Cũng xem phần 4.7.4 - Giải nén danh sách đối số của tài liệu Python.

Ngoài ra, bạn có thể xác định các hàm nhận *xvà **yđối số, điều này cho phép một hàm chấp nhận bất kỳ số lượng đối số vị trí và / hoặc được đặt tên nào không được đặt tên cụ thể trong khai báo.

Thí dụ:

def sum(*values):
    s = 0
    for v in values:
        s = s + v
    return s

s = sum(1, 2, 3, 4, 5)

hoặc với **:

def get_a(**values):
    return values['a']

s = get_a(a=1, b=2)      # returns 1

điều này có thể cho phép bạn chỉ định một số lượng lớn các tham số tùy chọn mà không cần phải khai báo chúng.

Và một lần nữa, bạn có thể kết hợp:

def sum(*values, **options):
    s = 0
    for i in values:
        s = s + i
    if "neg" in options:
        if options["neg"]:
            s = -s
    return s

s = sum(1, 2, 3, 4, 5)            # returns 15
s = sum(1, 2, 3, 4, 5, neg=True)  # returns -15
s = sum(1, 2, 3, 4, 5, neg=False) # returns 15

Một điểm nhỏ: đây không phải là toán tử. Các toán tử được sử dụng trong các biểu thức để tạo các giá trị mới từ các giá trị hiện có (ví dụ: 1 + 2 trở thành 3. * Và ** ở đây là một phần của cú pháp khai báo và gọi hàm.

Tôi thấy điều này đặc biệt hữu ích khi bạn muốn 'lưu trữ' một lệnh gọi hàm.

Ví dụ: giả sử tôi có một số bài kiểm tra đơn vị cho một hàm 'add':

def add(a, b): return a + b
tests = { (1,4):5, (0, 0):0, (-1, 3):3 }
for test, result in tests.items():
   print 'test: adding', test, '==', result, '---', add(*test) == result

Không có cách nào khác để gọi add, ngoài việc làm thủ công một cái gì đó như add (test [0], test [1]), điều này thật tệ. Ngoài ra, nếu có một số biến thay đổi, mã có thể trở nên khá xấu với tất cả các câu lệnh if mà bạn cần.

Một nơi khác, điều này hữu ích là để xác định các đối tượng Factory (đối tượng tạo đối tượng cho bạn). Giả sử bạn có một lớp Factory nào đó, tạo ra các đối tượng Xe và trả về chúng. Bạn có thể làm cho nó để myFactory.make_car ('red', 'bmw', '335ix') tạo Car ('red', 'bmw', '335ix'), sau đó trả về nó.

def make_car(*args):
   return Car(*args)

Điều này cũng hữu ích khi bạn muốn gọi một phương thức khởi tạo của lớp cha.

Nó được gọi là cú pháp cuộc gọi mở rộng. Từ tài liệu :

Nếu biểu thức cú pháp * xuất hiện trong lệnh gọi hàm, biểu thức phải đánh giá thành một chuỗi. Các phần tử từ chuỗi này được coi như thể chúng là các đối số vị trí bổ sung; nếu có các đối số vị trí x1, ..., xN và biểu thức ước lượng là một chuỗi y1, ..., yM, điều này tương đương với một lệnh gọi với M + N đối số vị trí x1, ..., xN, y1 ,. .., yM.

và:

Nếu biểu thức cú pháp ** xuất hiện trong lệnh gọi hàm, biểu thức phải đánh giá thành một ánh xạ, nội dung của nó được coi là đối số từ khóa bổ sung. Trong trường hợp từ khóa xuất hiện trong cả biểu thức và dưới dạng đối số từ khóa rõ ràng, ngoại lệ TypeError sẽ được đưa ra.

Trong một lệnh gọi hàm, dấu sao đơn biến một danh sách thành các đối số riêng biệt (ví dụ zip(*x)giống như zip(x1,x2,x3)if x=[x1,x2,x3]) và dấu sao kép biến một từ điển thành các đối số từ khóa riêng biệt (ví dụ f(**k)giống như f(x=my_x, y=my_y)if k = {'x':my_x, 'y':my_y}.

Trong định nghĩa hàm thì ngược lại: dấu sao đơn biến một số đối số tùy ý thành danh sách và dấu sao kép biến một số đối số từ khóa tùy ý thành từ điển. Ví dụ: def foo(*x)"foo có một số lượng đối số tùy ý và chúng sẽ có thể truy cập được thông qua danh sách x (tức là nếu người dùng gọi foo(1,2,3), xsẽ được [1,2,3])" và def bar(**k)thanh có nghĩa là "lấy một số lượng đối số từ khóa tùy ý và chúng sẽ có thể truy cập được thông qua từ điển k (tức là nếu người dùng gọi bar(x=42, y=23), ksẽ được {'x': 42, 'y': 23}) ”.