15+ Đề Trắc nghiệm Tin học 10 Kết nối tri thức Bài 28: Phạm vi của biến

Câu 1: Trong Python, biến được khai báo bên trong một hàm (không sử dụng từ khóa `global`) có phạm vi hoạt động như thế nào?

• A. Toàn cục, có thể truy cập từ bất kỳ đâu trong chương trình.
• B. Cục bộ, chỉ có hiệu lực bên trong hàm đó.
• C. Chỉ có hiệu lực sau khi hàm kết thúc.
• D. Chỉ có hiệu lực nếu được truyền vào như một tham số.

Câu 2: Biến toàn cục (global variable) trong Python là gì?

• A. Biến được khai báo ở mức ngoài cùng của chương trình, không nằm trong bất kỳ hàm hay lớp nào.
• B. Biến được khai báo bên trong một hàm nhưng sử dụng từ khóa `global`.
• C. Biến được truyền vào hàm như một tham số.
• D. Biến chỉ tồn tại trong suốt quá trình thực thi chương trình.

Câu 3: Xét đoạn code sau:
```python
x = 10
def my_function():
y = 5
print(x)
print(y)

my_function()
```
Kết quả khi chạy đoạn code trên là gì?

• A. 10
  5
• B. Báo lỗi do không truy cập được x bên trong hàm.
• C. Báo lỗi do không truy cập được y bên ngoài hàm.
• D. 5
  10

Câu 4: Xét đoạn code sau:
```python
a = 100
def change_a():
a = 200
print(f

• A. Trong ham: a = 200
  Ngoai ham: a = 200
• B. Trong ham: a = 100
  Ngoai ham: a = 100
• C. Trong ham: a = 200
  Ngoai ham: a = 100
• D. Báo lỗi.

Câu 5: Tại sao biến `a` bên trong hàm `change_a` ở Câu 4 lại không làm thay đổi giá trị của biến `a` bên ngoài hàm?

• A. Vì biến `a` bên ngoài hàm là biến hằng nên không thể thay đổi.
• B. Vì hàm chỉ có thể truy cập biến toàn cục để đọc, không thể ghi.
• C. Vì Python luôn tạo bản sao của biến khi truyền vào hàm.
• D. Vì việc gán `a = 200` bên trong hàm tạo ra một biến cục bộ mới tên là `a`, che khuất biến toàn cục cùng tên.

Câu 6: Để một hàm có thể thay đổi giá trị của một biến toàn cục, ta cần sử dụng từ khóa nào bên trong hàm trước khi sử dụng biến đó?

• A. global
• B. local
• C. extern
• D. public

Câu 7: Xét đoạn code sau:
```python
count = 0
def increment():
global count
count += 1

increment()
increment()
print(count)
```
Kết quả khi chạy đoạn code trên là gì?

• A. 0
• B. 1
• C. 2
• D. Báo lỗi.

Câu 8: Xét đoạn code sau:
```python
my_list = [1, 2, 3]
def modify_list(lst):
lst.append(4)

