12+ Đề Trắc Nghiệm Tin Học 11 (Kết Nối Tri Thức) Bài 30: Thiết Lập Thư Viện Cho Chương Trình

Câu 1: Mục đích chính của việc sử dụng thư viện trong lập trình là gì?

• A. Để làm cho chương trình chạy nhanh hơn một cách đáng kể.
• B. Để bắt buộc lập trình viên tuân theo một cấu trúc mã nhất định.
• C. Để cung cấp các chức năng có sẵn, giúp tái sử dụng mã và tăng hiệu quả lập trình.
• D. Để mã hóa chương trình, làm cho mã nguồn khó đọc hơn.

Câu 2: Lợi ích nổi bật nhất của việc sử dụng thư viện trong phát triển phần mềm là gì?

• A. Tăng cường khả năng tái sử dụng mã nguồn.
• B. Giảm kích thước tệp chương trình cuối cùng.
• C. Bảo vệ mã nguồn khỏi bị sao chép.
• D. Tự động sửa lỗi cú pháp trong mã.

Câu 3: Trong Python, lệnh `import math` thực hiện điều gì?

• A. Chỉ nhập một vài hàm phổ biến nhất từ thư viện math.
• B. Nhập toàn bộ module math vào không gian tên hiện tại, cho phép truy cập các thành viên thông qua tiền tố `math.`.
• C. Nhập toàn bộ module math và tự động đổi tên nó thành `m`.
• D. Chỉ tải mã nguồn của thư viện math nhưng chưa đưa vào bộ nhớ.

Câu 4: Bạn chỉ cần sử dụng hàm tính căn bậc hai (`sqrt`) từ thư viện `math`. Cú pháp import nào dưới đây là cách tốt nhất để làm điều này, giúp mã rõ ràng và tiết kiệm bộ nhớ hơn nếu thư viện lớn?

• A. `import math`
• B. `import math.sqrt`
• C. `from math import sqrt`
• D. `from math import *`

Câu 5: Giả sử bạn import hai module `mod1` và `mod2`, cả hai đều có một hàm tên là `process_data()`. Phương pháp import nào giúp bạn dễ dàng phân biệt và gọi đúng hàm từ mỗi module mà không bị xung đột tên?

• A. Sử dụng `import mod1` và `import mod2`, sau đó gọi `mod1.process_data()` và `mod2.process_data()`.
• B. Sử dụng `from mod1 import process_data` và `from mod2 import process_data`.
• C. Sử dụng `from mod1, mod2 import process_data`.
• D. Sử dụng `import mod1, mod2` và gọi `process_data()`.

Câu 6: Cho đoạn code sau:
```python
import math as m

# Để tính giá trị sin của 0.5 radian, bạn sẽ viết thế nào?
# ... code here ...
```
Chọn dòng code đúng để thay thế `# ... code here ...`.

• A. `result = math.sin(0.5)`
• B. `result = sin(0.5)`
• C. `result = m.math.sin(0.5)`
• D. `result = m.sin(0.5)`

Câu 7: Lệnh `from module_name import *` nhập tất cả các tên công khai (public names) từ `module_name` vào không gian tên hiện tại. Tại sao phương pháp import này thường không được khuyến khích, đặc biệt trong các dự án lớn?

• A. Nó làm cho chương trình chạy chậm hơn.
• B. Nó có thể gây ra xung đột tên (name collisions) với các biến hoặc hàm khác trong chương trình của bạn.
• C. Nó chỉ hoạt động với các thư viện chuẩn của Python.
• D. Nó yêu cầu kết nối internet để hoạt động.

Câu 8: Để tạo một thư viện riêng đơn giản trong Python (để các chương trình khác có thể import và sử dụng), bước cơ bản nhất bạn cần làm là gì?

• A. Viết các hàm hoặc lớp cần thiết vào một tệp có đuôi `.py` và lưu lại.
• B. Đóng gói các tệp mã nguồn vào một tệp nén (.zip hoặc .rar).
• C. Đăng ký tên thư viện của bạn trên một kho lưu trữ trực tuyến.
• D. Biên dịch mã nguồn thành tệp thực thi (.exe).

Câu 9: Giả sử bạn có một tệp tên là `utils.py` chứa một hàm `def greeting(name): return f"Hello, {name}!"`. Trong một tệp khác cùng thư mục, làm thế nào để import và sử dụng hàm `greeting`?

• A. `import utils.greeting` sau đó gọi `greeting("World")`.
• B. `import utils` sau đó gọi `utils.greeting("World")`.
• C. `from utils import *` sau đó gọi `utils.greeting("World")`.
• D. `import utils` sau đó gọi `greeting("World")`.

Câu 10: Thư viện chuẩn nào của Python cung cấp các hàm và hằng số cho các phép toán nâng cao như căn bậc hai, lũy thừa, hàm lượng giác, logarit và hằng số PI?

• A. math
• B. random
• C. os
• D. sys

