## Nền tảng Python:
### Cách coding ? (Indentation)
### Nắm cấu trúc căn bản :
- Tạo hàm như thế nào ?
- Lấy dữ liệu bàn phím như thế nào ? : Input()
- Ép Kiểu dữ liệu như thế nào ? (int,str...)
- Cấu trúc If else như thế nào ?
- Cấu trúc lựa chọn như thế nào ? match
- Các toán tử trong Python
- Viết được hiển thị nội dung CRUD của menu (..... Validate các sự lựa chọn)
- Nắm được dữ liệu căn bản kiểu dạng List,Tuple
- Generator
- Dictonary
- Lambda
- OOP (tạo class - sử dụng các object)
1.0 : Thế nào là constructor,get/set
1.1 : Đa hình
1.2 : Thừa kế
1.3 : Trừu tượng
1.4 : Đóng gói
- Xử lý Exception trong python như thế nào ?
- Vẽ đồ thị bar/line ... như thế nào ? (matplot)
- Serialize/Deserial Object như thế nào ?
- Thao tác cả các file như thế nào ?
- Multi Threading trong Python như thế nào ?
- Kết nối cơ sở dữ liệu (Mysql) như thế nào ?
- Framwork : FastApi, Django ?
=======================================================
### **1. Tạo hàm như thế nào?**
**Cách tạo hàm:**
* Sử dụng từ khóa `def` theo sau là tên hàm và dấu ngoặc đơn `()`.
* Các tham số (dữ liệu đầu vào) được đặt bên trong dấu ngoặc đơn.
* Nội dung của hàm được viết thụt vào so với dòng `def`.
* Sử dụng `return` để trả về kết quả.
**Ví dụ:**
```python
# Hàm tính tổng hai số
def tinh_tong(a, b):
tong = a + b
return tong
# Gọi hàm và in kết quả
ket_qua = tinh_tong(5, 3)
print(ket_qua) # Kết quả: 8
```
### **2. Lấy dữ liệu bàn phím như thế nào? : Input()**
Hàm `input()` được sử dụng để nhận dữ liệu từ người dùng qua bàn phím. Dữ liệu nhận được luôn ở dạng chuỗi (string).
**Ví dụ:**
```python
ten = input("Nhập tên của bạn: ")
print("Chào bạn, " + ten)
```
### **3. Ép Kiểu dữ liệu như thế nào? (int,str…)**
Ép kiểu là chuyển đổi một biến từ kiểu dữ liệu này sang kiểu dữ liệu khác.
* `int()`: Chuyển sang số nguyên.
* `str()`: Chuyển sang chuỗi.
* `float()`: Chuyển sang số thực.
**Ví dụ:**
```python
so_nguyen_str = "10"
so_nguyen = int(so_nguyen_str)
so_thuc = 3.14
so_thuc_str = str(so_thuc)
```
### **4. Cấu trúc If else như thế nào?**
Cấu trúc `if-else` cho phép bạn thực hiện các khối mã khác nhau dựa trên một điều kiện đúng hay sai.
**Ví dụ:**
```python
tuoi = 18
if tuoi >= 18:
print("Bạn đã đủ tuổi lái xe.")
else:
print("Bạn chưa đủ tuổi lái xe.")
```
### **5. Cấu trúc lựa chọn như thế nào? match**
Cấu trúc `match-case` (tương tự `switch-case` trong các ngôn ngữ khác) cho phép bạn so sánh một giá trị với nhiều mẫu khác nhau.
**Ví dụ:**
```python
ngon_ngu = "Python"
match ngon_ngu:
case "Python":
print("Bạn đã chọn Python.")
case "Java":
print("Bạn đã chọn Java.")
case _:
print("Ngôn ngữ khác.")
```
### **6. Các toán tử trong Python**
Python có nhiều loại toán tử khác nhau:
* **Toán tử số học:** `+`, `-`, `*`, `/`, `%` (chia lấy dư), `**` (lũy thừa), `//` (chia lấy phần nguyên).
* **Toán tử so sánh:** `==`, `!=`, `>`, `<`, `>=`, `<=`.
* **Toán tử logic:** `and`, `or`, `not`.
* **Toán tử gán:** `=`, `+=`, `-=`, `*=`, `/=`.
### **7. Viết được hiển thị nội dung CRUD của menu (… Validate các sự lựa chọn)**
CRUD là viết tắt của Create (Tạo), Read (Đọc), Update (Cập nhật), Delete (Xóa). Đây là các thao tác cơ bản với dữ liệu.
**Ví dụ menu CRUD đơn giản:**
```python
def hien_thi_menu():
print("1. Thêm sản phẩm")
print("2. Xem danh sách sản phẩm")
print("3. Cập nhật sản phẩm")
print("4. Xóa sản phẩm")
print("5. Thoát")
def validate_lua_chon(lua_chon):
if lua_chon.isdigit() and 1 <= int(lua_chon) <= 5:
return True
return False
# ... (các hàm xử lý cho từng lựa chọn)
```
### **8. Nắm được dữ liệu căn bản kiểu dạng List,Tuple**
* **List:** Là một tập hợp các phần tử có thứ tự và có thể thay đổi được. Được bao bởi dấu ngoặc vuông `[]`.
* **Tuple:** Tương tự như List nhưng không thể thay đổi sau khi đã tạo. Được bao bởi dấu ngoặc đơn `()`.
**Ví dụ:**
```python
# List
trai_cay_list = ["táo", "chuối", "cam"]
trai_cay_list[0] = "nho" # Có thể thay đổi
# Tuple
dong_vat_tuple = ("chó", "mèo", "chim")
# dong_vat_tuple[0] = "cá" # Sẽ gây lỗi
```
### **9. Generator**
Generator là một loại hàm đặc biệt trả về một đối tượng lặp (iterator). Nó tạo ra các giá trị theo yêu cầu, giúp tiết kiệm bộ nhớ.
**Ví dụ:**
```python
def dem_so(n):
i = 0
while i < n:
yield i
i += 1
for so in dem_so(5):
print(so)
```
### **10. Dictionary**
**Dictionary** là một tập hợp các cặp `key-value` không có thứ tự. Mỗi `key` là duy nhất và được dùng để truy cập `value` tương ứng.
**Ví dụ:**
```python
thong_tin_ca_nhan = {
"ten": "An",
"tuoi": 25,
"thanh_pho": "Hà Nội"
}
print(thong_tin_ca_nhan["ten"]) # Kết quả: An
```
### **11. Lambda**
**Hàm Lambda** là một hàm ẩn danh nhỏ, không có tên. Nó có thể có nhiều đối số nhưng chỉ có một biểu thức. Thường được dùng cho các công việc đơn giản, nhanh chóng.
**Ví dụ:**
```python
tong = lambda a, b: a + b
print(tong(5, 3)) # Kết quả: 8
```
### **12. OOP (tạo class - sử dụng các object)**
Lập trình hướng đối tượng (OOP) là một phương pháp lập trình dựa trên khái niệm về "đối tượng" và "lớp".
* **Lớp (Class):** Là một bản thiết kế hoặc khuôn mẫu để tạo ra các đối tượng.
* **Đối tượng (Object):** Là một thể hiện của một lớp, có các thuộc tính (dữ liệu) và phương thức (hành vi) riêng.
**Ví dụ:**
```python
class XeHoi:
def __init__(self, hang, mau):
self.hang = hang
self.mau = mau
def chay(self):
print(f"Xe {self.hang} màu {self.mau} đang chạy.")
xe1 = XeHoi("Toyota", "Đỏ")
xe1.chay()
```
#### **1.0: Thế nào là constructor, get/set**
* **Constructor (`__init__`)**: Là một phương thức đặc biệt được gọi khi một đối tượng mới được tạo. Nó dùng để khởi tạo các thuộc tính của đối tượng.
* **Getter/Setter**: Là các phương thức dùng để lấy (get) và thiết lập (set) giá trị cho các thuộc tính của đối tượng, giúp kiểm soát việc truy cập dữ liệu.
#### **1.1: Đa hình**
**Đa hình (Polymorphism)** cho phép các đối tượng của các lớp khác nhau phản ứng với cùng một phương thức theo cách riêng của chúng.
**Ví dụ:**
```python
class Cho:
def keu(self):
return "Gâu gâu"
class Meo:
def keu(self):
return "Meo meo"
# ...
```
#### **1.2: Thừa kế**
**Thừa kế (Inheritance)** cho phép một lớp (lớp con) kế thừa các thuộc tính và phương thức từ một lớp khác (lớp cha). Điều này giúp tái sử dụng mã.
**Ví dụ:**
```python
class DongVat:
def an(self):
print("Đang ăn...")
class Cho(DongVat):
def sua(self):
print("Gâu gâu")
con_cho = Cho()
con_cho.an() # Kế thừa từ lớp DongVat
con_cho.sua()
```
#### **1.3: Trừu tượng**
**Trừu tượng (Abstraction)** là việc ẩn đi các chi tiết triển khai phức tạp và chỉ hiển thị các chức năng cần thiết cho người dùng.
**Ví dụ:**
Trong Python, có thể sử dụng các lớp cơ sở trừu tượng (Abstract Base Classes) để định nghĩa các phương thức mà các lớp con phải triển khai.
#### **1.4: Đóng gói**
**Đóng gói (Encapsulation)** là việc gộp dữ liệu (thuộc tính) và các phương thức xử lý dữ liệu đó vào trong một đối tượng duy nhất. Nó giúp che giấu thông tin và bảo vệ dữ liệu khỏi sự truy cập không mong muốn từ bên ngoài.
### **13. Xử lý Exception trong python như thế nào?**
Sử dụng khối `try-except` để bắt và xử lý các lỗi (exception) có thể xảy ra trong chương trình.
**Ví dụ:**
```python
try:
ket_qua = 10 / 0
except ZeroDivisionError:
print("Lỗi: Không thể chia cho 0.")
```
### **14. Vẽ đồ thị bar/line … như thế nào? (matplotlib)**
Thư viện `matplotlib` được sử dụng phổ biến để vẽ đồ thị trong Python.
**Ví dụ vẽ đồ thị đường (line):**
```python
import matplotlib.pyplot as plt
x = [1, 2, 3, 4]
y = [2, 4, 1, 5]
plt.plot(x, y)
plt.xlabel("Trục X")
plt.ylabel("Trục Y")
plt.title("Đồ thị đường đơn giản")
plt.show()
```
### **15. Serialize/Deserialize Object như thế nào?**
**Serialize** (còn gọi là "pickling") là quá trình chuyển đổi một đối tượng Python thành một chuỗi byte. **Deserialize** ("unpickling") là quá trình ngược lại. Thư viện `pickle` được dùng cho việc này.
**Ví dụ:**
```python
import pickle
du_lieu = {"a": 1, "b": 2}
# Serialize
with open("data.pickle", "wb") as f:
pickle.dump(du_lieu, f)
# Deserialize
with open("data.pickle", "rb") as f:
du_lieu_moi = pickle.load(f)
print(du_lieu_moi)
```
### **16. Thao tác cả các file như thế nào?**
Python cung cấp các hàm để mở, đọc, ghi và đóng file.
**Ví dụ:**
```python
# Ghi file
with open("vidu.txt", "w") as f:
f.write("Xin chào Python!")
# Đọc file
with open("vidu.txt", "r") as f:
noi_dung = f.read()
print(noi_dung)
```
### **17. Multi Threading trong Python như thế nào?**
**Multi-threading** cho phép chương trình của bạn thực thi nhiều tác vụ (thread) cùng một lúc, cải thiện hiệu năng đối với các tác vụ liên quan đến I/O (vào/ra).
**Ví dụ:**
```python
import threading
def in_so():
for i in range(5):
print(i)
thread1 = threading.Thread(target=in_so)
thread2 = threading.Thread(target=in_so)
thread1.start()
thread2.start()
thread1.join()
thread2.join()
```
### **18. Kết nối cơ sở dữ liệu (Mysql) như thế nào?**
Để kết nối với MySQL, bạn cần cài đặt một thư viện kết nối như `mysql-connector-python`.
**Các bước cơ bản:**
1. Import thư viện.
2. Tạo kết nối đến cơ sở dữ liệu.
3. Tạo một đối tượng con trỏ (cursor).
4. Thực thi các câu lệnh SQL.
**Ví dụ:**
```python
import mysql.connector
db = mysql.connector.connect(
host="localhost",
user="yourusername",
password="yourpassword"
)
print(db)
```
### **19. Framework : FastApi, Django ?**
* **Django:** Là một framework web Python cấp cao, mạnh mẽ, khuyến khích phát triển nhanh chóng và thiết kế thực tế. Nó đi kèm với nhiều tính năng tích hợp sẵn như ORM (Object-Relational Mapping), trang quản trị, xác thực người dùng, và bảo mật. Django phù hợp cho các dự án lớn và phức tạp.
* **FastAPI:** Là một framework web hiện đại, hiệu suất cao để xây dựng các API (Giao diện lập trình ứng dụng). Nó nổi bật với tốc độ nhanh, khả năng tự động tạo tài liệu API và dễ sử dụng. FastAPI là lựa chọn tốt để xây dựng các microservices và các ứng dụng đòi hỏi hiệu năng cao.
Sign in with Wallet
Connect another wallet