modify_list(my_list)
print(my_list)
```
Kết quả khi chạy đoạn code trên là gì?

• A. [1, 2, 3]
• B. [1, 2, 3, 4]
• C. Báo lỗi.
• D. None

Câu 9: Tại sao hàm `modify_list` ở Câu 8 lại có thể làm thay đổi danh sách `my_list` bên ngoài hàm mà không cần dùng từ khóa `global`?

• A. Vì danh sách (list) là một đối tượng có thể thay đổi (mutable), và hàm nhận tham chiếu đến đối tượng gốc.
• B. Vì `my_list` là biến toàn cục.
• C. Vì phương thức `append` luôn hoạt động trên biến toàn cục.
• D. Vì Python tự động coi các đối tượng phức tạp như danh sách là toàn cục.

Câu 10: Xét đoạn code sau:
```python
my_value = 10
def change_value(val):
val = val + 5
print(f

• A. Trong ham: val = 15
  Ngoai ham: my_value = 15
• B. Trong ham: val = 10
  Ngoai ham: my_value = 10
• C. Trong ham: val = 10
  Ngoai ham: my_value = 15
• D. Trong ham: val = 15
  Ngoai ham: my_value = 10

Câu 11: Tại sao hàm `change_value` ở Câu 10 lại không làm thay đổi giá trị của biến `my_value` bên ngoài hàm?

• A. Vì biến `my_value` là biến toàn cục.
• B. Vì số nguyên (integer) là đối tượng có thể thay đổi (mutable).
• C. Vì số nguyên (integer) là đối tượng không thể thay đổi (immutable), phép gán `val = val + 5` tạo ra một đối tượng số nguyên mới và gán cho biến cục bộ `val`.
• D. Vì hàm không sử dụng từ khóa `global`.

Câu 12: Xét đoạn code sau:
```python
def create_local_var():
message =

• A. Hello from inside!
  Hello from inside!
• B. Báo lỗi cú pháp.
• C. Hello from inside!
  (Không in gì nữa)
• D. Hello from inside!
  Báo lỗi NameError: name "message" is not defined

Câu 13: Lỗi NameError xảy ra ở Câu 12 là do đâu?

• A. Biến `message` chưa được gán giá trị bên trong hàm.
• B. Biến `message` được khai báo cục bộ bên trong hàm và không thể truy cập từ bên ngoài hàm.
• C. Biến `message` bị trùng tên với một từ khóa của Python.
• D. Hàm `create_local_var` chưa được gọi.

Câu 14: Khi một biến có cùng tên tồn tại ở cả phạm vi toàn cục và phạm vi cục bộ trong một hàm, điều gì xảy ra khi bạn tham chiếu đến tên biến đó bên trong hàm (để đọc giá trị)?

• A. Biến cục bộ sẽ được ưu tiên, che khuất biến toàn cục (hiện tượng shadowing).
• B. Biến toàn cục sẽ được ưu tiên.
• C. Chương trình sẽ báo lỗi vì tên biến bị trùng.
• D. Python sẽ hỏi người dùng muốn sử dụng biến nào.

Câu 15: Xét đoạn code sau:
```python
value = 10
def process():
# Dòng code A
print(value)
value = 20 # Dòng code B
print(value)

process()
print(value)
```
Khi chạy đoạn code trên, điều gì sẽ xảy ra?

• A. 10
  20
  10
• B. 10
  20
  20
• C. 20
  20
  10
• D. Báo lỗi UnboundLocalError tại Dòng code A.

Câu 16: Lỗi UnboundLocalError ở Câu 15 xảy ra vì:

• A. Biến `value` được khai báo là toàn cục nhưng lại được sử dụng bên trong hàm.
• B. Biến `value` bên trong hàm chưa được gán giá trị trước khi được in ra.
• C. Python phát hiện có lệnh gán giá trị cho `value` bên trong hàm (Dòng code B), nên nó coi `value` là biến cục bộ. Tuy nhiên, Dòng code A lại cố gắng truy cập biến cục bộ này trước khi nó được gán giá trị.
• D. Biến `value` bên ngoài hàm bị xóa sau khi hàm được gọi.

Câu 17: Khi nào thì một biến cục bộ được tạo ra bên trong một hàm?

• A. Khi một giá trị được gán cho một tên biến lần đầu tiên bên trong hàm, trừ khi tên biến đó đã được khai báo là `global`.
• B. Ngay khi hàm được gọi.
• C. Khi biến đó được truyền vào như một tham số.
• D. Khi biến đó được sử dụng lần đầu tiên bên trong hàm.

Câu 18: Phạm vi của biến (variable scope) trong lập trình có vai trò gì?

• A. Xác định kiểu dữ liệu của biến.
• B. Quy định tốc độ truy cập biến.
• C. Cho phép một biến được sử dụng ở mọi nơi trong chương trình.
• D. Xác định phần nào của chương trình có thể truy cập hoặc thay đổi biến đó, giúp quản lý dữ liệu và tránh xung đột tên biến.

Câu 19: Xét đoạn code sau:
```python
my_number = 50
def modify_number(num):
num = 100
print(f

• A. Trong ham, num = 100
  Ngoai ham, my_number = 100
• B. Trong ham, num = 100
  Ngoai ham, my_number = 50
• C. Trong ham, num = 50
  Ngoai ham, my_number = 50
• D. Báo lỗi.

Câu 20: Điều gì xảy ra với các biến cục bộ sau khi hàm chứa chúng kết thúc quá trình thực thi?

• A. Chúng thường bị hủy và không thể truy cập được nữa.
• B. Chúng vẫn tồn tại nhưng chỉ có thể truy cập bằng cách gọi lại hàm.
• C. Chúng trở thành biến toàn cục.
• D. Chúng được lưu trữ vào bộ nhớ cache để sử dụng lần sau.

Câu 21: Xét đoạn code sau:
```python
def outer_function():
x = 10
def inner_function():
y = 20
print(x + y)
inner_function()

outer_function()
```
Kết quả khi chạy đoạn code trên là gì?

• A. 30
• B. Báo lỗi NameError: name "x" is not defined
• C. Báo lỗi NameError: name "y" is not defined
• D. Chương trình không in gì cả.

Câu 22: Trong đoạn code ở Câu 21, biến `y` có phạm vi như thế nào so với biến `x`?

• A. `y` là toàn cục, `x` là cục bộ.
• B. Cả `x` và `y` đều là toàn cục.
• C. Cả `x` và `y` đều là cục bộ, nhưng `y` có phạm vi nhỏ hơn, chỉ trong `inner_function`, trong khi `x` có phạm vi trong `outer_function` (bao gồm cả `inner_function`).
• D. `y` là cục bộ, `x` là tham số.

Câu 23: Xét đoạn code sau:
```python
status =

• A. global
• B. local
• C. Báo lỗi UnboundLocalError.
• D. Báo lỗi NameError.

Câu 24: Vẫn đoạn code ở Câu 23, nếu bỏ chú thích ở dòng `# status =

• A. global
• B. local
• C. Báo lỗi UnboundLocalError.
• D. Báo lỗi NameError.

Câu 25: Trong Python, khi bạn định nghĩa một hàm, nó tạo ra một phạm vi (scope) mới. Phạm vi này được gọi là gì?

• A. Phạm vi toàn cục (Global scope)
• B. Phạm vi cục bộ (Local scope)
• C. Phạm vi tích hợp (Built-in scope)
• D. Phạm vi bao đóng (Enclosing scope)

Câu 26: Xét đoạn code sau:
```python
count = 1
def do_this():
global count
for i in range(5):
count += 1

do_this()
print(count)
```
Kết quả khi chạy đoạn code trên là gì?

• A. 1
• B. 5
• C. 6
• D. 7

Câu 27: Biến `i` trong vòng lặp `for` ở Câu 26 có phạm vi như thế nào?

• A. Cục bộ trong hàm `do_this`.
• B. Toàn cục.
• C. Chỉ cục bộ trong vòng lặp `for`.
• D. Bị lỗi do không khai báo kiểu dữ liệu.

Câu 28: Xét đoạn code sau:
```python
my_data = {

• A. 0
• B. 1
• C. 2
• D. Báo lỗi.

Câu 29: Tại sao hàm `update_data` ở Câu 28 có thể thay đổi giá trị trong dictionary `my_data` mà không cần từ khóa `global`?

• A. Vì dictionary là đối tượng không thể thay đổi (immutable).
• B. Vì dictionary là đối tượng có thể thay đổi (mutable), và hàm đang sửa đổi nội dung của đối tượng gốc mà nó tham chiếu tới, không phải gán lại tên biến `my_data`.
• C. Vì `my_data` là biến toàn cục.
• D. Vì hàm chỉ thực hiện phép cộng, không phải phép gán.

Câu 30: Phát biểu nào sau đây là đúng về việc sử dụng biến toàn cục trong các hàm?

• A. Luôn nên sử dụng biến toàn cục để các hàm dễ dàng chia sẻ dữ liệu.
• B. Biến toàn cục chỉ có thể được đọc chứ không thể thay đổi trong hàm.
• C. Việc thay đổi biến toàn cục trong hàm bằng từ khóa `global` làm cho chương trình dễ hiểu và dễ gỡ lỗi hơn.
• D. Việc lạm dụng biến toàn cục và thay đổi chúng trong nhiều hàm có thể làm cho luồng dữ liệu khó kiểm soát, tăng khả năng phát sinh lỗi không mong muốn (side effects).

Câu 1: Trong Python, khi một biến được khai báo bên trong một hàm, nó có phạm vi hoạt động như thế nào?

• A. Toàn cục, có thể truy cập từ bất kỳ đâu trong chương trình.
• B. Cục bộ, chỉ có thể truy cập bên trong hàm nơi nó được khai báo.
• C. Được chia sẻ giữa tất cả các hàm trong cùng một tệp.
• D. Tồn tại cho đến khi chương trình kết thúc, bất kể vị trí khai báo.

Câu 2: Xem xét đoạn mã Python sau:

def ham_ngoai():
x = 10
def ham_trong():
print(x)
ham_trong()

ham_ngoai()

Giá trị nào sẽ được in ra khi thực thi đoạn mã trên?

• A. 10
• B. Biến x không được định nghĩa
• C. 0
• D. Lỗi cú pháp

Câu 3: Biến toàn cục trong Python được khai báo ở đâu?

• A. Bên trong một hàm cụ thể với từ khóa "global".
• B. Ở đầu mỗi chương trình Python.
• C. Bên ngoài tất cả các hàm trong một chương trình.
• D. Chỉ khi chương trình bắt đầu thực thi.

Câu 4: Cho đoạn mã Python:

x = 5

def thay_doi_x():
x = 10
print("Giá trị x trong hàm:", x)

thay_doi_x()
print("Giá trị x ngoài hàm:", x)

Đâu là kết quả đầu ra của đoạn mã này?

• A. Giá trị x trong hàm: 10
  Giá trị x ngoài hàm: 10
• B. Giá trị x trong hàm: 10
  Giá trị x ngoài hàm: 5
• C. Giá trị x trong hàm: 5
  Giá trị x ngoài hàm: 10
• D. Lỗi vì biến x được gán lại trong hàm

Câu 5: Từ khóa nào trong Python được sử dụng để khai báo rằng một biến bên trong hàm là biến toàn cục?

• A. local
• B. function
• C. static
• D. global

Câu 6: Xem xét đoạn mã sau:

x = 20

def sua_doi_toan_cuc():
global x
x = 25

sua_doi_toan_cuc()
print(x)

Giá trị nào của x sẽ được in ra?

• A. 20
• B. Không có giá trị nào được in
• C. 25
• D. Lỗi vì biến toàn cục không thể sửa đổi

Câu 7: Điều gì xảy ra nếu bạn cố gắng truy cập một biến cục bộ bên ngoài hàm mà nó được khai báo?

• A. Lỗi NameError sẽ xảy ra.
• B. Chương trình sẽ chạy nhưng có thể cho kết quả không mong muốn.
• C. Biến sẽ tự động được coi là biến toàn cục.
• D. Giá trị mặc định của biến (nếu có) sẽ được sử dụng.

Câu 8: Phạm vi của một biến quyết định điều gì?

• A. Kiểu dữ liệu của biến.
• B. Vùng mã lệnh mà biến có thể được truy cập.
• C. Thời gian tồn tại của biến trong bộ nhớ.
• D. Tốc độ truy cập vào biến.

Câu 9: Cho đoạn mã:

def tinh_tong(a, b):
c = a + b
return c

ket_qua = tinh_tong(5, 3)
print(c)

Đoạn mã này có lỗi không? Nếu có, lỗi ở dòng nào và vì sao?

• A. Không có lỗi.
• B. Lỗi ở dòng 2, biến "c" chưa được khai báo.
• C. Lỗi ở dòng 5, biến "c" là biến cục bộ của hàm "tinh_tong".
• D. Lỗi ở dòng 4, phép gán "ket_qua" không hợp lệ.

Câu 10: Trong một chương trình lớn, việc sử dụng biến cục bộ thay vì biến toàn cục mang lại lợi ích gì?

• A. Tăng tốc độ thực thi chương trình.
• B. Giảm khả năng xung đột tên biến và tăng tínhModular hóa.
• C. Tiết kiệm bộ nhớ.
• D. Cho phép truy cập biến từ nhiều chương trình khác nhau.

Câu 11: Xét đoạn mã:

def ham_a():
z = 7
def ham_b():
print(z)
ham_b()

print(z)

Hỏi dòng `print(z)` cuối cùng có gây ra lỗi không? Nếu có, đó là lỗi gì?

• A. Không lỗi, in ra giá trị 7.
• B. Có lỗi NameError, vì "z" không được định nghĩa trong phạm vi toàn cục.
• C. Có lỗi TypeError, vì "z" có kiểu dữ liệu không phù hợp.
• D. Có lỗi SyntaxError, vì cấu trúc hàm không đúng.

Câu 12: Cho chương trình Python sau:

x = 100

def ham_c():
x = 200
def ham_d():
nonlocal x
x = 300
ham_d()
print(x)

ham_c()
print(x)

Kết quả in ra của chương trình là gì?

• A. 200
  100
• B. 300
  100
• C. 300
  200
• D. Lỗi vì nonlocal không được dùng ở phạm vi toàn cục

Câu 13: Biến nào có "thời gian sống" dài nhất trong chương trình Python?

• A. Biến toàn cục.
• B. Biến cục bộ.
• C. Tham số của hàm.
• D. Biến nonlocal.

Câu 14: Trong tình huống nào sau đây, việc sử dụng biến toàn cục là phù hợp nhất?

• A. Khi biến chỉ được sử dụng trong một hàm duy nhất.
• B. Để đếm số lần một vòng lặp được thực hiện.
• C. Khi cần chia sẻ dữ liệu giữa nhiều hàm khác nhau trong chương trình.
• D. Để lưu trữ giá trị tạm thời trong một phép tính.

Câu 15: Điều gì sẽ xảy ra khi bạn gán giá trị cho một biến mà không khai báo nó trong một hàm Python?

• A. Lỗi NameError sẽ xảy ra.
• B. Python sẽ coi đó là một biến cục bộ mới trong hàm.
• C. Python sẽ tìm kiếm biến toàn cục có cùng tên và gán giá trị cho nó.
• D. Chương trình sẽ không thực thi được.

Câu 16: Cho đoạn mã:

def ham_e():
m = 50
return m

print(ham_e())
print(m)

Kết quả đoạn mã trên sẽ như thế nào?

• A. 50
  50
• B. 50
  None
• C. 50
  Giá trị mặc định của m
• D. In ra 50, sau đó gây lỗi NameError ở dòng cuối.

Câu 17: Trong Python, các tham số được định nghĩa trong dấu ngoặc đơn của định nghĩa hàm có phạm vi như thế nào?

• A. Toàn cục.
• B. Cục bộ trong hàm.
• C. Có thể truy cập từ bất kỳ hàm nào khác.
• D. Phạm vi phụ thuộc vào nơi hàm được gọi.

Câu 18: Xét đoạn mã:

def ham_f(p):
p = p + 10
print(p)

q = 5
ham_f(q)
print(q)

Giá trị nào sẽ được in ra?

• A. 15
  15
• B. 5
  15
• C. 15
  5
• D. Lỗi vì tham số p không được khai báo bên ngoài hàm

Câu 19: Mục đích chính của việc phân chia phạm vi biến (cục bộ và toàn cục) trong lập trình là gì?

• A. Để tăng hiệu suất chương trình.
• B. Để giảm dung lượng bộ nhớ sử dụng.
• C. Để làm cho mã chương trình ngắn gọn hơn.
• D. Để quản lý tên biến và tránh xung đột tên, tăng tính tổ chức của mã.

Câu 20: Trong Python, điều gì xảy ra khi một biến cục bộ có cùng tên với một biến toàn cục?

• A. Biến cục bộ sẽ che phủ (shadow) biến toàn cục trong phạm vi của hàm.
• B. Biến toàn cục sẽ được ưu tiên sử dụng.
• C. Python sẽ báo lỗi xung đột tên.
• D. Hai biến này sẽ chia sẻ cùng một vùng nhớ.

Câu 21: Cho đoạn mã:

r = 10

def ham_g():
r = r + 5
print(r)

ham_g()

Đoạn mã này có chạy được không? Nếu không, tại sao?

• A. Có, in ra 15.
• B. Không, gây lỗi UnboundLocalError vì biến "r" cục bộ được tham chiếu trước khi gán.
• C. Có, in ra 10.
• D. Không, gây lỗi TypeError vì không thể cộng số với biến chưa xác định.

Câu 22: Để sửa lỗi trong đoạn mã ở Câu 21 và muốn hàm `ham_g` tăng giá trị của biến toàn cục `r` lên 5, bạn cần làm gì?

• A. Thay "r = r + 5" bằng "r += 5".
• B. Khai báo lại "r = 10" bên trong hàm "ham_g".
• C. Thêm dòng "global r" vào đầu hàm "ham_g".
• D. Không cần sửa, mã sẽ tự động hiểu là biến toàn cục.

Câu 23: Trong Python, biến nào được ưu tiên truy cập khi có cả biến cục bộ và biến toàn cục cùng tên trong một hàm?

• A. Biến toàn cục.
• B. Biến cục bộ.
• C. Biến nào được khai báo trước.
• D. Tùy thuộc vào kiểu dữ liệu của biến.

Câu 24: Phạm vi của biến nonlocal trong Python là gì?

• A. Toàn cục.
• B. Cục bộ trong hàm hiện tại.
• C. Trong phạm vi của hàm bao ngoài gần nhất, không phải toàn cục.
• D. Chỉ trong các vòng lặp và điều kiện.

Câu 25: Cho đoạn mã:

s = 0

def tinh_sum_chan(n):
s_cuc_bo = 0
for i in range(2, n + 1, 2):
s_cuc_bo += i
return s_cuc_bo

ket_qua_chan = tinh_sum_chan(10)
print(s_cuc_bo)

Đoạn mã này có lỗi không? Nếu có, lỗi gì?

• A. Không có lỗi, in ra tổng các số chẵn từ 2 đến 10.
• B. Có lỗi NameError, vì "s_cuc_bo" là biến cục bộ của hàm "tinh_sum_chan".
• C. Có lỗi TypeError, vì không thể cộng số với biến chưa xác định.
• D. Có lỗi SyntaxError, vì vòng lặp for không đúng cú pháp.

Câu 26: Khi nào biến cục bộ được tạo ra trong Python?

• A. Khi chương trình bắt đầu chạy.
• B. Trước khi hàm được gọi.
• C. Khi hàm bắt đầu thực thi.
• D. Sau khi hàm kết thúc thực thi.

Câu 27: Điều gì xảy ra với biến cục bộ sau khi hàm kết thúc thực thi?

• A. Biến cục bộ trở thành biến toàn cục.
• B. Biến cục bộ vẫn tồn tại và có thể truy cập từ lần gọi hàm tiếp theo.
• C. Biến cục bộ được lưu vào bộ nhớ đệm để tái sử dụng.
• D. Biến cục bộ bị hủy và bộ nhớ được giải phóng.

Câu 28: Trong Python, bạn có thể có các biến cục bộ có cùng tên trong các hàm khác nhau không?

• A. Có, các biến cục bộ chỉ tồn tại trong phạm vi hàm của chúng.
• B. Không, tên biến cục bộ phải là duy nhất trong toàn chương trình.
• C. Chỉ khi các hàm này không được gọi cùng nhau.
• D. Chỉ khi các biến này có kiểu dữ liệu khác nhau.

Câu 29: Cho đoạn mã:

x = "global"

def ham_h():
global x
y = "local"
x = x * 2
print(x)
print(y)

ham_h()
print(x)

Kết quả đầu ra là gì?

• A. globalglobal
  local
  global
• B. globalglobal
  local
  globalglobal
• C. global
  local
  global
• D. Lỗi vì không thể nhân chuỗi với số

Câu 30: Trong lập trình, việc hiểu rõ phạm vi của biến giúp tránh được loại lỗi nào?

• A. Lỗi cú pháp (SyntaxError).
• B. Lỗi kiểu dữ liệu (TypeError).
• C. Lỗi liên quan đến truy cập biến không đúng phạm vi (ví dụ: NameError, UnboundLocalError).
• D. Lỗi tràn bộ nhớ (MemoryError).

Câu 1: Trong Python, biến nào được gọi là biến cục bộ?

• A. Biến được khai báo ở đầu chương trình.
• B. Biến được khai báo bên trong một hàm.
• C. Biến có thể truy cập từ bất kỳ đâu trong chương trình.
• D. Biến được sử dụng để lưu trữ dữ liệu toàn chương trình.

Câu 2: Điều gì xảy ra khi bạn cố gắng truy cập một biến cục bộ bên ngoài phạm vi của nó trong Python?

• A. Biến sẽ tự động trở thành biến toàn cục.
• B. Chương trình sẽ tiếp tục chạy nhưng giá trị biến sẽ là None.
• C. Python sẽ báo lỗi NameError.
• D. Giá trị của biến sẽ được trả về từ phạm vi gần nhất.

Câu 3: Xem xét đoạn mã Python sau:
```python
def ham_test():
x = 10
print(x)
print(x)```
Điều gì sẽ xảy ra khi chạy đoạn mã này?

• A. Chương trình in ra hai lần số 10.
• B. Chương trình in ra số 10 một lần.
• C. Chương trình chạy mà không có lỗi và không in ra gì.
• D. Chương trình báo lỗi NameError ở dòng `print(x)` thứ hai.

Câu 4: Từ khóa nào trong Python được sử dụng để khai báo một biến toàn cục bên trong một hàm?

• A. global
• B. local
• C. def
• D. variable

Câu 5: Đoạn mã Python sau sẽ in ra giá trị nào:
```python
x = 20
def ham_moi():
x = 5
print(x)
ham_moi()
print(x)```

• A. 20
  20
• B. 5
  5
• C. 5
  20
• D. 20
  5

Câu 6: Biến toàn cục có phạm vi hoạt động như thế nào trong chương trình Python?

• A. Chỉ trong hàm mà nó được khai báo.
• B. Chỉ trong các hàm được gọi sau khi nó được khai báo.
• C. Chỉ trong phần chương trình chính (ngoài hàm).
• D. Trong toàn bộ chương trình, bao gồm cả bên trong và bên ngoài các hàm.

Câu 7: Cho đoạn mã:
```python
def tinh_tong(a, b):
c = a + b
return c
ket_qua = tinh_tong(3, 7)
print(c)```
Điều gì xảy ra khi chạy mã này?

• A. In ra giá trị 10.
• B. Báo lỗi NameError vì biến "c" không được định nghĩa trong phạm vi toàn cục.
• C. In ra giá trị None.
• D. In ra giá trị ngẫu nhiên.

Câu 8: Trong tình huống nào bạn nên sử dụng biến toàn cục thay vì biến cục bộ?

• A. Khi bạn muốn biến chỉ được sử dụng trong một hàm cụ thể.
• B. Khi bạn muốn tối ưu hóa hiệu suất chương trình.
• C. Khi bạn muốn biến được chia sẻ và truy cập bởi nhiều hàm khác nhau trong chương trình.
• D. Không bao giờ nên sử dụng biến toàn cục vì chúng gây ra lỗi.

Câu 9: Xem xét đoạn mã:
```python
count = 0
def increment():
count = count + 1
increment()
print(count)```
Đoạn mã này có lỗi gì về phạm vi biến?

• A. Lỗi UnboundLocalError vì biến "count" được gán giá trị trước khi được tham chiếu trong hàm.
• B. Chương trình chạy và in ra giá trị 1.
• C. Chương trình chạy và in ra giá trị 0.
• D. Lỗi TypeError vì không thể cộng số với biến.

Câu 10: Để sửa lỗi trong đoạn mã ở Câu 9 và tăng giá trị biến toàn cục "count" trong hàm "increment", bạn cần làm gì?

• A. Thay đổi tên biến "count" trong hàm thành "local_count".
• B. Thêm dòng `global count` vào đầu hàm "increment".
• C. Xóa biến "count = 0" bên ngoài hàm.
• D. Không thể sửa được lỗi này.

Câu 11: Đoạn mã Python nào sau đây minh họa việc sử dụng biến toàn cục đúng cách?

• A. ```python
  def ham_a():
  global y = 10```
• B. ```python
  def ham_b(global z):
  z = 20```
• C. ```python
  x = 5
  def ham_c():
  global x
  x = x + 1```
• D. ```python
  def ham_d():
  x = global 30```

Câu 12: Điều gì là lợi ích chính của việc sử dụng biến cục bộ?

• A. Giúp chương trình chạy nhanh hơn.
• B. Giảm thiểu việc sử dụng bộ nhớ.
• C. Cho phép truy cập biến từ mọi nơi trong chương trình.
• D. Tăng tính mô đun hóa và giảm xung đột tên biến, làm cho code dễ bảo trì hơn.

Câu 13: Xét đoạn mã:
```python
def ham_ngoai():
z = 15
def ham_trong():
print(z)
ham_trong()
ham_ngoai()```
Biến "z" trong "ham_trong" được gọi là biến gì?

• A. Biến toàn cục
• B. Biến cục bộ của "ham_trong"
• C. Biến không cục bộ (non-local) hoặc biến bao quanh
• D. Biến không xác định

Câu 14: Phạm vi LEGB trong Python là viết tắt của những phạm vi nào?

• A. Local, Enclosing, Global, Built-in Functions
• B. Local, Enclosing function locals, Global, Built-in
• C. Limited, External, Global, Basic
• D. Logical, Executable, General, Binary

Câu 15: Trong phạm vi LEGB, phạm vi nào được Python tìm kiếm đầu tiên khi tham chiếu đến một biến?

• A. Local
• B. Enclosing function locals
• C. Global
• D. Built-in

Câu 16: Cho đoạn mã:
```python
a = 100
def ham_x():
a = 50
def ham_y():
nonlocal a
a = 25
ham_y()
print(a)
ham_x()
print(a)```
Đoạn mã này in ra giá trị nào?

• A. 50
  100
• B. 25
  25
• C. 25
  100
• D. 50
  50

Câu 17: Mục đích của từ khóa `nonlocal` trong Python là gì?

• A. Khai báo biến toàn cục trong hàm.
• B. Tham chiếu và sửa đổi biến trong phạm vi bao quanh gần nhất (không phải toàn cục).
• C. Tạo ra một biến cục bộ có phạm vi rộng hơn.
• D. Ngăn chặn việc sửa đổi biến bên ngoài hàm.

Câu 18: Biến "built-in" trong phạm vi LEGB là gì?

• A. Biến được xây dựng bởi người dùng.
• B. Biến được nhập từ các thư viện bên ngoài.
• C. Biến cục bộ đặc biệt.
• D. Các tên được định nghĩa sẵn trong Python như `print`, `len`, `int`.

Câu 19: Điều gì xảy ra nếu một biến cục bộ có cùng tên với một biến toàn cục trong cùng một chương trình?

• A. Biến toàn cục sẽ ghi đè biến cục bộ.
• B. Python sẽ báo lỗi xung đột tên.
• C. Trong phạm vi hàm, biến cục bộ sẽ được ưu tiên sử dụng.
• D. Cả hai biến không thể tồn tại trong chương trình.

Câu 20: Trong ngữ cảnh hàm lồng nhau, phạm vi "enclosing" nằm ở đâu?

• A. Bên ngoài tất cả các hàm.
• B. Trong hàm ngoài nhưng bên ngoài hàm trong.
• C. Bên trong hàm trong nhất.
• D. Chỉ tồn tại trong chương trình chính.

Câu 21: Khi một hàm kết thúc thực thi, điều gì xảy ra với các biến cục bộ được khai báo bên trong nó?

• A. Các biến cục bộ bị hủy và bộ nhớ được giải phóng.
• B. Các biến cục bộ trở thành biến toàn cục.
• C. Các biến cục bộ được giữ lại cho lần gọi hàm tiếp theo.
• D. Giá trị của biến cục bộ được lưu vào bộ nhớ cache.

Câu 22: Đoạn mã nào sau đây thể hiện rõ nhất khái niệm về phạm vi cục bộ?

• A. ```python
  x = 10
  print(x)```
• B. ```python
  def my_func():
  y = 5
  print(y)
  my_func()
  # print(y) # Lỗi```
• C. ```python
  global_var = 20
  def another_func():
  print(global_var)
  another_func()```
• D. ```python
  import math
  print(math.pi)```

Câu 23: Tại sao việc hiểu rõ phạm vi của biến lại quan trọng trong lập trình?

• A. Để viết code ngắn gọn hơn.
• B. Để chương trình chạy nhanh hơn.
• C. Để tránh lỗi không mong muốn do truy cập biến sai phạm vi và viết code có cấu trúc, dễ quản lý hơn.
• D. Để sử dụng ít bộ nhớ hơn.

Câu 24: Cho đoạn mã:
```python
m = 50
def outer_func():
m = 30
def inner_func():
m = 10
print(m)
inner_func()
print(m)
outer_func()
print(m)```
Đoạn mã này in ra các giá trị nào theo thứ tự?

• A. 10
  10
  10
• B. 10
  30
  30
• C. 30
  50
  10
• D. 10
  30
  50

Câu 25: Trong Python, nếu bạn muốn sửa đổi một biến toàn cục từ bên trong một hàm, bạn cần sử dụng từ khóa nào?

• A. global
• B. nonlocal
• C. local
• D. static

Câu 26: Biến nào có phạm vi rộng nhất trong một chương trình Python?

• A. Biến cục bộ
• B. Biến không cục bộ (nonlocal)
• C. Biến toàn cục
• D. Biến built-in

Câu 27: Điều gì sẽ xảy ra nếu bạn khai báo một biến bên trong một khối lệnh `if` hoặc `for` trong Python?

• A. Biến đó chỉ có phạm vi trong khối lệnh đó.
• B. Biến đó có phạm vi trong hàm hoặc module chứa khối lệnh đó.
• C. Python sẽ báo lỗi vì không được khai báo biến trong khối lệnh.
• D. Biến đó trở thành biến toàn cục.

Câu 28: Xem xét mã:
```python
def func1():
message =

• A. Phạm vi cục bộ của func2
• B. Phạm vi bao quanh (enclosing) của func1
• C. Phạm vi toàn cục
• D. Phạm vi built-in

Câu 29: Trong Python, bạn có thể có nhiều biến cục bộ khác nhau với cùng một tên, miễn là chúng nằm trong...

• A. Cùng một hàm
• B. Cùng một module
• C. Cùng một chương trình
• D. Các hàm khác nhau

Câu 30: Điều gì KHÔNG phải là một lợi ích của việc sử dụng phạm vi biến một cách hợp lý?

• A. Tăng tốc độ thực thi chương trình đáng kể.
• B. Giảm khả năng xảy ra lỗi do xung đột tên biến.
• C. Code trở nên dễ đọc và dễ bảo trì hơn.
• D. Tăng tính mô đun hóa của code.

Câu 1: Biến nào sau đây có phạm vi cục bộ trong một hàm Python?

• A. Biến được khai báo bằng từ khóa `global` bên trong hàm.
• B. Biến được khai báo bên trong hàm mà không có từ khóa `global`.
• C. Biến được khai báo ở đầu chương trình, trước tất cả các hàm.
• D. Biến được truyền vào hàm như một tham số.

Câu 2: Xem xét đoạn mã Python sau:
```python
x = 10

def my_function():
y = 5
print(x + y)

my_function()
print(y) # Dòng này gây lỗi
```
Dòng lệnh nào sẽ gây ra lỗi và tại sao?

• A. Dòng `print(y)` sẽ gây lỗi vì biến `y` có phạm vi cục bộ trong hàm `my_function`.
• B. Dòng `print(x + y)` sẽ gây lỗi vì không thể cộng biến toàn cục `x` với biến cục bộ `y`.
• C. Chương trình sẽ chạy mà không có lỗi vì Python tự động mở rộng phạm vi của `y`.
• D. Dòng `def my_function():` sẽ gây lỗi vì thiếu tham số đầu vào.

Câu 3: Trong Python, từ khóa nào được sử dụng để khai báo một biến toàn cục bên trong một hàm?

• A. `local`
• B. `def`
• C. `global`
• D. `external`

Câu 4: Cho đoạn mã Python:
```python
count = 0

def increment():
count += 1
print(count)

increment()
```
Đoạn mã này khi chạy sẽ:

• A. In ra `1`
• B. In ra `0`
• C. In ra `2`
• D. Báo lỗi `UnboundLocalError`

Câu 5: Để sửa lỗi trong đoạn mã ở Câu 4 và cho phép hàm `increment` thay đổi giá trị biến `count` toàn cục, bạn cần thêm dòng lệnh nào vào đầu hàm `increment`?

• A. `local count`
• B. `global count`
• C. `return count`
• D. `count = global`

Câu 6: Xét chương trình Python sau:
```python
def outer_function():
message = "Hello"

def inner_function():
nonlocal message
message = "World"

inner_function()
return message

print(outer_function())
```
Kết quả in ra màn hình là gì?

• A. `Hello`
• B. `Error`
• C. `World`
• D. `Hello World`

Câu 7: Điều gì xảy ra khi bạn cố gắng truy cập một biến cục bộ bên ngoài phạm vi của nó trong Python?

• A. Python sẽ tự động tạo một biến toàn cục mới với tên đó.
• B. Python sẽ báo lỗi `NameError`.
• C. Python sẽ sử dụng giá trị mặc định của biến (nếu có).
• D. Chương trình sẽ tiếp tục chạy nhưng có thể cho kết quả không mong muốn.

Câu 8: Trong ngữ cảnh phạm vi biến, "LEGB" là viết tắt của thứ tự phạm vi tìm kiếm biến trong Python. "G" trong "LEGB" đại diện cho:

• A. Local
• B. Enclosing function locals
• C. Global
• D. Built-in

Câu 9: Cho đoạn mã Python:
```python
def func1():
x = 5
def func2():
print(x)
func2()

func1()
```
Giá trị nào sẽ được in ra?

• A. 5
• B. Lỗi NameError
• C. 0
• D. Không có gì được in ra

Câu 10: Biến toàn cục được khai báo ở đâu trong chương trình Python?

• A. Bên trong một hàm cụ thể.
• B. Chỉ trong phần đầu của chương trình, sau các lệnh `import`.
• C. Trong bất kỳ khối lệnh nào.
• D. Bên ngoài tất cả các hàm và khối lệnh.

Câu 11: Xem xét đoạn mã:
```python
x = 20

def change_x(val):
x = val

change_x(10)
print(x)
```
Giá trị của `x` được in ra là bao nhiêu?

• A. 10
• B. Không có giá trị nào vì lỗi
• C. 20
• D. Một giá trị ngẫu nhiên

Câu 12: Trong Python, phạm vi nào có mức độ ưu tiên tìm kiếm biến cao nhất theo quy tắc LEGB?

• A. Local (cục bộ)
• B. Enclosing function locals (phạm vi hàm bao ngoài)
• C. Global (toàn cục)
• D. Built-in (tích hợp sẵn)

Câu 13: Hàm nào sau đây có thể truy cập và sửa đổi một biến toàn cục mà không cần từ khóa `global`?

• A. Hàm cố gắng gán một giá trị mới cho biến toàn cục.
• B. Hàm xóa biến toàn cục.
• C. Không có hàm nào có thể làm điều này.
• D. Hàm chỉ đọc giá trị của biến toàn cục.

Câu 14: Cho đoạn code:
```python
def scope_test():
def do_local():
spam =

• A. `test spam`
• B. `nonlocal spam`
• C. `global spam`
• D. `local spam`

Câu 15: Mục đích chính của việc sử dụng biến cục bộ thay vì biến toàn cục là gì?

• A. Để tăng tốc độ thực thi chương trình.
• B. Để tăng tính mô đun hóa và giảm tác dụng phụ không mong muốn trong chương trình.
• C. Để tiết kiệm bộ nhớ.
• D. Không có lợi ích cụ thể, chỉ là quy ước lập trình.

Câu 16: Trong Python, nếu một biến được gán giá trị bên trong một hàm, và một biến cùng tên tồn tại ở phạm vi toàn cục, thì biến nào sẽ được tham chiếu bên trong hàm đó?

• A. Biến cục bộ.
• B. Biến toàn cục.
• C. Cả hai biến cùng lúc.
• D. Tùy thuộc vào thứ tự khai báo.

Câu 17: Phạm vi của một biến xác định:

• A. Kiểu dữ liệu của biến.
• B. Thời gian tồn tại của biến trong bộ nhớ.
• C. Vùng của chương trình nơi biến có thể được truy cập và sử dụng.
• D. Giá trị lớn nhất mà biến có thể lưu trữ.

Câu 18: Điều gì sẽ xảy ra nếu bạn khai báo một biến toàn cục và một biến cục bộ có cùng tên trong cùng một chương trình?

• A. Chương trình sẽ báo lỗi vì trùng tên biến.
• B. Không có lỗi, biến cục bộ sẽ che phủ biến toàn cục trong phạm vi hàm.
• C. Biến toàn cục sẽ tự động đổi tên để tránh xung đột.
• D. Python sẽ chọn ngẫu nhiên một trong hai biến để sử dụng.

Câu 19: Cho đoạn mã:
```python
def outer():
o_var = 10
def inner():
print(o_var)
inner()

outer()
```
Biến `o_var` trong hàm `inner()` có phạm vi là:

• A. Local (cục bộ) của `inner()`
• B. Enclosing function locals (phạm vi hàm bao ngoài) của `inner()`
• C. Global (toàn cục)
• D. Built-in (tích hợp sẵn)

Câu 20: Khi nào một biến được coi là có "thời gian sống" (lifetime) kết thúc trong Python?

• A. Ngay sau khi biến được gán giá trị lần đầu.
• B. Khi chương trình bắt đầu thực thi.
• C. Đối với biến cục bộ, khi hàm chứa nó kết thúc; đối với biến toàn cục, khi chương trình kết thúc.
• D. Khi biến không còn được sử dụng trong chương trình.

Câu 21: Xét đoạn mã sau:
```python
def function_a():
var_a = 10
print(var_a)

def function_b():
print(var_a) # Cố gắng truy cập var_a

function_a()
function_b()
```
Điều gì xảy ra khi chạy đoạn mã này?

• A. In ra `10` hai lần.
• B. In ra `10` và sau đó in ra `0`.
• C. In ra `10` và sau đó in ra một giá trị ngẫu nhiên.
• D. In ra `10` và sau đó báo lỗi `NameError` khi `function_b()` cố gắng truy cập `var_a`.

Câu 22: Trong Python, nếu bạn muốn thay đổi giá trị của một biến toàn cục bên trong một hàm, bạn cần sử dụng từ khóa nào trước tên biến?

• A. `local`
• B. `global`
• C. `nonlocal`
• D. `var`

Câu 23: Biến nào có phạm vi rộng nhất trong một chương trình Python?

• A. Biến cục bộ trong một hàm.
• B. Biến trong phạm vi hàm bao ngoài.
• C. Biến toàn cục.
• D. Biến tích hợp sẵn (built-in).

Câu 24: Điều gì xảy ra khi bạn khai báo một biến bên trong một vòng lặp `for` trong Python?

• A. Biến chỉ có phạm vi bên trong vòng lặp `for` và không thể truy cập bên ngoài nó.
• B. Biến có phạm vi cục bộ với khối lệnh chứa vòng lặp `for` và có thể truy cập sau khi vòng lặp kết thúc trong phạm vi đó.
• C. Biến trở thành biến toàn cục.
• D. Python báo lỗi vì khai báo biến trong vòng lặp là không hợp lệ.

Câu 25: Cho đoạn mã:
```python
message =

• A. `Global`
  `Global`
• B. `Local`
  `Local`
• C. `Local`
  `Global`
• D. `Global`
  `Local`

Câu 26: Trong Python, nếu không tìm thấy biến trong phạm vi cục bộ và phạm vi bao ngoài, phạm vi nào sẽ được tìm kiếm tiếp theo theo quy tắc LEGB?

• A. Built-in (tích hợp sẵn)
• B. Global (toàn cục)
• C. Phạm vi module
• D. Phạm vi lớp (class)

Câu 27: Xét ví dụ:
```python
def outer_func():
count = 0
def inner_func():
count += 1 # Dự định sửa biến "count" của outer_func
return count
return inner_func()

print(outer_func())
```
Đoạn mã này sẽ:

• A. In ra `1`
• B. In ra `0`
• C. In ra `-1`
• D. Báo lỗi `UnboundLocalError`

Câu 28: Để khắc phục lỗi trong Câu 27, bạn cần sử dụng từ khóa nào trong `inner_func()` trước biến `count`?

• A. `local`
• B. `global`
• C. `nonlocal`
• D. `enclosing`

Câu 29: Biến tích hợp sẵn (built-in) trong Python có phạm vi là:

• A. Cục bộ (Local)
• B. Toàn cục (Global)
• C. Phạm vi hàm bao ngoài (Enclosing)
• D. Rộng nhất, có sẵn ở mọi nơi trong chương trình (Built-in)

Câu 30: Trong trường hợp nào thì việc sử dụng biến toàn cục được khuyến cáo hạn chế trong lập trình?

• A. Khiến chương trình trở nên khó đọc, khó bảo trì và dễ phát sinh lỗi do tác dụng phụ không mong muốn.
• B. Làm chậm tốc độ thực thi chương trình.
• C. Gây lãng phí bộ nhớ.
• D. Không có trường hợp nào nên hạn chế biến toàn cục, chúng luôn hữu ích.