Ký hiệu = (bằng) được định nghĩa là toán tử gán trong Python. Giá trị của biểu thức Python ở bên phải nó được gán cho một variable ở bên trái. Ký hiệu = như trong lập trình nói chung (và Python nói riêng) không nên bị nhầm lẫn với cách sử dụng của nó trong Toán học, nơi nó tuyên bố rằng các biểu thức ở cả hai bên của ký hiệu đều bằng nhau.
Xem xét các câu lệnh Python sau đây −
a = 10 b = 5 a = a + b print (a)
Ở lần đầu tiên, ít nhất đối với những người mới bắt đầu lập trình nhưng đã biết toán học, câu lệnh "a=a+b" trông có vẻ kỳ lạ. Làm thế nào mà a có thể bằng "a+b"? Tuy nhiên, cần nhấn mạnh lại rằng ký hiệu = ở đây là một toán tử gán và không được sử dụng để thể hiện sự bằng nhau giữa bên trái (LHS) và bên phải (RHS).
Bởi vì đây là một bài tập, biểu thức bên phải được đánh giá là 15, giá trị này được gán cho a.
Trong câu lệnh "a+=b", hai toán tử "+" và "=" có thể được kết hợp thành một toán tử "+=". Nó được gọi là toán tử cộng và gán. Trong một câu lệnh duy nhất, nó thực hiện phép cộng của hai toán hạng "a" và "b", và kết quả được gán cho toán hạng bên trái, tức là "a".
Ngoài toán tử gán đơn giản, Python cung cấp một số toán tử gán khác cho việc sử dụng nâng cao. Chúng được gọi là toán tử gán tích lũy hoặc gán tăng cường. Trong chương này, chúng ta sẽ học cách sử dụng các toán tử gán tăng cường được định nghĩa trong Python.
Python có các toán tử gán tăng cường cho tất cả các toán tử arithmetic và comparison .
Toán tử gán tăng cường trong Python kết hợp phép cộng và phép gán trong một câu lệnh. Vì Python hỗ trợ phép toán hỗn hợp, nên hai toán hạng có thể có các kiểu khác nhau. Tuy nhiên, kiểu của toán hạng bên trái sẽ thay đổi thành kiểu của toán hạng bên phải nếu nó rộng hơn.
Toán tử += là một toán tử tăng cường. Nó cũng được gọi là toán tử cộng dồn, vì nó cộng "b" vào "a" và gán kết quả trở lại cho biến a.
Các toán tử gán mở rộng sau đây trong Python:
Các ví dụ sau đây sẽ giúp bạn hiểu cách hoạt động của toán tử "+=" −
a=10
b=5
print ("Augmented addition of int and int")
a+=b # equivalent to a=a+b
print ("a=",a, "type(a):", type(a))
a=10
b=5.5
print ("Augmented addition of int and float")
a+=b # equivalent to a=a+b
print ("a=",a, "type(a):", type(a))
a=10.50
b=5+6j
print ("Augmented addition of float and complex")
a+=b #equivalent to a=a+b
print ("a=",a, "type(a):", type(a))
Nó sẽ tạo ra output −
Augmented addition of int and int a= 15 type(a): <class 'int'> Augmented addition of int and float a= 15.5 type(a): <class 'float'> Augmented addition of float and complex a= (15.5+6j) type(a): <class 'complex'>
Sử dụng ký hiệu -= để thực hiện phép trừ và gán trong một câu lệnh duy nhất. Câu lệnh "a-=b" thực hiện phép gán "a=a-b". Các toán hạng có thể thuộc bất kỳ loại số nào. Python thực hiện việc chuyển đổi kiểu ngầm định trên object có kích thước hẹp hơn.
a=10
b=5
print ("Augmented subtraction of int and int")
a-=b #equivalent to a=a-b
print ("a=",a, "type(a):", type(a))
a=10
b=5.5
print ("Augmented subtraction of int and float")
a-=b #equivalent to a=a-b
print ("a=",a, "type(a):", type(a))
a=10.50
b=5+6j
print ("Augmented subtraction of float and complex")
a-=b #equivalent to a=a-b
print ("a=",a, "type(a):", type(a))
Nó sẽ tạo ra output −
Augmented subtraction of int and int a= 5 type(a): <class 'int'> Augmented subtraction of int and float a= 4.5 type(a): <class 'float'> Augmented subtraction of float and complex a= (5.5-6j) type(a): <class 'complex'>
Toán tử "*=" hoạt động theo nguyên tắc tương tự. "a*=b" thực hiện phép nhân và gán, và tương đương với "a=a*b". Trong trường hợp nhân gia tăng của hai số phức, quy tắc nhân như đã thảo luận trong chương trước là áp dụng.
a=10
b=5
print ("Augmented multiplication of int and int")
a*=b #equivalent to a=a*b
print ("a=",a, "type(a):", type(a))
a=10
b=5.5
print ("Augmented multiplication of int and float")
a*=b #equivalent to a=a*b
print ("a=",a, "type(a):", type(a))
a=6+4j
b=3+2j
print ("Augmented multiplication of complex and complex")
a*=b #equivalent to a=a*b
print ("a=",a, "type(a):", type(a))
Nó sẽ tạo ra output −
Augmented multiplication of int and int a= 50 type(a): <class 'int'> Augmented multiplication of int and float a= 55.0 type(a): <class 'float'> Augmented multiplication of complex and complex a= (10+24j) type(a): <class 'complex'>
Ký hiệu kết hợp "/=" hoạt động như một toán tử chia và gán, do đó "a/=b" tương đương với "a=a/b". Phép chia giữa các toán hạng kiểu int hoặc float sẽ trả về kiểu float. Phép chia của hai số phức sẽ trả về một số phức. Dưới đây là các ví dụ về toán tử chia tăng cường.
a=10
b=5
print ("Augmented division of int and int")
a/=b #equivalent to a=a/b
print ("a=",a, "type(a):", type(a))
a=10
b=5.5
print ("Augmented division of int and float")
a/=b #equivalent to a=a/b
print ("a=",a, "type(a):", type(a))
a=6+4j
b=3+2j
print ("Augmented division of complex and complex")
a/=b #equivalent to a=a/b
print ("a=",a, "type(a):", type(a))
Nó sẽ tạo ra output −
Augmented division of int and int a= 2.0 type(a): <class 'float'> Augmented division of int and float a= 1.8181818181818181 type(a): <class 'float'> Augmented division of complex and complex a= (2+0j) type(a): <class 'complex'>
Để thực hiện phép toán chia lấy dư và gán trong một câu lệnh duy nhất, hãy sử dụng toán tử %= . Giống như toán tử chia lấy dư, phiên bản tăng cường của nó cũng không được hỗ trợ cho số phức.
a=10
b=5
print ("Augmented modulus operator with int and int")
a%=b #equivalent to a=a%b
print ("a=",a, "type(a):", type(a))
a=10
b=5.5
print ("Augmented modulus operator with int and float")
a%=b #equivalent to a=a%b
print ("a=",a, "type(a):", type(a))
Nó sẽ tạo ra output −
Augmented modulus operator with int and int a= 0 type(a): <class 'int'> Augmented modulus operator with int and float a= 4.5 type(a): <class 'float'>
Toán tử "**=" sẽ tính toán "a" lũy thừa của "b", và gán giá trị trở lại cho "a". Dưới đây là một số ví dụ −
a=10
b=5
print ("Augmented exponent operator with int and int")
a**=b #equivalent to a=a**b
print ("a=",a, "type(a):", type(a))
a=10
b=5.5
print ("Augmented exponent operator with int and float")
a**=b #equivalent to a=a**b
print ("a=",a, "type(a):", type(a))
a=6+4j
b=3+2j
print ("Augmented exponent operator with complex and complex")
a**=b #equivalent to a=a**b
print ("a=",a, "type(a):", type(a))
Nó sẽ tạo ra output −
Augmented exponent operator with int and int a= 100000 type(a): <class 'int'> Augmented exponent operator with int and float a= 316227.7660168379 type(a): <class 'float'> Augmented exponent operator with complex and complex a= (97.52306038414744-62.22529992036203j) type(a): <class 'complex'>
Để thực hiện phép chia lấy phần nguyên và gán trong một câu lệnh, hãy sử dụng toán tử "//=". "a//=b" tương đương với "a=a//b". Toán tử này không thể được sử dụng với số phức.
a=10
b=5
print ("Augmented floor division operator with int and int")
a//=b #equivalent to a=a//b
print ("a=",a, "type(a):", type(a))
a=10
b=5.5
print ("Augmented floor division operator with int and float")
a//=b #equivalent to a=a//b
print ("a=",a, "type(a):", type(a))
Nó sẽ tạo ra output −
Augmented floor division operator with int and int a= 2 type(a): <class 'int'> Augmented floor division operator with int and float a= 1.0 type(a): <class 'float'>