programming python

Hướng dẫn python modify dictionary in function - python sửa đổi từ điển trong chức năng

Điều đó là có thể, nhưng không nhất thiết được khuyến khích, tôi không thể tưởng tượng tại sao bạn không muốn vượt qua hoặc trả lại từ điển, nếu bạn chỉ không muốn trả lại từ điển, nhưng có thể vượt qua nó, bạn có thể sửa đổi nó để phản ánh Từ điển ban đầu mà không cần phải trả lại nó, ví dụ:

dict = {'1':'one','2':'two'}
def foo[d]:
   d['1'] = 'ONE'

print dict['1']  # prints 'one' original value
foo[dict]
print dict['1']  # prints 'ONE' ie, modification reflects in original value
                 # so no need to return it

Tuy nhiên, nếu bạn hoàn toàn không thể vượt qua nó vì bất kỳ lý do gì, bạn có thể sử dụng từ điển toàn cầu như sau:

global dict                    # declare dictionary as global
dict = {'1':'one','2':'two'}   # give initial value to dict

def foo[]:

   global dict   # bind dict to the one in global scope
   dict['1'] = 'ONE'

print dict['1']  # prints 'one'
foo[dict]
print dict['1']  # prints 'ONE'

Tôi muốn giới thiệu phương thức đầu tiên được trình bày trong khối mã đầu tiên, nhưng vui lòng sử dụng phương pháp thứ hai nếu thực sự cần thiết. Vui thích :]

Ngày 14 tháng 3 năm 2019

Các chức năng của Python [cả hai chức năng tích hợp và các chức năng tùy chỉnh mà chúng tôi tự viết] là những công cụ quan trọng để làm việc với dữ liệu. Nhưng những gì họ làm với dữ liệu của chúng tôi có thể hơi khó hiểu và nếu chúng tôi không biết về những gì xảy ra, nó có thể gây ra lỗi nghiêm trọng trong phân tích của chúng tôi.

Trong hướng dẫn này, chúng tôi sẽ xem xét kỹ cách Python xử lý các loại dữ liệu khác nhau khi chúng bị thao túng bên trong các chức năng và tìm hiểu cách đảm bảo rằng dữ liệu của chúng tôi chỉ được thay đổi khi chúng tôi muốn thay đổi.

Sự cô lập bộ nhớ trong các chức năng

Để hiểu cách Python xử lý các biến toàn cầu bên trong các chức năng, hãy để Lừa thực hiện một thử nghiệm nhỏ. Chúng tôi sẽ tạo hai biến toàn cầu, number_1 và number_2 và gán chúng cho số nguyên 5 và 10. Sau đó, chúng tôi sẽ sử dụng các biến toàn cầu đó làm đối số trong một hàm thực hiện một số toán học đơn giản. Chúng tôi cũng sẽ sử dụng các tên biến làm tên tham số chức năng. Sau đó, chúng tôi sẽ xem liệu tất cả các cách sử dụng biến bên trong chức năng của chúng tôi có ảnh hưởng đến giá trị toàn cầu của các biến này hay không.

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

150
5
10

Như chúng ta có thể thấy ở trên, hàm hoạt động chính xác và các giá trị của các biến toàn cầu

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

2 và

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

3 không thay đổi, mặc dù chúng tôi đã sử dụng chúng làm đối số và tên tham số trong hàm của chúng tôi. Điều này là do Python lưu trữ các biến từ một hàm ở một vị trí bộ nhớ khác với các biến toàn cầu. Họ bị cô lập. Do đó, biến

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

2 có thể có một giá trị [5] trên toàn cầu và một giá trị khác [50] bên trong hàm, nơi nó được phân lập.

[Ngẫu nhiên, nếu bạn nhầm lẫn về sự khác biệt giữa các tham số và đối số, tài liệu của Python về chủ đề này khá hữu ích.]

Những gì về danh sách và từ điển?

Danh sách

Chúng tôi đã thấy rằng những gì chúng tôi làm với một biến như

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

2 ở trên bên trong một hàm không ảnh hưởng đến giá trị toàn cầu của nó. Nhưng

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

