最終篇

第 26 天 - 網路 Python
- 26.1網頁版 Python
- 26.2Flask
- - 檔案夾結構
- 26.3設定你的專案目錄
- 26.4創建路由
- 26.5創建模板
- 26.6Python腳本
- 26.7導航
- 26.8創建布局
- - 提供靜態檔案
- 26.9部署
第 27 天 - Python 與 MongoDB
- 27.1MongoDB
- 27.2獲取連接字串（MongoDB URI）
- 27.3將 Flask 應用程式連接到 MongoDB 集群
- 27.3創建資料庫和集合
- 27.4將許多檔案插入到集合中
- 27.5MongoDB 查找
- 27.6用查詢查找
- 27.7使用修飾符查找查詢
- 27.8限制檔案
- 27.9排序查找
- 27.10使用查詢更新
- 27.11洗掉檔案
- 27.12洗掉一個集合
第 28 天 - API
- 28.1應用程式編程介面（API）
- 28.2構建API
- 28.3HTTP（超文本傳輸??協議）
- 28.4HTTP的結構
- 28.5初始請求行（狀態行）
- 28.6初始回應線（狀態線）
- 28.7標題欄位
- 28.8訊息體
- 28.9請求方法
第 29 天 - 構建 API
- 29.1API的結構
- 29.2使用 get 檢索資料
讓我們匯入Flask
- 29.3通過 id 獲取檔案
- 29.4使用 POST 創建資料
- 29.4使用 PUT 更新
- 29.5使用 Delete 洗掉檔案
第 30 天-結論

挑戰學習Python編程30天最終篇，要結束了，后面還會持續更新其他方面，關注我

你們的三連(點贊，收藏，評論)是我持續輸出的動力，感謝，
在興趣中學習，效益超乎想象，有趣的原始碼與學習經驗，工具安裝包，歡迎加我的微信：bobin1124，一起交流學習與分享，

第 26 天 - 網路 Python

26.1網頁版 Python

Python 是一種通用編程語言，可用于許多地方，在本節中，我們將了解如何在 Web 上使用 Python，Python 網頁框架作品很多，Django 和 Flask 是最受歡迎的，今天，我們將看到如何使用 Flask 進行 Web 開發，

26.2Flask

Flask 是一個用 Python 撰寫的 Web 開發框架，Flask 使用 Jinja2 模板引擎，Flask 也可以與其他現代前端庫一起使用，例如 React，

如果您還沒有安裝 virtualenv 包，請先安裝它，虛擬環境將允許將專案依賴項與本地機器依賴項隔離開來，

檔案夾結構

完成所有步驟后，您的專案檔案結構應如下所示：

├── 組態檔
├── app.py
├──環境
│ ├── bin
├──需求.txt
├── 靜態
│ └── css
│ └── main.css
└── 模板
    ├── about.html
    ├── home.html
    ├── layout.html
    ├── post.html
    └── 結果.html

26.3設定你的專案目錄

按照以下步驟開始使用 Flask，

步驟 1：使用以下命令安裝 virtualenv，

pip 安裝 virtualenv

第2步：

