Category: Python

djsurvey – Google Forms Alternative #01

kanakorn.h

November 24, 2019
ต่อจาก ddready – แพ็ครวม django + bootstrap4 + crispy form + docker พร้อมใช้งาน ในบทความนี้ ผมได้พยายามทำให้ใช้งาน Django ได้ง่ายขึ้น จนได้ แบบสำรวจอย่างง่าย พร้อมใช้งาน ใน 3 ขั้นตอน

Prerequesite

ติดตั้ง Python 3.6+ หรือ ใช้ Python Container แล้ว

Repository

https://github.com/nagarindkx/djsurvey

ง่าย ๆ 3 ขั้นตอน

1. Clone Repository

ใช้คำสั่ง git
```
git clone https://github.com/nagarindkx/djsurvey.git
```
หรือ Download ไปก็ได้

https://github.com/nagarindkx/djsurvey/archive/master.zip

2. กำหนดข้อคำถามในแบบสำรวจ

แก้ไขไฟล์
```
/code/main/survey/models.py
```
ตัวอย่างเช่น แบบสำรวจ ประกอบด้วย
1. ชื่อ
2. อีเมล
3. เพศ
4. วันเดือนปีเกิด
5. ผลไม้ที่ชอบ
6. ข้อเสนอแนะ
ก็สร้าง Model ตามนี้ ( แรก ๆ อาจจะรู้สึกน่ากลัว แต่พอเข้าใจแล้ว มันง่ายมาก)
```
from django.db import models
class Survey(models.Model):
    fullname = models.CharField(
        verbose_name="ชื่อ",
        max_length=255,  blank=False)
    email = models.EmailField(
        verbose_name="อีเมล",
        blank=False)
    gender = models.CharField(
        verbose_name="เพศ",
        max_length=1,    blank=False,
        choices=[('F', 'หญิง'), ('M', 'ชาย')],
        default='F',
    )
    birthdate = models.DateField(
        verbose_name="วันเดือนปีเกิด",
        auto_now=False,  blank=False)
    fruit = models.CharField(
        verbose_name="ผลไม้ที่ท่านชอบ",
        max_length=1,    blank=False,
        choices=[('a', 'แอปเปิ้ล'), ('b', 'มะละกอ'),
                 ('c', 'กล้วย'), ('d', 'ส้ม')],
        default='c',
    )
    comment = models.TextField(
        verbose_name="ข้อเสนอแนะ",
        blank=True)
```
แนะนำให้ใช้ Visual Studio Code จะทำงานได้ง่ายมาก

3. Migrate แล้ว Run

ใช้คำสั่งต่อไปนี้
```
python manage.py migrate
python manage.py runserver 0:8080
```
ชมผลงาน

http://localhost:8080/survey/

หรือ ตกแต่งอีกนิดหน่อย ก็จะได้แบบนี้

http://localhost:8080/advancedsurvey/

สำหรับผู้ที่ใช้ Docker สามารถ ทำตามขั้นตอนใน แนวทางการพัฒนา Web Application ด้วย django จาก local docker สู่ Google Cloud Run เพื่อนำขึ้น Google Cloud Run ได้เลย (แต่ต้องเชื่อมกับ Database จริง ๆ ก่อนนะ – โปรดติดตามตอนต่อไป)