Câu 11: Cho đoạn code sau:
```python
import math

value = 7.8
result_floor = math.floor(value)
result_ceil = math.ceil(value)

print(f

• A. Floor: 8.0, Ceil: 7.0
• B. Floor: 7.8, Ceil: 7.8
• C. Floor: 8, Ceil: 7
• D. Floor: 7, Ceil: 8

Câu 12: Khi sử dụng cú pháp `from module import item`, tên của `item` (ví dụ: tên hàm, biến) được đưa trực tiếp vào không gian tên hiện tại của script đang chạy. Điều này mang lại lợi ích gì so với `import module`?

• A. Có thể gọi `item` trực tiếp mà không cần dùng tiền tố tên module.
• B. Module được import sẽ chạy nhanh hơn.
• C. Chỉ nhập được một `item` duy nhất từ module.
• D. Giúp tránh hoàn toàn xung đột tên.

Câu 13: Bạn cần sử dụng hàm `random()` để tạo số thực ngẫu nhiên từ 0.0 đến 1.0. Cú pháp nào dưới đây là cách đúng để import và sử dụng hàm này từ thư viện `random`?

• A. `import random.random`, sau đó gọi `random()`.
• B. `import random`, sau đó gọi `random()`.
• C. `from random import random`, sau đó gọi `random()`.
• D. `from random import random`, sau đó gọi `random.random()`.

Câu 14: Thư viện chuẩn nào của Python thường được sử dụng để tương tác với hệ điều hành, ví dụ như làm việc với tệp tin và thư mục, hoặc truy cập các biến môi trường?

• A. sys
• B. os
• C. math
• D. random

Câu 15: Giả sử bạn cần tính chu vi của một hình tròn với bán kính `r` cho trước, sử dụng hằng số $pi$ từ thư viện `math`. Công thức tính chu vi là $C = 2 times pi times r$. Đoạn code nào sau đây thực hiện đúng việc này?

• A. ```python
  import math
  r = 5
  chu_vi = 2 * math.pi * r
  print(chu_vi)
  ```
• B. ```python
  from math import pi
  r = 5
  chu_vi = 2 * pi * math.r
  print(chu_vi)
  ```
• C. ```python
  import math
  r = 5
  chu_vi = math.2 * math.pi * r
  print(chu_vi)
  ```
• D. ```python
  from math import *
  r = 5
  chu_vi = 2 * pi * r
  print(chu_vi)
  ```
  (Đáp án 4 đúng về mặt cú pháp nếu chỉ xét dòng tính chu vi, nhưng lựa chọn 1 là cách import tường minh và phổ biến hơn nếu không cần dùng quá nhiều hàm, đồng thời câu hỏi yêu cầu cả đoạn code, và cách gọi `math.pi` trong A là chính xác khi import `math`.) Cập nhật: Phương án 4 cũng hoàn toàn đúng và có thể coi là hợp lý. Tuy nhiên, xét tính tường minh và tránh xung đột tên, phương án 1 thường được ưa chuộng hơn trong nhiều trường hợp. Giữ nguyên đáp án 1 dựa trên tiêu chí "đoạn code nào sau đây thực hiện đúng việc này" và cách gọi tường minh.

Câu 16: Bạn đang viết một chương trình cần thực hiện các phép toán phức tạp. Thay vì tự xây dựng các thuật toán từ đầu, bạn tìm và sử dụng các hàm có sẵn trong thư viện `math`. Hành động này thể hiện rõ nhất lợi ích nào của thư viện?

• A. Giảm thiểu lỗi cú pháp.
• B. Tăng tính bảo mật của mã nguồn.
• C. Tiết kiệm thời gian phát triển và đảm bảo độ tin cậy của các chức năng đã có sẵn.
• D. Làm cho chương trình dễ dàng chuyển đổi sang ngôn ngữ lập trình khác.

Câu 17: Khi Python thực hiện lệnh `import module_name`, nó sẽ tìm kiếm tệp `module_name.py` (hoặc các định dạng module/package khác) trong một danh sách các đường dẫn. Danh sách các đường dẫn này được lưu trữ trong biến nào của module `sys`?

• A. `sys.modules`
• B. `sys.path`
• C. `sys.argv`
• D. `sys.version`

Câu 18: Bạn muốn import hàm `pi` từ thư viện `math` nhưng lại muốn sử dụng nó trong code của mình với tên là `PI_VALUE` để dễ phân biệt. Cú pháp import nào cho phép bạn làm điều này?

• A. `import math.pi as PI_VALUE`
• B. `import math as PI_VALUE`
• C. `from math import PI_VALUE = pi`
• D. `from math import pi as PI_VALUE`

Câu 19: Điều gì sẽ xảy ra nếu bạn viết lệnh `import my_non_existent_module` trong một script Python và chạy nó?

• A. Chương trình sẽ báo lỗi `ModuleNotFoundError` (hoặc `ImportError`).
• B. Chương trình sẽ chạy bình thường nhưng không có chức năng của module đó.
• C. Python sẽ tự động tìm kiếm và tải module đó từ internet.
• D. Chương trình sẽ tạm dừng và yêu cầu người dùng nhập đường dẫn đến module.

Câu 20: Module `random` trong Python cung cấp nhiều hàm tạo số ngẫu nhiên. Hàm `random.randint(a, b)` có chức năng gì?

• A. Trả về một số thực ngẫu nhiên trong khoảng [a, b).
• B. Trả về một số thực ngẫu nhiên trong khoảng [a, b].
• C. Trả về một số nguyên ngẫu nhiên trong khoảng [a, b].
• D. Trả về một số nguyên ngẫu nhiên trong khoảng [a, b).

Câu 21: Bạn cần viết code để tạo một thư mục mới trong hệ thống tệp hoặc kiểm tra xem một đường dẫn có phải là tệp hay thư mục hay không. Thư viện chuẩn nào của Python là lựa chọn phù hợp nhất cho các tác vụ này?

• A. sys
• B. os
• C. shutil
• D. pathlib

Câu 22: Xét về hiệu quả sử dụng bộ nhớ khi bạn chỉ cần dùng rất ít hàm từ một module rất lớn, phương pháp `from module import item` thường được coi là hiệu quả hơn `import module`. Tại sao?

• A. `from module import item` chỉ nạp các `item` được chỉ định vào bộ nhớ, trong khi `import module` nạp toàn bộ module.
• B. `from module import item` nạp toàn bộ module nhưng giải phóng bộ nhớ nhanh hơn sau khi dùng.
• C. `import module` chỉ nạp các `item` cần thiết, còn `from module import item` nạp toàn bộ.
• D. Hiệu quả bộ nhớ giữa hai cách này là như nhau.

Câu 23: Trong cấu trúc thư viện Python, một "package" là gì và nó khác "module" ở điểm nào?

• A. Module là một tệp mã nguồn, còn package là một hàm duy nhất.
• B. Module là tập hợp các package, còn package là một tệp mã nguồn.
• C. Module chỉ chứa hàm, còn package chứa cả hàm và biến.
• D. Module là một tệp mã nguồn (.py), còn package là một thư mục chứa các module và có thể cả package con.

Câu 24: Bạn đã tạo một package tên là `my_utilities` và bên trong package này có một module tên là `string_helpers.py` chứa hàm `reverse_string(s)`. Trong script chính, bạn muốn import và sử dụng hàm `reverse_string`. Cú pháp nào dưới đây là đúng?

• A. `import my_utilities.string_helpers.reverse_string`
• B. `from my_utilities import string_helpers.reverse_string`
• C. `from my_utilities.string_helpers import reverse_string`
• D. `import reverse_string from my_utilities.string_helpers`

Câu 25: Tại sao việc phân chia một chương trình lớn thành nhiều module và sử dụng chúng như các thư viện con lại là một kỹ thuật quan trọng trong phát triển phần mềm?

• A. Để làm cho chương trình chạy nhanh hơn trên mọi hệ thống.
• B. Để giảm thiểu việc sử dụng biến toàn cục.
• C. Để tự động tạo giao diện người dùng cho chương trình.
• D. Để tổ chức mã nguồn, giúp dễ quản lý, bảo trì và phát triển theo nhóm.

Câu 26: Cho đoạn code sau:
```python
from math import sqrt as can_bac_hai

number = 25
result = can_bac_hai(number)
print(result)
```
Kết quả in ra màn hình là gì?

• A. 5.0
• B. 25.0
• C. Error
• D. can_bac_hai(25)

Câu 27: Bạn viết code `import math` nhưng khi cố gắng gọi `math.sqr(9)`, Python báo lỗi `AttributeError: module "math" has no attribute "sqr"`. Nguyên nhân phổ biến nhất của lỗi này là gì?

• A. Thư viện `math` chưa được cài đặt.
• B. Bạn đã gõ sai tên hàm (`sqr` thay vì `sqrt`).
• C. Bạn cần sử dụng `from math import sqr` thay vì `import math`.
• D. Python không hỗ trợ hàm tính căn bậc hai.

Câu 28: Hàm `math.floor(x)` có chức năng làm tròn số thực `x` xuống số nguyên gần nhất nhỏ hơn hoặc bằng `x`. Ví dụ: `math.floor(3.14)` trả về 3. Kết quả của `math.floor(-5.9)` là bao nhiêu?

• A. -5
• B. 5
• C. -6
• D. 6

Câu 29: Hàm `math.ceil(x)` có chức năng làm tròn số thực `x` lên số nguyên gần nhất lớn hơn hoặc bằng `x`. Ví dụ: `math.ceil(3.14)` trả về 4. Kết quả của `math.ceil(-5.9)` là bao nhiêu?

• A. -5
• B. 5
• C. -6
• D. 6

Câu 30: Bạn đã viết một bộ các hàm xử lý dữ liệu khách hàng (ví dụ: định dạng tên, kiểm tra email hợp lệ, tính tuổi từ ngày sinh) và muốn sử dụng lại chúng trong nhiều chương trình khác nhau. Cách tốt nhất để tổ chức và tái sử dụng bộ hàm này là gì?

• A. Copy-paste mã nguồn của các hàm vào đầu mỗi chương trình mới.
• B. Lưu các hàm này vào một (hoặc nhiều) tệp `.py` riêng biệt và import chúng như một module/package.
• C. Ghi chú chi tiết cách sử dụng các hàm vào một tệp văn bản.
• D. Chỉ sử dụng các hàm này trong một chương trình duy nhất để đảm bảo tính nhất quán.

Câu 1: Trong lập trình Python, giả sử bạn cần sử dụng hàm `sqrt` để tính căn bậc hai. Thay vì tự viết lại thuật toán, bạn có thể nhập và sử dụng hàm này từ một thư viện chuẩn. Thư viện nào trong Python thường chứa các hàm toán học thông dụng như `sqrt`?

• A. random
• B. os
• C. math
• D. sys

Câu 2: Bạn đang viết một chương trình và cần sử dụng hàm `sqrt` từ thư viện `math`. Cách nhập thư viện nào sau đây cho phép bạn gọi hàm `sqrt` một cách trực tiếp chỉ bằng tên `sqrt()` mà không cần tiền tố `math.`?

• A. import math
• B. from math import sqrt
• C. import math as m
• D. from math import *

Câu 3: Xét đoạn mã sau:
```python
import math

