Cara Cepat Membina API dalam Python

API ialah tulang belakang kebanyakan aplikasi yang bergantung pada pertukaran data atau penyepaduan luaran.

Belajar membina API dalam Python boleh membuka banyak peluang untuk menyambungkan apl anda dengan sistem lain dan membuat bahagian belakang yang serba boleh.

Di sini, saya akan membimbing anda melalui asas API, mencipta API REST dan membinanya dengan Flask dan FastAPI—dua rangka kerja Python yang popular.

1. Pengenalan kepada API

Dalam dunia digital hari ini, API ada di mana-mana sahaja.

Mereka membenarkan sistem dan aplikasi yang berbeza untuk bercakap antara satu sama lain, berkongsi data dan fungsi dengan lancar.

Sebagai contoh, apabila anda menggunakan apl untuk menyemak cuaca, ia sebenarnya memanggil API yang mengembalikan data cuaca.

API menjadikan kehidupan lebih mudah dengan bertindak sebagai perantara yang memproses permintaan dan mengembalikan data dengan cara yang standard.

Perlu juga diperhatikan bahawa API bukan sahaja menyediakan aplikasi pelanggan (seperti tapak web atau apl mudah alih).

API boleh digunakan antara sistem hujung belakang atau perkhidmatan mikro dalam infrastruktur yang sama untuk mengurus data dengan lebih cekap.

2. REST API

REST (Pemindahan Negeri Perwakilan) ialah salah satu cara paling popular untuk mencipta API kerana kesederhanaan dan keserasiannya dengan HTTP.

API RESTful distrukturkan untuk membenarkan kaedah HTTP standard (seperti GET, POST, PUT, DELETE) untuk memanipulasi sumber.

Mereka sering digunakan untuk mengurus operasi CRUD (Buat, Baca, Kemas Kini dan Padam), di mana setiap kaedah permintaan melakukan operasi pada data sumber.

Jika anda sedang membina perkhidmatan web, REST berkemungkinan format yang paling mudah didekati dan disokong secara meluas untuk bermula.

API REST juga tidak mempunyai kewarganegaraan, yang bermaksud setiap permintaan beroperasi secara bebas, membolehkan API REST berskala dengan lebih mudah.

3. Membina API dengan Flask

Kelalang adalah pilihan saya untuk projek bersaiz kecil atau sederhana, kerana ia ringan dan mudah untuk bangun dan dijalankan.

Kelalang membolehkan anda mengawal hampir setiap aspek API anda, tetapi ia juga memerlukan lebih sedikit kerja pada pengesahan data dan pengendalian ralat.

Fleksibiliti ini, bagaimanapun, sesuai untuk mereka yang mahukan lebih kawalan ke atas cara setiap bahagian API berfungsi.

Contoh Mencipta API Flask

Begini cara API pengurusan tugas boleh kelihatan dalam Flask.

Pertama sekali, pastikan anda memasang kelalang dengan pip:

pip install flask

Contoh ini menunjukkan cara anda boleh menyediakan titik akhir dengan cepat untuk mendapatkan dan membuat tugasan, serta mengemas kini dan memadam.

from flask import Flask, jsonify, request

app = Flask(__name__)

tasks = [
    {"id": 1, "task": "Learn Flask", "done": False},
    {"id": 2, "task": "Build API", "done": False}
]

@app.route('/tasks', methods=['GET'])
def get_tasks():
    return jsonify({"tasks": tasks})

@app.route('/tasks', methods=['POST'])
def create_task():
    new_task = {
        "id": len(tasks) + 1,
        "task": request.json["task"],
        "done": False
    }
    tasks.append(new_task)
    return jsonify(new_task), 201

