Notebooks/Gioi thieu ve Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MASSP SINH HỌC 2018\n",
    "## Giới thiệu về Python: Các phép tính đơn giản, tạo list và objects\n",
    "\n",
    "*Soạn bởi: Trương Khánh Nhật Khang, Lê Minh Nhật, 2018*\n",
    "\n",
    "*Dựa theo tài liệu của Justin Bois, Bi 1x 2017, http://bi1x.caltech.edu/2017/handouts/intro_to_python.html*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1. Bắt đầu Lập trình\n",
    "\n",
    "Ta sẽ làm việc trên Jupyter notebook nên trước hết các em hãy chạy Jupyter notebook bằng cách nhập\n",
    "\n",
    "```\n",
    "jupyter notebook\n",
    "```\n",
    "\n",
    "trong command line. Một cửa sổ mới hiện lên trong trình duyệt của các em. Sau đó các em tạo một script mới ở thanh menu kéo xuống tại góc trên bên phải.\n",
    "\n",
    "\n",
    "#### Hello, world\n",
    "\n",
    "Chúng sẽ bắt đầu bằng cách nhâp đoạn “Hello, world” trong ô code của jupyter notebook và ấn `shift+enter`. Em sẽ thấy \"`Hello, world`\" hiện ngay bên dưới dòng lệnh ấy.\n",
    "\n",
    "Cách để gọi hàm trong Python, function argument sẽ được đặt trong dấu ngoặc đơn, và đồng thời string (chuỗi) sẽ nằm trong dấu nháy đơn/kép.\n",
    "Hãy thử"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world.\n"
     ]
    }
   ],
   "source": [
    "# This prints hello world\n",
    "print ('Hello, world.')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lưu ý là dù phía trước lệnh print có các lệnh khác đi nữa, thì chỉ dòng \"`Hello, world`\" được xuất ra màn hình. Hơn nữa, dấu `#` bắt đầu cho comment string (chuỗi giải thích), điều này nghĩa là Python sẽ bỏ qua tất cả các câu chữ phía sau dấu `#` và không quan tâm tới chúng."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2. Variable Assignment (Gán biến)\n",
    "\n",
    "Gán một biến trong Python ta dùng dấu `=`. Các phép toán cộng trừ nhân chia cũng khá là đơn giản `+ - * /`\n",
    "\n",
    "Hãy thử"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is 3\n",
      "b is 27\n",
      "c is 16.5\n",
      "d is 16\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "b = a**3\n",
    "c = (b + 2*a) / 2\n",
    "d = (b + 2*a) // 2\n",
    "print('a is', a)\n",
    "print('b is',  b)\n",
    "print('c is', c)\n",
    "print ('d is', d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ở lệnh gán biến `b`, ta dùng phép toán `**` có nghĩa là hàm mũ bậc `n` của `b`. Ở phép tính với `d`, lệnh `//` giống như phép chia, nhưng sẽ làm tròn xuống kết quả.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3. List, tuples, indexing (Lập danh sách, tuple, trích dẫn)\n",
    "\n",
    "Các em còn nhớ Rosemary và Peter Grant? Đó là hai nhà khoa học đã đo đạc kích cỡ của mỏ chim ưng (finch) trên đảo Galapagos suốt nhiều năm trời. Các đo đạc của họ đã giúp ta có cái nhìn chính xác hơn về tốc độ của sự tiến hóa của các loài chim trong môi trường này.\n",
    "\n",
    "Giả sử các em được Rosemary và Peter Grant tuyển dụng lên đảo và được giao nhiệm vụ đo đạc độ dày mỏ của một số loài chim. Sau một ngày đo đạc, em được các số đo sau:\n",
    "\n",
    "`8.8   8.9   8.1   9.1   8.8   7.9   8.4   8.4   9.0   9.1   8.5`\n",
    "\n",
    "Để thuận tiện lưu giữ các số liệu này bằng Python, các em có thể dùng một list (danh sách), như sau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8.8, 8.9, 8.1, 9.1, 8.8, 7.9, 8.4, 8.4, 9.0, 9.1, 8.5]\n"
     ]
    }
   ],
   "source": [
    "beak_depths= [8.8, 8.9, 8.1, 9.1, 8.8, 7.9, 8.4, 8.4, 9.0, 9.1, 8.5]\n",
    "print(beak_depths)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Trích dẫn và chỉnh sửa một phần tử**\n",
    "\n",
    "List là một cấu trúc rất thuận lợi trong Python vì em có thể trích dẫn và chỉnh sửa nó. Ví dụ, em có thể trich dẫn như sau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Độ dày mỏ chim thứ nhất: 8.8\n",
      "Độ dày mỏ chim thứ hai: 8.9\n",
      "Độ dày mỏ chim cuối cùng: 8.5\n"
     ]
    }
   ],
   "source": [
    "print('Độ dày mỏ chim thứ nhất:', beak_depths[0])\n",
    "print('Độ dày mỏ chim thứ hai:', beak_depths[1])\n",
    "print('Độ dày mỏ chim cuối cùng:', beak_depths[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lưu ý là Python sử dụng zero-indexing, tức là phần tử đầu tiên tương ứng với vị trí số 0! Các em hãy cẩn thận!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Các em cũng có thể chỉnh sửa một list. Giả sử ngày hôm sau, em nhận ra là đã đo nhầm độ dày của chú chim thứ 5, em có thể sửa lại như sau"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8.8, 8.9, 8.1, 9.1, 7.8, 7.9, 8.4, 8.4, 9.0, 9.1, 8.5]\n"
     ]
    }
   ],
   "source": [
    "beak_depths[4] = 7.8 # Chú ý zero-indexing!\n",
    "print(beak_depths)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Trích dẫn nhiều phần tử**\n",
    "\n",
    "Đôi khi các em muốn phân tích một bộ phận của list ban đầu. Giả sử em muốn trích ra số liệu độ dày mỏ từ chú chim thứ 4 đến chú chim thứ 8.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Độ dày mỏ của các chú chim thứ 4 đến thứ 8:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[9.1, 7.8, 7.9, 8.4, 8.4]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('Độ dày mỏ của các chú chim thứ 4 đến thứ 8:')\n",
    "beak_depths[3:8] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ta phân tích kĩ hơn cú pháp `beak_depths[3:8]`. Chú ý do zero-indexing, số đầu tiên là số 3 (biểu thị chú chim thứ 4).\n",
    "\n",
    "Vậy vì sao số kết thúc không là 7 để biểu hiện chú chim thứ 8? Đó là vì Python mặc định sẽ kết thúc trích dẫn *trước khi* chạm đến số kết thúc.\n",
    "\n",
    "Một trường hợp khác thường gặp là trích dẫn các số rời nhau, ví dụ các em muốn biết độ dày mỏ của chú chim số 1, 3, 5, 7,... Các em theo dõi các ví dụ sau."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c is [8.8, 8.1, 7.8]\n",
      "d is [8.8, 9.1, 8.4]\n",
      "e is [8.9, 7.8, 8.4, 8.5]\n"
     ]
    }
   ],
   "source": [
    "c = beak_depths[0:5:2] # Từ phần tử 0 đến phần tử 4, bước nhảy là 2\n",
    "\n",
    "d = beak_depths[0:-2:3] # Từ phần tử 0 đến phần tử thứ 2 tính từ dưới lên, bước nhảy là 3\n",
    "\n",
    "e = beak_depths[1::3] # Từ phần tử 1 đến hết, bước nhảy là 3\n",
    "\n",
    "print('c is', c)\n",
    "print('d is', d)\n",
    "print('e is', e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tuple**\n",
    "\n",
    "Một cách khác để lưu trữ số liệu là bằng tuple. Một tuple cũng giống như list, nhưng có chỗ khác là em không thay đổi được, nghĩa là chỉ có thể tạo một lần và không chỉnh sửa được. Vì vậy nên ta ít gặp tuple hơn trong phân tích số liệu.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "beak depths are [8.8, 8.9, 8.1, 9.1, 7.8, 7.9, 8.4, 8.4, 9.0, 9.1, 8.5]\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-60-176ff5b967fa>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;31m# Không thể thay đổi được tuple\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mbeak_depths_tuple\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m7.8\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# Tạo tuple\n",
    "beak_depths_tuple = (8.8, 8.9, 8.1, 9.1, 8.8, 7.9, 8.4, 8.4, 9.0, 9.1, 8.5)\n",
    "print('beak depths are', beak_depths) \n",
    "\n",
    "# Không thể thay đổi được tuple\n",
    "beak_depths_tuple[5] = 7.8\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ở đây xuất hiện lỗi do không thể thay thế 8.8 trong `beak_depths_tuple[5]` bằng 7.8, lệnh gán này không hiệu lực với tuple. Đó có nghĩa là khi em nhập `my_tuple` lần nữa, kết quả vẫn sẽ không đổi."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3. Vật thể (objects) trong Python\n",
    "\n",
    "Như vậy là các em đã làm quen với cách lập, chỉnh sửa và trích dẫn list. Chúng ta đã thu thập được một số dữ liệu cho Rosemary và Peter Grant và đã tạo một list để lưu các số liệu đó. Nhưng nếu chỉ để lưu số liệu thì chắc ta đã không cần dùng Python làm gì :P\n",
    "\n",
    "Để bắt đầu phân tích dữ liệu trên, chắc các em có thể thắc mắc: độ dày mỏ cao nhất và thấp nhất của các chú chim là gì? Phân bố độ dày mỏ của chúng như thế nào? Với một dữ liệu nhỏ như vậy thì các em có thể tự nhìn và đếm được, nhưng với những bảng số liệu dàiiiiiiii (aka tất cả các số liệu nghiên cứu mà các em sẽ gặp sau này), thì không thể nào tự nhìn và tính được. \n",
    "\n",
    "Thật may là Python có thể giúp ta trả lời các câu hỏi này rất nhanh chóng. Trước khi đi vào chi tiết các câu lệnh, anh sẽ giới thiệu đôi nét về cách Python xử lí các vật thể (objects) trong chương trình.\n",
    "\n",
    "** Vật thể (objects)**\n",
    "\n",
    "Python là một ngôn ngữ theo dạng *object-oriented*. Điều đó có nghĩa là nó coi tất cả các giá trị và biến trong chương trình như là những *vật thể (objects)*. (**Chú ý**: khi các em đọc tài liệu lập trình tiếng Việt thì *objects* thường được dịch là *đối tượng* nhưng anh không thích từ này. Anh thích xem các biến của Python là các đồ vật, vật thể để dễ hình dung hơn và sẽ dùng từ này trong tài liệu MaSSP).\n",
    "\n",
    "Một *object* bao gồm:\n",
    "\n",
    "* **Tên** của vật thể đó (identity) được lưu trong bộ nhớ. Tên của list mình vừa tạo là `beak_depths`.\n",
    "* **Loại** của vật thể đó (type) để xác định cách mà object được trình bày. Loại của `beak_depths` là `list`.\n",
    "* **Giá trị** của vật thể đó (data) là giá trị của object. Giá trị của `beak_depths` là `[8.8, 8.9, 8.1, 9.1, 8.8, 7.9, 8.4, 8.4, 9.0, 9.1, 8.5]`.\n",
    "* **Phương pháp** (method) gắn với object đó. Các em đọc tiếp để xem giải thích.\n",
    "\n",
    "Để xác định được loại của mỗi vật thể, các em có thể dùng lệnh `type`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the type of a is <class 'int'>\n",
      "the type of b is <class 'float'>\n",
      "the type of beak_depths is <class 'list'>\n",
      "the type of beak_depths[0] is <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "b = 4.6\n",
    "\n",
    "print('the type of a is', type(a))\n",
    "print('the type of b is', type(b))\n",
    "print('the type of beak_depths is', type(beak_depths))\n",
    "print('the type of beak_depths[0] is', type(beak_depths[0]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Điều mà em có thể thấy là `beak_depths` là một list, và trong nó chứa đựng nhiều objects khác. Các objects trong list này là các `floats` (số thập phân lẻ như 1.1, 3.2,...).\n",
    "\n",
    "\n",
    "** Phương pháp**\n",
    "\n",
    "Bộ phận cuối cùng của một object là các phương pháp (methods) gắn với object đó. Mỗi object sẽ có những phương pháp đi kèm với nó. Ví dụ, một `list` các số sẽ có các phương pháp để giúp các em sắp xếp list đó (`sort()`), giúp em thêm phần tử (`append()`), xóa phần tử (`remove()`). \n",
    "\n",
    "Để gọi một phương pháp, ta dùng cú pháp \n",
    "\n",
    "`[tên object].[tên phương pháp] (các thông số quan trọng)`\n",
    "\n",
    "Ta lại nhìn vào list thân quen `beak_depths` và thực hiện một số tính toán."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Độ dày sau khi được sắp xếp theo thứ tự tăng dần:\n",
      "[7.9, 8.1, 8.4, 8.4, 8.5, 8.8, 8.8, 8.9, 9.0, 9.1, 9.1]\n",
      "Độ dày nhỏ nhât là 7.9\n",
      "Độ dày lớn nhất là 9.1\n",
      "Độ dày trung vị (median) là\n",
      "Số lượng chim đo được ngày hôm nay là: 11\n",
      "\n",
      "\n",
      "Thêm 9.9 vào cuối: \n",
      " [7.9, 8.1, 8.4, 8.4, 8.5, 8.8, 8.8, 8.9, 9.0, 9.1, 9.1, 9.9]\n",
      "Bỏ 9.9:\n",
      " [7.9, 8.1, 8.4, 8.4, 8.5, 8.8, 8.8, 8.9, 9.0, 9.1, 9.1]\n"
     ]
    }
   ],
   "source": [
    "# Sắp xếp list\n",
    "beak_depths = [8.8, 8.9, 8.1, 9.1, 8.8, 7.9, 8.4, 8.4, 9.0, 9.1, 8.5]\n",
    "beak_depths.sort()\n",
    "\n",
    "print('Độ dày sau khi được sắp xếp theo thứ tự tăng dần:')\n",
    "print(beak_depths)\n",
    "\n",
    "print('Độ dày nhỏ nhât là', beak_depths[0])\n",
    "print('Độ dày lớn nhất là', beak_depths[-1])\n",
    "print('Độ dày trung vị (median) là')\n",
    "print('Số lượng chim đo được ngày hôm nay là:', len(beak_depths))\n",
    "\n",
    "print('\\n')\n",
    "# Thêm và xóa phần tử\n",
    "beak_depths.append(9.9)\n",
    "print('Thêm 9.9 vào cuối: \\n', beak_depths)\n",
    "\n",
    "beak_depths.remove(9.9)\n",
    "print('Bỏ 9.9:\\n', beak_depths)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Như các em thấy, một `list` object có nhiều phương pháp bao gồm `append()` và `sort()`. Chúng được  goị tên theo chức năng, với các thông số (*arguments*) liên quan nằm trong dấu ngoặc. Tên của phương pháp đến từ tên của object tiếp nổi bỏi dấu chấm (.).\n",
    "\n",
    "Hàm `sort()` không có thông số nào nhưng vẫn yêu cầu nằm trong dấu ngoặc để sử dụng. Và rất hay là ta có thể dùng câu lệnh `append(số)` để thêm số mới  vào vị trí cuối của list.\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}