result = math.floor(4.7)
print(result)
```
Đoạn mã này sẽ in ra kết quả là bao nhiêu? (Lưu ý: hàm `floor()` làm tròn xuống số nguyên gần nhất).

• A. 4
• B. 5
• C. 4.0
• D. Báo lỗi

Câu 4: Tại sao việc sử dụng thư viện trong lập trình lại được khuyến khích, đặc biệt đối với các chức năng phổ biến như tính toán toán học hay xử lý chuỗi?

• A. Chỉ để làm cho mã nguồn ngắn gọn hơn.
• B. Bắt buộc phải sử dụng thư viện cho mọi chương trình.
• C. Vì các hàm trong thư viện luôn chạy nhanh hơn mã tự viết.
• D. Giúp tái sử dụng mã, tiết kiệm thời gian, giảm lỗi và tăng hiệu quả công việc.

Câu 5: Bạn muốn nhập thư viện `math` nhưng muốn gọi nó bằng tên ngắn gọn hơn là `m`. Cú pháp nào sau đây thực hiện được điều đó?

• A. import math is m
• B. from math import m
• C. import math as m
• D. math import m

Câu 6: Khi bạn sử dụng lệnh `from math import *`, điều gì xảy ra?

• A. Tất cả các tên (hàm, biến,...) từ thư viện math được nhập trực tiếp vào không gian tên hiện tại.
• B. Chỉ các hàm phổ biến nhất từ thư viện math được nhập.
• C. Thư viện math được nhập nhưng bạn vẫn phải dùng tiền tố math.
• D. Chỉ các hằng số trong thư viện math được nhập.

Câu 7: Xét đoạn mã sau:
```python
from math import sqrt
from cmath import sqrt as csqrt

print(sqrt(9))
print(csqrt(-1))
```
Kết quả của đoạn mã này là gì? (Lưu ý: thư viện `cmath` dùng cho số phức).

• A. 3.0 và báo lỗi vì căn bậc hai của số âm không được định nghĩa.
• B. 3.0 và 1j
• C. Báo lỗi vì hai hàm `sqrt` bị trùng tên.
• D. 9 và -1

Câu 8: Bạn đang làm việc với một dự án lớn và muốn chia nhỏ mã nguồn thành nhiều tệp Python riêng biệt để dễ quản lý. Mỗi tệp này, khi được sử dụng trong tệp chính, được gọi là gì?

• A. Module
• B. Function
• C. Variable
• D. Package

Câu 9: Khi sử dụng `import module_name`, làm thế nào để truy cập một hàm `my_function` bên trong `module_name`?

• A. my_function()
• B. module_name my_function()
• C. call module_name.my_function()
• D. module_name.my_function()

Câu 10: Giả sử bạn có một tệp `my_utils.py` chứa một hàm `def greet(name): print(f"Hello, {name}!")`. Trong một tệp Python khác cùng thư mục, bạn muốn sử dụng hàm `greet`. Cú pháp nhập và gọi hàm nào sau đây là đúng?

• A. import my_utils; my_utils.greet("World")
• B. from my_utils import *; my_utils.greet("World")
• C. include my_utils; greet("World")
• D. use my_utils; my_utils.greet("World")

Câu 11: Trong trường hợp nào bạn nên cân nhắc sử dụng cú pháp `from module import item1, item2` thay vì `import module`?

• A. Khi bạn cần sử dụng tất cả các hàm trong module.
• B. Khi bạn muốn tránh xung đột tên với các hàm khác.
• C. Khi bạn chỉ cần sử dụng một vài hàm hoặc biến cụ thể từ module và muốn gọi chúng trực tiếp.
• D. Khi module đó rất nhỏ.

Câu 12: Điều gì có thể xảy ra nếu bạn sử dụng `from module import *` trong một chương trình lớn?

• A. Chương trình chắc chắn sẽ chạy nhanh hơn.
• B. Chỉ các hàm bắt đầu bằng dấu gạch dưới `_` được nhập.
• C. Bạn sẽ không thể sử dụng bất kỳ hàm nào từ module đó.
• D. Có thể xảy ra xung đột tên nếu các tên trong module trùng với tên trong chương trình hoặc các module khác đã nhập.

Câu 13: Hệ sinh thái Python có một bộ sưu tập lớn các module và gói (package) có sẵn được cài đặt cùng với Python. Bộ sưu tập này được gọi là gì?

• A. Thư viện chuẩn Python (Python Standard Library)
• B. Kho lưu trữ PyPI (Python Package Index)
• C. Môi trường ảo (Virtual Environment)
• D. Trình quản lý gói (Package Manager)

Câu 14: Giả sử bạn muốn tính giá trị của sin(π/2). Bạn cần sử dụng hàm `sin` và hằng số `pi` từ thư viện `math`. Đoạn mã nào sau đây thực hiện đúng yêu cầu này?

• A. from math import sin, pi; result = sin(pi / 2)
• B. import math; result = math.sin(math.pi / 2)
• C. import math; result = sin(pi / 2)
• D. from math import *; result = math.sin(math.pi / 2)

Câu 15: Bạn viết một tệp Python tên là `calculations.py` chứa một hàm `add(a, b)` trả về tổng của a và b. Trong một tệp khác, bạn muốn sử dụng hàm này. Bạn đã đặt cả hai tệp trong cùng một thư mục. Lệnh nào sau đây cho phép bạn gọi hàm `add` bằng cách sử dụng `calc.add(5, 3)`?

• A. from calculations import add as calc
• B. import calculations as add
• C. from calculations import calc as add
• D. import calculations as calc

Câu 16: Khi bạn chạy một chương trình Python sử dụng lệnh `import my_module`, điều gì xảy ra lần đầu tiên lệnh này được thực thi?

• A. Mã nguồn trong tệp my_module.py được thực thi và một đối tượng module được tạo.
• B. Chỉ các hàm và biến được định nghĩa trong my_module được nạp vào bộ nhớ.
• C. Chương trình sẽ tìm kiếm các lỗi cú pháp trong my_module nhưng chưa thực thi.
• D. Tệp my_module.py bị xóa khỏi ổ đĩa.

Câu 17: Lợi ích chính của việc tổ chức mã nguồn thành các module riêng biệt là gì?

• A. Làm cho chương trình chạy nhanh hơn.
• B. Giảm dung lượng tệp chương trình.
• C. Tăng khả năng tái sử dụng mã và giúp quản lý dự án lớn dễ dàng hơn.
• D. Bảo vệ mã nguồn khỏi bị sao chép.

Câu 18: Bạn cần sử dụng hàm `ceil` (làm tròn lên) và `floor` (làm tròn xuống) từ thư viện `math`. Cách nhập nào sau đây là hiệu quả nhất nếu bạn chỉ cần hai hàm này?

• A. import math
• B. import math as m
• C. from math import *
• D. from math import ceil, floor

Câu 19: Xét đoạn mã:
```python
import random

