Week 1/Python-Basic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trong khoá học này, chúng ta sẽ sử dụng ngôn ngữ lập trình Python cho tất cả các bài tập. Python là một trong những ngôn ngữ lập trình đa năng tuyệt vời và có những thư viện phổ biến như python, scipy, matplotlib... Chính vì vậy mà Python trở thành ngôn ngữ được sử dụng rộng rãi trong giới khoa học máy tính.\n",
    "\n",
    "Bài viết này được viết dựa trên nội dung trong [CS228 Python Tuorial](https://github.com/kuleshov/cs228-material/blob/master/tutorials/python/cs228-python-tutorial.ipynb)\n",
    "\n",
    "### Giới Thiệu Về Python\n",
    "\n",
    "Python là một ngôn ngữ lập trình bậc cao. Những dòng Code của Python thường được cho là gần giống với mã giả, vì bạn có thể thực hiện những ý tưởng trong một vài dòng Code và rất dễ đọc. \n",
    "\n",
    "Ví dụ về thuật toán sắp xếp Quicksort trong Python:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 3, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "def quicksort(arr):\n",
    "    if len(arr) <= 1:\n",
    "        return arr\n",
    "    pivot = arr[len(arr) // 2]\n",
    "    left = [x for x in arr if x < pivot]\n",
    "    middle = [x for x in arr if x == pivot]\n",
    "    right = [x for x in arr if x > pivot]\n",
    "    return quicksort(left) + middle + quicksort(right)\n",
    "\n",
    "print(quicksort([3,6,8,10,1,2,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trong bài viết này, chúng ta sẽ tìm hiểu về các nội dung cơ bản sau đây:\n",
    "1. Kiểu dữ liệu \n",
    "2. Containers \n",
    "    - Lists (Kiểu danh sách)\n",
    "    - Dictionaries (Kiểu từ điển)\n",
    "    - Sets (Kiểu set)\n",
    "    - Tuples (Kiểu Tuple)\n",
    "3. Functions (hàm)\n",
    "4. Classes (lớp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lưu ý:** trong toàn bộ nội dung của khoá này sẽ sử dụng trên phiên bản 3.x.\n",
    "\n",
    "Các bạn có thể kiểm tra phiên bản hiện tại trong Command Line bằng dòng lệnh: `python --version`. Hoặc kiểm tra phiên bản trong Jupyter Notebook bằng dòng lệnh sau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.7.3\n"
     ]
    }
   ],
   "source": [
    "from platform import python_version\n",
    "print(python_version())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Kiểu dữ liệu \n",
    "\n",
    "Cũng giống như các ngôn ngữ khác, Python có các kiểu dữ liệu cơ bản bao gồm: integers, floats, booleans, và strings. \n",
    "\n",
    "#### 1.1 Numbers (Kiểu số)\n",
    "\n",
    "Kiểu integers (số nguyên) / floats (số thực) hoạt động giống như với các ngôn ngữ khác. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "3\n",
      "4\n",
      "2\n",
      "6\n",
      "9\n",
      "4\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "### Kiểu số nguyên (integers)\n",
    "x = 3\n",
    "print(type(x)) # Prints \"<class 'int'>\"\n",
    "print(x)       # Prints \"3\"\n",
    "print(x + 1)   # Thực hiện phép cộng; prints \"4\"\n",
    "print(x - 1)   # Thực nhiên phép trừ; prints \"2\"\n",
    "print(x * 2)   # Thực hiện phép nhân; prints \"6\"\n",
    "print(x ** 2)  # Thực hiện phép mũ; prints \"9\"\n",
    "x += 1\n",
    "print(x)  # Prints \"4\"\n",
    "x *= 2\n",
    "print(x)  # Prints \"8\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "2.5 3.5 5.0 6.25\n"
     ]
    }
   ],
   "source": [
    "### Kiểu số thực (floats)\n",
    "y = 2.5\n",
    "print(type(y)) # Prints \"<class 'float'>\"\n",
    "print(y, y + 1, y * 2, y ** 2) # Prints \"2.5 3.5 5.0 6.25\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Chú ý:** không giống như các ngôn ngữ khác, Python không có các phép toán `x++` hay `x--`.\n",
    "\n",
    "Tìm hiểu thêm về các phép toán trong Python tại [trang docs chính thức](https://docs.python.org/3.5/library/stdtypes.html#numeric-types-int-float-complex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2 Booleans \n",
    "\n",
    "Python thực hiện tất cả các phép toán thông thường trong đại số Boolean.\n",
    "\n",
    "Chúng ta có thể sử dụng các từ tiếng Anh thay cho các ký tự `&&`, `||`, v.v..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "t = True\n",
    "f = False\n",
    "print(type(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(t and f) # Logical AND; prints \"False\"\n",
    "print(t or f)  # Logical OR; prints \"True\"\n",
    "print(not t)   # Logical NOT; prints \"False\"\n",
    "print(t != f)  # Logical XOR; prints \"True\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.3 Strings "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python hỗ trợ rất tuyệt vời cho kiểu chuỗi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "5\n",
      "hello world\n",
      "hello world 12\n"
     ]
    }
   ],
   "source": [
    "hello = 'hello'    # Chuỗi ký tự sử dụng dấu nháy ' '\n",
    "world = \"world\"    # Hoặc sử dụng dấu nháy \" \"\n",
    "print(hello)       # Prints \"hello\"\n",
    "print(len(hello))  # lấy độ dài của chuỗi; prints \"5\"\n",
    "hw = hello + ' ' + world  # Kết nối chuỗi \n",
    "print(hw)  # prints \"hello world\"\n",
    "hw12 = '%s %s %d' % (hello, world, 12)  #  định dạng chuỗi kiểu sprintf\n",
    "print(hw12)  # prints \"hello world 12\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ngoài ra, còn có rất nhiều hàm hỗ trợ, các bạn có thể xem thêm trong [trang docs chính thức](https://docs.python.org/3.5/library/stdtypes.html#string-methods).\n",
    "\n",
    "Dưới đây là một số hàm phổ biến:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "HELLO\n",
      "            hello             \n",
      "world\n"
     ]
    }
   ],
   "source": [
    "s = \"hello\"\n",
    "# Viết hoa chữ cái đầu tiên \n",
    "print(s.capitalize())\n",
    "\n",
    "# Viết hoa toàn bộ chữ cái \n",
    "print(s.upper())\n",
    "\n",
    "# căn giữa \n",
    "print(s.center(30))\n",
    "\n",
    "# loại bỏ dấu cách thừa\n",
    "print('  world '.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Containers \n",
    "\n",
    "Trong Python có các kiểu chứa các dữ liệu như: Lists, Dictionaries, Sets, Tuples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1 Lists \n",
    "\n",
    "List trong Python là một dạng dữ liệu cho phép lưu trữ nhiều kiểu dữ liệu khác nhau, và chúng ta có thể thay đổi kích thước của nó:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 2] 2\n",
      "2\n",
      "[3, 1, 'foo']\n",
      "[3, 1, 'foo', 'bar']\n",
      "bar [3, 1, 'foo']\n"
     ]
    }
   ],
   "source": [
    "xs = [3, 1, 2]    # Tạo một list\n",
    "print(xs, xs[2])  # Prints \"[3, 1, 2] 2\"\n",
    "print(xs[-1])     # Các số âm thể hiện việc truy cập ngược từ cuối; prints \"2\"\n",
    "xs[2] = 'foo'     # List có thể chứa các phần tử khác nhau \n",
    "print(xs)         # Prints \"[3, 1, 'foo']\"\n",
    "xs.append('bar')  # Thêm phần tử mới vào list\n",
    "print(xs)         # Prints \"[3, 1, 'foo', 'bar']\"\n",
    "x = xs.pop()      # Xoá phần tử khỏi list \n",
    "print(x, xs)      # Prints \"bar [3, 1, 'foo']\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Đọc thêm về List: [Python List](https://docs.python.org/3.5/tutorial/datastructures.html#more-on-lists)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Slicing (cắt List):** ngoài việc truy cập từng phần tử trong List, Python cung cấp cú pháp ngắn gọn để truy cập nhiều phần tử (sublists). \n",
    "\n",
    "**Chú ý:** việc cắt List này không ảnh hưởng đến List ban đầu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "[2, 3]\n",
      "[2, 3, 4]\n",
      "[0, 1]\n",
      "[0, 1, 2, 3, 4]\n",
      "[0, 1, 2, 3]\n",
      "[0, 1, 8, 9, 4]\n"
     ]
    }
   ],
   "source": [
    "nums = list(range(5))     # tạo một list từ 0 đến 4\n",
    "print(nums)               # Prints \"[0, 1, 2, 3, 4]\"\n",
    "print(nums[2:4])          # lấy phần tử có vị trí 2 đến 4 (exclusive); prints \"[2, 3]\"\n",
    "print(nums[2:])           # lấy phần tử có vị trí 2 đến hết; prints \"[2, 3, 4]\"\n",
    "print(nums[:2])           # lấy phần tử từ đầu đến phần tử có vị trí 2 (exclusive); prints \"[0, 1]\"\n",
    "print(nums[:])            # lấy toàn bộ list; prints \"[0, 1, 2, 3, 4]\"\n",
    "print(nums[:-1])          # chỉ số có thể là số âm; prints \"[0, 1, 2, 3]\"\n",
    "nums[2:4] = [8, 9]        # thay đổi nhiều phần tử cùng lúc\n",
    "print(nums)               # Prints \"[0, 1, 8, 9, 4]\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Vòng lặp:** Bạn cũng có thể truy cập các phần tử của List bằng vòng lặp."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat\n",
      "dog\n",
      "monkey\n"
     ]
    }
   ],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for animal in animals:\n",
    "    print(animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nếu bạn muốn truy cập vào chỉ mục của từng phần tử của List, sử dụng hàm `enumerate`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#1: cat\n",
      "#2: dog\n",
      "#3: monkey\n"
     ]
    }
   ],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for idx, animal in enumerate(animals):\n",
    "    print('#%d: %s' % (idx + 1, animal))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**List comprehensions:** trong quá trình lập trình, chúng ta thường xuyên muốn thay đổi giá trị của các phần tử đồng loạt.\n",
    "\n",
    "Ví dụ: nhân giá trị của các phần tử bên trong List với 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Chúng ta không thực hiện được nhân với 2 theo cách sau. Điều này chỉ nhân số lượng thêm 2 lần.\n",
    "nums = [0, 1, 2, 3, 4]\n",
    "nums * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thay vào đó, chúng ta có thể sử dụng vòng lặp:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "squares = []\n",
    "for x in nums:\n",
    "    squares.append(x ** 2)\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chúng ta có thể làm cách trên đơn giản hơn bằng List Comprehensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "squares = [x ** 2 for x in nums]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chúng ta có thể sử dụng thêm các điều kiện khi dùng List Comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16]\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "even_squares = [x ** 2 for x in nums if x % 2 == 0]\n",
    "print(even_squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2 Dictionaries\n",
    "\n",
    "Dictionary trong Python là một tập hợp các cặp (key, value) không có thứ tự. Nó là một container mà chứa dữ liệu, được bao quanh bởi các dấu ngoặc móc đơn {}.\n",
    "\n",
    "Đọc thêm về [Python Dictionaries](https://docs.python.org/3.5/library/stdtypes.html#dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cute\n"
     ]
    }
   ],
   "source": [
    "d = {'cat': 'cute', 'dog': 'furry'}  # tạo một Dict \n",
    "print(d['cat'])       # Lấy giá trị có key = cat; prints \"cute\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print('cat' in d) # kiểm tra cat có trong dict ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wet\n"
     ]
    }
   ],
   "source": [
    "d['fish'] = 'wet'     # thêm một cặp key, value trong Dicts\n",
    "print(d['fish'])      # Prints \"wet\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'monkey'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-b78aff1f0d89>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Sẽ bị lỗi nếu `key` không tồn tại trong Dict\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'monkey'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'monkey'"
     ]
    }
   ],
   "source": [
    "# Sẽ bị lỗi nếu `key` không tồn tại trong Dict\n",
    "print(d['monkey'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N/A\n",
      "wet\n"
     ]
    }
   ],
   "source": [
    "# Thay vào đó chúng ta sẽ sử dụng lệnh `get`\n",
    "print(d.get('monkey', 'N/A'))  # Lấy giá trị có key = 'monkey' không có in ra 'N/A'; prints \"N/A\"\n",
    "print(d.get('fish', 'N/A'))    # Lấy giá trị có key = 'fish'không có in ra 'N/A'; prints \"wet\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Vòng lặp:** chúng ta có thể dễ dàng in các giá trị trong Dict bằng vòng lặp."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A person has 2 legs\n",
      "A cat has 4 legs\n",
      "A spider has 8 legs\n"
     ]
    }
   ],
   "source": [
    "d = {'person': 2, 'cat': 4, 'spider': 8}\n",
    "for animal in d:\n",
    "    legs = d[animal]\n",
    "    print('A %s has %d legs' % (animal, legs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionary comprehensions:** Cũng giống như List Comprehensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 2: 4, 4: 16}\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}\n",
    "print(even_num_to_square)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3 Sets\n",
    "\n",
    "Set là một kiểu chứa dữ liệu đặc biệt, nó chỉ chứa các giá trị riêng biệt không trùng lặp nhau.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "3\n",
      "{'fish', 'dog', 'cat'}\n"
     ]
    }
   ],
   "source": [
    "animals = {'cat', 'dog'}\n",
    "print('cat' in animals)   # kiểm tra phần tử trong set; prints \"True\"\n",
    "print('fish' in animals)  # prints \"False\"\n",
    "animals.add('fish')       # thêm phần tử vào set\n",
    "print('fish' in animals)  # Prints \"True\"\n",
    "print(len(animals))       # số lượng bên trong set; prints \"3\"\n",
    "print(animals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "{'fish', 'dog', 'cat'}\n"
     ]
    }
   ],
   "source": [
    "animals.add('cat')        # thêm phần tử vào set, nhưng `cat` đã có nên set không thay đổi\n",
    "print(len(animals))       # Prints \"3\"\n",
    "print(animals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "{'fish', 'dog'}\n"
     ]
    }
   ],
   "source": [
    "animals.remove('cat')     # xoá phần tử trong set \n",
    "print(len(animals))       # Prints \"2\"\n",
    "print(animals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Vòng lặp:** Bạn cũng có thể truy cập các phần tử của Set bằng vòng lặp."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#1: fish\n",
      "#2: dog\n",
      "#3: cat\n"
     ]
    }
   ],
   "source": [
    "animals = {'cat', 'dog', 'fish'}\n",
    "for idx, animal in enumerate(animals):\n",
    "    print('#%d: %s' % (idx + 1, animal))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Set comprehensions:** giống như Lists và Dictionaries, chúng ta cũng có thể tạo Set bằng phương thức Set Comprehensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "nums = {int(sqrt(x)) for x in range(30)}\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4 Tuples\n",
    "\n",
    "Tuple trong Python là một kiểu dữ liệu dùng để lưu trữ các đối tượng không thay đổi về sau (giống như hằng số)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "('monday', 'tuesday', 'wednesday', 'thursday')\n",
      "tuesday\n"
     ]
    }
   ],
   "source": [
    "day = ('monday', 'tuesday', 'wednesday', 'thursday')\n",
    "    \n",
    "print(type(day)) # Lấy kiểu dữ liệu \n",
    "print(day)       # in toàn bộ tuples \n",
    "print(day[1])    # truy cập vào phần tử index = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-30-d5a2c290c4ce>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Thực hiện thay đổi giá trị Tuples sẽ bị lỗi\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mday\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# Thực hiện thay đổi giá trị Tuples sẽ bị lỗi \n",
    "day[1] = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Functions\n",
    "\n",
    "Hàm trong Python được định nghĩa bằng từ khoá `def`. Ví dụ:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "negative\n",
      "zero\n",
      "positive\n"
     ]
    }
   ],
   "source": [
    "def sign(x):\n",
    "    if x > 0:\n",
    "        return 'positive'\n",
    "    elif x < 0:\n",
    "        return 'negative'\n",
    "    else:\n",
    "        return 'zero'\n",
    "\n",
    "for x in [-1, 0, 1]:\n",
    "    print(sign(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chúng ta có thể thêm đối số trong hàm như sau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Bob\n",
      "HELLO, FRED!\n"
     ]
    }
   ],
   "source": [
    "def hello(name, loud=False):\n",
    "    if loud:\n",
    "        print('HELLO, %s!' % name.upper())\n",
    "    else:\n",
    "        print('Hello, %s' % name)\n",
    "\n",
    "hello('Bob') # Prints \"Hello, Bob\"\n",
    "hello('Fred', loud=True)  # Prints \"HELLO, FRED!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Xem thêm về [Defining Functions](https://docs.python.org/3.5/tutorial/controlflow.html#defining-functions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cú pháp để sử dụng Class trong Python rất đơn giản:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Fred\n",
      "HELLO, FRED!\n"
     ]
    }
   ],
   "source": [
    "class Greeter(object):\n",
    "\n",
    "    # Constructor\n",
    "    def __init__(self, name):\n",
    "        self.name = name  # Cho giá trị của name vào self.name\n",
    "\n",
    "    # Instance method\n",
    "    def greet(self, loud=False):\n",
    "        if loud:\n",
    "            print('HELLO, %s!' % self.name.upper())\n",
    "        else:\n",
    "            print('Hello, %s' % self.name)\n",
    "\n",
    "g = Greeter('Fred')  # Khởi tạo Class g với đầu vào `Fred`\n",
    "g.greet()            # Gọi hàm greet() khi loud = False; prints \"Hello, Fred\"\n",
    "g.greet(loud=True)   # Gọi hàm greet() khi loud = True; prints \"HELLO, FRED!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Xem thêm về [Python Classes](https://docs.python.org/3.5/tutorial/classes.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bảng tổng kết \n",
    "\n",
    "Bảng tổng kết các kiến thức cơ bản trong Python [tải xuống tại đây](https://github.com/thanhhff/AIVN-Machine-Learning/blob/master/Python/Python3_reference_cheat_sheet.pdf)\n",
    "\n",
    " <img src=\"https://imgur.com/1hMqrPZ.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tổng kết \n",
    "\n",
    "Thông qua bài này, các bạn đã nắm một số kiến thức cơ bản trong lập trình Python. Những nội dung bên trên có thể hơi nhanh với một số bạn mới bắt đầu học Python. Tuy nhiên, những nội dung này khá quan trọng trong và dùng nhiều để Code trong Machine Learning. Các bạn hãy chú ý học kỹ và làm bài tập đầy đủ !"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}