2 là một số nguyên, đây là một loại dữ liệu khá cơ bản. Điều gì xảy ra nếu chúng ta thử cùng một thử nghiệm với một loại dữ liệu khác, như một danh sách? Dưới đây, chúng tôi sẽ tạo ra một hàm gọi là

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

7 sẽ sao chép mục cuối cùng trong bất kỳ danh sách nào chúng tôi chuyển nó dưới dạng đối số.

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

[1, 2, 3, 3]
[1, 2, 3, 3]

Như chúng ta có thể thấy, ở đây giá trị toàn cầu của

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

8 đã được cập nhật, mặc dù giá trị của nó chỉ được thay đổi bên trong hàm!

Từ điển

Bây giờ, hãy để viết một chức năng lấy một từ điển làm đối số để xem liệu một biến từ điển toàn cầu sẽ được sửa đổi khi nó bị thao tác bên trong một chức năng hay không.

Để làm cho điều này thực tế hơn một chút, chúng tôi sẽ sử dụng dữ liệu từ bộ dữ liệu ____29 mà Lừa sử dụng trong khóa học về Nguyên tắc cơ bản Python của chúng tôi [dữ liệu có sẵn để tải xuống tại đây].

Trong đoạn trích bên dưới, chúng tôi bắt đầu với một từ điển có chứa số lượng ứng dụng với mỗi độ tuổi trong bộ dữ liệu [do đó có 4.433 ứng dụng được xếp hạng là 4+, 987 ứng dụng được xếp hạng 9+, v.v.] . Hãy để tưởng tượng chúng tôi muốn tính toán tỷ lệ phần trăm cho mỗi xếp hạng tuổi, vì vậy chúng tôi có thể có được một bức tranh về xếp hạng tuổi nào là phổ biến nhất trong số các ứng dụng trong App Store.

Để làm điều này, chúng tôi sẽ viết một hàm gọi là

150
5
10

0 sẽ lấy từ điển làm đối số và chuyển đổi số lượng thành tỷ lệ phần trăm. Chúng tôi cần phải bắt đầu số lượng ở mức 0 và sau đó lặp lại từng giá trị trong từ điển, thêm chúng vào số lượng để chúng tôi nhận được tổng số xếp hạng. Sau đó, chúng tôi sẽ lặp lại từ điển một lần nữa và thực hiện một số toán học cho từng giá trị để tính tỷ lệ phần trăm.