คุณกำลังเจอปัญหาเหล่านี้อยู่ใช่ไม๊ ?
- Google Forms ก็ง่ายดีแหล่ะ แต่ จะทำอย่างไรให้เก็บข้อมูลไว้ในฐานข้อมูลได้ ?
- อยากให้ ผู้ใช้งาน Upload เอกสารเข้ามา / แก้ไขข้อมูล ซึ่ง Google Forms ก็ทำได้ แต่ต้อง Login ด้วย Google Account ก่อน จึงจะทำได้
- Google Forms ก็ทำ Conditions ได้แหล่ะ (Go to section base on answer) แต่ ถ้าจะให้มีการคำนวนที่ซับซ้อนกว่านั้น ก่อนจะเลือกคำถามถัดไป จะทำอย่างไร ?
ปัญหาเหล่านี้จะหมดไป เมื่อคุณใช้ Django !
- ติดตั้งได้ บน Web Server ของคุณ!
- Login ด้วย Facebook/Twitter/Google/Line หรือ Email หรือ จะเป็น Single Sign-On ก็ยังได้
- ทุกอย่างสามารถ Customize ได้ ทำแบบสอบถามที่ซับซ้อนได้
ไว้เจอกันในตอนต่อ ๆ ไปครับ
November 24, 2019
ddready – แพ็ครวม django + bootstrap4 + crispy form + docker พร้อมใช้งาน

kanakorn.h

November 19, 2019
สำหรับใครที่อยากจะลองพัฒนา Web Application ด้วย django web framework ผมได้รวบรวมเป็นชุดเริ่มต้น ซึ่งจะสามารถสร้าง Responsive Web และ มีแบบฟอร์มที่สวยงามด้วย crispy form มาเรียบร้อย ใช้งานได้ทั้ง แบบ Python บนเครื่อง และ แบบ Docker ลองทำตามดูได้ครับ

ต้นแบบ มี Bootstrap 4 พร้อมใช้งาน

มี Login Form มาให้เลย

เข้ามาในส่วนของ Profile และ Logout ได้

Repository

สามารถเปิด URL ต่อไปนี้ เพื่อไป Download หรือ จะใช้ git clone ก็ได้

https://github.com/nagarindkx/ddready.git

https://gitlab.psu.ac.th/kanakorn.h/ddready.git

จากนั้น ให้เปิด cmd ไปยังตำแหน่งที่ clone ลงมา

สำหรับผู้ที่ติดตั้ง python อยู่แล้ว

แล้วใช้คำสั่งต่อไปนี้
```
pip install -r requirements.txt
cd code
cd main
waitress-serve --listen *:8080 main.wsgi:application
```
สำหรับผู้ที่จะใช้ Docker

บน Windows ใช้คำสั่งต่อไปนี้
```
set PROJECTNAME="projectname"
set GCP-PROJECT-ID="gcp-project-id"
set SERVICE="service"
docker build --rm -f "Dockerfile" -t %PROJECTNAME%:dev .
docker run -d -v %CD%\code:/code -p 8080:8080 --name %PROJECTNAME% %PROJECTNAME%:dev
docker exec -it %PROJECTNAME% /bin/sh -c "[ -e /bin/bash ] && /bin/bash || /bin/sh"
```
ทดสอบใช้งาน

http://localhost:8080

ในตอนต่อไป จะแนะนำวิธีการสร้าง แบบสอบถาม ทดแทนการใช้ Google Forms ครับ
November 19, 2019
แนวทางการพัฒนา Web Application ด้วย django จาก local docker สู่ Google Cloud Run

kanakorn.h

October 26, 2019
ในการพัฒนาแอพพลิเคชั่น เราก็จะเจอปัญหานึงเสมอ ๆ คือ เวอร์ชั่น (Version) ของเครื่องมือที่ใช้ในการพัฒนานั้น แต่ละโปรเจคมีความแตกต่างกัน เช่น ในกรณีของ การพัฒนา Web Application ด้วย django web framework เราอาจจะอยากใช้ python รุ่นล่าสุด คือ 3.8 แต่ในขณะเดียวกัน เมื่อหลังบ้านต้องการไปติดต่อ Tensorflow 2.0 ซึ่งยังต้องใช้งานกับ Python 3.6 เป็นต้น วิธีแก้ไขปัญหาทั่วไปคือ ติดตั้ง package ‘virtualenv’ เพื่อให้การพัฒนาแต่ละโปรเจค มี Environment แตกต่างกันได้