@app.route('/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        task.update(request.json)
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        tasks.remove(task)
        return jsonify({"message": "Task deleted"})
    return jsonify({"message": "Task not found"}), 404

if __name__ == '__main__':
    app.run(debug=True)

Kod Python ini menyediakan API REST menggunakan Flask untuk mengurus senarai tugasan, membenarkan pelanggan membuat, mendapatkan semula, mengemas kini dan memadamkan tugasan.

Tugas disimpan dalam senarai di mana setiap tugasan ialah kamus dengan id, tugas dan status selesai.

Titik akhir /tasks menyokong permintaan GET untuk mengembalikan senarai penuh tugas dan permintaan POST untuk menambah tugasan baharu, secara automatik memberikan setiap tugasan ID unik.

Titik tamat tambahan, /tasks/, membenarkan pengguna berinteraksi dengan tugasan individu: GET mendapatkan semula tugasan tertentu mengikut ID, PUT mengemas kininya dan DELETE mengalih keluarnya daripada senarai.

Jika tugasan dengan ID yang ditentukan tidak ditemui, titik akhir ini mengembalikan ralat 404 dengan mesej yang sesuai.

API berjalan dalam mod nyahpepijat, menjadikannya sesuai untuk tujuan pembangunan dan ujian.

Hanya maklum bahawa untuk projek yang lebih besar, anda mungkin perlu menambah lebih banyak mekanisme penghalaan dan pengesahan berstruktur.

4. Membina API dengan FastAPI

FastAPI ialah pilihan terbaik untuk aplikasi atau projek sensitif prestasi yang memerlukan lebih sedikit struktur dan keselamatan jenis.

FastAPI direka bentuk untuk menjadi lebih pantas secara lalai (berkat keupayaan tak segeraknya) dan menawarkan pengesahan data yang mantap di luar kotak menggunakan Pydantic.

Saya dapati FastAPI sangat intuitif dan mudah digunakan, terutamanya untuk projek yang saya perlukan keupayaan async dan mahukan pengesahan terbina dalam tanpa pakej pihak ketiga.

Selain itu, dokumentasi automatik (melalui UI Swagger) menjadikannya sangat mudah.

Contoh Mencipta API FastAPI

Begini rupa API pengurusan tugasan dalam FastAPI.

Jangan lupa pasang fastapi dan uvicorn dahulu dengan pip:

pip install flask

Kemudian anda boleh mencipta API:

from flask import Flask, jsonify, request

app = Flask(__name__)

tasks = [
    {"id": 1, "task": "Learn Flask", "done": False},
    {"id": 2, "task": "Build API", "done": False}
]

@app.route('/tasks', methods=['GET'])
def get_tasks():
    return jsonify({"tasks": tasks})

@app.route('/tasks', methods=['POST'])
def create_task():
    new_task = {
        "id": len(tasks) + 1,
        "task": request.json["task"],
        "done": False
    }
    tasks.append(new_task)
    return jsonify(new_task), 201

@app.route('/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        task.update(request.json)
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        tasks.remove(task)
        return jsonify({"message": "Task deleted"})
    return jsonify({"message": "Task not found"}), 404

if __name__ == '__main__':
    app.run(debug=True)

Kod Python ini mencipta API pengurusan tugas menggunakan FastAPI, memanfaatkan model Pydantic untuk pengesahan data dan penguatkuasaan jenis.

Ia mentakrifkan model Tugasan dengan id, tugasan dan status selesai serta memulakan senarai tugasan.

API termasuk titik akhir untuk melaksanakan operasi CRUD pada tugasan: titik akhir /tasks membenarkan permintaan GET untuk mendapatkan semula senarai tugas dan permintaan POST untuk menambah tugasan baharu, mengesahkan data masuk secara automatik.

Titik akhir /tasks/{task_id} membenarkan pengambilan tugasan khusus dengan GET, mengemas kini dengan PUT dan pemadaman dengan DELETE, mengembalikan ralat 404 jika tugasan dengan id yang ditentukan tidak ditemui.

Keupayaan asynchronous FastAPI dan dokumentasi bersepadu menjadikan API ini cekap dan mudah diuji, sesuai untuk pembangunan pesat.

5. Menguji API

Ujian adalah kritikal, terutamanya apabila mencipta API yang akan digunakan oleh aplikasi lain.

Flask dan FastAPI menyediakan sokongan yang sangat baik untuk ujian unit, menjadikannya mudah untuk mengesahkan setiap gelagat titik akhir.

Untuk memudahkan ujian, saya syorkan menggunakan pytest untuk struktur ujian umum, kerana ia serasi dengan Flask dan FastAPI.

Untuk FastAPI khususnya, TestClient ialah alat yang berguna untuk mengejek permintaan HTTP dan menyemak respons.

Anda perlu memasang httpx dengan pip:

pip install flask

Berikut ialah contoh untuk menguji titik akhir FastAPI:

from flask import Flask, jsonify, request

app = Flask(__name__)

tasks = [
    {"id": 1, "task": "Learn Flask", "done": False},
    {"id": 2, "task": "Build API", "done": False}
]

@app.route('/tasks', methods=['GET'])
def get_tasks():
    return jsonify({"tasks": tasks})

@app.route('/tasks', methods=['POST'])
def create_task():
    new_task = {
        "id": len(tasks) + 1,
        "task": request.json["task"],
        "done": False
    }
    tasks.append(new_task)
    return jsonify(new_task), 201

@app.route('/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        task.update(request.json)
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        tasks.remove(task)
        return jsonify({"message": "Task deleted"})
    return jsonify({"message": "Task not found"}), 404

if __name__ == '__main__':
    app.run(debug=True)

Dengan kedua-dua rangka kerja, ujian adalah mudah dan membolehkan anda mengesahkan bahawa API anda berkelakuan seperti yang diharapkan, terutamanya apabila ia berkembang.

6. Perbandingan Antara Flask dan FastAPI

Mari kita lihat perbandingan antara Flask dan FastAPI

Jika anda sedang mengusahakan prototaip pantas atau projek yang lebih kecil, kesederhanaan Flask mungkin semua yang anda perlukan.

Untuk projek yang memerlukan keselarasan tinggi, pengesahan data atau autodokumentasi, FastAPI menyediakan persekitaran yang lebih berkuasa dan kaya dengan ciri.

7. Kesimpulan

Kedua-dua Flask dan FastAPI mempunyai kekuatan yang menjadikannya sesuai untuk pelbagai jenis projek.

Jika anda baru dalam pembangunan web Python, bermula dengan Flask boleh membantu anda memahami asas sebelum beralih kepada sesuatu yang lebih maju.

FastAPI, sebaliknya, ialah pilihan yang ideal jika anda mencari pembangunan API moden yang berprestasi tinggi dengan pengesahan dan dokumentasi terbina dalam.

Tidak kira yang anda pilih, Python menawarkan ekosistem yang teguh untuk pembangunan API.

Kedua-dua rangka kerja akan membolehkan anda mencipta API yang boleh menggerakkan aplikasi yang pelbagai, daripada tapak web ringkas kepada perkhidmatan mikro yang kompleks.

Kuncinya ialah mencuba, memahami setiap kekuatan rangka kerja dan memilih alat yang sesuai untuk keperluan anda.

Atas ialah kandungan terperinci Cara Cepat Membina API dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!