content_ratings = {'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}

def make_percentages[a_dictionary]:
    total = 0
    for key in a_dictionary:
        count = a_dictionary[key]
        total += count

    for key in a_dictionary:
        a_dictionary[key] = [a_dictionary[key] / total] * 100

    return a_dictionary

Trước khi chúng tôi nhìn vào đầu ra, hãy để nhanh chóng xem xét những gì xảy ra ở trên. Sau khi gán từ điển của chúng tôi về xếp hạng tuổi ứng dụng cho biến

150
5
10

1, chúng tôi tạo một hàm mới gọi là

150
5
10

0 có một đối số duy nhất:

150
5
10

Để tìm ra bao nhiêu phần trăm ứng dụng thuộc vào mỗi xếp hạng tuổi, chúng tôi sẽ cần biết tổng số ứng dụng, vì vậy trước tiên chúng tôi đặt một biến mới có tên

150
5
10

4 thành

150
5
10

5 và sau đó lặp qua mỗi khóa trong

150
5
10

3, thêm nó vào

150
5
10

Sau khi kết thúc, tất cả những gì chúng ta cần làm là lặp qua

150
5
10

3 một lần nữa, chia mỗi mục cho tổng số và sau đó nhân kết quả với 100. Điều này sẽ cho chúng ta một từ điển với tỷ lệ phần trăm.

Nhưng điều gì xảy ra khi chúng ta sử dụng

150
5
10

1 toàn cầu của chúng ta làm đối số cho chức năng mới này?

c_ratings_percentages = make_percentages[content_ratings]
print[c_ratings_percentages]
print[content_ratings]

{'4+': 61.595109073224954, '9+': 13.714047519799916, '12+': 16.04835348061692, '17+': 8.642489926358204}
{'4+': 61.595109073224954, '9+': 13.714047519799916, '12+': 16.04835348061692, '17+': 8.642489926358204}

Giống như chúng ta đã thấy với các danh sách, biến

150
5
10

1 toàn cầu của chúng ta đã được thay đổi, mặc dù nó chỉ được sửa đổi bên trong hàm

150
5
10

0 mà chúng ta đã tạo.

Vì vậy, những gì thực sự xảy ra ở đây? Chúng tôi đã vượt qua sự khác biệt giữa các loại dữ liệu có thể thay đổi và bất biến.mutable and immutable data types.

Các loại dữ liệu có thể thay đổi và bất biến

Trong Python, các loại dữ liệu có thể bị đột biến [có thể thay đổi] hoặc bất biến [không thể thay đổi]. Và trong khi hầu hết các loại dữ liệu mà chúng tôi đã làm việc trong Python giới thiệu là bất biến [bao gồm số nguyên, phao, dây, booleans và bộ dữ liệu], danh sách và từ điển là có thể thay đổi. Điều đó có nghĩa là một danh sách hoặc từ điển toàn cầu có thể được thay đổi ngay cả khi nó được sử dụng bên trong một hàm, giống như chúng ta đã thấy trong các ví dụ trên.a global list or dictionary can be changed even when it’s used inside of a function, just like we saw in the examples above.

Để hiểu được sự khác biệt giữa có thể thay đổi [có thể thay đổi] và bất biến [không thể thay đổi], nó rất hữu ích khi xem xét cách Python thực sự đối xử với các biến này.

Hãy bắt đầu bằng cách xem xét một bài tập biến đơn giản:

a = 5

Tên biến

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

2 hoạt động giống như một con trỏ về phía

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

3 và nó giúp chúng tôi lấy

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

3 bất cứ khi nào chúng tôi muốn.

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

3 là một số nguyên và số nguyên là các loại dữ liệu bất biến. Nếu một loại dữ liệu là bất biến, điều đó có nghĩa là nó có thể được cập nhật sau khi nó được tạo ra. Nếu chúng tôi làm

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

6, chúng tôi không thực sự cập nhật

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

3 lên

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

8. Trong hoạt hình dưới đây, chúng ta có thể thấy rằng:can’t be updated once it’s been created. If we do

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

6, we’re not actually updating

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

3 to

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

8. In the animation below, we can see that:

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

2 ban đầu chỉ vào

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

6 được chạy và điều này di chuyển con trỏ từ

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

3 sang

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

8, nó thực sự không thay đổi số

initial_list = [1, 2, 3]

def duplicate_last[a_list]:
    last_element = a_list[-1]
    a_list.append[last_element]
    return a_list

new_list = duplicate_last[a_list = initial_list]
print[new_list]
print[initial_list]

Các loại dữ liệu có thể thay đổi như danh sách và từ điển hành xử khác nhau. Họ có thể được cập nhật. Vì vậy, ví dụ, hãy để một danh sách rất đơn giản:can be updated. So, for example, let’s make a very simple list:

global dict                    # declare dictionary as global
dict = {'1':'one','2':'two'}   # give initial value to dict

def foo[]:

   global dict   # bind dict to the one in global scope
   dict['1'] = 'ONE'

print dict['1']  # prints 'one'
foo[dict]
print dict['1']  # prints 'ONE'

Nếu chúng tôi nối một

[1, 2, 3, 3]
[1, 2, 3, 3]

5 vào cuối danh sách này, chúng tôi không chỉ đơn giản là chỉ

[1, 2, 3, 3]
[1, 2, 3, 3]

6 về phía một danh sách khác, chúng tôi sẽ cập nhật trực tiếp danh sách hiện có:

Ngay cả khi chúng tôi tạo nhiều biến danh sách, miễn là chúng trỏ đến cùng một danh sách, tất cả chúng sẽ được cập nhật khi danh sách đó được thay đổi, như chúng ta có thể thấy trong mã bên dưới:

global dict                    # declare dictionary as global
dict = {'1':'one','2':'two'}   # give initial value to dict

def foo[]:

   global dict   # bind dict to the one in global scope
   dict['1'] = 'ONE'

print dict['1']  # prints 'one'
foo[dict]
print dict['1']  # prints 'ONE'

global dict                    # declare dictionary as global
dict = {'1':'one','2':'two'}   # give initial value to dict

def foo[]:

   global dict   # bind dict to the one in global scope
   dict['1'] = 'ONE'

print dict['1']  # prints 'one'
foo[dict]
print dict['1']  # prints 'ONE'

Ở đây, một hình ảnh hoạt hình về những gì mà thực sự xảy ra trong mã ở trên:

Điều này giải thích tại sao các biến toàn cầu của chúng tôi đã được thay đổi khi chúng tôi đang thử nghiệm các danh sách và từ điển trước đó. Bởi vì danh sách và từ điển có thể thay đổi, thay đổi chúng [ngay cả bên trong một hàm] thay đổi danh sách hoặc từ điển, đó là trường hợp cho các loại dữ liệu bất biến.

Giữ các loại dữ liệu có thể thay đổi không thay đổi

Nói chung, chúng tôi không muốn các chức năng của chúng tôi thay đổi các biến toàn cầu, ngay cả khi chúng chứa các loại dữ liệu có thể thay đổi như danh sách hoặc từ điển. Điều đó bởi vì trong các phân tích và chương trình phức tạp hơn, chúng tôi có thể thường xuyên sử dụng nhiều chức năng khác nhau. Nếu tất cả chúng đang thay đổi danh sách và từ điển mà họ đang làm việc, thì việc theo dõi những gì thay đổi là gì.

Rất may, có một cách dễ dàng để vượt qua điều này: chúng ta có thể tạo một bản sao của danh sách hoặc từ điển bằng phương pháp Python tích hợp được gọi là

[1, 2, 3, 3]
[1, 2, 3, 3]

Nếu bạn đã học được về các phương pháp, đừng lo lắng. Họ đã bao gồm trong khóa học Python trung gian của chúng tôi, nhưng đối với hướng dẫn này, tất cả những gì bạn cần biết là

[1, 2, 3, 3]
[1, 2, 3, 3]

7 hoạt động như

[1, 2, 3, 3]
[1, 2, 3, 3]

global dict                    # declare dictionary as global
dict = {'1':'one','2':'two'}   # give initial value to dict

def foo[]:

   global dict   # bind dict to the one in global scope
   dict['1'] = 'ONE'

print dict['1']  # prints 'one'
foo[dict]
print dict['1']  # prints 'ONE'

Chúng ta hãy xem xét một cái nhìn khác về chức năng mà chúng ta đã viết cho các danh sách và cập nhật nó để những gì xảy ra bên trong chức năng của chúng ta không thay đổi

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

8. Tất cả những gì chúng ta cần làm là thay đổi đối số mà chúng ta chuyển đến chức năng của mình từ

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

8 thành

content_ratings = {'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}

def make_percentages[a_dictionary]:
    total = 0
    for key in a_dictionary:
        count = a_dictionary[key]
        total += count

    for key in a_dictionary:
        a_dictionary[key] = [a_dictionary[key] / total] * 100

    return a_dictionary

global dict                    # declare dictionary as global
dict = {'1':'one','2':'two'}   # give initial value to dict

def foo[]:

   global dict   # bind dict to the one in global scope
   dict['1'] = 'ONE'

print dict['1']  # prints 'one'
foo[dict]
print dict['1']  # prints 'ONE'

global dict                    # declare dictionary as global
dict = {'1':'one','2':'two'}   # give initial value to dict

def foo[]:

   global dict   # bind dict to the one in global scope
   dict['1'] = 'ONE'

print dict['1']  # prints 'one'
foo[dict]
print dict['1']  # prints 'ONE'

Như chúng ta có thể thấy, điều này đã khắc phục vấn đề của chúng tôi. Tại đây, tại sao: Sử dụng

[1, 2, 3, 3]
[1, 2, 3, 3]

7 tạo ra một bản sao riêng của danh sách, do đó thay vì chỉ vào chính

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

content_ratings = {'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}

def make_percentages[a_dictionary]:
    total = 0
    for key in a_dictionary:
        count = a_dictionary[key]
        total += count

    for key in a_dictionary:
        a_dictionary[key] = [a_dictionary[key] / total] * 100

    return a_dictionary

5 chỉ vào một danh sách mới bắt đầu dưới dạng bản sao của

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

8. Bất kỳ thay đổi nào được thực hiện đối với

content_ratings = {'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}

def make_percentages[a_dictionary]:
    total = 0
    for key in a_dictionary:
        count = a_dictionary[key]
        total += count

    for key in a_dictionary:
        a_dictionary[key] = [a_dictionary[key] / total] * 100

    return a_dictionary

5 sau thời điểm đó được thực hiện trong danh sách riêng biệt đó, chứ không phải chính

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

8, do đó, giá trị toàn cầu của

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

8 không thay đổi.

Tuy nhiên, giải pháp này vẫn không hoàn hảo, bởi vì chúng tôi sẽ phải nhớ thêm

[1, 2, 3, 3]
[1, 2, 3, 3]

7 mỗi khi chúng tôi chuyển một đối số cho chức năng của chúng tôi hoặc rủi ro vô tình thay đổi giá trị toàn cầu của

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

8. Nếu chúng tôi không muốn phải lo lắng về điều đó, chúng tôi thực sự có thể tạo bản sao đó bên trong chính chức năng:

global dict                    # declare dictionary as global
dict = {'1':'one','2':'two'}   # give initial value to dict

def foo[]:

   global dict   # bind dict to the one in global scope
   dict['1'] = 'ONE'

print dict['1']  # prints 'one'
foo[dict]
print dict['1']  # prints 'ONE'

global dict                    # declare dictionary as global
dict = {'1':'one','2':'two'}   # give initial value to dict

def foo[]:

   global dict   # bind dict to the one in global scope
   dict['1'] = 'ONE'

print dict['1']  # prints 'one'
foo[dict]
print dict['1']  # prints 'ONE'

Với phương pháp này, chúng ta có thể truyền một biến toàn cầu có thể thay đổi như

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

8 cho chức năng của chúng ta và giá trị toàn cầu won được thay đổi vì chính chức năng tạo một bản sao và sau đó thực hiện các hoạt động của nó trên bản sao đó.

Phương pháp

[1, 2, 3, 3]
[1, 2, 3, 3]

7 cũng hoạt động cho từ điển. Như với danh sách, chúng tôi chỉ có thể thêm

[1, 2, 3, 3]
[1, 2, 3, 3]

7 vào đối số rằng chúng tôi chuyển chức năng của mình để tạo một bản sao mà sẽ được sử dụng cho chức năng mà không thay đổi biến gốc:

global dict                    # declare dictionary as global
dict = {'1':'one','2':'two'}   # give initial value to dict

def foo[]:

   global dict   # bind dict to the one in global scope
   dict['1'] = 'ONE'

print dict['1']  # prints 'one'
foo[dict]
print dict['1']  # prints 'ONE'

global dict                    # declare dictionary as global
dict = {'1':'one','2':'two'}   # give initial value to dict

def foo[]:

   global dict   # bind dict to the one in global scope
   dict['1'] = 'ONE'

print dict['1']  # prints 'one'
foo[dict]
print dict['1']  # prints 'ONE'

Nhưng một lần nữa, sử dụng phương pháp đó có nghĩa là chúng ta cần nhớ thêm

[1, 2, 3, 3]
[1, 2, 3, 3]

7 mỗi khi chúng ta chuyển từ điển vào hàm

150
5
10

0 của chúng ta. Nếu chúng tôi thường xuyên sử dụng chức năng này, tốt hơn là nên thực hiện việc sao chép vào chính chức năng để chúng tôi không thể nhớ làm điều này.

Dưới đây, chúng tôi sẽ sử dụng

[1, 2, 3, 3]
[1, 2, 3, 3]

7 bên trong chính chức năng. Điều này sẽ đảm bảo rằng chúng ta có thể sử dụng nó mà không thay đổi các biến toàn cầu mà chúng ta chuyển cho nó làm đối số và chúng ta không cần phải nhớ thêm

[1, 2, 3, 3]
[1, 2, 3, 3]

7 cho mỗi đối số chúng ta vượt qua.

number_1 = 5
number_2 = 10

def multiply_and_add[number_1, number_2]:
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add[number_1, number_2]
print[a_sum]
print[number_1]
print[number_2]

global dict                    # declare dictionary as global
dict = {'1':'one','2':'two'}   # give initial value to dict

def foo[]:

   global dict   # bind dict to the one in global scope
   dict['1'] = 'ONE'

print dict['1']  # prints 'one'
foo[dict]
print dict['1']  # prints 'ONE'

Như chúng ta có thể thấy, việc sửa đổi chức năng của chúng ta để tạo một bản sao từ điển của chúng ta và sau đó thay đổi số lượng thành phần trăm chỉ trong bản sao đó đã cho phép chúng ta thực hiện thao tác mà chúng ta muốn mà không thực sự thay đổi

150
5
10

Kết luận

Trong hướng dẫn này, chúng tôi đã xem xét sự khác biệt giữa các loại dữ liệu có thể thay đổi, có thể thay đổi và các loại dữ liệu bất biến, không thể. Chúng tôi đã học cách chúng tôi có thể sử dụng phương pháp

[1, 2, 3, 3]
[1, 2, 3, 3]

7 để tạo các bản sao của các loại dữ liệu có thể thay đổi như danh sách và từ điển để chúng tôi có thể làm việc với chúng trong các chức năng mà không thay đổi giá trị toàn cầu của chúng.

Hướng dẫn này có giúp ích gì không?

Chọn con đường của bạn để tiếp tục học các kỹ năng dữ liệu có giá trị.

Hướng dẫn Python

Thực hành các kỹ năng lập trình Python của bạn khi bạn làm việc thông qua các hướng dẫn miễn phí của chúng tôi.

Các khóa học khoa học dữ liệu

Cam kết nghiên cứu của bạn với các khóa học khoa học dữ liệu trong trình duyệt tương tác của chúng tôi ở Python, R, SQL, v.v.

Bạn có thể sửa đổi một từ điển trong Python không?

Có bạn có thể, từ điển là một đối tượng có thể thay đổi để chúng có thể được sửa đổi trong các chức năng, nhưng nó phải được xác định trước khi bạn thực sự gọi hàm. Để thay đổi giá trị của biến toàn cầu chỉ vào một đối tượng bất biến, bạn phải sử dụng tuyên bố toàn cầu., dictionary is an mutable object so they can be modified within functions, but it must be defined before you actually call the function. To change the value of global variable pointing to an immutable object you must use the global statement.

Bạn có thể sử dụng từ điển bên trong chức năng Python không?

Trong Python, mọi thứ đều là một đối tượng, vì vậy từ điển có thể được truyền như một đối số cho một hàm như các biến khác được truyền. Kwargs, viết tắt của các đối số từ khóa.the dictionary can be passed as an argument to a function like other variables are passed. “ kwargs ” stands for keyword arguments.

Bạn có thể cập nhật một giá trị trong một từ điển không?

Các giá trị của từ điển Python có thể được cập nhật bằng hai cách sau đây, tức là sử dụng phương thức Update [] và cũng, sử dụng dấu ngoặc vuông.Từ điển đại diện cho cặp giá trị khóa trong Python, được đặt trong niềng răng xoăn.Các phím là duy nhất và một đại tràng tách nó khỏi giá trị, trong khi dấu phẩy tách các mục.using the update[] method and also, using square brackets. Dictionary represents the key-value pair in Python, enclosed in curly braces. The keys are unique and a colon separates it from value, whereas comma separates the items.

Cập nhật [] trong Python là gì?

Phương thức Cập nhật từ điển Python [] Phương thức Cập nhật [] Phương thức chèn các mục được chỉ định vào từ điển.Các mục được chỉ định có thể là một từ điển hoặc một đối tượng có thể lặp lại với các cặp giá trị chính.inserts the specified items to the dictionary. The specified items can be a dictionary, or an iterable object with key value pairs.