---
# System prepended metadata

title: Virgil - Practice Python - S21 Variable and if
tags: [' LearnWorld', ' PracticePython', Virgil]

---

---
title: Virgil - Practice Python - S21 Variable and if
tags: Virgil, LearnWorld, PracticePython
---

# Variable and If-statement

## Introduction

```python
course_number = 0

course_number = course_number + 1

if course_number > 0:
    print("I have learned at CoderSchool")

coderschool_quote = "Always be learning!"
print(coderschool_quote)
```

Đoạn code đơn giản phía trên thể hiện một vài điểm quan trọng trong Python về biến (variable) và phép gán (assignment operator):

- Dòng đầu tiên tạo ra một biến (variable) có tên là `course_number`, sau đó **gán** cho biến giá trị bằng 0. Dấu `=` ở đây gọi là phép gán (**assignment operator**).
- Tên biến trong Python được đặt theo quy ước **snake_case** (tên biến có thể chứa nhiều từ đơn tách nhau bởi dấu gạch dưới `_`).
- Biến `course_number` không cần được "khai báo" trước khi sử dụng như một vài ngôn ngữ lập trình khác.
- Dòng code thứ hai là một ví dụ của **reassignment**. Dấu `=` hay assignment operator vẫn được sử dụng ở đây cho ta hiểu hơn về cách thức hoạt động của nó. Ở đây Python sẽ tính giá trị vế bên phải sau đó gán cho variable phía bên trái. Như vậy về phải `course_number + 1` sẽ được tính là `0 + 1 = 1`, kết quả 1 sẽ được lưu vào cùng biến `course_number` khiến giá trị nó lưu giữ được "update" thành `1`.

Tiếp theo hãy phân tích câu lệnh `if`. Ở đây dòng chữ `I have learned at CoderSchool` sẽ được in ra màn hình nếu giá trị của biến `course_number` lớn hơn `0`. Một số điểm cần lưu ý:

- `course_number > 0` được gọi là **conditionals**, hay biểu thức logic. Biểu thức này sẽ trả về giá trị đúng `True` hoặc sai `False`.
- Dấu `:` cuối câu lệnh `if` ám chỉ một nhóm câu lệnh (**block of code**) bắt đầu, và dòng tiếp theo sẽ được lùi dòng vào 4 khoảng trống (theo quy ước) để thể hiện câu lệnh thuộc về lệnh `if` và sẽ được gọi nếu biểu thức logic là đúng.
- Câu lệnh `coderschool_quote = "Always be learning!"` không lùi dòng thể hiện nó không thuộc về block of code của lệnh `if`.

Có thể thấy Python nổi tiếng vì sự đơn giản và dễ đọc, kể cả chưa quen với câu lệnh if, bạn cũng có thể đoán được đại khái cách nó hoạt động. Chúng ta sẽ đi sâu hơn vào cú pháp lệnh `if` ở phần tiếp theo.

## Kiểu dữ liệu dạng số (numbers) và các phép toán

Khi bạn tạo một variable như `course_number = 0`, Python sẽ hiểu variable chứa giá trị `0` và có kiểu dữ liệu (datatype) là `int` (viết tắt của **Integer** số nguyên).

Nếu bạn viết code:

```python
weight = 100.5
```

Python sẽ hiểu variable `weight` chứa giá trị `100.5` với kiểu dữ liệu `float` (số thực). `int` và `float` là hai kiểu dữ liệu dạng số cơ bản của Python.

Để xem kiểu dữ liệu của một biến, bạn có thể dùng hàm `type()`, ví dụ:

```
a = 1
print(type(a))
s = "CoderSchool"
print(type(s))
```

### Các phép toán với dữ liệu dạng số

Bảng sau đây tóm tắt các phép toán chính:

| Operator | Name           | Description                                        |
| -------- | -------------- | -------------------------------------------------- |
| `a + b`  | Addition       | Sum of `a` and `b`                                 |
| `a - b`  | Subtraction    | Difference of `a` and `b`                          |
| `a * b`  | Multiplication | Product of `a` and `b`                             |
| `a / b`  | True division  | Quotient of `a` and `b`                            |
| `a // b` | Floor division | Quotient of `a` and `b`, removing fractional parts |
| `a % b`  | Modulus        | Integer remainder after division of `a` by `b`     |
| `a ** b` | Exponentiation | `a` raised to the power of `b`                     |
| `-a`     | Negation       | The negative of `a`                                |

Ngoài các phép tính cộng, trừ, nhân, chia, ở đây bạn có thể mới thấy phép chia lấy nguyên (Floor Division) và phép chia lấy dư (Modulus). Để dễ hiểu bạn hãy chạy đoạn code dưới đây:

```python
a = 16
b = 3

print(a // b)
print(a % b)
```

`16` chia `3` sẽ được `5` dư `1`. Ở đây `5` sẽ là kết quả của `a // b` còn `1` sẽ là kết quả của `a % b`.

## Kiểu dữ liệu logic Boolean và các phép toán logic

Python có kiểu dữ liệu `bool` viết tắt của **Boolean** là kiểu dữ liệu chỉ có thể là một trong hai giá trị đúng **True** hoặc sai **False**

```
x = True
print(x)
print(type(x))
```

Giá trị `True` và `False` là kết quả của các phép toán logic **boolean operators** thường được sử dụng làm điều kiện (**conditionals**) trong câu lệnh `if`.

