Hướng dẫn python change parameter in function - tham số thay đổi python trong hàm

Vui lòng cho phép tôi chỉnh sửa lại. Những khái niệm này là kinh nghiệm của tôi từ việc học Python bằng cách thử lỗi và internet, chủ yếu là StackoverFlow. Có những sai lầm và có sự giúp đỡ.

Các biến Python sử dụng tham chiếu, tôi nghĩ tham chiếu như các liên kết quan hệ từ tên, lưu trữ bộ nhớ và giá trị.

Khi chúng tôi làm B = A, chúng tôi thực sự tạo ra một biệt danh của A và bây giờ A có 2 tên, A và B. Khi chúng tôi gọi B, chúng tôi thực sự đang gọi A. Chúng tôi tạo ra một mực theo giá trị của biến khác, thay vì Tạo một giá trị mới, đây là những gì chúng ta gọi là tham chiếu. Và suy nghĩ này sẽ dẫn đến 2 porbems.

Khi chúng tôi làm

A = [1]
B = A   # Now B is an alias of A

A.append(2)  # Now the value of A had been changes
print(B)
>>> [1, 2]  
# B is still an alias of A
# Which means when we call B, the real name we are calling is A

# When we do something to B,  the real name of our object is A
B.append(3)
print(A)
>>> [1, 2, 3]

Đây là những gì xảy ra khi chúng ta chuyển các đối số cho các chức năng

def test(B):
    print('My name is B')
    print(f'My value is {B}') 
    print(' I am just a nickname,  My real name is A')
    B.append(2)


A = [1]
test(A) 
print(A)
>>> [1, 2]

Chúng tôi chuyển một đối số của một hàm, nhưng tên của đối số này trong hàm đó là B. Cùng một tên có tên khác nhau. Vì vậy, khi chúng tôi làm B.append, chúng tôi đang thực hiện ____10 khi chúng tôi chuyển một đối số cho một chức năng, chúng tôi sẽ không truyền một biến, chúng tôi đang truyền một bí danh.
So when we do B.append, we are doing

def test(B):
    print('My name is B')
    print(f'My value is {B}') 
    print(' I am just a nickname,  My real name is A')
    B.append(2)


A = [1]
test(A) 
print(A)
>>> [1, 2]

Và đây là 2 vấn đề.

1. Dấu hiệu bằng nhau luôn tạo ra một tên mới

A = [1]
B = A
B.append(2)
A = A[0]  # Now the A is a brand new name, and has nothing todo with the old A from now on.

B.append(3)
print(A)
>>> 1
# the relation of A and B is removed when we assign the name A to something else
# Now B is a independent variable of hisown.

Dấu hiệu bình đẳng là một trạng thái của tên mới rõ ràng,

Đây là phần bị che khuất của tôi

 A = [1, 2, 3]

# No equal sign, we are working on the origial object,
A.append(4)
>>> [1, 2, 3, 4]

# This would create a new A
A = A + [4]  
>>> [1, 2, 3, 4]

và chức năng

def test(B):
    B = [1, 2, 3]   # B is a new name now, not an alias of A anymore
    B.append(4)  # so this operation won't effect A
    
A = [1, 2, 3]
test(A)
print(A)
>>> [1, 2, 3]

# ---------------------------

def test(B):
    B.append(4)  # B is a nickname of A, we are doing A
    
A = [1, 2, 3]
test(A)
print(A)
>>> [1, 2, 3, 4]

Vấn đề đầu tiên là

1. Phía bên trái và phương trình luôn là một tên mới, biến mới,

2. Trừ khi bên phải là một cái tên, như B = A, điều này chỉ tạo ra một bí danh

Vấn đề thứ hai, có một cái gì đó sẽ không bao giờ được thay đổi, chúng ta không thể sửa đổi bản gốc, chỉ có thể tạo một cái mới.

Đây là những gì chúng ta gọi là bất biến.

Khi chúng ta làm

def test(B):
    print('My name is B')
    print(f'My value is {B}') 
    print(' I am just a nickname,  My real name is A')
    B.append(2)


A = [1]
test(A) 
print(A)
>>> [1, 2]

Khi chúng tôi làm B = A, chúng tôi sao chép adress và giá trị từ A đến B, tất cả các hoạt động thành B Hiệu ứng cùng một quảng cáo của giá trị của A.

Khi nói đến chuỗi, số và tuple. cặp giá trị và địa chỉ không bao giờ có thể thay đổi. Khi chúng tôi đặt một str cho một số địa chỉ, nó đã bị khóa ngay lập tức, kết quả của tất cả các sửa đổi sẽ được đưa vào các địa chỉ khác.

def test(B):
    print('My name is B')
    print(f'My value is {B}') 
    print(' I am just a nickname,  My real name is A')
    B.append(2)


A = [1]
test(A) 
print(A)
>>> [1, 2]

def test(B):
    print('My name is B')
    print(f'My value is {B}') 
    print(' I am just a nickname,  My real name is A')
    B.append(2)


A = [1]
test(A) 
print(A)
>>> [1, 2]

Giá trị và địa chỉ của một chuỗi, một số hoặc một tuple được bảo vệ, khóa, bất biến.

Tất cả những gì chúng ta có thể làm việc trên một chuỗi là bởi cú pháp của

def test(B):
    print('My name is B')
    print(f'My value is {B}') 
    print(' I am just a nickname,  My real name is A')
    B.append(2)


A = [1]
test(A) 
print(A)
>>> [1, 2]

Vui lòng mở rộng cuộc thảo luận này nếu bạn vẫn còn bối rối. Cuộc thảo luận này giúp tôi tìm ra đột biến / bất biến / refetence / arging / biến / tên một lần cho tất cả, hy vọng điều này cũng có thể giúp đỡ ai đó.

################# sau

đã sửa đổi câu trả lời của tôi hàng tấn lần và nhận ra rằng tôi không phải nói gì, Python đã giải thích chính nó rồi.

a = 'string'
a.replace('t', '_')
print(a)
>>> 'string'

a = a.replace('t', '_')
print(a)
>>> 's_ring'

b = 100
b + 1
print(b)
>>> 100

b = b + 1
print(b)
>>> 101

def test_id(arg):
    c = id(arg)
    arg = 123
    d = id(arg)
    return

a = 'test ids'
b = id(a)
test_id(a)
e = id(a)

# b = c  = e != d

# this function do change original value
del change_like_mutable(arg):
    arg.append(1)
    arg.insert(0, 9)
    arg.remove(2)
    return
 
test_1 = [1, 2, 3]
change_like_mutable(test_1)



# this function doesn't 
def wont_change_like_str(arg):
     arg = [1, 2, 3]
     return


test_2 = [1, 1, 1]
wont_change_like_str(test_2)
print("Doesn't change like a imutable", test_2)

Ma quỷ này không phải là tham chiếu / giá trị / có thể thay đổi hoặc không / thể hiện, không gian tên hoặc biến / danh sách hoặc str, đó là cú pháp, dấu hiệu bằng nhau.

Bạn có thể thay đổi tham số trong chức năng Python không?

Bạn có thể thay đổi giá trị của một tham số trong một hàm không?

Làm thế nào để bạn gán các tham số cho một hàm trong Python?

Làm cách nào để thay đổi một biến cục bộ bên trong một hàm trong Python?