asabeneh@Asabeneh:~/Desktop$ mkdir python_for_web
asabeneh@Asabeneh:~/Desktop$ cd python_for_web/
asabeneh@Asabeneh:~/Desktop/python_for_web$ virtualenv venv
asabeneh@Asabeneh:~/Desktop/python_for_web$ source venv/bin/activate
(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ pip freeze
(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ pip install Flask
(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ pip freeze
Click==7.0
Flask==1.1.1
itsdangerous==1.1.0
Jinja2==2.10.3
MarkupSafe==1.1.1
Werkzeug==0.16.0
(env) asabeneh@Asabeneh:~/Desktop/python_for_web$

我們創建了一個名為 python_for_web 的專案主管，在專案中，我們創建了一個虛擬環境venv，它可以是任何名稱，但我更喜歡稱之為venv，然后我們激活了虛擬環境，我們使用 pip freeze 檢查專案目錄中已安裝的包，pip freeze 的結果是空的，因為一個包還沒有安裝，

現在，讓我們在專案目錄中創建 app.py 檔案并撰寫以下代碼，app.py 檔案將是專案中的主檔案，下面的代碼有flask模塊，os模塊，

26.4創建路由

回家路線，

#讓我們
從 flask 匯入 flask import Flask 
import  os  #匯入作業系統模塊

app  =  Flask ( __name__ )

@app.route('/') # 這個裝飾器創建 home 路由
def  home ():
     return  '<h1>Welcome</h1>'

@app.route('/about')
def  about ():
     return  '<h1>About us</h1>'


如果 __name__  ==  '__main__' ：
#部署，我們使用ENVIRON 
#使之成為生產和開發作業
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

要運行flask 應用程式，請在主flask 應用程式目錄中撰寫python app.py，

運行python app.py 后，檢查本地主機 5000，

讓我們添加額外的路線，創建關于路由

#讓我們
從 flask 匯入 flask import Flask 
import  os  #匯入作業系統模塊

app  =  Flask ( __name__ )

@app.route('/') # 這個裝飾器創建 home 路由
def  home ():
     return  '<h1>Welcome</h1>'

@app.route('/about')
def  about ():
     return  '<h1>About us</h1>'

如果 __name__  ==  '__main__' ：
#部署，我們使用ENVIRON 
#使之成為生產和開發作業
  port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

現在，我們在上面的代碼中添加了 about 路由，如果我們想渲染一個 HTML 檔案而不是字串呢？可以使用函式render_templae渲染 HTML 檔案，讓我們創建一個名為 templates 的檔案夾，并在專案目錄中創建 home.html 和 about.html，讓我們也從flask匯入render_template函式，

26.5創建模板

在模板檔案夾中創建 HTML 檔案，

主頁.html

<!DOCTYPE html >
 < html  lang =" en " > 
  < head > 
    < meta  charset =" UTF-8 " />
     <元 名稱="viewport" content =" width=device-width, initial-scale=1.0 " / >
     < title >首頁</ title > 
  </ head >

  < body > 
    < h1 >Welcome Home</ h1 > 
  </ body > 
</ html >

關于.html

<!DOCTYPE html >
 < html  lang =" en " > 
  < head > 
    < meta  charset =" UTF-8 " />
     <元 名稱="viewport" content =" width=device-width, initial-scale=1.0 " / >
     < title >關于</ title > 
  </ head >

  < body > 
    < h1 >關于我們</ h1 > 
  </ body > 
</ html >

26.6Python腳本

app.py

# 讓我們
從 flask 匯入 flask import Flask , render_template 
import  os  # 匯入作業系統模塊

app  =  Flask ( __name__ )

@app.route('/')  # 這個裝飾器創建 home 路由
def  home ():
     return  render_template ( 'home.html' )

@app.route（'/about'）
def  about（）：
    回傳 render_template（'about.html'）

如果 __name__  ==  '__main__' ：
#部署，我們使用ENVIRON 
#使之成為生產和開發作業
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

如您所見，要轉到不同的頁面或導航，我們需要導航，讓我們為每個頁面添加一個鏈接，或者讓我們創建一個用于每個頁面的布局，

26.7導航

<ul>
  <li><a href="/">Home</a></li>
  <li><a href="/about">About</a></li>
</ul>

現在，我們可以使用上面的鏈接在頁面之間導航，讓我們創建處理表單資料的附加頁面，你可以叫它任何名字，我喜歡叫它 post.html，

我們可以使用 Jinja2 模板引擎將資料注入到 HTML 檔案中，

# 讓我們
從 flask 匯入 flask import Flask , render_template , request , redirect , url_for 
import  os  # 匯入作業系統模塊

app  =  Flask ( __name__ )

@app.route ( '/' ) # 這個裝飾器創建 home 路由
def  home ():
     techs  = [ 'HTML' , 'CSS' , 'Flask' , 'Python' ]
     name  =  '30 Days Of Python Programming' 
    return  render_template ( ' home.html' , techs = techs , name  =  name , title  =  'Home' )

@app.route( '/about' ) 
def  about ():
     name  =  '30 Days Of Python Programming' 
    return  render_template ( 'about.html' , name  =  name , title  =  'About Us' )

@app.route( '/post' ) 
def  post ():
     name  =  'Text Analyzer' 
    return  render_template ( 'post.html' , name  =  name , title  =  name )


如果 __name__  ==  '__main__' ：

#部署
#使之成為生產和開發作業
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

讓我們也看看模板：

主頁.html

<!DOCTYPE html >
 < html  lang =" en " > 
  < head > 
    < meta  charset =" UTF-8 " />
     <元 名稱="視口" content =" width=device-width, initial-scale=1.0 " / >
     < title >首頁</ title > 
  </ head >
<body>
    <ul>
      <li><a href="/">Home</a></li>
      <li><a href="/about">About</a></li>
    </ul>
    <h1>Welcome to {{name}}</h1>
     <ul>
    {% for tech in techs %}
      <li>{{tech}}</li>
    {% endfor %}
    </ul>
  </body>
</html>

關于.html

<!DOCTYPE html >
 < html  lang =" en " > 
  < head > 
    < meta  charset =" UTF-8 " />
     <元 名稱="視口" content =" width=device-width, initial-scale=1.0 " / >
     < title >關于我們</ title > 
  </ head >

  <body>
    <ul>
      <li><a href="/">Home</a></li>
      <li><a href="/about">About</a></li>
    </ul>
    <h1>About Us</h1>
    <h2>{{name}}</h2>
  </body>
</html>

26.8創建布局

在模板檔案中，有很多重復的代碼，我們可以寫一個布局，我們可以洗掉重復，讓我們在模板檔案夾中創建 layout.html，創建布局后，我們將匯入到每個檔案中，

提供靜態檔案

在您的專案目錄中創建一個靜態檔案夾，在靜態檔案夾中創建 CSS 或樣式檔案夾并創建一個 CSS 樣式表，我們使用url_for模塊來提供靜態檔案，

布局.html

<!DOCTYPE html >
 < html  lang =" en " > 
  < head > 
    < meta  charset =" UTF-8 " />
     <元 名稱="視口" content =" width=device-width, initial-scale=1.0 " / >
     < link 
      href =" https://fonts.googleapis.com/css?family=Lato:300,400|Nunito:300,400|Raleway:300,400,500&display=swap "
       rel ="樣式表"
    />
    < link 
      rel ="樣式表"
       href =" {{url_for('static', filename='css/main.css') }} "
    />
     {% if title %}
    <title>30 Days of Python - {{ title}}</title>
    {% else %}
    <title>30 Days of Python</title>
    {% endif %}
 </head>

  <body>
    <header>
      <div class="menu-container">
        <div>
          <a class="brand-name nav-link" href="/">30DaysOfPython</a>
        </div>
        <ul class="nav-lists">
          <li class="nav-list">
            <a class="nav-link active" href="{{ url_for('home') }}">Home</a>
          </li>
          <li class="nav-list">
            <a class="nav-link active" href="{{ url_for('about') }}">About</a>
          </li>
          <li class="nav-list">
            <a class="nav-link active" href="{{ url_for('post') }}"
              >Text Analyzer</a
            >
          </li>
        </ul>
      </div>
    </header>
    <main>
      {% block content %} {% endblock %}
    </main>
  </body>
</html>

現在，讓我們洗掉其他模板檔案中的所有重復代碼并匯入 layout.html，href 使用url_for函式和路由函式的名稱來連接每個導航路由，

主頁.html

{% extends 'layout.html' %} {% block content %}
<div class="container">
  <h1>Welcome to {{name}}</h1>
  <p>
    此應用程式清理文本并分析單詞、字符和
    文本中出現頻率最高的詞，通過單擊文本分析器檢查它
    選單，您需要以下技術來構建此 Web 應用程式：
  </ p > 
  <ul class="tech-lists">
    {% for tech in techs %}
    <li class="tech">{{tech}}</li>

    {% endfor %}
  </ul>
</div>

{% endblock %}

關于.html

{% extends 'layout.html' %} {% block content %}
 < div  class =" container " > 
  < h1 >關于{{name}} </ h1 > 
  < p >
    這是 30 天的 Python 編程挑戰，如果你一直在編碼
    到目前為止，你太棒了，祝賀你的作業做得好！
  </ p > 
</ div > 
{% endblock %}

后.html

{% extends 'layout.html' %} {% block content %}
 < div  class =" container " > 
  < h1 >文本分析器</ h1 > 
  < form  action =" https://thirtydaysofpython-v1.herokuapp.com/post" method="POST"> 
    < DIV > 
      < textarea的 行=” 25 “名稱=”內容“的自動對焦> </ textarea的> 
    </ div > 
    <div > 
      < input  type =" submit " class =" btn " value ="處理文本"/>
     </ div > 
  </ form > 
</ div >

{% 結束塊 %}

請求方法，有不同的請求方法（GET、POST、PUT、DELETE）是常見的請求方法，它們允許我們進行 CRUD（創建、讀取、更新、洗掉）操作，

在帖子中，我們將根據請求的型別使用 GET 和 POST 方法替代，請查看下面代碼中的外觀，請求方法是處理請求方法和訪問表單資料的函式，應用程式

# 讓我們
從 flask 匯入 flask import Flask , render_template , request , redirect , url_for 
import  os  # 匯入作業系統模塊

app  =  Flask ( __name__ )
 # 停止快取靜態檔案
app . 配置[ 'SEND_FILE_MAX_AGE_DEFAULT' ] =  0



@app.route ( '/' ) # 這個裝飾器創建 home 路由
def  home ():
     techs  = [ 'HTML' , 'CSS' , 'Flask' , 'Python' ]
     name  =  '30 Days Of Python Programming' 
    return  render_template ( ' home.html' , techs = techs , name  =  name , title  =  'Home' )

@app.route ( '/about' ) 
def  about ():
     name  =  '30 Days Of Python Programming' 
    return  render_template ( 'about.html' , name  =  name , title  =  'About Us' )

@app.route（'/result'）
def  result（）：
    回傳 render_template（'result.html'）

@app.route ( '/post' , methods = [ 'GET' , 'POST' ]) 
def  post ():
     name  =  'Text Analyzer' 
    if  request，method  ==  'GET' :
         如果request，則回傳 render_template ( 'post.html' , name  =  name , title  =  name )
    if request.method =='POST':
        content = request.form['content']
        print(content)
        return redirect(url_for('result'))

如果 __name__  ==  '__main__' ：
# 部署
#使之成為生產和開發作業
   port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

到目前為止，我們已經看到了如何使用模板以及如何向模板注入資料，如何進行通用布局，現在，讓我們處理靜態檔案，在project Director中創建一個名為static的檔案夾，并創建一個名為css的檔案夾，在 css 檔案夾中創建 main.css，你的主要，css 檔案將鏈接到 layout.html，

您不必撰寫css檔案，復制并使用它，讓我們繼續進行部署，

26.9部署

創建 Heroku 帳戶
Heroku 為前端和全堆疊應用程式提供免費部署服務，在heroku上創建一個帳戶并為您的機器安裝 heroku CLI，安裝heroku后寫下以下命令

登錄 Heroku

asabeneh@Asabeneh: ~ $ heroku 登錄
heroku：按任意鍵打開瀏覽器登錄或 q 退出：

讓我們通過單擊鍵盤上的任意鍵來查看結果，當您按鍵盤上的任意鍵時，它將打開 heroku 登錄頁面并單擊登錄頁面，然后你將本地機器連接到遠程 heroku 服務器，如果你連接到遠程服務器，你會看到這個，

asabeneh@Asabeneh: ~ $ heroku 登錄
heroku：按任意鍵打開瀏覽器登錄或 q 退出：
打開瀏覽器到 https://cli-auth.heroku.com/auth/browser/be12987c-583a-4458-a2c2-ba2ce7f41610
登錄...進行
已記錄在為asabeneh@gmail.com
asabeneh@Asabeneh：~ $

創建需求和Procfile
在我們將代碼推送到遠程服務器之前，我們需要一些要求

要求.txt
組態檔

(env) asabeneh@Asabeneh: ~ /Desktop/python_for_web$ pip freeze
Click==7.0
Flask==1.1.1
itsdangerous==1.1.0
Jinja2==2.10.3
MarkupSafe==1.1.1
Werkzeug==0.16.0
(env) asabeneh@Asabeneh: ~ /Desktop/python_for_web$ touch requirements.txt
(env) asabeneh@Asabeneh: ~ /Desktop/python_for_web$ pip freeze > requirements.txt
(env) asabeneh@Asabeneh: ~ /Desktop/python_for_web$ cat requirements.txt
Click==7.0
Flask==1.1.1
itsdangerous==1.1.0
Jinja2==2.10.3
MarkupSafe==1.1.1
Werkzeug==0.16.0
(env) asabeneh@Asabeneh: ~ /Desktop/python_for_web$ touch Procfile
(env) asabeneh @ Asabeneh: ~ / Desktop / python_for_web $ ls
Procfile 環境/靜態/
app.py requirements.txt 模板/
(env) asabeneh@Asabeneh: ~ /Desktop/python_for_web$

Procfile 將具有在我們的 Heroku 上的示例中在 Web 服務器中運行應用程式的命令，

網路：python app.py

將專案推送到heroku
現在，它已準備好部署，在 heroku 上部署應用程式的步驟

混帳初始化
git 添加，
git commit -m “提交訊息”
heroku 創建“應用程式名稱作為一個詞”
git push heroku master
heroku open（啟動部署的應用程式）

這個步驟后，你會得到這樣一個應用程式
在這里插入圖片描述

第 27 天 - Python 與 MongoDB

Python 是一種后端技術，它可以連接不同的資料庫應用程式，它可以連接到 SQL 和 noSQL 資料庫，在本節中，我們將 Python 與 MongoDB 資料庫（noSQL 資料庫）連接起來，

27.1MongoDB

MongoDB 是一個 NoSQL 資料庫，MongoDB 將資料存盤在類似 JSON 的檔案中，這使 MongoDB 非常靈活和可擴展，讓我們看看 SQL 和 NoSQL 資料庫的不同術語，下表將區分 SQL 與 NoSQL 資料庫，

SQL 與 NoSQL
在這里插入圖片描述

在本節中，我們將重點介紹 NoSQL 資料庫 MongoDB，讓我們通過單擊登錄按鈕在mongoDB上注冊，然后單擊下一頁上的注冊，

在這里插入圖片描述

填寫欄位并單擊繼續

在這里插入圖片描述

選擇免費計劃

在這里插入圖片描述

選擇最接近的空閑區域并為您的集群指定任何名稱，

在這里插入圖片描述

現在，創建了一個免費的沙箱

在這里插入圖片描述

所有本地主機訪問

在這里插入圖片描述

添加用戶和密碼

在這里插入圖片描述

創建一個 mongoDB uri 鏈接

在這里插入圖片描述

選擇 Python 3.6 或以上驅動

在這里插入圖片描述

27.2獲取連接字串（MongoDB URI）

復制連接字串鏈接，你會得到這樣的東西

mongodb+srv://asabeneh: <密碼> @30daysofpython-twxkr.mongodb.net/test ? retryWrites=true & w=majority

不要擔心 url，它是將您的應用程式與 mongoDB 連接的一種方式，讓我們用您用來添加用戶的密碼替換密碼占位符，

例子：

mongodb+srv://asabeneh:123123123@30daysofpython-twxkr.mongodb.net/test ? retryWrites=true & w=majority

現在，我替換了所有內容，密碼為 123123，資料庫名稱為三十天_python，這只是一個例子，你的密碼必須比這強一點，

Python 需要一個 mongoDB 驅動程式來訪問 mongoDB 資料庫，我們將使用pymongo和dnspython將我們的應用程式與 mongoDB base 連接起來，在您的專案目錄中安裝 pymongo 和 dnspython，

pip 安裝 pymongo dnspython

必須安裝“dnspython”模塊才能使用 mongodb+srv:// URI，dnspython 是 Python 的 DNS 工具包，它支持幾乎所有的記錄型別，

27.3將 Flask 應用程式連接到 MongoDB 集群

# 匯入flask 
from  flask  import  Flask , render_template 
import  os  # 匯入作業系統模塊
MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' 
client  =  py . MongoClient（MONGODB_URI）
print(client.list_database_names())

print(client.list_database_names())
#部署，我們使用ENVIRON 
#使之成為生產和開發作業
   port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

當我們運行上面的代碼時，我們得到了默認的 mongoDB 資料庫，

['admin', 'local']

27.3創建資料庫和集合

讓我們創建一個資料庫，如果 mongoDB 中的資料庫和集合不存在，則會創建它，讓我們創建一個資料庫名稱三十天_of_python和學生集合，創建資料庫

db = client.name_of_databse #我們可以像這樣或第二種方式創建資料庫
db = client[ ' name_of_database ' ]

# 匯入flask 
from  flask  import  Flask , render_template 
import  os  # 匯入作業系統模塊
MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' 
client  =  py . MongoClient ( MONGODB_URI )
 # 創建資料庫
db  =  client . 30_days_of_python 
# 創建學生集合并插入檔案
db.students.insert_one ({ '姓名'：'Asabeneh' ，'國家'：'芬蘭'，'城市'：'赫爾辛基'，'時代'：250 }）
print(client.list_database_names())

app = Flask(__name__)
if __name__ == '__main__':
#部署，我們使用ENVIRON 
#使之成為生產和開發作業
   port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

創建資料庫后，我們還創建了一個學生集合，并使用insert_one()方法插入檔案，現在，資料庫三十天_of_python和學生集合已創建，檔案已插入，檢查您的 mongoDB 集群，您將看到資料庫和集合，在集合內部，會有一個檔案，

[ ['thirty_days_of_python', 'admin', 'local'] ]

如果你在 mongoDB 集群上看到這個，說明你已經成功創建了一個資料庫和一個集合，

在這里插入圖片描述

如果您在圖中看到，該檔案已經創建了一個長 id 作為主鍵，每次我們創建一個檔案 mongoDB 都會為它創建一個唯一的 id，

27.4將許多檔案插入到集合中

該insert_one（）方法一次插入一個專案，如果我們想在任何一次我們使用插入許多檔案insert_many（）方法或回圈，我們可以使用 for 回圈一次插入多個檔案，

# 匯入flask 
from  flask  import  Flask , render_template 
import  os  # 匯入作業系統模塊
MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' 
client  =  py . MongoClient ( MONGODB_URI )

學生 = [
        { 'name' : 'David' , 'country' : 'UK' , 'city' : 'London' , 'age' : 34 },
        { 'name' : 'John' , 'country' : '瑞典' , 'city' : 'Stockholm' , 'age' : 28 },
        { 'name' : 'Sami' , 'country' : 'Finland' , 'city' : 'Helsinki' , 'age' : 25 },
    ]
for student in students:
    db.students.insert_one(student)


app = Flask(__name__)
if __name__ == '__main__':
    #部署，我們使用ENVIRON 
    #使之成為生產和開發作業
   port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

27.5MongoDB 查找

該find（）方法和findOne（）方法是在MongoDB中的資料庫集合中找到資料常用的方法，它類似于 MySQL 資料庫中的 SELECT 陳述句，讓我們使用find_one()方法來獲取資料庫集合中的檔案，
1.*find_one({"_id": ObjectId(“id”})：如果沒有提供id，則獲取第一次出現

# 匯入flask 
from  flask  import  Flask , render_template 
import  os  # 匯入作業系統模塊
MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' 
client  =  py . MongoClient ( MONGODB_URI )
 db  =  client [ 'thirty_days_of_python' ] # 訪問資料庫
student = db.students.find_one()
print(student)


app = Flask(__name__)
if __name__ == '__main__':
   # 部署，我們使用ENVIRON 
   #使之成為生產和開發作業
   port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{ ' _id '：物件（' 5df68a21f106fe2d315bbc8b '），'名'：' Asabeneh '，'國'：'赫爾辛基'，'城市'：'赫爾辛基'，'年齡'：250}

上面的查詢回傳第一個條目，但我們可以使用特定的 _id 定位特定的檔案，舉個例子，用David的id來獲取David物件，’_id’:ObjectId(‘5df68a23f106fe2d315bbc8c’)

# 讓我們
從 flask  import  Flask匯入flask , render_template 
import  os  #
從 bson匯入作業系統模塊，objectid  import  ObjectId  # id 物件
MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' 
client  =  pymongo . MongoClient ( MONGODB_URI )
 db  =  client [ 'thirty_days_of_python' ] # 訪問資料庫
student = db.students.find_one({'_id':ObjectId('5df68a23f106fe2d315bbc8c')})
print(student)

app = Flask(__name__)
if __name__ == '__main__':
    #部署，我們使用ENVIRON 
    #使之成為生產和開發作業
   port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}

我們已經通過上面的例子看到了如何使用find_one()，讓我們移動一個到find()

2.find()：如果我們不傳遞查詢物件，則回傳集合中的所有出現，該物件是 pymongo.cursor 物件，

# 讓我們
從 flask 匯入 flask import Flask , render_template 
import  os  # 匯入作業系統模塊

MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
客戶端 =  pymongo，MongoClient（MONGODB_URI）
db = client['thirty_days_of_python'] # accessing the database
students = db.students.find()
for student in students:
    print(student)

app = Flask(__name__)
if __name__ == '__main__':
    # for deployment we use the environ
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}
{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}
{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

我們可以通過在find({}, {}) 中傳遞第二個物件來指定要回傳的欄位，0 表示不包含，1 表示包含但我們不能混合 0 和 1，除了 _id，

# 讓我們
從 flask 匯入 flask import Flask , render_template 
import  os  # 匯入作業系統模塊

MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
客戶端 =  pymongo，MongoClient（MONGODB_URI）
db = client['thirty_days_of_python'] # accessing the database
students = db.students.find({}, {"_id":0,  "name": 1, "country":1}) # 0 means not include and 1 means include
for student in students:
    print(student)

app = Flask(__name__)
if __name__ == '__main__':
    # for deployment we use the environ
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'name': 'Asabeneh', 'country': 'Finland'}
{'name': 'David', 'country': 'UK'}
{'name': 'John', 'country': 'Sweden'}
{'name': 'Sami', 'country': 'Finland'}

27.6用查詢查找

在 mongoDB 中找到一個查詢物件，我們可以傳遞一個查詢物件，我們可以過濾我們想要過濾掉的檔案，

# let's import the flask
from flask import Flask, render_template
import os # importing operating system module

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # accessing the database

query = {
    "country":"Finland"
}
students = db.students.find(query)

for student in students:
    print(student)


app = Flask(__name__)
if __name__ == '__main__':
    # for deployment we use the environ
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

 # 匯入作業系統模塊

MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
客戶端 =  pymongo，MongoClient ( MONGODB_URI )
 db  =  client [ 'thirty_days_of_python' ] # 訪問資料庫

query = {
    "country":"Finland"
}
students = db.students.find(query)

for student in students:
    print(student)


app = Flask(__name__)
if __name__ == '__main__':
    # for deployment we use the environ
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

使用修飾符查詢

# 讓我們
從 Flask  匯入Flask import Flask , render_template 
import  os  # 匯入作業系統模塊
import  pymongo

MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
客戶端 =  pymongo，MongoClient ( MONGODB_URI )
db = client['thirty_days_of_python'] # accessing the database

query = {
    "city":"Helsinki"
}
students = db.students.find(query)
for student in students:
    print(student)


app = Flask(__name__)
if __name__ == '__main__':
    # for deployment we use the environ
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

27.7使用修飾符查找查詢

# 讓我們
從  Flask 匯入 Flask import Flask , render_template 
import  os  # 匯入作業系統模塊
import  pymongo

MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
客戶端 =  pymongo，MongoClient ( MONGODB_URI )
db = client['thirty_days_of_python'] # accessing the database
query = {
    "country":"Finland",
    "city":"Helsinki"
}
students = db.students.find(query)
for student in students:
    print(student)


app = Flask(__name__)
if __name__ == '__main__':
    # for deployment we use the environ
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

使用修飾符查詢

# 讓我們
從 Flask  匯入  Flask import Flask , render_template 
import  os  # 匯入作業系統模塊
import  pymongo

MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
客戶端 =  pymongo，MongoClient（MONGODB_URI）
db = client['thirty_days_of_python'] # accessing the database
query = {"age":{"$gt":30}}
students = db.students.find(query)
for student in students:
    print(student)

app = Flask(__name__)
if __name__ == '__main__':
    # for deployment we use the environ
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}
{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}

# 讓我們
從 Flask 匯入 Flask import Flask , render_template 
import  os  # 匯入作業系統模塊
import  pymongo

MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
客戶端 =  pymongo，MongoClient（MONGODB_URI）
db = client['thirty_days_of_python'] # accessing the database
query = {"age":{"$gt":30}}
students = db.students.find(query)
for student in students:
    print(student)

{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

27.8限制檔案

我們可以使用limit()方法限制回傳的檔案數量，

# 讓我們
從 Flask  匯入 Flask  import Flask , render_template 
import  os  # 匯入作業系統模塊
import  pymongo

MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # accessing the database
db.students.find().limit(3)

27.9排序查找

默認情況下，排序按升序排列，我們可以通過添加 -1 引數將排序更改為降序，

# 讓我們
從 Flask 匯入 Flask import Flask , render_template 
import  os  # 匯入作業系統模塊
import  pymongo

MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
客戶端 =  pymongo，MongoClient（MONGODB_URI）
db = client['thirty_days_of_python'] # accessing the database
students = db.students.find().sort('name')
for student in students:
    print(student)


students = db.students.find().sort('name',-1)
for student in students:
    print(student)

students = db.students.find().sort('age')
for student in students:
    print(student)

students = db.students.find().sort('age',-1)
for student in students:
    print(student)

app = Flask(__name__)
if __name__ == '__main__':
    # for deployment we use the environ
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

升序

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}
{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}
{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

降序排列

{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}
{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28}
{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}
{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}

27.10使用查詢更新

我們將使用update_one()方法來更新一項，它需要兩個物件，一個是查詢，第二個是新物件，第一個人 Asabeneh 的年齡非常令人難以置信，讓我們更新 Asabeneh 的年齡，

# 讓我們
從 Flask 匯入 Flask import Flask , render_template 
import  os  # 匯入作業系統模塊
import  pymongo

MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
客戶端 =  pymongo，MongoClient ( MONGODB_URI )
 db  =  client [ 'thirty_days_of_python' ] # 訪問資料庫

query = {'age':250}
new_value = {'$set':{'age':38}}

db.students.update_one(query, new_value)
# lets check the result if the age is modified
for student in db.students.find():
    print(student)


app = Flask(__name__)
if __name__ == '__main__':
    # for deployment we use the environ
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 38}
{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}
{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

當我們想一次更新許多檔案時，我們使用upate_many()方法，

27.11洗掉檔案

delete_one()方法洗掉一個檔案，所述delete_one（）需要一個查詢物件引數，它只洗掉第一次出現，讓我們從集合中洗掉一個約翰，

# 讓我們
從 Flask 匯入Flask import Flask , render_template 
import  os  # 匯入作業系統模塊
import  pymongo

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # accessing the database

query = {'name':'John'}
db.students.delete_one(query)

for student in db.students.find():
    print(student)
# lets check the result if the age is modified
for student in db.students.find():
    print(student)


app = Flask(__name__)
if __name__ == '__main__':
    # for deployment we use the environ
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 38}
{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

如您所見，John 已從集合中洗掉，

當我們要洗掉很多檔案時，我們使用delete_many()方法，它需要一個查詢物件，如果我們將一個空的查詢物件傳遞給delete_many({})，它將洗掉集合中的所有檔案，

27.12洗掉一個集合

使用drop()方法，我們可以從資料庫中洗掉一個集合，

# 讓我們
從 Flask 匯入 Flask import Flask , render_template 
import  os  # 匯入作業系統模塊
import  pymongo

MONGODB_URI  =  'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
 db  =  client [ 'thirty_days_of_python' ] # 訪問資料庫
db.students.drop()

現在，我們已經從資料庫中洗掉了學生集合，
在這里插入圖片描述

第 28 天 - API

28.1應用程式編程介面（API）

API 代表應用程式編程介面，我們將在本節中介紹的 API 型別將是 Web API，Web API 是定義的介面，企業與使用其資產的應用程式之間通過該介面發生互動，這也是一種服務級別協議 (SLA)，用于指定功能提供者并為其 API 用戶公開服務路徑或 URL，

在 Web 開發的背景關系中，API 被定義為一組規范，例如超文本傳輸??協議 (HTTP) 請求訊息，以及回應訊息結構的定義，通常采用 XML 或 JavaScript 物件表示法 (JSON ）格式，

Web API 已經從基于簡單物件訪問協議 (SOAP) 的 Web 服務和面向服務的架構 (SOA) 轉向更直接的表示狀態傳輸 (REST) 樣式的 Web 資源，

社交媒體服務、網路 API 允許網路社區在社區和不同平臺之間共享內容和資料，

使用 API，在一個地方動態創建的內容可以發布并更新到網路上的多個位置，

例如，Twitter 的 REST API 允許開發人員訪問核心 Twitter 資料，搜索 API 為開發人員提供與 Twitter 搜索和趨勢資料互動的方法，

許多應用程式提供 API 端點，API 的一些示例，例如國家API、貓品種 API，

在本節中，我們將介紹一個 RESTful API，它使用 HTTP 請求方法來獲取、PUT、POST 和 DELETE 資料，

28.2構建API

RESTful API 是一種應用程式介面 (API)，它使用 HTTP 請求來獲取、PUT、POST 和 DELETE 資料，在前面的章節中，我們學習了 python、flask 和 mongoDB，我們將利用我們獲得的知識使用 Python Flask 和 mongoDB 資料庫開發 RESTful API，每個具有 CRUD（創建、讀取、更新、洗掉）操作的應用程式都有一個 API 來創建資料、獲取資料、更新資料或從資料庫中洗掉資料，

要構建 API，最好了解 HTTP 協議和 HTTP 請求和回應周期，

28.3HTTP（超文本傳輸??協議）

HTTP 是客戶端和服務器之間建立的通信協議，在這種情況下，客戶端是瀏覽器，而服務器是您訪問資料的地方，HTTP 是一種網路協議，用于傳送資源，這些資源可以是萬維網上的檔案，無論是 HTML 檔案、影像檔案、查詢結果、腳本還是其他檔案型別，

瀏覽器是 HTTP 客戶端，因為它將請求發送到 HTTP 服務器（Web 服務器），然后該服務器將回應發送回客戶端，

28.4HTTP的結構

HTTP 使用客戶端-服務器模型，HTTP 客戶端打開連接并向 HTTP 服務器發送請求訊息，HTTP 服務器回傳回應訊息，即請求的資源，當請求回應周期完成時，服務器關閉連接，
在這里插入圖片描述

請求和回應訊息的格式相似，兩種訊息都有

初始行，
零個或多個標題行，
一個空行（即 CRLF 本身），以及
可選的訊息體（例如檔案、查詢資料或查詢輸出），

讓我們通過瀏覽此站點來查看請求和回應訊息的示例：https : //thirtydaysofpython-v1-final.herokuapp.com/，此站點已部署在 Heroku 免費 dyno 上，由于請求量大，在幾個月內可能無法運行，支持這項作業使服務器一直運行，
在這里插入圖片描述

28.5初始請求行（狀態行）

初始請求行與回應不同，請求行由三個部分組成，以空格分隔：

方法名稱（GET、POST、HEAD）
請求資源的路徑，
正在使用的 HTTP 版本，例如 GET / HTTP/1.1

GET 是最常見的 HTTP，有助于獲取或讀取資源，POST 是創建資源的常見請求方法，

28.6初始回應線（狀態線）

初始回應行，稱為狀態行，也由空格分隔的三個部分組成：

HTTP版本
給出請求結果的回應狀態代碼，以及描述狀態代碼的原因，狀態行的示例是： HTTP/1.0 200 OK 或 HTTP/1.0 404 Not Found 注意：

最常見的狀態代碼是： 200 OK：請求成功，結果資源（例如檔案或腳本輸出）在訊息正文中回傳，500 服務器錯誤可以在此處找到 HTTP 狀態代碼的完整串列，也可以在這里找到，

28.7標題欄位

正如您在上面的螢屏截圖中看到的，標題行提供有關請求或回應的資訊，或者有關訊息正文中發送的物件的資訊，

GET / HTTP/1.1
Host: thirtydaysofpython-v1-final.herokuapp.com
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36
Sec-Fetch-User: ?1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: navigate
Referer: https://thirtydaysofpython-v1-final.herokuapp.com/post
Accept-Encoding: gzip, deflate, br
Accept-Language: en-GB,en;q=0.9,fi-FI;q=0.8,fi;q=0.7,en-CA;q=0.6,en-US;q=0.5,fr;q=0.4

28.8訊息體

HTTP 訊息可能在標題行之后發送了一個資料主體，在回應中，這是將請求的資源回傳給客戶端的地方（訊息正文的最常見用途），或者如果出現錯誤，則可能是解釋性文本，在請求中，這是將用戶輸入的資料或上傳的檔案發送到服務器的地方，

如果 HTTP 訊息包含正文，則訊息中通常會有描述正文的標題行，特別是，

Content-Type: 標頭給出了正文中資料的 MIME 型別（text/html、application/json、text/plain、text/css、image/gif），Content-Length: 標頭給出了正文中的位元組數，

28.9請求方法

GET、POST、PUT 和 DELETE 是我們將要實作 API 或 CRUD 操作應用程式的 HTTP 請求方法，

GET：GET 方法用于使用給定的 URI 從給定的服務器檢索和獲取資訊，使用 GET 的請求應該只檢索資料，對資料沒有其他影響，
POST：POST 請求用于創建資料并將資料發送到服務器，例如使用 HTML 表單創建新帖子、檔案上傳等，
PUT：用上傳的內容替換目標資源的所有當前表示，我們使用它來修改或更新資料，
DELETE：洗掉資料

第 29 天 - 構建 API

在本節中，我們將介紹一個 RESTful API，它使用 HTTP 請求方法來獲取、PUT、POST 和 DELETE 資料，

RESTful API 是一種應用程式介面 (API)，它使用 HTTP 請求來獲取、PUT、POST 和 DELETE 資料，在前面的章節中，我們學習了 python、flask 和 mongoDB，我們將利用我們獲得的知識使用 python flask 和 mongoDB 開發 RESTful API，每個具有 CRUD（創建、讀取、更新、洗掉）操作的應用程式都有一個 API 來創建資料、獲取資料、更新資料或從資料庫中洗掉資料，

瀏覽器只能處理 get 請求，因此，我們必須有一個工具可以幫助我們處理所有請求方法（GET、POST、PUT、DELETE），

API示例

國家 API：https : //restcountries.eu/rest/v2/all
貓品種 API：https : //api.thecatapi.com/v1/breeds

Postman是一個非常流行的 API 開發工具，所以，如果你喜歡做這個部分，你需要下載 postman，Postman 的另一種選擇是Insomnia，

在這里插入圖片描述

29.1API的結構

API 端點是一個 URL，可以幫助檢索、創建、更新或洗掉資源，結構如下所示：示例：https : //api.twitter.com/1.1/lists/members.json 回傳指定串列的成員，僅當經過身份驗證的用戶擁有指定串列時，才會顯示私人串列成員，公司名稱的名稱后跟版本，然后是 API 的用途，方法：HTTP 方法和 URL

API 使用以下 HTTP 方法進行物件操作：

GET        Used for object retrieval
POST       Used for object creation and object actions
PUT        Used for object update
DELETE     Used for object deletion

讓我們構建一個 API 來收集有關 30DaysOfPython 學生的資訊，我們將收集姓名、國家、城市、出生日期、技能和簡歷，

為了實作這個 API，我們將使用：

郵差
Python
Flask
MongoDB

29.2使用 get 檢索資料

在這一步中，讓我們使用虛擬資料并將其作為 json 回傳，要將其作為 json 回傳，將使用 json 模塊和 Response 模塊，

讓我們匯入Flask


from flask import Flask,  Response
import json

app = Flask(__name__)

@app.route('/api/v1.0/students', methods = ['GET'])
def students ():
    student_list = [
        {
            'name':'Asabeneh',
            'country':'Finland',
            'city':'Helsinki',
            'skills':['HTML', 'CSS','JavaScript','Python']
        },
        {
            'name':'David',
            'country':'UK',
            'city':'London',
            'skills':['Python','MongoDB']
        },
        {
            'name':'John',
            'country':'Sweden',
            'city':'Stockholm',
            'skills':['Java','C#']
        }
    ]
    return Response(json.dumps(student_list), mimetype='application/json')


if __name__ == '__main__':
    # for deployment
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

當您在瀏覽器上請求http://localhost:5000/api/v1.0/students url 時，您將得到以下資訊：

在這里插入圖片描述

當您在瀏覽器上請求http://localhost:5000/api/v1.0/students url 時，您將得到以下資訊：

在這里插入圖片描述

讓我們將 Flask 應用程式與 MongoDB 連接并從 mongoDB 資料庫中獲取資料，而不是顯示虛擬資料，

from flask import Flask,  Response
import json
import pymongo


app = Flask(__name__)

#
MONGODB_URI='mongodb+srv://asabeneh:your_password@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # accessing the database

@app.route('/api/v1.0/students', methods = ['GET'])
def students ():

    return Response(json.dumps(student), mimetype='application/json')


if __name__ == '__main__':
    # for deployment
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)
通過連接Flask，我們可以從三十天_of_python 資料庫中獲取學生收集資料，

```python
[
    {
        "_id": {
            "$oid": "5df68a21f106fe2d315bbc8b"
        },
        "name": "Asabeneh",
        "country": "Finland",
        "city": "Helsinki",
        "age": 38
    },
    {
        "_id": {
            "$oid": "5df68a23f106fe2d315bbc8c"
        },
        "name": "David",
        "country": "UK",
        "city": "London",
        "age": 34
    },
    {
        "_id": {
            "$oid": "5df68a23f106fe2d315bbc8e"
        },
        "name": "Sami",
        "country": "Finland",
        "city": "Helsinki",
        "age": 25
    }
]

29.3通過 id 獲取檔案

我們可以使用 id 訪問 signle 檔案，讓我們使用他的 id 訪問 Asabeneh， http://localhost:5000/api/v1.0/students/5df68a21f106fe2d315bbc8b

# 讓我們匯入Flask

from flask import Flask,  Response
import json
from bson.objectid import ObjectId
import json
from bson.json_util import dumps
import pymongo


app = Flask(__name__)

#
MONGODB_URI='mongodb+srv://asabeneh:your_password@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # accessing the database

@app.route('/api/v1.0/students', methods = ['GET'])
def students ():

    return Response(json.dumps(student), mimetype='application/json')
@app.route('/api/v1.0/students/<id>', methods = ['GET'])
def single_student (id):
    student = db.students.find({'_id':ObjectId(id)})
    return Response(dumps(student), mimetype='application/json')

if __name__ == '__main__':
    # for deployment
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

[
    {
        "_id": {
            "$oid": "5df68a21f106fe2d315bbc8b"
        },
        "name": "Asabeneh",
        "country": "Finland",
        "city": "Helsinki",
        "age": 38
    }
]

29.4使用 POST 創建資料

我們使用POST請求方式來創建資料

# 讓我們匯入Flask

from flask import Flask,  Response
import json
from bson.objectid import ObjectId
import json
from bson.json_util import dumps
import pymongo
from datetime import datetime


app = Flask(__name__)

#
MONGODB_URI='mongodb+srv://asabeneh:your_password@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # accessing the database

@app.route('/api/v1.0/students', methods = ['GET'])
def students ():

    return Response(json.dumps(student), mimetype='application/json')
@app.route('/api/v1.0/students/<id>', methods = ['GET'])
def single_student (id):
    student = db.students.find({'_id':ObjectId(id)})
    return Response(dumps(student), mimetype='application/json')
@app.route('/api/v1.0/students', methods = ['POST'])
def create_student ():
    name = request.form['name']
    country = request.form['country']
    city = request.form['city']
    skills = request.form['skills'].split(', ')
    bio = request.form['bio']
    birthyear = request.form['birthyear']
    created_at = datetime.now()
    student = {
        'name': name,
        'country': country,
        'city': city,
        'birthyear': birthyear,
        'skills': skills,
        'bio': bio,
        'created_at': created_at

    }
    db.students.insert_one(student)
    return ;
def update_student (id):
if __name__ == '__main__':
    # for deployment
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

29.4使用 PUT 更新

# 讓我們匯入Flask

from flask import Flask,  Response
import json
from bson.objectid import ObjectId
import json
from bson.json_util import dumps
import pymongo
from datetime import datetime


app = Flask(__name__)

#
MONGODB_URI='mongodb+srv://asabeneh:your_password@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # accessing the database

@app.route('/api/v1.0/students', methods = ['GET'])
def students ():

    return Response(json.dumps(student), mimetype='application/json')
@app.route('/api/v1.0/students/<id>', methods = ['GET'])
def single_student (id):
    student = db.students.find({'_id':ObjectId(id)})
    return Response(dumps(student), mimetype='application/json')
@app.route('/api/v1.0/students', methods = ['POST'])
def create_student ():
    name = request.form['name']
    country = request.form['country']
    city = request.form['city']
    skills = request.form['skills'].split(', ')
    bio = request.form['bio']
    birthyear = request.form['birthyear']
    created_at = datetime.now()
    student = {
        'name': name,
        'country': country,
        'city': city,
        'birthyear': birthyear,
        'skills': skills,
        'bio': bio,
        'created_at': created_at

    }
    db.students.insert_one(student)
    return
@app.route('/api/v1.0/students/<id>', methods = ['PUT']) # this decorator create the home route
def update_student (id):
    query = {"_id":ObjectId(id)}
    name = request.form['name']
    country = request.form['country']
    city = request.form['city']
    skills = request.form['skills'].split(', ')
    bio = request.form['bio']
    birthyear = request.form['birthyear']
    created_at = datetime.now()
    student = {
        'name': name,
        'country': country,
        'city': city,
        'birthyear': birthyear,
        'skills': skills,
        'bio': bio,
        'created_at': created_at

    }
    db.students.update_one(query, student)
    # return Response(dumps({"result":"a new student has been created"}), mimetype='application/json')
    return
def update_student (id):
if __name__ == '__main__':
    # for deployment
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

29.5使用 Delete 洗掉檔案

# 讓我們匯入Flask

from flask import Flask,  Response
import json
from bson.objectid import ObjectId
import json
from bson.json_util import dumps
import pymongo
from datetime import datetime


app = Flask(__name__)

#
MONGODB_URI='mongodb+srv://asabeneh:your_password@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # accessing the database

@app.route('/api/v1.0/students', methods = ['GET'])
def students ():

    return Response(json.dumps(student), mimetype='application/json')
@app.route('/api/v1.0/students/<id>', methods = ['GET'])
def single_student (id):
    student = db.students.find({'_id':ObjectId(id)})
    return Response(dumps(student), mimetype='application/json')
@app.route('/api/v1.0/students', methods = ['POST'])
def create_student ():
    name = request.form['name']
    country = request.form['country']
    city = request.form['city']
    skills = request.form['skills'].split(', ')
    bio = request.form['bio']
    birthyear = request.form['birthyear']
    created_at = datetime.now()
    student = {
        'name': name,
        'country': country,
        'city': city,
        'birthyear': birthyear,
        'skills': skills,
        'bio': bio,
        'created_at': created_at

    }
    db.students.insert_one(student)
    return
@app.route('/api/v1.0/students/<id>', methods = ['PUT']) # this decorator create the home route
def update_student (id):
    query = {"_id":ObjectId(id)}
    name = request.form['name']
    country = request.form['country']
    city = request.form['city']
    skills = request.form['skills'].split(', ')
    bio = request.form['bio']
    birthyear = request.form['birthyear']
    created_at = datetime.now()
    student = {
        'name': name,
        'country': country,
        'city': city,
        'birthyear': birthyear,
        'skills': skills,
        'bio': bio,
        'created_at': created_at

    }
    db.students.update_one(query, student)
    # return Response(dumps({"result":"a new student has been created"}), mimetype='application/json')
    return
@app.route('/api/v1.0/students/<id>', methods = ['PUT']) # this decorator create the home route
def update_student (id):
    query = {"_id":ObjectId(id)}
    name = request.form['name']
    country = request.form['country']
    city = request.form['city']
    skills = request.form['skills'].split(', ')
    bio = request.form['bio']
    birthyear = request.form['birthyear']
    created_at = datetime.now()
    student = {
        'name': name,
        'country': country,
        'city': city,
        'birthyear': birthyear,
        'skills': skills,
        'bio': bio,
        'created_at': created_at

    }
    db.students.update_one(query, student)
    # return Response(dumps({"result":"a new student has been created"}), mimetype='application/json')
    return ;
@app.route('/api/v1.0/students/<id>', methods = ['DELETE'])
def delete_student (id):
    db.students.delete_one({"_id":ObjectId(id)})
    return
if __name__ == '__main__':
    # for deployment
    # to make it work for both production and development
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

在這里插入圖片描述

第 30 天-結論

🎉 恭喜！ 🎉
在準備這份材料的程序中，我從中學到了很多東西，也激勵我去做更多的事情，那么對于你們應該也從中學到些東西吧，能陪我堅持到最后這一天你，真的很優秀，恭喜你達到這個水平，挑戰30天學習Python編程，有了這些基礎，現在你可以去學習資料分析、機器學習或 Web 開發與爬蟲，一起加油！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/306244.html

標籤：python

上一篇：[Python]題集①

下一篇：【Python爬蟲】爬一個專門看小姐姐的網站，寫一段緊張刺激的代碼（附原始碼）

最終篇：簡潔易懂，初學者挑戰學習Python編程30天 (五)

最終篇

第 26 天 - 網路 Python

26.1網頁版 Python

26.2Flask

檔案夾結構

26.3設定你的專案目錄

26.4創建路由

26.5創建模板

26.6Python腳本

26.7導航

26.8創建布局

提供靜態檔案

26.9部署

第 27 天 - Python 與 MongoDB

27.1MongoDB

27.2獲取連接字串（MongoDB URI）

27.3將 Flask 應用程式連接到 MongoDB 集群

27.3創建資料庫和集合

27.4將許多檔案插入到集合中

27.5MongoDB 查找

27.6用查詢查找

27.7使用修飾符查找查詢

27.8限制檔案

27.9排序查找

27.10使用查詢更新

27.11洗掉檔案

27.12洗掉一個集合

第 28 天 - API

28.1應用程式編程介面（API）

28.2構建API

28.3HTTP（超文本傳輸??協議）

28.4HTTP的結構

28.5初始請求行（狀態行）

28.6初始回應線（狀態線）

28.7標題欄位

28.8訊息體

28.9請求方法

第 29 天 - 構建 API

29.1API的結構

29.2使用 get 檢索資料

讓我們匯入Flask

29.3通過 id 獲取檔案

29.4使用 POST 創建資料

29.4使用 PUT 更新

29.5使用 Delete 洗掉檔案

第 30 天-結論