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 - Đề 07 được xây dựng với nhiều câu hỏi chất lượng, sát với nội dung chương trình học, giúp bạn dễ dàng ôn tập và kiểm tra kiến thức hiệu quả. Hãy cùng bắt đầu làm bài tập trắc nghiệm ngay để nâng cao hiểu biết và chuẩn bị tốt cho kỳ thi sắp tới!
Câu 1: Trong Python, biến được khai báo bên trong một hàm có phạm vi (scope) là gì?
- A. Toàn cục (Global)
- B. Cục bộ (Local)
- C. Bên ngoài (Outer)
- D. Chung (Common)
Câu 2: Xem xét đoạn mã sau:
```python
x = 10
def my_function():
y = 5
print(x + y)
my_function()
```
Biến `x` trong đoạn mã trên có phạm vi là gì?
- A. Toàn cục (Global)
- B. Cục bộ (Local)
- C. Không có phạm vi
- D. Phạm vi của hàm `my_function`
Câu 3: Xem xét đoạn mã sau:
```python
x = 10
def my_function():
y = 5
print(x + y)
my_function()
```
Biến `y` trong đoạn mã trên có phạm vi là gì?
- A. Toàn cục (Global)
- B. Cục bộ (Local)
- C. Phạm vi bên ngoài hàm
- D. Phạm vi của biến `x`
Câu 4: Xem xét đoạn mã sau:
```python
def my_function():
z = 20
print(z)
my_function()
print(z)
```
Khi chạy đoạn mã này, điều gì sẽ xảy ra ở dòng `print(z)` thứ hai?
- A. In ra giá trị 20
- B. In ra giá trị None
- C. In ra giá trị rỗng
- D. Báo lỗi `NameError` vì biến `z` không tồn tại ở phạm vi toàn cục
Câu 5: Xem xét đoạn mã sau:
```python
a = 5
def change_a():
a = 15
print("Trong ham:", a)
change_a()
print("Ngoai ham:", a)
```
Kết quả khi chạy đoạn mã này là gì?
- A. Trong ham: 15
Ngoai ham: 15
- B. Trong ham: 5
Ngoai ham: 5
- C. Trong ham: 15
Ngoai ham: 5
- D. Báo lỗi
Câu 6: Xem xét đoạn mã sau:
```python
count = 0
def increment():
count += 1
print(count)
increment()
```
Khi chạy đoạn mã này, điều gì sẽ xảy ra?
- A. Báo lỗi `UnboundLocalError` vì Python cố gắng sửa đổi biến `count` cục bộ trước khi nó được gán giá trị trong hàm.
- B. In ra 1
- C. In ra 0
- D. Báo lỗi `NameError`
Câu 7: Để sửa lỗi trong đoạn mã ở câu 6 (muốn hàm `increment` thay đổi biến `count` toàn cục), ta cần sử dụng từ khóa nào bên trong hàm?
- A. global
- B. local
- C. nonlocal
- D. static
Câu 8: Xem xét đoạn mã sau (đã sửa từ câu 6):
```python
count = 0
def increment():
global count
count += 1
print(count)
increment()
print("Cuoi cung:", count)
```
Kết quả khi chạy đoạn mã này là gì?
- A. 1
Cuoi cung: 0
- B. 1
Cuoi cung: 1
- C. 0
Cuoi cung: 1
- D. Báo lỗi
Câu 9: Xem xét đoạn mã sau:
```python
def process_value(x):
x = x * 2
print("Trong ham:", x)
value = 10
process_value(value)
print("Ngoai ham:", value)
```
Kết quả khi chạy đoạn mã này là gì?
- A. Trong ham: 20
Ngoai ham: 20
- B. Trong ham: 10
Ngoai ham: 10
- C. Trong ham: 20
Ngoai ham: 10
- D. Báo lỗi
Câu 10: Lý do khiến biến `value` ở phạm vi toàn cục trong câu 9 không bị thay đổi sau khi gọi hàm `process_value` là gì?
- A. Tham số `x` trong hàm là một biến cục bộ mới, chỉ nhận bản sao giá trị của `value` khi hàm được gọi. Việc gán lại giá trị cho `x` bên trong hàm không ảnh hưởng đến `value` bên ngoài.
- B. Biến `value` được khai báo trước hàm nên nó là biến toàn cục và không thể bị thay đổi bởi hàm.
- C. Hàm `process_value` không sử dụng từ khóa `global`.
- D. Biến `value` là một số nguyên, là kiểu dữ liệu bất biến (immutable).
Câu 11: Xem xét đoạn mã sau:
```python
def modify_list(my_list):
my_list.append(4)
print("Trong ham:", my_list)
numbers = [1, 2, 3]
modify_list(numbers)
print("Ngoai ham:", numbers)
```
Kết quả khi chạy đoạn mã này là gì?
- A. Trong ham: [1, 2, 3, 4]
Ngoai ham: [1, 2, 3]
- B. Trong ham: [1, 2, 3]
Ngoai ham: [1, 2, 3]
- C. Trong ham: [1, 2, 3]
Ngoai ham: [1, 2, 3, 4]
- D. Trong ham: [1, 2, 3, 4]
Ngoai ham: [1, 2, 3, 4]
Câu 12: Lý do biến `numbers` ở phạm vi toàn cục trong câu 11 bị thay đổi sau khi gọi hàm `modify_list` là gì?
- A. Tham số `my_list` và biến `numbers` cùng tham chiếu đến một đối tượng danh sách trong bộ nhớ. Phương thức `append` sửa đổi trực tiếp đối tượng đó.
- B. Hàm `modify_list` đã sử dụng từ khóa `global` một cách ngầm định.
- C. Danh sách (list) là kiểu dữ liệu bất biến (immutable).
- D. Python luôn truyền tham số theo tham chiếu (pass by reference).
Câu 13: Xem xét đoạn mã sau:
```python
def reassign_list(my_list):
my_list = [5, 6, 7]
print("Trong ham:", my_list)
numbers = [1, 2, 3]
reassign_list(numbers)
print("Ngoai ham:", numbers)
```
Kết quả khi chạy đoạn mã này là gì?
- A. Trong ham: [5, 6, 7]
Ngoai ham: [5, 6, 7]
- B. Trong ham: [5, 6, 7]
Ngoai ham: [1, 2, 3]
- C. Trong ham: [1, 2, 3]
Ngoai ham: [5, 6, 7]
- D. Báo lỗi
Câu 14: Phân tích sự khác biệt về phạm vi và tác động lên biến gốc giữa hàm `modify_list` (câu 11) và `reassign_list` (câu 13).
- A. Cả hai hàm đều thay đổi biến danh sách gốc bên ngoài hàm vì danh sách là kiểu dữ liệu khả biến.
- B. Hàm `modify_list` thay đổi biến gốc vì nó gán lại giá trị mới cho tham số, còn `reassign_list` thì không.
- C. Hàm `modify_list` thay đổi đối tượng danh sách gốc bằng phương thức nội tại (`append`), còn `reassign_list` gán tham số cho một đối tượng danh sách mới trong phạm vi cục bộ của hàm.
- D. Cả hai hàm đều không thay đổi biến danh sách gốc vì tham số hàm luôn là biến cục bộ.
Câu 15: Biến toàn cục (global variable) có thể được truy cập (đọc giá trị) từ bên trong một hàm mà không cần khai báo gì thêm không?
- A. Có.
- B. Không, phải dùng từ khóa `global`.
- C. Không, phải truyền biến đó làm tham số.
- D. Chỉ khi biến toàn cục là một số.
Câu 16: Biến toàn cục (global variable) có thể bị thay đổi giá trị từ bên trong một hàm mà không sử dụng từ khóa `global` không?
- A. Có.
- B. Không, việc gán giá trị mới cho một biến trùng tên sẽ tạo ra một biến cục bộ mới.
- C. Chỉ khi biến toàn cục là một danh sách.
- D. Chỉ khi hàm đó không có tham số.
Câu 17: Khi một hàm kết thúc việc thực thi, các biến cục bộ được khai báo bên trong hàm đó sẽ như thế nào?
- A. Chúng vẫn tồn tại và có thể được truy cập từ bên ngoài hàm.
- B. Chúng vẫn tồn tại nhưng chỉ có thể được truy cập khi hàm được gọi lại.
- C. Chúng bị hủy và không thể truy cập được nữa.
- D. Chúng trở thành biến toàn cục.
Câu 18: Xem xét đoạn mã sau:
```python
def func1():
x = 10
print(x)
def func2():
y = 20
print(y)
func1()
func2()
```
Biến `x` trong `func1` và biến `y` trong `func2` có mối quan hệ phạm vi như thế nào?
- A. Cả hai đều là biến toàn cục.
- B. Biến `x` là toàn cục, biến `y` là cục bộ.
- C. Biến `x` và `y` chia sẻ cùng một phạm vi cục bộ.
- D. Cả hai đều là biến cục bộ trong các phạm vi riêng biệt của từng hàm.
Câu 19: Trong Python, thứ tự tìm kiếm (tra cứu) biến khi nó được sử dụng trong một phạm vi (ví dụ: bên trong một hàm) là gì?
- A. Phạm vi cục bộ hiện tại -> Phạm vi bao quanh (nếu có) -> Phạm vi toàn cục -> Phạm vi các tên dựng sẵn (built-in).
- B. Phạm vi toàn cục -> Phạm vi cục bộ hiện tại -> Phạm vi bao quanh -> Phạm vi các tên dựng sẵn.
- C. Phạm vi cục bộ hiện tại -> Phạm vi toàn cục -> Phạm vi bao quanh -> Phạm vi các tên dựng sẵn.
- D. Phạm vi các tên dựng sẵn -> Phạm vi toàn cục -> Phạm vi bao quanh -> Phạm vi cục bộ hiện tại.
Câu 20: Xem xét đoạn mã sau:
```python
def outer_function():
a = 1
def inner_function():
b = 2
print(a + b)
inner_function()
outer_function()
```
Trong đoạn mã này, biến `a` có phạm vi nào đối với `inner_function`?
- A. Cục bộ (Local) của `inner_function`
- B. Toàn cục (Global)
- C. Bao quanh (Enclosing) - phạm vi của hàm `outer_function`
- D. Biến dựng sẵn (Built-in)
Câu 21: Xem xét đoạn mã sau:
```python
def create_counter():
count = 0
def increment():
# Cần làm gì ở đây để thay đổi "count" của outer_function?
pass # Chỗ cần thay đổi
return count
return increment
counter = create_counter()
# print(counter()) # Nếu chạy sẽ báo lỗi hoặc không như mong muốn
```
Để hàm `increment` có thể thay đổi biến `count` trong `outer_function` (phạm vi bao quanh), ta cần sử dụng từ khóa nào ở dòng `pass` và sửa lại dòng dưới đó?
- A. global count
- B. nonlocal count
- C. local count
- D. Không cần từ khóa nào, chỉ cần count += 1
Câu 22: Biến được tạo ra trong khối lệnh của câu lệnh `if` hoặc `for` (không nằm trong hàm) trong Python có phạm vi là gì?
- A. Chúng có phạm vi giống với phạm vi chứa khối lệnh đó (ví dụ: phạm vi toàn cục nếu nằm ngoài hàm).
- B. Chúng có phạm vi cục bộ chỉ bên trong khối `if` hoặc `for`.
- C. Chúng có phạm vi toàn cục.
- D. Chúng có phạm vi bao quanh.
Câu 23: Xem xét đoạn mã sau:
```python
msg =
- A. Báo lỗi `NameError`
- B. In ra chuỗi rỗng
- C. In ra `Toan cuc`
- D. In ra `None`
Câu 24: Xem xét đoạn mã sau:
```python
def my_func(data):
data = data * 2
print("Inside:", data)
value = 5
my_func(value)
print("Outside:", value)
my_list = [1, 2]
my_func(my_list)
print("Outside:", my_list)
```
Dự đoán kết quả khi chạy đoạn mã này.
- A. Inside: 10
Outside: 10
Inside: [1, 2, 1, 2]
Outside: [1, 2, 1, 2]
- B. Inside: 10
Outside: 5
Inside: [1, 2, 1, 2]
Outside: [1, 2]
- C. Inside: 10
Outside: 10
Inside: [1, 2, 1, 2]
Outside: [1, 2]
- D. Inside: 10
Outside: 5
Inside: [1, 2, 1, 2]
Outside: [1, 2, 1, 2]
Câu 25: Trong Python, biến được truyền vào làm tham số cho một hàm sẽ có phạm vi như thế nào bên trong hàm?
- A. Luôn là biến cục bộ của hàm.
- B. Là biến toàn cục nếu biến gốc là toàn cục.
- C. Là biến tham chiếu đến biến gốc bên ngoài.
- D. Có phạm vi bao quanh.
Câu 26: Xem xét đoạn mã sau:
```python
def set_x(val):
global x
x = val
x = 0
set_x(100)
print(x)
```
Kết quả khi chạy đoạn mã này là gì?
- A. 0
- B. Báo lỗi
- C. 100
- D. None
Câu 27: Việc sử dụng từ khóa `global` trong một hàm cho phép điều gì?
- A. Tạo một biến cục bộ mới có tên trùng với biến toàn cục.
- B. Cho phép hàm thay đổi giá trị của một biến toàn cục đã tồn tại.
- C. Cho phép hàm truy cập (đọc) giá trị của biến toàn cục.
- D. Tạo một biến có phạm vi bao quanh.
Câu 28: Đâu là nhược điểm tiềm ẩn của việc sử dụng quá nhiều biến toàn cục trong chương trình?
- A. Làm cho mã khó hiểu và khó bảo trì hơn vì bất kỳ hàm nào cũng có thể thay đổi giá trị của chúng một cách không mong muốn.
- B. Làm tăng tốc độ thực thi chương trình.
- C. Giúp các hàm trở nên độc lập hơn.
- D. Ngăn chặn việc sử dụng biến cục bộ cùng tên.
Câu 29: Xem xét đoạn mã sau:
```python
def process_data(data):
data = data + [5, 6]
print("Inside:", data)
my_list = [1, 2]
process_data(my_list)
print("Outside:", my_list)
```
Kết quả khi chạy đoạn mã này là gì? (Lưu ý: `+` với danh sách tạo danh sách mới)
- A. Inside: [1, 2, 5, 6]
Outside: [1, 2, 5, 6]
- B. Inside: [1, 2, 5, 6]
Outside: [1, 2]
- C. Inside: [1, 2]
Outside: [1, 2]
- D. Báo lỗi
Câu 30: Điền vào chỗ trống: Phạm vi của biến xác định _________ của biến trong chương trình.
- A. kiểu dữ liệu
- B. giá trị ban đầu
- C. khả năng thay đổi
- D. khu vực mà biến có thể được truy cập hợp lệ
Câu 31: Trong Python, nếu một biến có cùng tên tồn tại ở cả phạm vi cục bộ và toàn cục, khi bạn tham chiếu đến tên biến đó bên trong hàm, Python sẽ ưu tiên sử dụng biến nào?
- A. Biến cục bộ.
- B. Biến toàn cục.
- C. Biến được khai báo trước.
- D. Báo lỗi vì trùng tên.
Câu 32: Xem xét đoạn mã sau:
```python
def calculate(a, b):
result = a * b
return result
x = 5
y = 10
z = calculate(x, y)
print(z)
# print(result) # Dòng này sẽ gây lỗi
```
Biến `result` trong hàm `calculate` có phạm vi là gì?
- A. Toàn cục.
- B. Cục bộ của hàm `calculate`.
- C. Phạm vi của biến `z`.
- D. Phạm vi bao quanh.
Câu 33: Điều gì xảy ra nếu bạn cố gắng truy cập một biến cục bộ sau khi hàm chứa nó đã kết thúc thực thi?
- A. Bạn sẽ nhận được giá trị cuối cùng của biến đó.
- B. Bạn sẽ nhận được giá trị mặc định của biến đó.
- C. Chương trình sẽ báo lỗi `NameError`.
- D. Biến đó tự động trở thành biến toàn cục.
Câu 34: Xem xét đoạn mã sau:
```python
counter = 0
def increment_counter():
global counter
for i in range(5):
counter += 1
increment_counter()
print(counter)
```
Kết quả in ra cuối cùng của biến `counter` là bao nhiêu?
- A. 0
- B. 1
- C. 5
- D. Báo lỗi (Lưu ý: Câu hỏi này kiểm tra sự hiểu biết kết hợp giữa `global` và vòng lặp, `range` tạo ra 5 lần lặp, mỗi lần tăng `counter` lên 1)
Câu 35: Trong Python, các tham số truyền vào hàm (parameters) hoạt động như các biến có phạm vi nào?
- A. Cục bộ (Local) của hàm.
- B. Toàn cục (Global).
- C. Bao quanh (Enclosing).
- D. Tham chiếu đến biến gốc bên ngoài.