แต่จากการใช้งานจริง พบว่า สุดท้าย ตอนเอาไป Production บนเครื่อง Server ก็ต้องตามไปติดตั้งเครื่องมือ และรุ่นที่ถูกต้อง แม้ใน Python จะมีคำสั่ง pip install -r requirements.txt ก็ตาม แต่ก็ยังไปติดปัญหาว่า OS ของเครื่องที่จะ Production นั้น รองรับรุ่นของเครื่องมืออีกหรือไม่ด้วย

แนวทางการใช้ Container ด้วย Docker จึงเป็นที่นิยม เพราะ เมื่อเราพัฒนาเสร็จแล้ว สามารถ Pack เข้าไปใน Container แล้วเอาไป Deploy ได้ โดย (แทบจะ) ไม่ต้องกังวลกับ Environment ปลายทาง อีกทั้ง ยังสามารถทดสอบ Environment ใหม่ ๆ ก่อนจะ Deploy ได้ด้วย เช่นการเปลี่ยนรุ่นของ Python เป็นต้น

ในบทความนี้ จะนำเสนอ แนวทางการสร้าง docker container เพื่อใช้เป็นฐานในการพัฒนา django และ สามารถต่อยอด ติดตั้ง package อื่น ๆ ตามต้องการ ตั้งแต่ Development ไปจนถึง Deployment สู่ Serverless Environment อย่าง Google Cloud Run

สร้าง Development Container

เริ่มจาก สร้างโฟลเดอร์ใหม่ขึ้นมา ในนั้นมี 2 ไฟล์ คือ Dockerfile และ requirements.txt กับ โฟลเดอร์ ชื่อ code

Dockerfile
- ใช้ image ของ python เป็นรุ่น 3.7-slim ซึ่งตัดส่วนที่ไม่จำเป็นออกแล้ว (ไม่ใช้ alpine เนื่องจาก พบรายงานว่า แม้จะมีขนาดเล็กกว่า แต่ถูกจำกัดทรัพยากรบางอย่าง ทำให้ทำงานได้ช้ากว่า)
- สร้าง /code แล้วเข้าไปใช้พื้นที่นี้ (เหมือนคำสั่ง mkdir /code ; cd /code อะไรประมาณนั้น)
- สั่งให้ copy ไฟล์ requirements.txt ไปใช้ที่ root ( / )
- จากนั้น Upgrade คำสั่ง pip เป็นรุ่นล่าสุด แล้ว ติดตั้ง package ตามที่กำหนดใน requirements.txt
- เปิด Port 8080 ไว้ เพื่อใช้ในการทดสอบ และเป็นไปในแนวทางเดียวกับการใช้บน Google Cloud Run ต่อไป
```
FROM python:3.7-slim
WORKDIR /code/
COPY requirements.txt /
RUN pip install -U pip \
    && pip install -r /requirements.txt
EXPOSE 8080
```
requirements.txt

ในการพัฒนา django เมื่อทำการติดตั้ง package ใดเพิ่มเติมด้วยคำสั่ง pip install ก็จะบันทึกรายการ พร้อมรุ่นของ package มาในไฟล์นี้ ในที่นี้ ใช้ django, guincorn และ whitenoise เป็นหลัก (จะมีรายการ dependency ติดเข้ามาด้วย)
```
Django==2.2.6
gunicorn==19.9.0
pytz==2019.3
sqlparse==0.3.0
whitenoise==4.1.4
```
จากนั้นใช้คำสั่งต่อไปนี้ สร้าง (build) docker image จากไฟล์ Dockerfile ข้างต้น โดยมี option ที่เกี่ยวข้องดังนี้
```
docker build --rm -f "Dockerfile" -t mydjango:dev .
```
- –rm เมื่อ build แล้ว ก็ลบ container ชั่วคราวทิ้ง
- -f กำหนดว่าจะเรียกจากไฟล์ใด วิธีนี้ มีประโยชน์ เวลาที่จะต้องมี Dockerfile ทั้ง Development และ Production ในโฟลเดอร์เดียวกัน ซึ่งจำเป็นต้องใช้ชื่อไฟล์ที่แตกต่างกัน
- -t เป็นตั้งชื่อ docker image และ ชื่อ tag
- . คือ ให้ build จากตำแหน่งปัจจุบัน
ขั้นตอนนี้จะได้ docker image ชื่อ mydjango และมี tag เป็น dev แล้ว้

