Hướng dẫn how do you edit a variable in a function python? - làm thế nào để bạn chỉnh sửa một biến trong một hàm python?

Hãy nghĩ về chúng như là một phần của chức năng. Khi hàm kết thúc, tất cả các biến của nó cũng chết.

x=2
y=3

def func[x,y]:
    x=200
    y=300

func[x,y] #inside this function, x=200 and y=300
#but by this line the function is over and those new values are discarded
print[x,y] #so this is looking at the outer scope again

Nếu bạn muốn một hàm để sửa đổi một giá trị theo cách chính xác của bạn đã viết nó, bạn có thể sử dụng

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Vấn đề với điều này là nó làm cho việc gỡ lỗi một cơn ác mộng trong trường hợp tốt nhất, và hoàn toàn không thể hiểu được trong trường hợp xấu nhất. Những thứ như thế này thường được gọi là "tác dụng phụ" trong các chức năng - thiết lập một giá trị bạn không cần thiết lập và làm như vậy mà không trả lại rõ ràng, đó là một điều xấu. Nói chung, các chức năng duy nhất bạn nên viết để sửa đổi các mục tại chỗ là các phương thức đối tượng [những thứ như

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

Cách đúng đắn để làm điều gì đó như thế này là sử dụng giá trị trả về. Hãy thử một cái gì đó như

def func[x,y]:
    x = x+200 #this can be written x += 200
    y = y+300 #as above: y += 300
    return [x,y] #returns a tuple [x,y]

x = 2
y = 3
func[x,y] # returns [202, 303]
print[x,y] #prints 2 3

Tại sao điều đó không hoạt động? Vâng, bởi vì bạn chưa bao giờ nói với chương trình làm bất cứ điều gì với tuple

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

#func as defined above

x=2 ; y=3
x,y = func[x,y] #this unpacks the tuple [202,303] into two values and x and y
print[x,y] #prints 202 303

Biến¶

Hãy nhớ lại rằng một biến là một nhãn cho một vị trí trong bộ nhớ. Nó có thể được sử dụng để giữ một giá trị. Trong các ngôn ngữ được gõ tĩnh, các biến có các loại được xác định trước và một biến chỉ có thể được sử dụng để giữ các giá trị của loại đó. Trong Python, chúng tôi có thể sử dụng lại cùng một biến để lưu trữ các giá trị thuộc bất kỳ loại nào.

Một biến tương tự như chức năng bộ nhớ được tìm thấy trong hầu hết các máy tính, trong đó nó chứa một giá trị có thể được truy xuất nhiều lần và lưu trữ một giá trị mới xóa cũ. Một biến khác với bộ nhớ của máy tính ở chỗ người ta có thể có nhiều biến lưu trữ các giá trị khác nhau và mỗi biến được đề cập theo tên.

Xác định các biến

Để xác định một biến mới trong Python, chúng tôi chỉ cần gán một giá trị cho một nhãn. Ví dụ: đây là cách chúng tôi tạo một biến có tên là

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

Đây chính xác là cùng một cú pháp như gán một giá trị mới cho một biến hiện có được gọi là

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

Nếu chúng tôi cố gắng truy cập giá trị của một biến đã được xác định ở bất cứ đâu, trình thông dịch sẽ thoát với lỗi tên.

Chúng ta có thể xác định một số biến trong một dòng, nhưng điều này thường được coi là kiểu xấu:

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

Để phù hợp với phong cách lập trình tốt, chúng ta nên sử dụng các tên có ý nghĩa cho các biến.

Phạm vi biến đổi và tuổi thọ

Không phải tất cả các biến đều có thể truy cập được từ tất cả các phần của chương trình của chúng tôi và không phải tất cả các biến tồn tại trong cùng một khoảng thời gian. Trường hợp một biến có thể truy cập được và thời gian tồn tại trong bao lâu phụ thuộc vào cách xác định nó. Chúng tôi gọi là một phần của một chương trình trong đó một biến có thể truy cập phạm vi của nó và thời lượng mà biến tồn tại tuổi thọ của nó.

Một biến được xác định trong phần thân chính của tệp được gọi là biến toàn cầu. Nó sẽ được hiển thị trong toàn bộ tệp và cả bên trong bất kỳ tệp nào nhập tệp đó. Các biến toàn cầu có thể có những hậu quả không lường trước được vì các hiệu ứng phạm vi rộng của chúng-đó là lý do tại sao chúng ta gần như không bao giờ nên sử dụng chúng. Chỉ các đối tượng được dự định sẽ được sử dụng trên toàn cầu, như các chức năng và các lớp, nên được đặt vào không gian tên toàn cầu.

Một biến được xác định bên trong một hàm là cục bộ với hàm đó. Nó có thể truy cập từ điểm mà nó được xác định cho đến khi kết thúc hàm và tồn tại miễn là hàm được thực thi. Các tên tham số trong định nghĩa hàm hoạt động giống như các biến cục bộ, nhưng chúng chứa các giá trị mà chúng ta chuyển vào hàm khi chúng ta gọi nó. Khi chúng tôi sử dụng toán tử gán [

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

Dưới đây là một ví dụ về các biến trong các phạm vi khác nhau:

# This is a global variable
a = 0

if a == 0:
    # This is still a global variable
    b = 1

def my_function[c]:
    # this is a local variable
    d = 3
    print[c]
    print[d]

# Now we call the function, passing the value 7 as the first and only parameter
my_function[7]

# a and b still exist
print[a]
print[b]

# c and d don't exist anymore -- these statements will give us name errors!
print[c]
print[d]

Ghi chú

Bên trong của một cơ thể lớp cũng là một phạm vi biến cục bộ mới. Các biến được xác định trong phần thân lớp [nhưng ngoài bất kỳ phương thức lớp nào] được gọi là thuộc tính lớp. Chúng có thể được tham chiếu bằng tên trần của chúng trong cùng một phạm vi, nhưng chúng cũng có thể được truy cập từ bên ngoài phạm vi này nếu chúng ta sử dụng toán tử truy cập thuộc tính [

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

Nhà điều hành chuyển nhượng

Như chúng ta đã thấy trong các phần trước, toán tử gán trong Python là một dấu hiệu bằng duy nhất [

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

a_number = 5              # a_number becomes 5
a_number = total          # a_number becomes the value of total
a_number = total + 5      # a_number becomes the value of total + 5
a_number = a_number + 1   # a_number becomes the value of a_number + 1

Câu nói cuối cùng có thể trông hơi lạ nếu chúng ta giải thích

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

# This is a global variable
a = 0

if a == 0:
    # This is still a global variable
    b = 1

def my_function[c]:
    # this is a local variable
    d = 3
    print[c]
    print[d]

# Now we call the function, passing the value 7 as the first and only parameter
my_function[7]

# a and b still exist
print[a]
print[b]

# c and d don't exist anymore -- these statements will give us name errors!
print[c]
print[d]

# This is a global variable
a = 0

if a == 0:
    # This is still a global variable
    b = 1

def my_function[c]:
    # this is a local variable
    d = 3
    print[c]
    print[d]

# Now we call the function, passing the value 7 as the first and only parameter
my_function[7]

# a and b still exist
print[a]
print[b]

# c and d don't exist anymore -- these statements will give us name errors!
print[c]
print[d]

Gán một giá trị ban đầu cho biến được gọi là khởi tạo biến. Trong một số ngôn ngữ xác định một biến có thể được thực hiện trong một bước riêng biệt trước khi gán giá trị đầu tiên. Do đó, có thể trong các ngôn ngữ đó để một biến được xác định nhưng không có giá trị - điều này có thể dẫn đến lỗi hoặc hành vi bất ngờ nếu chúng ta cố gắng sử dụng giá trị trước khi nó được gán. Trong Python, một biến được xác định và gán một giá trị trong một bước duy nhất, vì vậy chúng tôi gần như sẽ không bao giờ gặp phải các tình huống như thế này.

Phía bên trái của câu lệnh gán phải là mục tiêu hợp lệ:

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

Một câu lệnh gán có thể có nhiều mục tiêu được phân tách bằng các dấu hiệu bằng. Biểu thức ở phía bên phải của dấu hiệu tương đương cuối cùng sẽ được gán cho tất cả các mục tiêu. Tất cả các mục tiêu phải hợp lệ:

# both a and b will be set to zero:
a = b = 0

# this is illegal, because we can't set 0 to b:
a = 0 = b

Người vận hành phân công gộp

Chúng ta đã thấy rằng chúng ta có thể gán kết quả của một biểu thức số học cho một biến:

Đếm là một cái gì đó được thực hiện thường xuyên trong một chương trình. Ví dụ, chúng tôi có thể muốn giữ số lần xảy ra bao nhiêu lần một sự kiện nhất định bằng cách sử dụng một biến gọi là

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

Đây thực tế là một hoạt động rất phổ biến. Python có một toán tử tốc ký,

# This is a global variable
a = 0

if a == 0:
    # This is still a global variable
    b = 1

def my_function[c]:
    # this is a local variable
    d = 3
    print[c]
    print[d]

# Now we call the function, passing the value 7 as the first and only parameter
my_function[7]

# a and b still exist
print[a]
print[b]

# c and d don't exist anymore -- these statements will give us name errors!
print[c]
print[d]

# These statements mean exactly the same thing:
count = count + 1
count += 1

# We can increment a variable by any number we like.
count += 2
count += 7
count += a + b

Có một toán tử tương tự,

# This is a global variable
a = 0

if a == 0:
    # This is still a global variable
    b = 1

def my_function[c]:
    # this is a local variable
    d = 3
    print[c]
    print[d]

# Now we call the function, passing the value 7 as the first and only parameter
my_function[7]

# a and b still exist
print[a]
print[b]

# c and d don't exist anymore -- these statements will give us name errors!
print[c]
print[d]

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Các toán tử gán hợp chất phổ biến khác được đưa ra trong bảng dưới đây:

# This is a global variable
a = 0

if a == 0:
    # This is still a global variable
    b = 1

def my_function[c]:
    # this is a local variable
    d = 3
    print[c]
    print[d]

# Now we call the function, passing the value 7 as the first and only parameter
my_function[7]

# a and b still exist
print[a]
print[b]

# c and d don't exist anymore -- these statements will give us name errors!
print[c]
print[d]

# This is a global variable
a = 0

if a == 0:
    # This is still a global variable
    b = 1

def my_function[c]:
    # this is a local variable
    d = 3
    print[c]
    print[d]

# Now we call the function, passing the value 7 as the first and only parameter
my_function[7]

# a and b still exist
print[a]
print[b]

# c and d don't exist anymore -- these statements will give us name errors!
print[c]
print[d]

a_number = 5              # a_number becomes 5
a_number = total          # a_number becomes the value of total
a_number = total + 5      # a_number becomes the value of total + 5
a_number = a_number + 1   # a_number becomes the value of a_number + 1

# This is a global variable
a = 0

if a == 0:
    # This is still a global variable
    b = 1

def my_function[c]:
    # this is a local variable
    d = 3
    print[c]
    print[d]

# Now we call the function, passing the value 7 as the first and only parameter
my_function[7]

# a and b still exist
print[a]
print[b]

# c and d don't exist anymore -- these statements will give us name errors!
print[c]
print[d]

a_number = 5              # a_number becomes 5
a_number = total          # a_number becomes the value of total
a_number = total + 5      # a_number becomes the value of total + 5
a_number = a_number + 1   # a_number becomes the value of a_number + 1

a_number = 5              # a_number becomes 5
a_number = total          # a_number becomes the value of total
a_number = total + 5      # a_number becomes the value of total + 5
a_number = a_number + 1   # a_number becomes the value of a_number + 1

a_number = 5              # a_number becomes 5
a_number = total          # a_number becomes the value of total
a_number = total + 5      # a_number becomes the value of total + 5
a_number = a_number + 1   # a_number becomes the value of a_number + 1

a_number = 5              # a_number becomes 5
a_number = total          # a_number becomes the value of total
a_number = total + 5      # a_number becomes the value of total + 5
a_number = a_number + 1   # a_number becomes the value of a_number + 1

a_number = 5              # a_number becomes 5
a_number = total          # a_number becomes the value of total
a_number = total + 5      # a_number becomes the value of total + 5
a_number = a_number + 1   # a_number becomes the value of a_number + 1

a_number = 5              # a_number becomes 5
a_number = total          # a_number becomes the value of total
a_number = total + 5      # a_number becomes the value of total + 5
a_number = a_number + 1   # a_number becomes the value of a_number + 1

a_number = 5              # a_number becomes 5
a_number = total          # a_number becomes the value of total
a_number = total + 5      # a_number becomes the value of total + 5
a_number = a_number + 1   # a_number becomes the value of a_number + 1

a_number = 5              # a_number becomes 5
a_number = total          # a_number becomes the value of total
a_number = total + 5      # a_number becomes the value of total + 5
a_number = a_number + 1   # a_number becomes the value of a_number + 1

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

Thông tin thêm về phạm vi: Biến ranh giới

Điều gì sẽ xảy ra nếu chúng ta muốn truy cập một biến toàn cầu từ bên trong một hàm? Có thể, nhưng làm như vậy đi kèm với một vài cảnh báo:

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Câu lệnh in sẽ xuất ra

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Khi chúng ta gọi hàm, câu lệnh in bên trong đầu ra

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

Theo mặc định, câu lệnh gán tạo các biến trong phạm vi cục bộ. Vì vậy, việc gán bên trong hàm không sửa đổi biến toàn cầu

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

Điều gì sẽ xảy ra nếu chúng ta thực sự muốn sửa đổi một biến toàn cầu từ bên trong một hàm? Chúng ta có thể sử dụng từ khóa

# both a and b will be set to zero:
a = b = 0

# this is illegal, because we can't set 0 to b:
a = 0 = b

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Chúng tôi không được đề cập đến cả biến toàn cầu và biến cục bộ cùng tên bên trong cùng một hàm. Chương trình này sẽ cho chúng tôi một lỗi:

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Bởi vì chúng tôi đã tuyên bố

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

Lưu ý rằng thường là thực tế rất tệ để truy cập các biến toàn cầu từ các chức năng bên trong và thậm chí thực hành tồi tệ hơn để sửa đổi chúng. Điều này gây khó khăn cho việc sắp xếp chương trình của chúng tôi thành các phần được đóng gói một cách hợp lý không ảnh hưởng đến nhau theo những cách bất ngờ. Nếu một hàm cần truy cập một số giá trị bên ngoài, chúng ta nên truyền giá trị vào hàm dưới dạng tham số. Nếu hàm là phương pháp của một đối tượng, đôi khi phù hợp để biến giá trị thành một thuộc tính của cùng một đối tượng - chúng ta sẽ thảo luận về điều này trong chương về hướng đối tượng.

Ghi chú

Ngoài ra còn có từ khóa

# both a and b will be set to zero:
a = b = 0

# this is illegal, because we can't set 0 to b:
a = 0 = b

# both a and b will be set to zero:
a = b = 0

# this is illegal, because we can't set 0 to b:
a = 0 = b

# both a and b will be set to zero:
a = b = 0

# this is illegal, because we can't set 0 to b:
a = 0 = b

Bài tập 1¶

1. Mô tả phạm vi của các biến

   # this is fine:
   a = 3
   
   # these are all illegal:
   3 = 4
   3 = a
   a + b = 3
   

   4,

   # both a and b will be set to zero:
   a = b = 0
   
   # this is illegal, because we can't set 0 to b:
   a = 0 = b
   

   9,

   # These statements mean exactly the same thing:
   count = count + 1
   count += 1
   
   # We can increment a variable by any number we like.
   count += 2
   count += 7
   count += a + b
   

   0 và

   # These statements mean exactly the same thing:
   count = count + 1
   count += 1
   
   # We can increment a variable by any number we like.
   count += 2
   count += 7
   count += a + b
   

   1 trong ví dụ này:

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   5

2. Tuổi thọ của các biến này là gì? Khi nào chúng sẽ được tạo ra và phá hủy?

3. Bạn có thể đoán điều gì sẽ xảy ra nếu chúng ta chỉ định

   # These statements mean exactly the same thing:
   count = count + 1
   count += 1
   
   # We can increment a variable by any number we like.
   count += 2
   count += 7
   count += a + b
   

   0 giá trị

   # These statements mean exactly the same thing:
   count = count + 1
   count += 1
   
   # We can increment a variable by any number we like.
   count += 2
   count += 7
   count += a + b
   

   3 thay thế không?

4. Tại sao đây sẽ là một vấn đề? Bạn có thể nghĩ ra một cách để tránh nó?

Sửa đổi các giá trị

Hằng số trong

Trong một số ngôn ngữ, có thể xác định các biến đặc biệt chỉ có thể được gán một giá trị một lần - một khi giá trị của chúng đã được đặt, chúng không thể thay đổi. Chúng tôi gọi các loại hằng số biến này. Python không cho phép chúng tôi đặt ra một hạn chế như vậy đối với các biến, nhưng có một quy ước được sử dụng rộng rãi để đánh dấu các biến nhất định để chỉ ra rằng giá trị của chúng không có nghĩa là thay đổi: chúng tôi viết tên của chúng trong tất cả các mũ, với các từ ngữ tách biệt:

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Tại sao chúng ta bận tâm xác định các biến mà chúng ta không có ý định thay đổi? Xem xét ví dụ này:

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Có một số lý do tốt để xác định

# These statements mean exactly the same thing:
count = count + 1
count += 1

# We can increment a variable by any number we like.
count += 2
count += 7
count += a + b

# These statements mean exactly the same thing:
count = count + 1
count += 1

# We can increment a variable by any number we like.
count += 2
count += 7
count += a + b

Các số theo nghĩa đen nằm rải rác trong một chương trình được gọi là Số ma thuật của Hồi giáo - sử dụng chúng được coi là phong cách mã hóa kém. Điều này không áp dụng cho các số nhỏ được coi là tự giải thích-nó dễ hiểu tại sao tổng số được khởi tạo về 0 hoặc tăng bởi một.

Đôi khi chúng tôi muốn sử dụng một biến để phân biệt giữa một số tùy chọn riêng biệt. Rất hữu ích khi đề cập đến các giá trị tùy chọn bằng cách sử dụng các hằng số thay vì sử dụng trực tiếp chúng nếu chính các giá trị không có ý nghĩa nội tại:

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Trong ví dụ trên, các giá trị

# These statements mean exactly the same thing:
count = count + 1
count += 1

# We can increment a variable by any number we like.
count += 2
count += 7
count += a + b

# These statements mean exactly the same thing:
count = count + 1
count += 1

# We can increment a variable by any number we like.
count += 2
count += 7
count += a + b

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

# These statements mean exactly the same thing:
count = count + 1
count += 1

# We can increment a variable by any number we like.
count += 2
count += 7
count += a + b

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Một số thư viện Python xác định các hằng số phổ biến cho sự thuận tiện của chúng tôi, ví dụ:

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Lưu ý rằng nhiều hằng số tích hợp don don tuân theo quy ước đặt tên tất cả các phạm vi.

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

Một số giá trị trong Python có thể được sửa đổi, và một số không thể. Điều này không bao giờ có nghĩa là chúng ta có thể thay đổi giá trị của một biến - nhưng nếu một biến chứa một giá trị của một loại bất biến, chúng ta chỉ có thể gán cho nó một giá trị mới. Chúng ta không thể thay đổi giá trị hiện có theo bất kỳ cách nào.

Các số nguyên, số và chuỗi dấu phẩy động đều là các loại bất biến-trong tất cả các ví dụ trước, khi chúng tôi thay đổi các giá trị của các biến hiện tại, chúng tôi đã sử dụng toán tử gán để gán cho chúng các giá trị mới:

def func[x,y]:
    x = x+200 #this can be written x += 200
    y = y+300 #as above: y += 300
    return [x,y] #returns a tuple [x,y]

x = 2
y = 3
func[x,y] # returns [202, 303]
print[x,y] #prints 2 3

Ngay cả toán tử này cũng không sửa đổi giá trị của

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Chúng tôi đã gặp phải bất kỳ loại có thể thay đổi nào, nhưng chúng tôi sẽ sử dụng chúng rộng rãi trong các chương sau. Danh sách và từ điển là có thể thay đổi, và hầu hết các đối tượng mà chúng ta có thể tự viết:

def func[x,y]:
    x = x+200 #this can be written x += 200
    y = y+300 #as above: y += 300
    return [x,y] #returns a tuple [x,y]

x = 2
y = 3
func[x,y] # returns [202, 303]
print[x,y] #prints 2 3

Thông tin thêm về Input¶

Trong các phần trước của đơn vị này, chúng tôi đã học cách tạo chương trình hiển thị thông báo bằng hàm

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    x = x+200 #this can be written x += 200
    y = y+300 #as above: y += 300
    return [x,y] #returns a tuple [x,y]

x = 2
y = 3
func[x,y] # returns [202, 303]
print[x,y] #prints 2 3

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    x = x+200 #this can be written x += 200
    y = y+300 #as above: y += 300
    return [x,y] #returns a tuple [x,y]

x = 2
y = 3
func[x,y] # returns [202, 303]
print[x,y] #prints 2 3

Chương trình này vẫn sẽ chỉ cố gắng đọc trong đầu vào một lần và thoát nếu nó không chính xác. Nếu chúng tôi muốn tiếp tục yêu cầu người dùng đầu vào cho đến khi đúng, chúng tôi có thể làm điều gì đó như sau:

def func[x,y]:
    x = x+200 #this can be written x += 200
    y = y+300 #as above: y += 300
    return [x,y] #returns a tuple [x,y]

x = 2
y = 3
func[x,y] # returns [202, 303]
print[x,y] #prints 2 3

Chúng tôi sẽ tìm hiểu thêm về các giá trị, vòng lặp và ngoại lệ Boolean sau này.

Ví dụ: Tính toán tiêu thụ xăng của xe hơi

Trong ví dụ này, chúng tôi sẽ viết một chương trình đơn giản yêu cầu người dùng cho khoảng cách đi bằng xe hơi và giá trị tiền tệ của xăng được sử dụng để che đi khoảng cách đó. Từ thông tin này, cùng với giá mỗi lít xăng, chương trình sẽ tính toán hiệu quả của chiếc xe, cả hai lít trên 100 km và km mỗi lít.

Đầu tiên chúng tôi sẽ định nghĩa giá xăng là một hằng số ở đầu. Điều này sẽ giúp chúng tôi dễ dàng cập nhật giá khi thay đổi vào thứ Tư đầu tiên hàng tháng:

def func[x,y]:
    x = x+200 #this can be written x += 200
    y = y+300 #as above: y += 300
    return [x,y] #returns a tuple [x,y]

x = 2
y = 3
func[x,y] # returns [202, 303]
print[x,y] #prints 2 3

Khi chương trình bắt đầu, chúng tôi muốn in ra một tin nhắn chào mừng:

def func[x,y]:
    x = x+200 #this can be written x += 200
    y = y+300 #as above: y += 300
    return [x,y] #returns a tuple [x,y]

x = 2
y = 3
func[x,y] # returns [202, 303]
print[x,y] #prints 2 3

Hỏi người dùng cho tên của mình:

def func[x,y]:
    x = x+200 #this can be written x += 200
    y = y+300 #as above: y += 300
    return [x,y] #returns a tuple [x,y]

x = 2
y = 3
func[x,y] # returns [202, 303]
print[x,y] #prints 2 3

Hỏi người dùng cho khoảng cách di chuyển:

def func[x,y]:
    x = x+200 #this can be written x += 200
    y = y+300 #as above: y += 300
    return [x,y] #returns a tuple [x,y]

x = 2
y = 3
func[x,y] # returns [202, 303]
print[x,y] #prints 2 3

Sau đó hỏi người dùng số tiền đã trả:

def func[x,y]:
    x = x+200 #this can be written x += 200
    y = y+300 #as above: y += 300
    return [x,y] #returns a tuple [x,y]

x = 2
y = 3
func[x,y] # returns [202, 303]
print[x,y] #prints 2 3

Bây giờ chúng tôi sẽ thực hiện các tính toán:

#func as defined above

x=2 ; y=3
x,y = func[x,y] #this unpacks the tuple [202,303] into two values and x and y
print[x,y] #prints 202 303

Cuối cùng, chúng tôi đưa ra kết quả:

#func as defined above

x=2 ; y=3
x,y = func[x,y] #this unpacks the tuple [202,303] into two values and x and y
print[x,y] #prints 202 303

Bài tập 2¶

1. Viết một chương trình Python để chuyển đổi nhiệt độ được đưa ra theo độ Fahrenheit thành tương đương với độ C. Bạn có thể giả sử rằng t_c = [5/9] x [t_f - 32], trong đó t_c là nhiệt độ trong ° C và T_F là nhiệt độ tính bằng ° F. Chương trình của bạn nên yêu cầu người dùng cho một giá trị đầu vào và in đầu ra. Các giá trị đầu vào và đầu ra phải là số điểm nổi.T_c = [5/9] x [T_f - 32], where T_c is the temperature in °C and T_f is the temperature in °F. Your program should ask the user for an input value, and print the output. The input and output values should be floating-point numbers.
2. Điều gì có thể làm cho chương trình này sụp đổ? Chúng ta cần làm gì để xử lý tình huống này một cách duyên dáng hơn?

Loại chuyển đổi

Khi chúng tôi viết nhiều chương trình hơn, chúng tôi thường sẽ thấy rằng chúng tôi cần chuyển đổi dữ liệu từ loại này sang loại khác, ví dụ từ chuỗi sang số nguyên hoặc từ số nguyên sang số điểm nổi. Có hai loại chuyển đổi loại trong Python: chuyển đổi ngầm và rõ ràng.

Chuyển đổi ngầm

Nhớ lại từ phần về các toán tử dấu phẩy động rằng chúng ta có thể tùy ý kết hợp các số nguyên và số điểm nổi trong một biểu thức số học-và kết quả của bất kỳ biểu thức nào như vậy sẽ luôn là một số điểm nổi. Điều này là do Python sẽ chuyển đổi các số nguyên thành số điểm nổi trước khi đánh giá biểu thức. Đây là một chuyển đổi ngầm - chúng tôi không phải tự chuyển đổi bất cứ điều gì. Thường không mất độ chính xác khi một số nguyên được chuyển đổi thành số điểm nổi.

Ví dụ: số nguyên

# These statements mean exactly the same thing:
count = count + 1
count += 1

# We can increment a variable by any number we like.
count += 2
count += 7
count += a + b

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

# These statements mean exactly the same thing:
count = count + 1
count += 1

# We can increment a variable by any number we like.
count += 2
count += 7
count += a + b

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

# These statements mean exactly the same thing:
count = count + 1
count += 1

# We can increment a variable by any number we like.
count += 2
count += 7
count += a + b

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Hãy để một cái nhìn vào một ví dụ phức tạp hơn:

#func as defined above

x=2 ; y=3
x,y = func[x,y] #this unpacks the tuple [202,303] into two values and x and y
print[x,y] #prints 202 303

Python thực hiện các hoạt động theo thứ tự ưu tiên và quyết định xem có cần chuyển đổi trên cơ sở hoạt động hay không. Trong ví dụ

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

# this is fine:
a = 3

# these are all illegal:
3 = 4
3 = a
a + b = 3

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

# These statements mean exactly the same thing:
count = count + 1
count += 1

# We can increment a variable by any number we like.
count += 2
count += 7
count += a + b

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

# These statements mean exactly the same thing:
count = count + 1
count += 1

# We can increment a variable by any number we like.
count += 2
count += 7
count += a + b

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Chuyển đổi rõ ràng

Chuyển đổi số từ

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Hàm

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

#func as defined above

x=2 ; y=3
x,y = func[x,y] #this unpacks the tuple [202,303] into two values and x and y
print[x,y] #prints 202 303

Chuyển đổi rõ ràng đôi khi cũng được gọi là đúc-chúng ta có thể đọc về một

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

Chuyển đổi đến và từ chuỗi

Như chúng ta đã thấy trong các phần trước, Python hiếm khi thực hiện các chuyển đổi ngầm đến và từ

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

#func as defined above

x=2 ; y=3
x,y = func[x,y] #this unpacks the tuple [202,303] into two values and x and y
print[x,y] #prints 202 303

Để chuyển đổi số thành chuỗi, chúng ta có thể sử dụng định dạng chuỗi - đây thường là cách sạch nhất và dễ đọc nhất để chèn nhiều giá trị vào một thông báo. Nếu chúng ta muốn chuyển đổi một số duy nhất thành một chuỗi, chúng ta cũng có thể sử dụng chức năng

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

#func as defined above

x=2 ; y=3
x,y = func[x,y] #this unpacks the tuple [202,303] into two values and x and y
print[x,y] #prints 202 303

Thêm về Chuyển đổi Or

Trong Python, các chức năng như

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

#func as defined above

x=2 ; y=3
x,y = func[x,y] #this unpacks the tuple [202,303] into two values and x and y
print[x,y] #prints 202 303

Các giá trị của loại

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

#func as defined above

x=2 ; y=3
x,y = func[x,y] #this unpacks the tuple [202,303] into two values and x and y
print[x,y] #prints 202 303

Điều kiện thường là một biểu thức đánh giá giá trị boolean:

#func as defined above

x=2 ; y=3
x,y = func[x,y] #this unpacks the tuple [202,303] into two values and x and y
print[x,y] #prints 202 303

Tuy nhiên, hầu hết mọi giá trị có thể được chuyển đổi hoàn toàn thành Boolean nếu nó được sử dụng trong một câu như thế này:

#func as defined above

x=2 ; y=3
x,y = func[x,y] #this unpacks the tuple [202,303] into two values and x and y
print[x,y] #prints 202 303

Điều này thường hoạt động theo cách mà bạn mong đợi: các số khác không là các giá trị

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

def func[x,y]:
    global x #these tell the function to look at the outer scope 
    global y #and use those references to x and y, not the inner scope
    x=200
    y=300

func[x,y]
print[x,y] #prints 200 300

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

Bài tập 3¶

1. Chuyển đổi

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   61 thành một chiếc phao.
2. Chuyển đổi

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   62 thành một số nguyên [với làm tròn].
3. Chuyển đổi

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   61 thành một số nguyên [với làm tròn].
4. Chuyển đổi

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   62 thành một chuỗi.
5. Chuyển đổi

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   65 thành một chuỗi.
6. Chuyển đổi

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   65 thành một chiếc phao.
7. Chuyển đổi

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   65 thành boolean.

Câu trả lời cho các bài tập

Trả lời cho bài tập 1¶

1. # this is fine:
   a = 3
   
   # these are all illegal:
   3 = 4
   3 = a
   a + b = 3
   

   4 là một biến cục bộ trong phạm vi

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   69 vì nó là một tên đối số.

   # both a and b will be set to zero:
   a = b = 0
   
   # this is illegal, because we can't set 0 to b:
   a = 0 = b
   

   9 cũng là một biến cục bộ bên trong

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   69, vì nó được gán một giá trị bên trong

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   69.

   # These statements mean exactly the same thing:
   count = count + 1
   count += 1
   
   # We can increment a variable by any number we like.
   count += 2
   count += 7
   count += a + b
   

   0 và

   # These statements mean exactly the same thing:
   count = count + 1
   count += 1
   
   # We can increment a variable by any number we like.
   count += 2
   count += 7
   count += a + b
   

   1 đều là các biến toàn cầu. Không có vấn đề gì khi

   # These statements mean exactly the same thing:
   count = count + 1
   count += 1
   
   # We can increment a variable by any number we like.
   count += 2
   count += 7
   count += a + b
   

   1 được tạo ra bên trong một khối

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   76, bởi vì bên trong khối

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   76 không phải là phạm vi mới - mọi thứ bên trong khối đều là một phần của phạm vi giống như bên ngoài [trong trường hợp này là phạm vi toàn cầu]. Chỉ các định nghĩa chức năng [bắt đầu bằng

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   78] và các định nghĩa lớp [bắt đầu bằng

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   79] cho thấy sự khởi đầu của một mức độ phạm vi mới.
2. Cả

   # this is fine:
   a = 3
   
   # these are all illegal:
   3 = 4
   3 = a
   a + b = 3
   

   4 và

   # both a and b will be set to zero:
   a = b = 0
   
   # this is illegal, because we can't set 0 to b:
   a = 0 = b
   

   9 sẽ được tạo mỗi khi

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   69 được gọi và phá hủy khi

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   69 đã hoàn tất việc thực hiện.

   # These statements mean exactly the same thing:
   count = count + 1
   count += 1
   
   # We can increment a variable by any number we like.
   count += 2
   count += 7
   count += a + b
   

   0 được tạo khi nó được gán giá trị

   # this is fine:
   a = 3
   
   # these are all illegal:
   3 = 4
   3 = a
   a + b = 3
   

   5 và tồn tại trong phần còn lại của việc thực hiện chương trình.

   # These statements mean exactly the same thing:
   count = count + 1
   count += 1
   
   # We can increment a variable by any number we like.
   count += 2
   count += 7
   count += a + b
   

   1 được tạo bên trong khối

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   76 [khi nó được gán giá trị được trả về từ hàm] và cũng tồn tại cho phần còn lại của việc thực hiện chương trình.
3. Như chúng ta sẽ tìm hiểu trong chương tiếp theo, các khối

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   76 được thực thi có điều kiện. Nếu

   # These statements mean exactly the same thing:
   count = count + 1
   count += 1
   
   # We can increment a variable by any number we like.
   count += 2
   count += 7
   count += a + b
   

   0 không lớn hơn

   # this is fine:
   a = 3
   
   # these are all illegal:
   3 = 4
   3 = a
   a + b = 3
   

   5 trong chương trình này, khối

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   76 sẽ không được thực thi và nếu điều đó xảy ra thì biến

   # These statements mean exactly the same thing:
   count = count + 1
   count += 1
   
   # We can increment a variable by any number we like.
   count += 2
   count += 7
   count += a + b
   

   1 sẽ không bao giờ được tạo.
4. Chúng tôi có thể sử dụng biến sau này trong mã, giả sử rằng nó luôn tồn tại và có sự cố chương trình của chúng tôi một cách bất ngờ nếu nó không có. Nó được coi là thực hành mã hóa kém để cho phép một biến được xác định hoặc không xác định tùy thuộc vào kết quả của một tuyên bố có điều kiện. Tốt hơn là đảm bảo rằng luôn luôn được xác định, bất kể điều gì - ví dụ, bằng cách gán nó một số giá trị mặc định khi bắt đầu. Việc kiểm tra xem một biến có giá trị mặc định dễ dàng hơn nhiều và sạch sẽ hơn nhiều hay không.

Trả lời cho bài tập 2¶

1. Đây là một chương trình ví dụ:

   # Define three variables at once:
   count, result, total = 0, 0, 0
   
   # This is equivalent to:
   count = 0
   result = 0
   total = 0
   

   1

   Ghi chú

   Biểu tượng định dạng

   def func[x,y]:
       global x #these tell the function to look at the outer scope 
       global y #and use those references to x and y, not the inner scope
       x=200
       y=300
   
   func[x,y]
   print[x,y] #prints 200 300
   

   93 được sử dụng với phao và hướng dẫn Python chọn một cách có thể đọc được của con người để hiển thị phao.

2. Chương trình có thể gặp sự cố nếu người dùng nhập giá trị không thể chuyển đổi thành số dấu phẩy động. Chúng tôi sẽ cần thêm một số loại kiểm tra lỗi để đảm bảo rằng điều này không xảy ra - ví dụ, bằng cách lưu trữ giá trị chuỗi và kiểm tra nội dung của nó. Nếu chúng tôi thấy rằng giá trị đã nhập không hợp lệ, chúng tôi có thể in thông báo lỗi và thoát hoặc tiếp tục nhắc người dùng để nhập cho đến khi nhập hợp lệ được nhập.

Trả lời cho bài tập 3¶

Đây là câu trả lời ví dụ:

# Define three variables at once:
count, result, total = 0, 0, 0

# This is equivalent to:
count = 0
result = 0
total = 0

Bạn có thể thay đổi một biến trong một chức năng python?

Làm thế nào để bạn cập nhật một biến trong Python?

Làm cách nào để thay đổi giá trị của một biến trong một hàm?

Làm thế nào để bạn truy cập một biến bên trong một hàm trong Python?