so_ngau_nhien = random.randint(1, 10)
print(so_ngau_nhien)
```
Hàm `randint(a, b)` từ thư viện `random` có chức năng gì?

• A. Trả về một số thực ngẫu nhiên trong khoảng [a, b).
• B. Trả về một số thực ngẫu nhiên trong khoảng [a, b].
• C. Trả về một số nguyên ngẫu nhiên trong khoảng [a, b].
• D. Chọn ngẫu nhiên một phần tử từ một dãy.

Câu 20: Giả sử bạn có hai module `module_a.py` và `module_b.py`, cả hai đều chứa một hàm tên là `process_data()`. Nếu bạn sử dụng `from module_a import *` và sau đó `from module_b import *`, điều gì sẽ xảy ra khi bạn gọi `process_data()`?

• A. Chương trình sẽ báo lỗi do trùng tên hàm.
• B. Hàm process_data() từ module_b sẽ được gọi.
• C. Hàm process_data() từ module_a sẽ được gọi.
• D. Cả hai hàm process_data() sẽ được gọi lần lượt.

Câu 21: Bạn cần thực hiện một phép tính yêu cầu độ chính xác cao với các giá trị thập phân, ví dụ như tính toán tài chính. Thư viện chuẩn Python nào cung cấp các công cụ thích hợp cho việc này, khác với `math` vốn làm việc với số dấu phẩy động chuẩn?

• A. decimal
• B. fractions
• C. statistics
• D. cmath

Câu 22: Khi bạn tạo một tệp Python mới và lưu nó với tên `my_library.py`, tệp này có thể được sử dụng như một module trong các chương trình Python khác. Điều kiện cần để một tệp `.py` hoạt động như một module là gì?

• A. Nó phải chứa ít nhất một lớp (class).
• B. Nó phải có một hàm tên là `main()`.
• C. Nó phải bắt đầu bằng dòng `__module__ = True`.
• D. Chỉ cần là một tệp chứa mã Python và có đuôi `.py`.

Câu 23: Giả sử bạn đã nhập thư viện `math` bằng lệnh `import math`. Bạn muốn tính logarit tự nhiên (logarit cơ số e) của một số. Hàm nào trong thư viện `math` bạn sẽ sử dụng?

• A. math.log()
• B. math.ln()
• C. math.log_e()
• D. math.natural_log()

Câu 24: Bạn nhận được một đoạn mã sử dụng thư viện `collections` với dòng nhập `from collections import Counter`. Dòng này cho biết điều gì?

• A. Toàn bộ thư viện collections được nhập vào bộ nhớ.
• B. Chỉ lớp Counter từ thư viện collections được nhập vào bộ nhớ.
• C. Thư viện collections được đổi tên thành Counter.
• D. Lớp Counter được nhập và đổi tên thành collections.

Câu 25: Xét hai cách nhập thư viện `math` sau:
Cách 1: `import math`
Cách 2: `from math import *`
So sánh về việc sử dụng bộ nhớ và khả năng xảy ra xung đột tên, cách nào tiềm ẩn rủi ro hơn trong chương trình lớn và phức tạp?

• A. Cách 1, vì nó nhập toàn bộ module.
• B. Cách 2, vì nó nhập tất cả tên trực tiếp vào không gian tên hiện tại.
• C. Cả hai cách đều có rủi ro như nhau.
• D. Không có cách nào tiềm ẩn rủi ro.

Câu 26: Bạn cần tính ước số chung lớn nhất (GCD) của hai số nguyên. Thư viện chuẩn nào trong Python cung cấp hàm cho phép thực hiện phép tính này?

• A. math
• B. random
• C. os
• D. sys

Câu 27: Khi bạn định nghĩa một hàm hoặc một lớp trong một tệp Python (`.py`), bạn đang tạo ra một đơn vị mã có thể tái sử dụng. Đơn vị này, khi được sử dụng bởi các chương trình khác thông qua lệnh `import`, được gọi là gì của chương trình?

• A. Biến toàn cục
• B. Hằng số
• C. Thư viện (hoặc module)
• D. Đối tượng

Câu 28: Giả sử bạn đang viết một chương trình xử lý tệp và thư mục trên hệ điều hành. Thư viện chuẩn Python nào sẽ là lựa chọn phù hợp nhất để thực hiện các thao tác này (ví dụ: tạo thư mục, liệt kê tệp)?

• A. math
• B. random
• C. sys
• D. os

Câu 29: Khi bạn sử dụng lệnh `from my_module import my_function`, điều gì xảy ra nếu `my_function` không tồn tại trong `my_module.py`?

• A. Chương trình sẽ báo lỗi ImportError.
• B. Hàm my_function sẽ được tạo tự động với nội dung rỗng.
• C. Lệnh nhập sẽ bị bỏ qua và chương trình tiếp tục chạy.
• D. Chương trình sẽ tìm kiếm my_function trong các module khác.

Câu 30: Tại sao việc sử dụng các hàm từ thư viện chuẩn (như `math.sqrt`) thường hiệu quả và đáng tin cậy hơn so với việc tự viết lại cùng một chức năng?

• A. Mã nguồn của thư viện chuẩn ngắn gọn hơn.
• B. Chỉ có thư viện chuẩn mới có thể truy cập phần cứng máy tính.
• C. Các hàm đã được tối ưu hóa về hiệu suất và kiểm thử kỹ lưỡng để đảm bảo tính đúng đắn và đáng tin cậy.
• D. Việc tự viết lại là không thể.

Câu 1: Trong lập trình Python, việc tổ chức mã nguồn thành các thư viện (modules) mang lại lợi ích chính nào sau đây?

• A. Giảm dung lượng bộ nhớ chương trình.
• B. Tăng khả năng tái sử dụng mã nguồn và tổ chức chương trình hiệu quả hơn.
• C. Giúp chương trình chạy nhanh hơn đáng kể.
• D. Bắt buộc để sử dụng bất kỳ hàm nào.

Câu 2: Bạn cần sử dụng hàm `sqrt()` và hằng số `pi` từ thư viện `math` trong Python. Cách nhập (import) nào sau đây là hiệu quả nhất về mặt sử dụng tài nguyên và vẫn cho phép bạn gọi các thành phần này một cách trực tiếp (không cần tiền tố `math.`)?

• A. `import math`
• B. `import math as m`
• C. `from math import sqrt, pi`
• D. `from math import *`

Câu 3: Giả sử bạn đã nhập thư viện `math` bằng lệnh `import math as mt`. Khi đó, để tính giá trị căn bậc hai của một số `x`, cú pháp gọi hàm đúng là gì?

• A. `math.sqrt(x)`
• B. `sqrt(x)`
• C. `mt.sqr(x)`
• D. `mt.sqrt(x)`

Câu 4: Trong cấu trúc dữ liệu danh sách liên kết (Linked List), mỗi phần tử (node) thường bao gồm những thành phần thông tin cơ bản nào?

• A. Dữ liệu của phần tử và con trỏ/liên kết đến phần tử tiếp theo.
• B. Chỉ dữ liệu của phần tử.
• C. Dữ liệu của phần tử và con trỏ/liên kết đến phần tử trước đó.
• D. Dữ liệu của phần tử, con trỏ đến phần tử tiếp theo và con trỏ đến phần tử trước đó.

Câu 5: Khi bạn viết một hàm hoặc một lớp trong một tệp Python (`.py`) và lưu nó. Tệp `.py` này có thể được coi là gì để các chương trình Python khác có thể sử dụng lại mã bên trong nó?

• A. Một tệp thực thi (executable file).
• B. Một module hoặc thư viện.
• C. Một tệp dữ liệu.
• D. Một tệp cấu hình.

Câu 6: Giả sử bạn có một module tên là `my_calculations.py` chứa hàm `add(a, b)` và hàm `subtract(a, b)`. Bạn muốn sử dụng chỉ hàm `add` trong chương trình chính của mình. Lệnh import nào là phù hợp nhất?

• A. `import my_calculations`
• B. `import my_calculations.add`
• C. `from my_calculations import add`
• D. `from my_calculations import *`

Câu 7: Xét một danh sách liên kết đơn. Để thêm một phần tử mới vào đầu danh sách, bạn cần cập nhật con trỏ `next` của phần tử mới trỏ tới đâu và cập nhật con trỏ `head` của danh sách trỏ tới đâu?

• A. Con trỏ `next` của phần tử mới trỏ tới node mà `head` hiện tại đang trỏ tới; `head` trỏ tới phần tử mới.
• B. Con trỏ `next` của phần tử mới trỏ tới `None`; `head` trỏ tới phần tử mới.
• C. Con trỏ `next` của phần tử mới trỏ tới phần tử cuối cùng hiện tại; `head` không thay đổi.
• D. `head` trỏ tới phần tử mới; con trỏ `next` của phần tử mới không quan trọng.

Câu 8: Lệnh `from math import *` có ưu điểm là bạn có thể gọi các hàm của thư viện `math` mà không cần tiền tố `math.`. Tuy nhiên, nó có một nhược điểm tiềm ẩn nghiêm trọng là gì?

• A. Chỉ nhập được một số hàm nhất định từ thư viện.
• B. Chương trình sẽ chạy chậm hơn đáng kể.
• C. Không thể sử dụng được các hằng số trong thư viện.
• D. Có thể gây xung đột tên (name collision) nếu có các hàm cùng tên trong các module khác nhau hoặc trong chương trình chính của bạn.

Câu 9: Giả sử bạn đang viết một chương trình xử lý hình học và cần tính diện tích hình tròn. Bạn biết rằng thư viện `math` có chứa hằng số `pi`. Đoạn mã nào sau đây sử dụng thư viện `math` một cách đúng đắn để tính diện tích hình tròn với bán kính `r`?

• A. ```python
  import math
  r = 5
  dien_tich = math.pi * r**2
  ```
• B. ```python
  r = 5
  dien_tich = pi * r**2
  ```
• C. ```python
  from math import pi
  r = 5
  dien_tich = math.pi * r**2
  ```
• D. ```python
  import math as p
  r = 5
  dien_tich = p.PI * r**2
  ```

Câu 10: Khi bạn muốn tìm kiếm một phần tử có khóa `k` trong một danh sách liên kết đơn, thao tác cơ bản bạn cần thực hiện là gì?

• A. Truy cập trực tiếp đến vị trí của phần tử bằng chỉ số (index).
• B. Duyệt tuần tự từ node đầu tiên (head), kiểm tra dữ liệu của từng node cho đến khi tìm thấy hoặc duyệt hết danh sách.
• C. Sử dụng phương pháp tìm kiếm nhị phân.
• D. Thêm phần tử `k` vào danh sách rồi mới tìm kiếm.

Câu 11: Giả sử bạn đã xây dựng một module Python tên là `data_structures.py` chứa định nghĩa lớp `LinkedList` cho danh sách liên kết. Trong một chương trình khác, bạn muốn tạo một đối tượng danh sách liên kết mới. Lệnh import và khởi tạo nào là đúng?

• A. ```python
  from data_structures import LinkedList
  my_list = LinkedList()
  ```
• B. ```python
  import data_structures.LinkedList
  my_list = LinkedList()
  ```
• C. ```python
  import data_structures
  my_list = LinkedList()
  ```
• D. ```python
  from data_structures import *
  my_list = data_structures.LinkedList()
  ```

Câu 12: Tại sao việc sử dụng các hàm có sẵn trong thư viện chuẩn của Python (như `math`, `random`, `os`,...) thường được khuyến khích hơn là tự viết lại các chức năng tương tự?

• A. Các hàm trong thư viện chuẩn luôn chạy nhanh hơn mọi hàm tự viết.
• B. Không thể tự viết lại các hàm tương tự được.
• C. Các hàm này đã được kiểm thử kỹ lưỡng, tối ưu hóa và đáng tin cậy; giúp tiết kiệm thời gian phát triển.
• D. Việc tự viết lại là vi phạm bản quyền.

Câu 13: Khi xóa node đầu tiên khỏi một danh sách liên kết đơn không rỗng `L`, bạn cần thực hiện thao tác cập nhật con trỏ `head` như thế nào?

• A. Gán `L.head = None`.
• B. Gán `L.head = L.head.next.next`.
• C. Không cần cập nhật `L.head`, chỉ cần xóa node đầu tiên.
• D. Gán `L.head = L.head.next`.

Câu 14: Bạn đã viết một module Python tên là `utils.py` chứa một số hàm tiện ích. Để sử dụng tất cả các hàm trong `utils.py` trong chương trình chính và gọi chúng bằng cách thêm tiền tố `utils.` trước tên hàm, lệnh import nào là đúng?

• A. `import utils`
• B. `from utils import *`
• C. `from utils import utils`
• D. `import utils.*`

Câu 15: Xét đoạn mã Python sau: `import math`. Nếu bạn cố gắng gọi `print(math.sin(math.pi / 2))`, kết quả dự kiến sẽ là bao nhiêu?

• A. 0.0
• B. math.sin(math.pi / 2)
• C. Lỗi, vì cần import `sin` và `pi` cụ thể.
• D. 1.0 (hoặc một giá trị rất gần 1.0 do sai số dấu phẩy động).

Câu 16: Khi nào thì việc sử dụng lệnh `from ten_thu_vien import *` có thể được chấp nhận hoặc ít gây rủi ro hơn?

• A. Khi bạn đang làm việc trong một script nhỏ, thử nghiệm nhanh và biết rõ nội dung của module được import.
• B. Trong các dự án lớn với nhiều module khác nhau.
• C. Khi module được import có rất nhiều hàm và bạn muốn sử dụng hầu hết chúng.
• D. Luôn luôn là cách tốt nhất để import.

Câu 17: Giả sử bạn có một danh sách liên kết đơn và muốn xóa một node không phải node đầu tiên. Thao tác cơ bản bạn cần thực hiện là gì để duy trì tính liên kết của danh sách?

• A. Chỉ cần đặt node cần xóa về `None`.
• B. Cập nhật con trỏ `next` của node cần xóa trỏ tới `None`.
• C. Tìm node trước node cần xóa và cập nhật con trỏ `next` của node đó trỏ tới node sau node cần xóa.
• D. Duyệt lại toàn bộ danh sách và xây dựng lại từ đầu, bỏ qua node cần xóa.

Câu 18: Việc phân chia chương trình lớn thành các module (thư viện) nhỏ hơn có liên quan đến nguyên lý thiết kế chương trình nào?

• A. Nguyên lý "Don"t Repeat Yourself" (DRY).
• B. Nguyên lý mô-đun hóa (Modularity).
• C. Nguyên lý trừu tượng hóa (Abstraction).
• D. Tất cả các nguyên lý trên đều có liên quan ở mức độ nhất định.

Câu 19: Bạn muốn làm tròn số `3.7` xuống số nguyên gần nhất bằng cách sử dụng thư viện `math`. Lệnh nào sau đây là đúng?

• A. ```python
  import math
  result = math.floor(3.7)
  ```
• B. ```python
  import math
  result = math.round(3.7)
  ```
• C. ```python
  from math import ceil
  result = ceil(3.7)
  ```
• D. ```python
  import math
  result = math.int(3.7)
  ```

Câu 20: Xét đoạn mã sau:
```python
# file my_module.py
def greet(name):
return f"Hello, {name}"