### Phép toán so sánh - Comparison Operations

| Operation | Description                      |
| --------- | -------------------------------- |
| `a == b`  | `a` equal to `b`                 |
| `a != b`  | `a` not equal to `b`             |
| `a < b`   | `a` less than `b`                |
| `a > b`   | `a` greater than `b`             |
| `a <= b`  | `a` less than or equal to `b`    |
| `a >= b`  | `a` greater than or equal to `b` |

Lưu ý:

- So sánh `a` có bằng `b` hay không dùng hai dấu bằng `==` thay vì một. Bạn nhớ rằng một dấu bằng `=` là phép gán (assignment operator), không phải là biểu thức logic.
- Phép toán so sánh "khác" `a != b` trả về `True` nếu giá trị của `a` khác `b`.
- `a <= b` là phép so sánh a nhỏ hơn hoặc bằng b hay không, và `a >= b` là a lớn hơn hoặc bằng b hay không (Cách nhớ là đọc từ trái qua phải)

### `and`, `or`, và `not`

Python cho phép bạn kết nối các biểu thức logic với nhau thông qua `and`, `or`, và `not`. Ví dụ:

```python
# The US Constitution says you must be a natural born citizen AND at least 35 years old

is_natural_born_citizen = True
age = 40

if is_natural_born_citizen and (age >= 35):
    print('Yes')
else:
    print('No')
```

Trong ví dụ trên `and` kết nối hai biểu thức logic:

- Biểu thức đầu tiên là biến `is_natural_born_citizen` trả về giá trị `True`
- Biểu thức thứ hai là `age >= 35` cũng trả về True

Kết quả của `and` chỉ đúng khi cả hai biểu thức đều đúng, nên ở đây kết quả là `Yes`. Bạn có thể thay đổi giá trị của biến `is_natural_born_citizen` hoặc `age` để kết quả ra `No` không?

Kết quả của `or` đúng khi một trong hai biểu thức đúng, ví dụ:

```python
grade_1 = 9
grade_2 = 4

if (grade_1 <= 5) or (grade_2 <= 5):
    print('failed')
else:
    print('passed')
```

Trong ví dụ trên `grade_1` và `grade_2` chứa điểm của hai bài kiểm tra. Kết quả tổng kết là trượt `failed` nếu một trong hai bài có điểm dưới 5.

Khác với `and` và `or`, `not` không kết hợp hai biểu thức logic mà chỉ cần một. Phép `not` sẽ đúng khi biểu thức logic mà nó đừng trước là sai và ngược lại. Ví dụ:

```python
grade = 9

if not grade < 5:
    print('passed')
else:
    print('failed')
```

Ở đây, `passed` sẽ được in ra nếu `grade` không nhỏ hơn 5.

Lưu ý, bạn có thể kết hợp `and`, `or` và `not` lại thành những biểu thức rất phức tạp. Ví dụ cho một biến `year`, viết logic kiểm tra giá trị của `year` có phải là năm nhuận hay không, nếu biết:

- Năm nhuận là năm chia hết cho 400
- Năm nhuận là năm chia hết cho 4 nhưng không chia hết cho 100

```python
year = 1000

if ((year % 4 == 0) and (year % 100 != 0)) or (year % 400 == 0):
    print('Leap Year')
else:
    print('not a Leap Year')
```

Chú ý cách đóng mở ngoặc trong biểu thức logic ở trên.

## Câu lệnh `if`

Ví dụ dưới đây thể hiện cú pháp đầy đủ của câu lệnh `if`:

```python
x = 1

if x == 0:
    print(x, "is zero")
elif x > 0:
    print(x, "is positive")
elif x < 0:
    print(x, "is negative")
else:
    print(x, "is unlike anything I've ever seen...")
```

Bạn đã quen thuộc với `if` và `else` trong các ví dụ ở trên. Còn `elif` là viết tắt của `else if`. Các điều kiện `x == 0`, `x > 0`, `x < 0` sẽ được kiểm tra lần lượt. Nếu một trong các điều kiện đúng thì câu lệnh `print` tương ứng sẽ được thực thi và kết thúc câu lệnh `if`. Nếu tất cả các điều kiện đều sai thì lệnh `print` của `else` cuối cùng sẽ được thực thi.

Lưu ý rằng sẽ chỉ có 1 trong số các câu lệnh `print` ở trên được thực thi.

## Nâng cao và mở rộng

- Bạn có thể gán 2 giá trị cho 2 biến trong cùng một câu lệnh, ví dụ:

```python
a, b = 1, 2
```

- Bạn có thể đảo giá trị của hai biến cho nhau trong một câu lệnh, ví dụ:

```python
a, b = b, a
```

- Bạn có thể lồng các câu lệnh `if` vào với nhau, ví dụ:

```python
price = 100
is_discount = True
quantity = 10

if is_discount:
    if quantity > 5:
        price = price * 0.8
    else:
        price = price * 0.9

print('Final Price:', price)
```

- **Ternary operator**: Khi bạn có một đoạn lệnh sử dụng `if .. else ..` đơn giản, bạn có thể viết ngắn gọn lại thành một dòng lệnh theo cú pháp ternary operator:

```
[on_true] if [expression] else [on_false]
```

```python
if grade > 5:
    result = 'passed'
else:
    result = 'failed'

# Equivalent
result = 'passed' if grade > 5 else 'failed'
```
