Giải thích
Vấn đề ở đây là giá trị của
>>> i = [] # instead of an int, i is now a *mutable* object
>>> def f[i=i]:
... print['i =', i]
...
>>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it
>>> f[]
i = [5]
1 không được lưu khi hàm >>> i = [] # instead of an int, i is now a *mutable* object
>>> def f[i=i]:
... print['i =', i]
...
>>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it
>>> f[]
i = [5]
2 được tạo. Thay vào đó, >>> i = [] # instead of an int, i is now a *mutable* object
>>> def f[i=i]:
... print['i =', i]
...
>>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it
>>> f[]
i = [5]
2 tìm kiếm giá trị của >>> i = [] # instead of an int, i is now a *mutable* object
>>> def f[i=i]:
... print['i =', i]
...
>>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it
>>> f[]
i = [5]
1 khi nó được gọi.Nếu bạn nghĩ về nó, hành vi này có ý nghĩa hoàn hảo. Trên thực tế, đó là các chức năng hợp lý duy nhất có thể hoạt động. Hãy tưởng tượng bạn có một chức năng truy cập một biến toàn cầu, như thế này:
global_var = 'foo'
def my_function[]:
print[global_var]
global_var = 'bar'
my_function[]
Khi bạn đọc mã này, bạn sẽ - tất nhiên - mong đợi nó in "thanh", không phải "foo", bởi vì giá trị của
>>> i = [] # instead of an int, i is now a *mutable* object
>>> def f[i=i]:
... print['i =', i]
...
>>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it
>>> f[]
i = [5]
5 đã thay đổi sau khi chức năng được khai báo. Điều tương tự cũng xảy ra trong mã của riêng bạn: Vào thời điểm bạn gọi >>> i = [] # instead of an int, i is now a *mutable* object
>>> def f[i=i]:
... print['i =', i]
...
>>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it
>>> f[]
i = [5]
2, giá trị của >>> i = [] # instead of an int, i is now a *mutable* object
>>> def f[i=i]:
... print['i =', i]
...
>>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it
>>> f[]
i = [5]
1 đã thay đổi và được đặt thành >>> i = [] # instead of an int, i is now a *mutable* object
>>> def f[i=i]:
... print['i =', i]
...
>>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it
>>> f[]
i = [5]
8.Giải pháp
Thực tế có nhiều cách để giải quyết vấn đề này. Dưới đây là một vài lựa chọn:
Buộc liên kết sớm của
1 bằng cách sử dụng nó làm đối số mặc định>>> i = [] # instead of an int, i is now a *mutable* object >>> def f[i=i]: ... print['i =', i] ... >>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it >>> f[] i = [5]
Không giống như các biến đóng [như
1], các đối số mặc định được đánh giá ngay lập tức khi hàm được xác định:>>> i = [] # instead of an int, i is now a *mutable* object >>> def f[i=i]: ... print['i =', i] ... >>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it >>> f[] i = [5]
1 được chụp và lưu.for i in range[3]: def f[i=i]: # >> i = [] # instead of an int, i is now a *mutable* object >>> def f[i=i]: ... print['i =', i] ... >>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it >>> f[] i = [5]
>>> i = 0 >>> def f[i=i]: ... pass >>> f.__defaults__ # this is where the current value of i is stored [0,] >>> # assigning a new value to i has no effect on the function's default arguments >>> i = 5 >>> f.__defaults__ [0,]
Sử dụng một nhà máy chức năng để nắm bắt giá trị hiện tại là
1 trong một đóng cửa>>> i = [] # instead of an int, i is now a *mutable* object >>> def f[i=i]: ... print['i =', i] ... >>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it >>> f[] i = [5]
Root của vấn đề của bạn là
1 là một biến có thể thay đổi. Chúng ta có thể giải quyết vấn đề này bằng cách tạo một biến khác được đảm bảo sẽ không bao giờ thay đổi - và cách dễ nhất để làm điều này là một sự đóng cửa:>>> i = [] # instead of an int, i is now a *mutable* object >>> def f[i=i]: ... print['i =', i] ... >>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it >>> f[] i = [5]
def f_factory[i]: def f[]: return i # i is now a *local* variable of f_factory and can't ever change return f for i in range[3]: f = f_factory[i] functions.append[f]
Sử dụng
4 để liên kết giá trị hiện tại củaOutput [[0, item_1], [1, item_1], [2, item_2], . . ., [n, item_n]]
1 với>>> i = [] # instead of an int, i is now a *mutable* object >>> def f[i=i]: ... print['i =', i] ... >>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it >>> f[] i = [5]
2>>> i = [] # instead of an int, i is now a *mutable* object >>> def f[i=i]: ... print['i =', i] ... >>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it >>> f[] i = [5]
4 cho phép bạn đính kèm các đối số vào một chức năng hiện có. Theo một cách nào đó, nó cũng là một loại nhà máy chức năng.Output [[0, item_1], [1, item_1], [2, item_2], . . ., [n, item_n]]
import functools def f[i]: return i for i in range[3]: f_with_i = functools.partial[f, i] # important: use a different variable than "f" functions.append[f_with_i]
Hãy cẩn thận: Các giải pháp này chỉ hoạt động nếu bạn gán một giá trị mới cho biến. Nếu bạn sửa đổi đối tượng được lưu trữ trong biến, bạn sẽ gặp lại vấn đề tương tự: These solutions only work if you assign a new value to the variable. If you modify the object stored in the variable, you'll experience the same problem again:
>>> i = [] # instead of an int, i is now a *mutable* object
>>> def f[i=i]:
... print['i =', i]
...
>>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it
>>> f[]
i = [5]
Lưu ý cách
>>> i = [] # instead of an int, i is now a *mutable* object
>>> def f[i=i]:
... print['i =', i]
...
>>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it
>>> f[]
i = [5]
1 vẫn thay đổi mặc dù chúng tôi đã biến nó thành một đối số mặc định! Nếu mã của bạn đột biến >>> i = [] # instead of an int, i is now a *mutable* object
>>> def f[i=i]:
... print['i =', i]
...
>>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it
>>> f[]
i = [5]
1, thì bạn phải liên kết một bản sao của >>> i = [] # instead of an int, i is now a *mutable* object
>>> def f[i=i]:
... print['i =', i]
...
>>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it
>>> f[]
i = [5]
1 với chức năng của bạn, như vậy:
1colour = ["Black", "Purple", "Brown", "Yellow", "Blue"] list[enumerate[colour]]
2colour = ["Black", "Purple", "Brown", "Yellow", "Blue"] list[enumerate[colour]]
3colour = ["Black", "Purple", "Brown", "Yellow", "Blue"] list[enumerate[colour]]
Khi bạn lặp qua một chuỗi trong Python như một danh sách, tuple, chuỗi hoặc từ điển, bạn có bao giờ cảm thấy mã của mình là lộn xộn hoặc bạn muốn xóa một số biến khỏi nó không? May mắn thay, Python có một số chức năng
4 hữu ích làm cho mã của bạn ngắn gọn và dễ đọc hơn.colour = ["Black", "Purple", "Brown", "Yellow", "Blue"]
list[enumerate[colour]]
Trong hướng dẫn này, chúng tôi sẽ tìm hiểu về các chức năng
colour = ["Black", "Purple", "Brown", "Yellow", "Blue"]
list[enumerate[colour]]
4 khác nhau với các ví dụ đơn giản để hiểu cách chúng hoạt động.Cách lặp qua một chuỗi với hàm liệt kê [] trong Python
Chức năng
colour = ["Black", "Purple", "Brown", "Yellow", "Blue"]
list[enumerate[colour]]
6 của Python trên một chuỗi [List, Tuple, String hoặc Dictionary] trong khi theo dõi giá trị chỉ mục trong một biến riêng biệt.Hãy xem cú pháp:
colour = ["Black", "Purple", "Brown", "Yellow", "Blue"]
list[enumerate[colour]]
7Nó bao gồm hai đối số:
- Có thể lặp lại - một đối tượng có thể lặp lại hoặc một chuỗi, đó là một đối tượng có thể được lặp lại. – An iterable object or a sequence, that is an object that can be looped.
- Bắt đầu - Giá trị chỉ mục hoặc giá trị bắt đầu của số đếm. Theo mặc định, giá trị bắt đầu từ 0.– Index value or starting value of the count. By default, the value starts at 0.
Đây là đầu ra bạn nhận được:
Output
[[0, item_1], [1, item_1], [2, item_2], . . ., [n, item_n]]
Như bạn có thể thấy, chúng tôi nhận được các yếu tố trong điều kiện có thể cùng với các chỉ số tương ứng của chúng.
Hãy lấy một ví dụ mà không có chỉ mục:
colour = ["Black", "Purple", "Brown", "Yellow", "Blue"]
list[enumerate[colour]]
Output:
[[0, 'Black'], [1, 'Purple'], [2, 'Brown'], [3, 'Yellow'], [4, 'Blue']]
Như bạn có thể thấy, chỉ mục bắt đầu từ 0. Chúng tôi chưa sử dụng đối số thứ hai. Theo mặc định, giá trị của chỉ mục bắt đầu ở 0.
Hãy lấy một ví dụ khác với một chỉ mục:
colour = ["Black", "Purple", "Brown", "Yellow", "Blue"]
list[enumerate[colour, 10]]
for i in range[3]:
def f[i=i]: # f.__defaults__ # this is where the current value of i is stored
[0,]
>>> # assigning a new value to i has no effect on the function's default arguments
>>> i = 5
>>> f.__defaults__
[0,]
0Với một vòng lặp:
>>> i = 0
>>> def f[i=i]:
... pass
>>> f.__defaults__ # this is where the current value of i is stored
[0,]
>>> # assigning a new value to i has no effect on the function's default arguments
>>> i = 5
>>> f.__defaults__
[0,]
1>>> i = 0
>>> def f[i=i]:
... pass
>>> f.__defaults__ # this is where the current value of i is stored
[0,]
>>> # assigning a new value to i has no effect on the function's default arguments
>>> i = 5
>>> f.__defaults__
[0,]
2Ở đây, bạn chỉ nhận được các giá trị, không phải các phím trong khi lặp qua từ điển.
Cách lặp qua một chuỗi với hàm zip [] trong Python
Hàm
Output:
[[0, 'Black'], [1, 'Purple'], [2, 'Brown'], [3, 'Yellow'], [4, 'Blue']]
0 mất nhiều hơn một giá trị có cùng giá trị và kết hợp chúng và trả về một trình lặp. Một trình lặp có thể là một tuple, một danh sách hoặc từ điển.Hãy xem cú pháp:
>>> i = 0
>>> def f[i=i]:
... pass
>>> f.__defaults__ # this is where the current value of i is stored
[0,]
>>> # assigning a new value to i has no effect on the function's default arguments
>>> i = 5
>>> f.__defaults__
[0,]
3Nó bao gồm hai đối số:
>>> i = 0
>>> def f[i=i]:
... pass
>>> f.__defaults__ # this is where the current value of i is stored
[0,]
>>> # assigning a new value to i has no effect on the function's default arguments
>>> i = 5
>>> f.__defaults__
[0,]
4Có thể lặp lại - một đối tượng có thể lặp lại hoặc một chuỗi, đó là một đối tượng có thể được lặp lại.
- Bắt đầu - Giá trị chỉ mục hoặc giá trị bắt đầu của số đếm. Theo mặc định, giá trị bắt đầu từ 0. can be lists, tuples, strings, sets, or dictionaries.
Đây là đầu ra bạn nhận được:
>>> i = 0
>>> def f[i=i]:
... pass
>>> f.__defaults__ # this is where the current value of i is stored
[0,]
>>> # assigning a new value to i has no effect on the function's default arguments
>>> i = 5
>>> f.__defaults__
[0,]
5>>> i = 0
>>> def f[i=i]:
... pass
>>> f.__defaults__ # this is where the current value of i is stored
[0,]
>>> # assigning a new value to i has no effect on the function's default arguments
>>> i = 5
>>> f.__defaults__
[0,]
6Như bạn có thể thấy, chúng tôi nhận được các yếu tố trong điều kiện có thể cùng với các chỉ số tương ứng của chúng.
Hãy lấy một ví dụ mà không có chỉ mục:
Đây là đầu ra bạn nhận được:
>>> i = 0
>>> def f[i=i]:
... pass
>>> f.__defaults__ # this is where the current value of i is stored
[0,]
>>> # assigning a new value to i has no effect on the function's default arguments
>>> i = 5
>>> f.__defaults__
[0,]
7>>> i = 0
>>> def f[i=i]:
... pass
>>> f.__defaults__ # this is where the current value of i is stored
[0,]
>>> # assigning a new value to i has no effect on the function's default arguments
>>> i = 5
>>> f.__defaults__
[0,]
8Như bạn có thể thấy, chúng tôi nhận được các yếu tố trong điều kiện có thể cùng với các chỉ số tương ứng của chúng.
Hãy lấy một ví dụ mà không có chỉ mục:Python 3.10, there is a new parameter
Output:
[[0, 'Black'], [1, 'Purple'], [2, 'Brown'], [3, 'Yellow'], [4, 'Blue']]
1
which checks the length of the elements. It will give us an error if the length of the elements do not match. Let's take an example:>>> i = 0
>>> def f[i=i]:
... pass
>>> f.__defaults__ # this is where the current value of i is stored
[0,]
>>> # assigning a new value to i has no effect on the function's default arguments
>>> i = 5
>>> f.__defaults__
[0,]
9def f_factory[i]:
def f[]:
return i # i is now a *local* variable of f_factory and can't ever change
return f
for i in range[3]:
f = f_factory[i]
functions.append[f]
0Như bạn có thể thấy, chỉ mục bắt đầu từ 0. Chúng tôi chưa sử dụng đối số thứ hai. Theo mặc định, giá trị của chỉ mục bắt đầu ở 0.
def f_factory[i]:
def f[]:
return i # i is now a *local* variable of f_factory and can't ever change
return f
for i in range[3]:
f = f_factory[i]
functions.append[f]
1def f_factory[i]:
def f[]:
return i # i is now a *local* variable of f_factory and can't ever change
return f
for i in range[3]:
f = f_factory[i]
functions.append[f]
2Hãy lấy một ví dụ khác với một chỉ mục:
def f_factory[i]:
def f[]:
return i # i is now a *local* variable of f_factory and can't ever change
return f
for i in range[3]:
f = f_factory[i]
functions.append[f]
3def f_factory[i]:
def f[]:
return i # i is now a *local* variable of f_factory and can't ever change
return f
for i in range[3]:
f = f_factory[i]
functions.append[f]
4Vì vậy, ở đây chỉ mục của chúng tôi bắt đầu vào lúc 10 khi chúng tôi đặt đối số bắt đầu thành 10 bắt đầu số lượng từ 10.
Bạn phải chỉ định danh sách hoặc tuple để lấy đầu ra, nếu không nó sẽ chỉ cung cấp cho bạn kết quả này:
Hãy xem cú pháp:
def f_factory[i]:
def f[]:
return i # i is now a *local* variable of f_factory and can't ever change
return f
for i in range[3]:
f = f_factory[i]
functions.append[f]
5Nó bao gồm hai đối số:
- Có thể lặp lại - một đối tượng có thể lặp lại hoặc một chuỗi, đó là một đối tượng có thể được lặp lại. – a sequence that can be a list, a tuple, a string, and so on.
- Bắt đầu - Giá trị chỉ mục hoặc giá trị bắt đầu của số đếm. Theo mặc định, giá trị bắt đầu từ 0. – is optional. It is a function that you can use to customize the sort order. The default option is None.
- Đây là đầu ra bạn nhận được: – is also optional. It is a Boolean. Here, the default value is False which is in ascending order. True will be descending order.
Đây là đầu ra bạn nhận được:
def f_factory[i]:
def f[]:
return i # i is now a *local* variable of f_factory and can't ever change
return f
for i in range[3]:
f = f_factory[i]
functions.append[f]
6def f_factory[i]:
def f[]:
return i # i is now a *local* variable of f_factory and can't ever change
return f
for i in range[3]:
f = f_factory[i]
functions.append[f]
7Như bạn có thể thấy, chúng tôi nhận được các yếu tố trong điều kiện có thể cùng với các chỉ số tương ứng của chúng.
Đầu ra trên cho thấy một danh sách được sắp xếp theo thứ tự tăng dần. Nếu bạn muốn nó theo thứ tự giảm dần, bạn có thể sử dụng đối số
Output:
[[0, 'Black'], [1, 'Purple'], [2, 'Brown'], [3, 'Yellow'], [4, 'Blue']]
4. Hãy lấy một ví dụ:def f_factory[i]:
def f[]:
return i # i is now a *local* variable of f_factory and can't ever change
return f
for i in range[3]:
f = f_factory[i]
functions.append[f]
8def f_factory[i]:
def f[]:
return i # i is now a *local* variable of f_factory and can't ever change
return f
for i in range[3]:
f = f_factory[i]
functions.append[f]
9Các giá trị ban đầu không thay đổi vì hàm
Output:
[[0, 'Black'], [1, 'Purple'], [2, 'Brown'], [3, 'Yellow'], [4, 'Blue']]
3 không thay đổi các giá trị ban đầu - nó sẽ chỉ tạo ra đầu ra. Đầu ra sẽ là một danh sách đặt hàng.Hàm
Output:
[[0, 'Black'], [1, 'Purple'], [2, 'Brown'], [3, 'Yellow'], [4, 'Blue']]
6 có thể được tích hợp hoặc xác định người dùng mà bạn có thể sử dụng để thao tác thứ tự đầu ra.Trước tiên hãy lấy một ví dụ với chức năng tích hợp trong:
import functools
def f[i]:
return i
for i in range[3]:
f_with_i = functools.partial[f, i] # important: use a different variable than "f"
functions.append[f_with_i]
0import functools
def f[i]:
return i
for i in range[3]:
f_with_i = functools.partial[f, i] # important: use a different variable than "f"
functions.append[f_with_i]
1Theo mặc định, đầu ra sẽ theo thứ tự tăng dần. Bạn phải đảo ngược đối số như thế này:
import functools
def f[i]:
return i
for i in range[3]:
f_with_i = functools.partial[f, i] # important: use a different variable than "f"
functions.append[f_with_i]
2import functools
def f[i]:
return i
for i in range[3]:
f_with_i = functools.partial[f, i] # important: use a different variable than "f"
functions.append[f_with_i]
3Số lượng đối số phải là một trong khi sử dụng một đối số chính. Hãy lấy một ví dụ với chức năng do người dùng xác định:
import functools
def f[i]:
return i
for i in range[3]:
f_with_i = functools.partial[f, i] # important: use a different variable than "f"
functions.append[f_with_i]
4import functools
def f[i]:
return i
for i in range[3]:
f_with_i = functools.partial[f, i] # important: use a different variable than "f"
functions.append[f_with_i]
5Tôi đã sử dụng chức năng Lambda để đơn giản, nhưng bạn có thể sử dụng phương thức truyền thống để định nghĩa chức năng nếu bạn muốn.
Cách lặp qua một chuỗi với hàm đảo ngược [] trong Python
Hàm
Output:
[[0, 'Black'], [1, 'Purple'], [2, 'Brown'], [3, 'Yellow'], [4, 'Blue']]
7 trả về các phần tử theo thứ tự ngược từ một đối tượng có thể lặp lại.Hãy xem cú pháp:
import functools
def f[i]:
return i
for i in range[3]:
f_with_i = functools.partial[f, i] # important: use a different variable than "f"
functions.append[f_with_i]
6Đối số của hàm đảo ngược:
- itable, đó là một chuỗi như một danh sách, tuple, bộ, v.v. –It is a sequence like a list, tuple, set, and so on.
Hãy lấy một ví dụ:
import functools
def f[i]:
return i
for i in range[3]:
f_with_i = functools.partial[f, i] # important: use a different variable than "f"
functions.append[f_with_i]
7import functools
def f[i]:
return i
for i in range[3]:
f_with_i = functools.partial[f, i] # important: use a different variable than "f"
functions.append[f_with_i]
8Bạn phải chỉ định một danh sách hoặc một tuple nếu không nó sẽ chỉ cung cấp cho bạn một địa chỉ như ví dụ dưới đây:
import functools
def f[i]:
return i
for i in range[3]:
f_with_i = functools.partial[f, i] # important: use a different variable than "f"
functions.append[f_with_i]
9>>> i = [] # instead of an int, i is now a *mutable* object
>>> def f[i=i]:
... print['i =', i]
...
>>> i.append[5] # instead of *assigning* a new value to i, we're *mutating* it
>>> f[]
i = [5]
0Sự kết luận
Các chức năng tích hợp giúp bạn viết các chức năng Python của bạn một cách rõ ràng và súc tích. Họ sẽ giúp bạn thực hiện chức năng của mình mà không bị lộn xộn.
Trong hướng dẫn này, bạn đã tìm hiểu về các chức năng tích hợp khác nhau trong Python. Bạn đã thấy các ví dụ khác nhau, và bây giờ bạn có thể thực hành theo trình tự của riêng bạn. Hy vọng bạn tìm thấy hướng dẫn này hữu ích.
Theo dõi tôi trên Twitter. Mã hóa hạnh phúc!
Học mã miễn phí. Chương trình giảng dạy nguồn mở của Freecodecamp đã giúp hơn 40.000 người có được việc làm với tư cách là nhà phát triển. Bắt đầu