# file main.py
import my_module
message = my_module.greet("Alice")
print(message)
```
Đoạn mã này minh họa điều gì về việc sử dụng module?

• A. Cách định nghĩa một lớp trong module.
• B. Cách sử dụng bí danh khi import.
• C. Cách định nghĩa một hàm trong module và import/sử dụng nó trong một tệp khác.
• D. Cách xử lý ngoại lệ khi import module.

Câu 21: Trong ngữ cảnh của danh sách liên kết, con trỏ `head` của danh sách liên kết rỗng sẽ có giá trị là gì trong Python?

• A. 0
• B. Một đối tượng Node rỗng.
• C. Một địa chỉ bộ nhớ ngẫu nhiên.
• D. `None`.

Câu 22: Giả sử bạn có một hàm `calculate_discount(total, discount_rate)` trong module `pricing.py`. Bạn muốn import hàm này và gọi nó trực tiếp mà không cần tiền tố `pricing.`. Lệnh import và gọi hàm nào là đúng?

• A. ```python
  import pricing
  discount = calculate_discount(100, 0.1)
  ```
• B. ```python
  from pricing import calculate_discount
  discount = calculate_discount(100, 0.1)
  ```
• C. ```python
  import pricing.calculate_discount
  discount = pricing.calculate_discount(100, 0.1)
  ```
• D. ```python
  from pricing import *
  discount = pricing.calculate_discount(100, 0.1)
  ```

Câu 23: Tại sao việc sử dụng thư viện (module) giúp cải thiện khả năng bảo trì (maintenance) của chương trình?

• A. Mã nguồn được chia thành các phần độc lập, dễ dàng tìm và sửa lỗi hoặc cập nhật một phần mà không ảnh hưởng lớn đến các phần khác.
• B. Giúp mã nguồn trở nên phức tạp hơn, khó hiểu hơn.
• C. Chỉ áp dụng cho các chương trình rất nhỏ.
• D. Không có mối liên hệ trực tiếp giữa thư viện và bảo trì chương trình.

Câu 24: Trong danh sách liên kết đơn, để hiển thị tất cả các phần tử, bạn cần bắt đầu từ node nào và di chuyển như thế nào?

• A. Bắt đầu từ node cuối cùng và di chuyển ngược về đầu.
• B. Bắt đầu từ một node ngẫu nhiên và di chuyển theo cả hai hướng.
• C. Bắt đầu từ node đầu tiên (head) và di chuyển đến node tiếp theo bằng con trỏ `next` cho đến khi gặp `None`.
• D. Chỉ cần in ra con trỏ `head`.

Câu 25: Bạn đang phát triển một ứng dụng và nhận thấy có một đoạn mã xử lý dữ liệu được lặp đi lặp lại ở nhiều nơi trong chương trình. Giải pháp tốt nhất để xử lý vấn đề này, tận dụng khái niệm thư viện/module là gì?

• A. Sao chép và dán đoạn mã đó vào tất cả những nơi cần dùng.
• B. Viết lại đoạn mã đó dưới dạng một hàm riêng biệt trong cùng một tệp.
• C. Bỏ qua, vì việc lặp mã không ảnh hưởng lớn.
• D. Đóng gói đoạn mã xử lý dữ liệu vào một hàm, đặt hàm đó vào một module riêng và import/sử dụng hàm đó ở những nơi cần thiết.

Câu 26: Giả sử bạn muốn tạo một thư viện (module) Python của riêng mình. Bước đầu tiên và cơ bản nhất bạn cần làm là gì?

• A. Viết các hàm, lớp, hoặc biến bạn muốn đưa vào thư viện vào một tệp Python (`.py`).
• B. Đăng ký tên thư viện của bạn trên PyPI (Python Package Index).
• C. Cài đặt một công cụ quản lý gói như `pip`.
• D. Biên dịch mã nguồn Python thành mã máy.

Câu 27: Khi bạn sử dụng `from math import sqrt`, điều gì xảy ra với các hàm khác trong thư viện `math` (ví dụ: `sin`, `cos`, `floor`,...)?

• A. Tất cả các hàm khác cũng được nhập vào bộ nhớ nhưng bạn không thể gọi chúng.
• B. Các hàm khác không được nhập vào bộ nhớ và bạn không thể gọi chúng trực tiếp (trừ khi import lại theo cách khác).
• C. Các hàm khác tự động được đổi tên.
• D. Các hàm khác chỉ có thể được gọi sau khi bạn sử dụng hàm `sqrt` ít nhất một lần.

Câu 28: Xét thao tác xóa node cuối cùng khỏi một danh sách liên kết đơn. Tại sao thao tác này lại phức tạp hơn việc xóa node đầu tiên?

• A. Bạn cần tìm đến node trước node cuối cùng để cập nhật con trỏ `next` của nó thành `None`, điều này đòi hỏi duyệt qua gần hết danh sách.
• B. Node cuối cùng không có con trỏ `next`.
• C. Bạn cần cập nhật con trỏ `head`.
• D. Python tự động xử lý việc xóa node cuối cùng mà không cần code phức tạp.

Câu 29: Bạn đang làm việc với một thư viện do người khác viết. Bạn thấy rằng có một hàm tên là `process_data()` trong module `data_handler`. Cách tốt nhất để sử dụng hàm này mà không gây nhầm lẫn với các hàm cùng tên trong chương trình của bạn là gì?

• A. Sử dụng `from data_handler import *`.
• B. Sử dụng `import data_handler` và gọi hàm là `data_handler.process_data()`.
• C. Sử dụng `from data_handler import process_data` và gọi hàm là `process_data()`.
• D. Đổi tên hàm `process_data` trong chương trình của bạn.

Câu 30: Tưởng tượng bạn có một danh sách liên kết đơn biểu diễn một hàng đợi. Khi một phần tử mới được thêm vào hàng đợi (enqueue), nó được thêm vào đâu? Khi một phần tử được lấy ra khỏi hàng đợi (dequeue), nó được lấy ra từ đâu?

• A. Thêm vào cuối, lấy ra từ đầu.
• B. Thêm vào đầu, lấy ra từ cuối.
• C. Thêm vào cuối, lấy ra từ cuối.
• D. Thêm vào đầu, lấy ra từ đầu.

Câu 1: Khi viết một chương trình lớn trong Python, việc chia nhỏ mã nguồn thành các tệp riêng biệt (module) và sử dụng chúng như thư viện mang lại lợi ích chính nào sau đây?

• A. Giúp chương trình chạy nhanh hơn đáng kể.
• B. Làm cho mã nguồn khó đọc và khó hiểu hơn.
• C. Bắt buộc phải viết lại toàn bộ mã nguồn khi cần chỉnh sửa một phần nhỏ.
• D. Tăng khả năng tái sử dụng mã nguồn và giúp quản lý dự án dễ dàng hơn.

Câu 2: Giả sử bạn có một tệp Python tên là `my_module.py` chứa một hàm tên là `calculate_area(radius)`. Trong một tệp chương trình khác, bạn muốn sử dụng hàm này. Lệnh nhập (import) nào sau đây cho phép bạn gọi hàm bằng cú pháp `my_module.calculate_area(r)`?

• A. from my_module import calculate_area
• B. import calculate_area from my_module
• C. import my_module
• D. from my_module import *

Câu 3: Xét hai cách nhập thư viện `math` trong Python:
Cách 1: `import math`
Cách 2: `from math import sqrt`
Nhận định nào sau đây là đúng khi sử dụng `sqrt` sau khi nhập theo hai cách trên?

• A. Cả hai cách đều cho phép gọi hàm bằng `sqrt(x)`.
• B. Cách 1 gọi là `math.sqrt(x)`, Cách 2 gọi là `sqrt(x)`.
• C. Cách 1 gọi là `sqrt(x)`, Cách 2 gọi là `math.sqrt(x)`.
• D. Cả hai cách đều phải gọi hàm bằng `math.sqrt(x)`.

Câu 4: Bạn cần sử dụng hàm `floor` (làm tròn xuống) và `ceil` (làm tròn lên) từ thư viện `math`. Lệnh nhập nào sau đây là hiệu quả nhất nếu bạn chỉ cần hai hàm này và muốn gọi chúng trực tiếp bằng tên (không có tiền tố `math.`)?

• A. from math import floor, ceil
• B. import math
• C. import math.floor, math.ceil
• D. from math import *

Câu 5: Việc sử dụng lệnh `from module import *` (nhập tất cả) có ưu điểm là mã nguồn gọi hàm/biến từ module sẽ ngắn gọn hơn. Tuy nhiên, nhược điểm tiềm ẩn của cách nhập này là gì?

• A. Chỉ nhập được các hàm, không nhập được biến.
• B. Chỉ nhập được các biến, không nhập được hàm.
• C. Có thể gây xung đột tên (name collision) nếu module chứa tên trùng với tên đã tồn tại trong chương trình chính.
• D. Làm cho chương trình chạy chậm hơn đáng kể.

Câu 6: Giả sử bạn đã nhập thư viện `math` bằng lệnh `import math`. Để tính căn bậc hai của một số `x`, bạn sẽ sử dụng cú pháp nào?

• A. math.sqrt(x)
• B. sqrt(x)
• C. math.sqrt x
• D. sqrt math(x)

Câu 7: Bạn viết một module Python tên là `utils.py` chứa hàm `is_prime(n)` để kiểm tra số nguyên tố. Trong chương trình chính `main.py`, bạn muốn nhập module này với tên gọi tắt là `u`. Lệnh nhập nào sau đây là đúng?

• A. import utils as u
• B. from utils import u
• C. import u = utils
• D. import utils as u

Câu 8: Sau khi thực hiện lệnh `from math import pi`, bạn có thể sử dụng giá trị của số Pi bằng cách nào?

• A. math.pi
• B. pi
• C. Pi
• D. math.Pi

Câu 9: Bạn tạo một tệp `constants.py` chứa dòng code `MY_CONSTANT = 100`. Trong một tệp khác, bạn muốn sử dụng biến `MY_CONSTANT`. Cách nào sau đây là hợp lệ để nhập và sử dụng nó?

• A. `import constants` rồi dùng `MY_CONSTANT`
• B. `from constants import MY_CONSTANT` rồi dùng `constants.MY_CONSTANT`
• C. `from constants import MY_CONSTANT` rồi dùng `MY_CONSTANT`
• D. Không thể nhập biến từ tệp khác.

Câu 10: Xét đoạn mã sau:
```python
# file my_module.py
def greet(name):
print(f

• A. In ra màn hình: `Hello, Alice!`
• B. Báo lỗi vì không tìm thấy hàm `greet`.
• C. Không in gì cả.
• D. In ra màn hình: `my_module.greet(

Câu 11: Xét đoạn mã sau:
```python
# file my_module.py
__version__ =

• A. Báo lỗi vì không thể nhập biến `__version__`.
• B. In ra màn hình:
  `Module version: 1.0`
  `my_module.__version__`
• C. In ra màn hình:
  `Module version: 1.0`
  `1.0`
• D. Chỉ in ra màn hình: `Module version: 1.0`

Câu 12: Bạn đang viết một chương trình xử lý chuỗi và cần sử dụng một số hàm phức tạp mà bạn đã viết trước đó và lưu trong tệp `string_utils.py`. Tệp này chứa các hàm như `reverse_string`, `is_palindrome`. Bạn muốn sử dụng các hàm này trong chương trình chính mà không cần viết lại. Đây là ví dụ điển hình cho việc sử dụng thư viện/module nhằm mục đích gì?

• A. Tái sử dụng mã nguồn.
• B. Bảo mật mã nguồn.
• C. Tăng tốc độ biên dịch.
• D. Giảm dung lượng tệp chương trình chính.

Câu 13: Trong Python, khi bạn sử dụng lệnh `import some_module`, hệ thống sẽ tìm tệp `some_module.py` ở những vị trí nào?

• A. Chỉ trong thư mục hiện tại của tệp chương trình đang chạy.
• B. Chỉ trong thư mục cài đặt Python.
• C. Chỉ trong các thư mục được liệt kê trong biến môi trường PATH.
• D. Trong thư mục hiện tại, các thư mục của thư viện chuẩn Python, và các thư mục trong biến môi trường PYTHONPATH.

Câu 14: Giả sử bạn có hai module:
`module_a.py`: Chứa hàm `process_data()`
`module_b.py`: Chứa hàm `process_data()`
Trong chương trình chính, bạn thực hiện:
`from module_a import process_data`
`from module_b import process_data`
Sau đó gọi `process_data()`. Hàm nào sẽ được thực thi?

• A. Cả hai hàm sẽ được thực thi.
• B. Hàm `process_data()` từ `module_b.py` sẽ được thực thi (ghi đè).
• C. Hàm `process_data()` từ `module_a.py` sẽ được thực thi.
• D. Chương trình sẽ báo lỗi xung đột tên (name collision).

Câu 15: Để tránh xung đột tên như trong Câu 14, bạn có thể sử dụng cách nhập nào sau đây?
```python
# Trong chương trình chính
import module_a
import module_b
# Cách gọi hàm?
```
Cách gọi hàm nào là đúng sau khi nhập như trên?

• A. module_a.process_data() và module_b.process_data() không còn khả dụng.
• B. Chỉ có thể gọi `process_data()` và nó sẽ thực thi hàm từ `module_b`.
• C. Gọi hàm từ module_a bằng `module_a.process_data()` và từ module_b bằng `module_b.process_data()`.
• D. Chương trình vẫn báo lỗi xung đột tên.

Câu 16: Hoặc, để tránh xung đột tên trong Câu 14 bằng cách sử dụng `from ... import ...` nhưng vẫn muốn gọi trực tiếp bằng tên gốc, bạn có thể làm gì?

• A. Không thể tránh xung đột tên khi dùng `from ... import ...` nếu tên trùng nhau.
• B. Sử dụng `from module_a import process_data as process_data_a` và `from module_b import process_data as process_data_b`.
• C. Chỉ nhập một trong hai module.
• D. Không có cách nào dùng `from ... import ...` mà vẫn gọi trực tiếp bằng tên gốc nếu tên bị trùng giữa hai module được nhập vào cùng một namespace.

Câu 17: Khi bạn tạo một tệp Python (`.py`) và đặt các hàm, biến vào đó, tệp đó tự động trở thành gì trong ngữ cảnh của Python?

• A. Một module.
• B. Một package.
• C. Một lớp (class).
• D. Một thư viện chuẩn.

Câu 18: Để nhóm nhiều module có liên quan lại với nhau thành một cấu trúc phân cấp, bạn sử dụng khái niệm gì trong Python?

• A. Thư viện (Library).
• B. Module.
• C. Package.
• D. Framework.

Câu 19: Giả sử bạn có một package tên là `my_package` chứa một module tên là `data.py`. Module `data.py` này có một hàm tên là `load_config()`. Trong chương trình chính, để nhập và gọi hàm này bằng cú pháp `my_package.data.load_config()`, bạn sẽ sử dụng lệnh nhập nào?

• A. from my_package.data import load_config
• B. import my_package.data
• C. import my_package
• D. from my_package import data.load_config

Câu 20: Tiếp tục với ví dụ ở Câu 19. Để nhập và gọi hàm `load_config()` trực tiếp bằng tên `load_config()`, bạn sẽ sử dụng lệnh nhập nào?

• A. from my_package.data import load_config
• B. import my_package.data.load_config
• C. from my_package import load_config
• D. import load_config from my_package.data

Câu 21: Ưu điểm chính của việc sử dụng bí danh (alias) khi nhập module hoặc thành phần từ module (ví dụ: `import math as m` hoặc `from collections import Counter as Ctr`) là gì?

• A. Giúp chương trình chạy nhanh hơn.
• B. Bắt buộc phải sử dụng bí danh.
• C. Làm cho tên gốc không còn sử dụng được.
• D. Giúp rút ngắn tên dài hoặc tránh xung đột tên bằng cách đặt tên mới ngắn gọn/khác biệt.

Câu 22: Khi bạn nhập một module lần đầu tiên trong một chương trình Python, Python thực hiện điều gì?

• A. Chỉ đọc nội dung của tệp module mà không thực thi.
• B. Thực thi toàn bộ mã nguồn trong tệp module đó từ trên xuống dưới.
• C. Chỉ thực thi các hàm hoặc biến được chỉ định trong lệnh import.
• D. Biên dịch toàn bộ mã module thành mã máy trước khi thực thi chương trình chính.

Câu 23: Điều gì xảy ra nếu bạn cố gắng nhập một module không tồn tại trong các thư mục tìm kiếm của Python?

• A. Chương trình sẽ chạy nhưng các hàm/biến từ module đó sẽ không hoạt động.
• B. Python tự động tìm kiếm module đó trên Internet.
• C. Chương trình sẽ báo lỗi `ModuleNotFoundError`.
• D. Python sẽ tạo một tệp rỗng với tên module đó.

Câu 24: Giả sử bạn có một module tên là `my_data_structures.py` chứa định nghĩa lớp `Node` và lớp `LinkedList`. Bạn muốn sử dụng lớp `LinkedList` trong chương trình chính. Lệnh nhập nào sau đây là phù hợp nhất nếu bạn muốn gọi lớp này bằng tên đầy đủ (có tiền tố module)?

• A. import my_data_structures
• B. from my_data_structures import LinkedList
• C. from my_data_structures import *
• D. import LinkedList from my_data_structures

Câu 25: Sau khi nhập theo lệnh `import my_data_structures` (như trong Câu 24), để tạo một đối tượng danh sách liên kết mới, bạn sử dụng cú pháp nào?

• A. LinkedList()
• B. new LinkedList()
• C. my_data_structures.LinkedList.new()
• D. my_data_structures.LinkedList()

Câu 26: Xét đoạn mã sau:
```python
# file my_math.py
def add(a, b):
return a + b

# file main.py
from my_math import add

result = add(5, 3)
print(result)
```
Kết quả khi chạy `main.py` là gì?

• A. Báo lỗi vì không có tiền tố `my_math.`
• B. In ra màn hình: `8`
• C. In ra màn hình: `add(5, 3)`
• D. Báo lỗi vì hàm `add` không được định nghĩa.

Câu 27: Khi bạn cài đặt một thư viện bên ngoài (ví dụ: sử dụng pip để cài đặt thư viện `requests`), các tệp của thư viện đó thường được đặt ở đâu để Python có thể tìm thấy khi bạn sử dụng lệnh `import`?

• A. Trong thư mục `site-packages` thuộc thư mục cài đặt Python hoặc môi trường ảo.
• B. Luôn trong thư mục hiện tại của chương trình đang chạy.
• C. Trong thư mục người dùng (ví dụ: Documents).
• D. Trên Internet và được tải xuống mỗi lần chạy.

Câu 28: Giả sử bạn đang debug một chương trình và nhận được lỗi `AttributeError: module "my_module" has no attribute "my_function"`. Điều này có nghĩa là gì?

• A. Bạn đã nhập module `my_module` sai cú pháp.
• B. Module `my_module` không tồn tại.
• C. Module `my_module` tồn tại, nhưng không chứa hàm hoặc thuộc tính tên là `my_function` hoặc bạn đã nhập sai cách khiến `my_function` không nằm trong namespace có thể truy cập qua `my_module.`.
• D. Hàm `my_function` yêu cầu đối số đầu vào không hợp lệ.

Câu 29: Bạn có một hàm `process()` trong module `data_processor.py`. Bạn muốn nhập hàm này và sử dụng nó với tên gọi tắt là `dp_process`. Lệnh nhập nào sau đây là đúng?

• A. import data_processor.process as dp_process
• B. from data_processor import process as dp_process
• C. import dp_process = data_processor.process
• D. from data_processor import process as dp_process

Câu 30: Khi sử dụng các hàm từ một thư viện, ví dụ thư viện `math`, bạn thường không cần quan tâm đến mã nguồn chi tiết bên trong các hàm đó. Điều này thể hiện lợi ích nào của việc sử dụng thư viện?

• A. Tính trừu tượng và đóng gói (abstraction and encapsulation).
• B. Tăng tốc độ gõ code.
• C. Giảm kích thước tệp module.
• D. Yêu cầu kiến thức chuyên sâu về thuật toán.

Câu 1: Một lập trình viên đang phát triển một ứng dụng cần thực hiện nhiều phép tính toán học phức tạp như căn bậc hai, lũy thừa, và các hàm lượng giác. Thay vì tự viết lại các thuật toán này, lập trình viên nên làm gì để tiết kiệm thời gian và đảm bảo độ chính xác? Chọn giải pháp phù hợp nhất.

• A. Viết lại tất cả các thuật toán từ đầu để hiểu rõ nguyên lý hoạt động.
• B. Tìm kiếm trên mạng các đoạn mã có sẵn và sao chép vào chương trình chính.
• C. Sử dụng các hàm có sẵn trong thư viện toán học chuẩn của ngôn ngữ lập trình (ví dụ: thư viện `math` trong Python).
• D. Yêu cầu đồng nghiệp viết riêng các hàm đó và gửi cho mình.

Câu 2: Trong Python, bạn muốn sử dụng hàm tính căn bậc hai. Lệnh nhập thư viện nào dưới đây sẽ cho phép bạn gọi trực tiếp hàm này bằng tên `sqrt()` mà không cần tiền tố của thư viện?

• A. import math
• B. import math as m
• C. from math import *
• D. from math import sqrt

Câu 3: Giả sử bạn đã nhập thư viện `math` bằng lệnh `import math`. Để tính giá trị sin của góc `x` (đơn vị radian), cú pháp gọi hàm đúng là gì?

• A. sin(x)
• B. math.sin(x)
• C. import sin from math
• D. math(sin(x))

Câu 4: Lệnh nhập thư viện `import math as m` có ý nghĩa gì?

• A. Nhập toàn bộ thư viện math và đặt bí danh (alias) là `m` để gọi các hàm.
• B. Chỉ nhập hàm `m` từ thư viện `math`.
• C. Nhập thư viện `math` và chỉ cho phép sử dụng hàm `m`.
• D. Đây là cú pháp không hợp lệ trong Python.

Câu 5: Đoạn mã sau sẽ in ra kết quả gì?
```python
import math
print(math.floor(3.7) + math.ceil(3.2))
```

• A. 6.0
• B. 7.0
• C. 7
• D. 6

Câu 6: Việc sử dụng lệnh `from module import *` để nhập tất cả các tên từ một module vào không gian tên hiện tại tiềm ẩn rủi ro gì?

• A. Làm chậm quá trình thực thi chương trình.
• B. Gây xung đột tên (name conflict) nếu có các tên trùng lặp giữa module và chương trình hiện tại hoặc giữa các module khác được nhập theo cách này.
• C. Chỉ nhập các hàm, không nhập các biến hoặc lớp.
• D. Không thể sử dụng các hàm đã nhập mà không có tiền tố.