(ในที่นี้ พัฒนาบนเครื่องคอมพิวเตอร์ที่เป็น Windows 10 ซึ่ง %CD% จะให้ค่า Current Directory แบบ Absolute path ออกมา เช่นเดียวกับบน Linux ที่ใช้ $(pwd) )

ต่อไป สั่ง run ด้วยคำสั่ง และ options ดังต่อไปนี้
```
docker run --rm -it -p 8080:8080  -v %CD%\code:/code  mydjango:dev bash
```
- –rm เมื่อจบการทำงาน ก็ลบ container ชั่วคราวทิ้ง
- -it คือ interactive และเปิด TTY
- -p เพื่อเชื่อม port 8080 จากภายนอก เข้าไปยัง port 8080 ภายใน container
- -v เพื่อเชื่อม Volume หรือโฟลเดอร์ของเครื่อง host กับ /code ภายใน container ขั้นตอนนี้สำคัญ
- bash ข้างท้าย เพื่อส่งคำสั่ง เรียก bash shell ขึ้นมา ซึ่งจะสัมพันธ์กับ -it ข้างต้น ทำให้สามารถใช้งาน shell ภายใน container ได้เลย
ผลที่ได้คือ bash shell และ อยู่ที่ /code ภายใน container
```
root@757bcbb07c7f:/code#
```
ตอนนี้ เราก็สามารถสร้าง django ได้ตามปรกติแล้ว (คลิกดูตัวอย่างเบื้องต้น) แต่ในตัวอย่างนี้ จะเริ่มจากการสร้าง project ชื่อ main เพื่อใช้ในขั้นตอนต่อไป ด้วยคำสั่งต่อไปนี้
```
django-admin startproject main
cd main
```
ในระหว่างการพัฒนา สามารถใช้คำสั่ง runserver โดยเปิด Port 8080 ใน container เพื่อทดสอบได้ดังนี้ (สอดคล้องตามที่อธิบายข้างต้น)
```
python manage.py runserver 0.0.0.0:8080
```
สร้าง Production Docker Image

คำสั่งข้างต้น สามารถใช้ได้เฉพาะขั้นตอนการพัฒนา แต่เมื่อพัฒนาเสร็จแล้ว ควรใช้ Application Server แทน ในที่นี้จำใช้ gunicorn แต่ก่อนอื่น จะต้องปรับ Configuration ของ django ให้พร้อมในการ Deployment ก่อน

main/settings.py
```
# แก้ไข
DEBUG = False
ALLOWED_HOSTS = ['localhost','SERVICE-ID.run.app']

# เพิ่ม
MIDDLEWARE = [
    ...
    # Whitenoise
    'whitenoise.middleware.WhiteNoiseMiddleware',
    ...
]
# เพิ่ม
STATIC_ROOT = os.path.join(BASE_DIR, 'static')
```
มีเพิ่มเติมคือ whitenoise ซึ่งเป็น package สำหรับจัดการเกี่ยวกับการให้บริการ static file ในตัว มิเช่นนั้นจะต้องไปตั้งค่าใน Web Server ให้จัดการแทน

เมื่อเราตั้งค่า DEBUG = False จะต้องกำหนด ALLOWED_HOSTS เสมอ ในที่นี้กำหนดให้เป็น localhost และ Production URL (SERVICE-ID.run.app) ที่จะเกิดขึ้นเมื่อสร้าง Service บน Google Cloud Run ครั้งแรกไปแล้ว (ค่อยกลับมาแก้ไขแล้ว Revision อีกครั้ง)

ใช้คำสั่งต่อไปนี้เพื่อรวบรวม static files ต่าง ๆ มาไว้ในที่เดียวกัน ในที่นี้ คือที่ โฟลเดอร์ static
```
python manage.py collectstatic
```
ทดสอบ Production ด้วย gunicorn ด้วยคำสั่งต่อไปนี้
```
gunicorn --bind 0.0.0.0:8080 main.wsgi
```
ทดสอบเรียก Local Admin Console ( http://localhost:8080/admin ) ดู ถ้าเรียก static file เช่นกลุ่ม css ได้ ก็พร้อมสำหรับจะนำขึ้น Google Cloud Run ต่อไป

สุดท้าย สร้าง Production Dockerfile และ สรุป requirements.txt ดังนี้

Dockerfile.production
```
FROM python:3.7-slim
WORKDIR /code
COPY ./code/* ./
RUN pip install -U pip \
    && pip install -r requirements.txt
EXPOSE 8080
CMD [ "gunicorn","--bind","0.0.0.0:8080", "main.wsgi"]
```
requirements.txt
```
pip freeze > requirements.txt
```
จากนั้น ใช้คำสั่งต่อไปนี้ เพื่อสร้าง Production Docker Image (ออกมาจาก Development Container shell ก่อน) โดยจะใช้ tag เป็น latest
```
docker build -t mydjango:latest -f "Dockerfile.production" .
```
ส่ง Production Docker Image ขึ้น Google Container Registry

Google Cloud Run จะเรียกใช้ docker image ที่อยู่บน Google Container Registry เท่านั้น
- เปิด Google Console
- สร้าง Project ใหม่ และ ตั้งค่า Billing
- เปิดใช้งาน Google Cloud Run และ Google Container Registry
- ติดตั้อง Google Cloud SDK เพื่อให้สามารถ push ขึ้นได้ และ ยืนยันตัวตนด้วย Google Account
แล้วใช้คำสั่งต่อไปนี้ เพื่อ tag
```
docker tag mydjango:latest gcr.io/YOUR-GCP-PROJECT-ID/SERVICE-NAME
```
- YOUR-GCP-PROJECT-ID เป็น Project ID ที่สร้างขึ้น
- SERVICE-NAME ชื่อ service ที่จะสร้าง
แล้วก็ push ขึ้น Google Container Registry
```
docker push gcr.io/YOUR-GCP-PROJECT-ID/SERVICE-NAME
```
สร้าง Google Cloud Run Service

สร้าง Service โดยเลือก Image ที่ต้องการ

เมื่อเสร็จแล้วจะได้ URL อย่าลืมเอาไปแก้ไขใน main/settings.py ในส่วนของ ALLOWED_HOSTS แทน SERVICE-ID.run.app

จากนั้น build, tag และ push ขึ้น Google Cloud Registry อีกครั้ง แล้ว Deploy New Revision เป็นอันเรียบร้อย

อันนี้เป็นการ Proof of Concept ในบทความต่อไป จะนำเสนอตัวอย่างการใช้งานจริงครับ
October 26, 2019
Variables ใน Robot Framework

thichaluk.s

August 27, 2019
วันนี้เรามาดูตัวแปร ใน Robot Framework กันดีกว่า ดู ๆ ไปตัวแปรมันก็แปลกดีนะ มาดูกันว่าเป็นไงบ้าง
1. Case Insensitive –> ตัวพิมพ์เล็ก – พิมพ์ใหญ่เป็นตัวเดียวกัน
2. Ignore space –> ไม่สนใจช่องว่าง
3. Ignore underscore –> ไม่แคร์ Underscore 555
มาดูประเภทของตัวแปรกัน ดังรูปจ้า
1. ค่าคงที่
2. List
3. Dictionary หรือ Json
ตามตัวอย่าง มารันดูข้อมูลกันจะเห็นได้ว่ามันจะรันตามลำดับ ที่เราแสดง Log to console

ลองดูว่าถ้าเราจะให้แสดง List เฉพาะคำว่า Chotkaew จะทำยังไง ให้มองว่า Thichaluk เป็น index ที่ 0 และ Chotkaew เป็น index ที่ 1

รันดูผลลัพธ์กัน

มาลองดูของ dictionary กันบ้าง ให้แสดงค่าของ Thichaluk

รันดูผลลัพธ์

ทุกคนคงจะมองเห็นการเข้าถึงข้อมูลแต่ละประเภทกันแล้วใช่มั๊ยค่ะ

ต่อไปมาลองสร้าง List กับ Dictionary อย่างง่าย ๆ กัน รูปแบบคำสั่งก็ไปหาดูได้ที่ https://robotframework.org ที่ Libraries –> Builtin ที่ Builtin คลิก View หา Create List กับ Create Dictionary

รันดูผลลัพธ์
August 27, 2019
ทดสอบ API ด้วย Robot Framework (Get Request)

thichaluk.s

August 16, 2019
ก็ยังคงเขียนเกี่ยวกับ robot framework อีกนั่นแหละ ^_^ วันนี้เลยจะมาเขียนตัวอย่างการทดสอบ api ด้วย Robot Framework (Get Request) อย่างง่ายกันค่ะ

สิ่งที่ต้องใช้
1. API ที่จะใช้ในการทดสอบ อันนี้จะใช้ API ที่ http://thetestingworldapi.com ค่ะ
2. เครื่องมือที่ใช้เขียน Notepad++ ^_^
3. Cmd
ขั้นแรกเราไปที่ http://thetestingworldapi.com แล้วคลิกที่ API ในที่นี้ขอเลือก API ของ StudentsDetails ดังรูปค่ะ

จากนั้นก็เปิด Notpad++ ขึ้นมาเลยค่ะ

ที่ Settings ต้องเรียก Library RequestsLibrary นะ แต่ก่อนอื่นต้องไปลง Library ตัวนี้กันก่อน โดยใช้คำสั่ง

pip install robotframework-requests

ถ้าลงแล้วก็จะตรวจสอบได้ โดยใช้คำสั่ง pip freeze ดังรูป

มาที่ Notepad++ กันต่อ ^_^ เขียนคำสั่ง ดังนี้เลย

จะเห็นได้ว่าเรามีแสดง status_code ออกมาด้วย มารู้จักความหมายของ status_code แต่ละตัวกันดีกว่า

2xx คือ OK
3xx คือ Redirection
4xx คือ Resource not found
5xx คือ Server error

มารันผลลัพธ์กันดีกว่า

อันนี้ไม่ขอรัน code ในส่วนของ content นะ ไปรันกันเอาเอง เพราะมันเยอะมากตาลาย capture รูปมาก็คงดูไม่รู้เรื่อง ^_^

การทดสอบ Get Request อย่างง่าย ก็ประมาณนี้นะคะ
August 16, 2019

วิธีเชื่อมต่อ PostgreSQL จาก python

kanakorn.h

January 25, 2019

ในการเชื่อมต่อกับ PostgreSQL จาก Python นั้น จะต้องใช้ Package ‘psycopg2’

คำสั่งในการติดตั้งคือ

pip install psycopg2

วิธีการเรียกใช้จาก python


import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import psycopg2
from IPython.display import display, HTML # used to print out pretty pandas dataframes
import matplotlib.dates as dates
import matplotlib.lines as mlines

%matplotlib inline
plt.style.use('ggplot') 

# specify user/password/where the database is
sqluser = 'username'
sqlpass = 'userpasswordgohere'
dbname = 'dbname'
schema_name = 'someschema'
host = 'host.postgresql.server'

query_schema = 'SET search_path to ' + schema_name + ';'

# connect to the database
con = psycopg2.connect(dbname=dbname, user=sqluser, password=sqlpass, host=host)

query = query_schema + 'select * from sometable'
df = pd.read_sql_query(query,con)

ก็จะได้ df เป็น Dataframe เอาไปใช้งานต่อได้

จบ

January 25, 2019

python #02 – ติดตั้ง Tensorflow และ Keras

kanakorn.h

November 27, 2018
ต่อจาก python #01 – ติดตั้ง jupyter notebook บน Windows

ต่อไปเราจะใช้ Machine Learning Library “Tensorflow” และใช้ “Keras” ซึ่งเป็น High-level Neuron Network API ซึ่งจะไปเรียกใช้ Backend คือ Tensorflow อีกชั้นหนึ่ง

จาก jupyter notebook ทำตามขั้นตอนต่อไปนี

1. คำสั่งต่อไปนี้ เพื่อติดตั้ง Tensorflow
```
! pip install tensorflow
```
2. คำสั่งต่อไปนี้ เพื่อติดตั้ง Keras
```
! pip install keras
```
จะได้ผลประมาณนี้

สร้าง Neural Network ด้วย Keras

เริ่มจาก import ส่วนต่าง ๆ ได้แก่ Models และ Layers
```
import keras
from keras.models import Sequential
from keras.layers import Input, Dense
```
สมมุติเราจะสร้าง Model แบบนี้
```
model = Sequential([
    Dense(8, activation='relu', input_shape=(10,), name="Hidden_Layer_1"),
    Dense(5, activation='relu', name='Hidden_Layer_2'),
    Dense(3, activation='softmax' , name='Output_Layer')
])
```
เสร็จแล้วก็ต้อง compile ตั้งค่า Hyperparameters ต่าง ๆ
```
model.compile( loss='categorical_crossentropy',
    optimizer=keras.optimizers.adam(lr=0.001),
    metrics=['accuracy'])
```
ดู Summary
```
model.summary()
```
ได้ผลประมาณนี้
November 27, 2018
python #01 – ติดตั้ง jupyter notebook บน Windows

kanakorn.h

November 27, 2018
jupyter Notebook เป็น Open Source Web Application ให้เราสามารถเขียนภาษา python ได้ง่ายขึ้น สามารถ Share ได้ด้วย และยังสามารถใส่คำอธิบาย (Markdown) ได้ด้วย ติดตั้งลงในเครื่องส่วนตัวได้ ในบทความนี้ แสดงวิธีติดตั้งและใช้งานบน Microsoft Windows ดังนี้

1. ขั้นแรก ต้องมี Python ก่อน (หมายเหตุ: ณ เวลานี้ 27/11/61 รุ่นล่าสุดคือ 3.7.1 แต่เนื่องจากจะแนะนำการใช้งาน Tensorflow, Keras จึงยังต้องเลือกใช้ Python 3.6.7)

https://www.python.org/ftp/python/3.6.7/python-3.6.7.exe

เมื่อติดตั้งแล้ว ควร Restart เครื่องสักหนึ่งครั้ง

2. ติดตั้ง pip ซึ่งใช้ในการติดตั้งเครื่องมือต่าง ๆ
เปิด Windows Console (กดปุ่ม Win + R) แล้วพิมพ์คำสั่ง cmd
จากนั้น ใช้คำสั่งต่อไปนี้
```
python -m pip install --upgrade pip setuptools wheel
```
3. (Optional) ติดตั้ง virtualenv เพื่อให้สามารถจัดการ Virtual Environment ได้ง่ายขึ้น เพราะอาจจะต้องทำหลาย Project ซึ่งใช้รุ่นของ Package/Module ที่แตกต่างกันบนเครื่องเดียวกัน
```
pip install virtualenv
```
4. ติดตั้ง jupyter notebook
```
pip install jupyter
```
5. เมื่อติดตั้งเสร็จแล้ว ก็ใช้คำสั่งต่อไปนี้
```
jupyter notebook
```
ระบบจะเปิด Web Browser มายัง http://localhost:8888

จากนั้น คลิกที่ปุ่ม New > Python3

จากนั้น เราก็จะสามารถใช้คำสั่ง Python ทั่ว ๆ ไปได้

นอกจากนี้ ยัง Save ได้ และสามารถส่งต่อให้ผู้อื่นใช้ได้ด้วย
November 27, 2018