---
# System prepended metadata

title: PYTHON CƠ BẢN

---

# PYTHON CƠ BẢN
## In và chú thích
### In
* Sử dụng hàm **print()** để hiển thị thông tin ra màn hình
* Ví dụ: Hiển thị ra màn hình dòng chữ "Hello World!"
```python=
print("Hello World!")
# hoặc
print('Hello World!')
# có thể dùng nháy đơn hoặc nháy kép trong câu lệnh in ra thông tin trên màn hình
 ```
Chạy chương trình, ta có kết quả

![](https://i.imgur.com/l2HdOvm.png)

*  Để hiển thị ra màn các phép tính của các số trong Python thì ta cần dùng hàm **print()** với các **toán tử**(+, -, *, /, %...) 
*  Ví dụ: Hiển thị ra màn hình tổng, hiệu, tích, thương, chia lấy dư của hai số nguyên 45 và 5.
```python=
print(45 + 5)
print(45 - 5)
print(45 * 5)
print(45 / 5)
print(45 % 5)
```
Chạy chương trình, ta có kết quả

![](https://i.imgur.com/j5fBpIR.png)

* Lưu ý: Khi sử dụng hàm print() để thực hiện một phép toán bạn không được sử dụng cặp dấu nháy đôi "" hoặc nháy đơn '', vì nếu sử dụng cặp dấu nháy thì chương trình sẽ hiểu đó là một chuỗi các ký tự chứ không phải một phép toán. Ví dụ chương trình sau:
```python=
print('1 + 1')
```
Chạy chương trình, ta có kết quả
![](https://i.imgur.com/U4Vo5ej.png)

* Hoặc nếu bạn muốn hiện thị trên màn hình một phép toán gồm cả phép tính và kết quả, bạn có thể làm như sau:
```python=
print('1 + 2 =', 1 + 2)
```
Chạy chương trình, ta có kết quả:
![](https://i.imgur.com/t69nVB4.png)

* Lưu ý: nếu bạn thêm khoảng trắng vào sau dấu '=' trong ví dụ trên thì kết quả sẽ có 1 khoảng trắng (hàm print() sẽ tự động thêm vào một khoảng trắng với mỗi một tham số mới). Ví dụ:
```python=
print('1 + 2 = ', 1 + 2)
```
Chạy chương trình, ta có kết quả:
![](https://i.imgur.com/5kMja0P.png)
### Comment
* Comment hay còn gọi là chú thích được dùng để giải thích các dòng code, giúp cho người đọc hay chính người viết code sau này hiểu được source code dễ dàng hơn. Các ký tự và đoạn code trong comment sẽ không ảnh hưởng tới kết quả chương trình.
* Trong Python có 2 loại comment là comment trên một dòng và comment trên nhiều dòng.
#### Comment trên 1 dòng
* Comment trên một dòng sẽ được bắt đầu với ký tự '**#**'
* Ví dụ:
```python=
# Dòng code bên dưới dùng để hiện thị từ Hello World
print('Hello World') # Bạn có thể comment ngay bên cạnh dòng code như thế này
```
Kết quả khi chạy chương trình:
![](https://i.imgur.com/57Xj7Af.png)

#### Comment trên nhiều dòng
* Comment trên nhiều dòng trong ngôn ngữ lập trình Python sẽ bắt đầu bằng 3 dấu nháy đơn ''' hoặc 3 dấu nháy kép """ và kết thúc cũng bằng 3 dấu nháy đơn ''' hoặc 3 dấu nháy kép """
* Ví dụ:
```python=
'''
Dòng code bên dưới được dùng để hiển thị ra màn hình dòng chữ Hello World
hihihi
hehehe
'''
print('Hello World')
```
Kết quả khi chạy chương trình:
![](https://i.imgur.com/57Xj7Af.png)

## Kiểu dữ liệu, biến và ép kiểu
### Biến
* Khái niệm biến trong lập trình cũng giống khái niệm biến trong toán học, biến được sử dụng để lưu trữ dữ liệu trong chương trình. Dữ liệu được lưu trữ trong một biến có thể thay đổi trong khi chạy chương trình. 
Trong Python, bạn không cần khai báo biến một cách tường minh trước khi sử dụng cũng như khai báo kiểu dữ liệu của chúng. Biến được tạo ra khi ta bắt đầu gán giá trị cho nó.
* Ví dụ
```python=
# Khai báo biến a và gán giá trị cho a = 5
a = 3
# Khai báo biến b và gán giá trị cho b = 7
b = 4
print("a + b =",a + b)
```
 Kết quả khi chạy chương trình
![](https://i.imgur.com/540PgBF.png)

### Kiểu dữ liệu
* Trong Python cũng như các ngôn ngữ lập trình khác, một biến luôn có kiểu dữ liệu. Một số kiểu dữ liệu cơ bản trong Python:

   - **int**: đây là kiểu dữ liệu được dùng để lưu trữ các số nguyên (1, 2, 3, 4, ...).
    - **float**: đây là kiểu dữ liệu dùng để lưu trữ các biến kiểu số thực (1.43, 5.34, 3.333, ...).
    - **bool**: đây là kiểu dữ liệu dùng để lưu trữ các giá trị luận lý (True hoặc False)
    - **str**: đây là kiểu dữ liệu dùng để lưu trữ các xâu ký tự ("Viet Nam", "Codelearn", ...)
    - Ngoài ra trong Python còn một số kiểu dữ liệu khác như **list, set, dict, tuple, complex** 
* Để kiểm tra kiểu dữ liệu của biến, bạn có thể sử dụng hàm **type()**
* Ví dụ
```python=
name = "Python"
year = 2023
pi = 3.14

print(type(name))
print(type(year))
print(type(pi))
```
 Kết quả khi chạy chương trình

![](https://i.imgur.com/0kBjYWe.png)

* Một số lưu ý khi đặt tên biến

   - Tên biến có thể được bắt đầu bằng ký tự _ hoặc bất cứ chữ cái nào (in hoa hoặc in thường).
   - Tên biến không được bắt đầu bằng chữ số. Ví dụ tên biến 1value là không hợp lệ.
   - Tên biến không được bao gồm dấu cách trong đó.
   - Không sử dụng các từ khóa có sẵn trong Python như print, if, else... để đặt tên cho biến. Ví dụ tên biến print là không hợp lệ, tên biến print1, print_2, printHello... là hợp lệ.
  
* Ngoài kiểu dữ liệu số thì kiểu dữ liệu chuỗi ký tự (str) cũng có các toán tử như +, *, [], in, not in, ... Trong đó toán tử + dùng để nối chuỗi và toán tử * dùng để lặp chuỗi. 
* Ví dụ
```python=
name = "Python "
print("Hello " + name)
print(name * 3)
```
Kết quả sau khi chạy chương trình:

![](https://i.imgur.com/2Tk3q87.png)

## Input
* Để nhập dữ liệu cho biến từ bàn phím rất đơn giản, bạn sử dụng hàm **input()**
* Ví dụ
```python=
# Nhập dữ liệu cho biến từ bàn phím
name = input()
age = input()
print("Hello " + name)
print(type(age))
```
 Nhập vào từ bàn phím 

![](https://i.imgur.com/okWdkBS.png)

Chạy chương trình ta có kết quả

![](https://i.imgur.com/bbqEk6m.png)

* Trong Python, dữ liệu nhập từ bàn phím luôn có kiểu là str (hàm **input()** trả về **kiểu str**), mà biến **kiểu str** thì **không thể tính toán được**. Do đó khi bạn cần chuyển kiểu dữ liệu của biến về kiểu int, bạn có thể làm như sau:
```python=
age = int(input())
print(type(age))
```
* Khi bạn nhập số 10 thì chương trình có kết quả:
![](https://i.imgur.com/YbTsUkA.png)

## Toán tử

* Python xây dựng 7 loại hình tính toán trên toán tử như sau:

  - Python Arithmetic Operator (toán tử số học)
  - Python Relational Operator (toán tử quan hệ)
  - Python Assignment Operator (toán tử gán)
  - Python Membership Operator (toán tử membership)
  - Python Identity Operator (toán tử identity)
  - Python Logical Operator (toán tử logic)
  - Python Bitwise Operator (toán tử thao tác bit)
### Arithmetic Operators (Toán tử số học)

Đây là toán tử dùng để thao tác với các phép toán như cộng, trừ, nhân, chia, chia dư,...

![](https://i.imgur.com/KuQ96Yo.png)


* Ví dụ
```python=
a = 3
b = 5

print('a + b =', a+b)
print('a - b =', a-b)
print('a * b =', a*b)
print('a / b =', a/b)
print('a % b =', a % b)
print('a // b =', a//b)
print('a ** b =', a**b)
```
Kết quả sau khi chạy chương trình
![](https://i.imgur.com/rylpUFI.png)

### Relational Operator (toán tử quan hệ)
Các toán tử so sánh được dùng để so sánh hai giá trị với nhau. Kết quả của các toán tử này sẽ là True hoăc False (đúng hoặc sai). Các toán tử so sánh sẽ giúp ta kiểm tra xem hai giá trị có bằng, lớn hơn hay nhỏ hơn nhau hay không,...

![](https://i.imgur.com/3B1yP4Q.png)
* Ví dụ
```python=
# So sánh hai số
a = 4
b = 6

print("a > b :", a>b)
print("a < b :", a<b)
print("a = b :", a==b)
print("a >= b :", a>=b)
print("a <= b :", a<=b)
print("a != b :", a!=b)
```
Kết quả khi chạy chương trình

![](https://i.imgur.com/jOZRDMQ.png)

### Python Assignment Operator (toán tử gán)
Toán tử gán thường được dùng để gán giá trị của vế phải sang cho vế trái.

![](https://i.imgur.com/FBML9su.png)
* Ví dụ
```python=
a = 10
print("a =", a)
b = a
print("b =", b)

b += a
print("b +=a then b =", b)

b -= a
print("b -=a then b =", b)
 
b *= a
print("b *=a then b =", b)
 
b <<= a
print("b <<=a then b =", b)
```
 Kết quả

![](https://i.imgur.com/wWv2oXK.png)


### Membership Operator (toán tử membership)
* Toán tử membership là toán tử dùng để kiểm xem một giá trị có nằm trong giá trị khác hay không.
**in** và **not in** là hai toán tử membership với cách sử dụng rất đơn giản.
* **Lưu ý**: Trong một dictionary, toán tử membership chỉ giúp chúng ta **kiểm tra key**, chứ không **kiểm tra value**.

![](https://i.imgur.com/IaJA8Wb.png)
* Ví dụ
```python=
x = 'Hello world'
print('H' in x)
print('hello' not in x)
print('W' in x)
```
 Kết quả
![](https://i.imgur.com/QDmZvxf.png)

### Identity Operator (toán tử identity)
Toán tử định danh (identity) được dùng để xác định xem hai biến có đang trỏ tới cùng một đối tượng hay không. Với các kiểu dữ liệu như int, str, float,... thì toán tử này tương đương với toán tử ==.

Trong Python, is và is not chính là 2 toán tử định danh.

![](https://i.imgur.com/B8UeXtM.png)

* Ví dụ
```python=
a = 5
b = 7
print(a is b)
print(a is not b)
```
 Kết quả

![](https://i.imgur.com/uqGdE91.png)

### Logical Operator (toán tử logic)
Toán tử logical (logic) not, or và and là các toán tử được dùng để kết hợp các mệnh đề lại với nhau.

![](https://i.imgur.com/MLE8sTU.png)

* Ví dụ
```python=
x = True
y = False
print(x and y)
print(x or y)
print(not x)
```
 Kết quả

![](https://i.imgur.com/YC4m2AW.png)

### Bitwise Operator (toán tử thao tác bit)
Toán tử trên bit thực hiện các thao tác trên từng bit của toán hạng. Toán hạng sẽ được tự động được chuyển đổi để biểu diễn dưới dạng bit rồi thực hiện các toán tử trên bit.

![](https://i.imgur.com/YV2snva.png)

* Ví dụ:
```python=

x = 10
y = 4

print("x & y =", x & y)

print("x | y =", x | y)

print("~x =", ~x)

print("x ^ y =", x ^ y)

print("x >> y =", x >> 2)

print("x << y =", x << 2)
```
Kết quả

![](https://i.imgur.com/a9xYemq.png)

## If - Else

 Mệnh đề if-else được dùng để kiểm tra một điều kiện có đúng hay không, nếu đúng thì khối lệnh bên trong if sẽ được thực thi, ngược lại nếu điều kiện là sai thì khối lệnh bên trong else sẽ được thực thi.
 **Lưu ý**: khối lệnh trong if và else chính là các đoạn code được thụt lề vào trong (ở các ngôn ngữ lập trình khác thì khối lệnh được xác định bằng cặp dấu {} nhưng đối với Python thì khối lệnh được xác định bằng việc thụt lề).
*  Ví dụ: Kiểm tra tính chẵn lẻ của một số 
```python=
n = int(input())
if n % 2 == 0:
    # Nếu n là số chẵn thì hiển thị ra màn hình n số chẵn
    print(n, "la so chan")
else:
    # Ngược lại, nếu n không là số chẵn thì hiển thị ra màn hình n là số lẻ
    print(n, "la so le")
```
Nếu bạn nhập n = 6 thì kết quả khi chạy chương trình như sau
![](https://i.imgur.com/ifvjBeO.png)


Nếu bên trong mệnh đề else có mệnh đề if thì bạn có thể rút gọn thành **elif**
* Ví dụ:
```python=
a = int(input())
b = int(input())
if a == b:
    print("a = b")
elif a > b:
    print("a > b")
else:
    print("a < b")
```
## Vòng lặp
Vòng lặp được hiểu đơn giản là lặp lại một đoạn code nhiều lần. Trong Python có hỗ trợ 2 loại vòng lặp là vòng lặp **while** và vòng lặp **for**.
### While
Vòng lặp while được dùng để lặp lại một hành động cho tới khi điều kiện lặp không còn thỏa mãn nữa. Cú pháp của vòng lặp while:
```python
while điều kiện:
    # Khối lệnh này sẽ được thực thi nếu điều kiện đúng
```
* Ví dụ
```pt=
n = int(input())
i = 1
tong = 0
while i <= n:
    tong += i
    i += 1
print(tong)
```
Nhập n = 10 thì ta có kết quả
![](https://i.imgur.com/G3MtfeD.png)


### For
Không giống với vòng lặp while, vòng lặp for được dùng để lặp qua một tập hợp cho trước, vòng lặp for thường được sử dụng với hàm **range()**
 **range()** chính là hàm trả về một tập hợp

* Ví dụ
```python=
for i in range (1, 5):
    print(i)
```
Kết quả
![](https://i.imgur.com/cQ7IdIp.png)

Ngoài ra, bạn có thể sử dụng vòng lặp for để duyệt qua các ký tự của một xâu

```python=
name = 'Hello Python'
for c in name:
    print(c)
```
Kết quả khi chạy chương trình
![](https://i.imgur.com/kf6JV0u.png)

### Break
Câu lệnh break được dùng để thoát khỏi vòng lặp, khi chương trình gặp câu lệnh break thì vòng lặp sẽ không được thực thi tiếp

* Ví dụ
```python=
for i in range(1, 20):
    if i == 5:
        break
    print(i)
```
Kết quả
![](https://i.imgur.com/bleG6up.png)

### Continue
Khi gặp câu lệnh continue trong vòng lặp, các đoạn code bên dưới câu lênh này trong vòng lặp sẽ không được thực thi.
* Ví dụ
```python=
for i in range(1, 10):
    if i % 2 == 0:
        continue
    print(i)
```
Kết quả
![](https://i.imgur.com/Hqa2CLI.png)


## Mảng và liệt kê

list trong Python là một kiểu dữ liệu cho phép lưu trữ nhiều kiểu dữ liệu khác. Để khởi tạo một list trong Python bạn có thể sử dụng cặp dấu []
* Ví dụ
```python=
list1 = [1, 2, 3]
print(list1[0])
print(list1[1])
print(list1[2])
```
Kết quả
> 1
> 2
> 3

**Lưu ý**: list1[1] không phải là phần tử đầu tiên của list mà phải là list1[0] (do chỉ số của list được bắt đầu từ 0).

**Một số hàm thường gặp trong list**
### append()
* Để thêm một phần tử vào cuối của list bạn dùng hàm **append()**
* Ví dụ:
```python=
lst = [1, 2]
lst.append(4)
lst.append(6)
print(lst)
```
Kết quả
> [1, 2, 4, 6]

### len()
**Len()** là hàm dùng để tìm độ dài hoặc là số phần tử của một đối tượng trong python.
Chúng ta sử dụng hàm **len()** trong python tìm độ dài chuỗi trong python, đếm số phần tử trong list python cũng như là đếm số phần tử trong mảng python
```python=
lst = [2, 3, 1]
print(len(lst))
```
Kết quả khi chạy chương trình
> 3

### min(), max()
Đây là hai hàm được dùng để trả về phần tử lớn nhất và nhỏ nhất trong **list**
```python=
lst = [2, 18, 3]
print(max(lst))
print(min(lst))
```
Kết quả khi chạy chương trình
> 18
> 2

### insert()
Đây là hàm dùng để thêm một phần tử vào một ví trí trong **list**
* Ví dụ
```python=
chucai = ['a', 'b', 'c', 'd']
chucai.insert(3, 'f')
print(chucai)
```
Kết quả
> ['a', 'b', 'c', 'f', 'd']

### remove()
Hàm này dùng để xóa một phần tử khỏi **list**
* Ví dụ:
```python=
list2 = [1, 2, 3, 4]
list2.remove(3)
print(list2)
```
Kết quả
> [1, 2, 4]

### pop()
Hàm **pop()** được dùng để xóa một phần tử với chỉ số cho trước trong **list**
* Ví dụ:
```python=
list3 = ['ho', 'ten dem', 'ten']
list3.pop(1) # Xóa phần tử thứ 2 khỏi list
print(list3)
```
Kết quả
> ['ho', 'ten']

### sort()
Hàm này được dùng để sắp xếp các phần tử trong list theo một thứ tự nhất định.
* Ví dụ:
```python=
list4 = [10, 6, 1, 5, 9, 3]
list4.sort() # Sắp xếp theo thứ tự tăng dần
print(list4)
```
Kết quả
> [1, 3, 5, 6, 9, 10]

### reverse()
Đây là hàm dùng để đảo ngược list
* Ví dụ
```python=
list5 = [10, 6, 1, 5, 9, 3]
list5.reverse()
print(list5)
```
Kết quả
> [3, 9, 5, 1, 6, 10]

### count()
Đây là hàm dùng để đếm số lần xuất hiện của một thành phần trong list
* Ví dụ
```python=
list6 = [1, 4, 5, 9, 13, 4]
print(list6.count(4))

```
Kết quả
> 2

### clear()
Đây là hàm dùng để xóa hết các phần tử bên trong list
* Ví dụ:
```python=
list7 = [1, 3, 4]
list7.clear()
print(list7)
```
Kết quả
> []


## Chuỗi
Trong Python, chuỗi là một tập hợp các kí tự Unicode. Tuy nhiên, Python không có kiểu kí tự (character) giống các ngôn ngữ lập trình khác, thay vào đó bạn có thể hiểu rằng ký tự là một xâu có độ dài bằng 1.

Để khai báo một chuỗi trong Python bạn có thể sử dụng một cặp dấu nháy đơn hoặc nháy đôi. Ngoài ra bạn cũng có thể sử dụng 3 cặp nháy đơn, nháy đôi để tạo ra một chuỗi trên nhiều dòng.
* Ví dụ
```python=
s = '''
Toan
Ly
Hoa
'''
print(s)
```
Kết quả chạy chương trình
> Toan
Ly
Hoa

* Một số phương thức để xử lý chuỗi trong Python

### Phương thức lower()
Đây là phương thức được dùng để chuyển 1 chuỗi về dạng in thường:
```python=
s = 'HELLO WORLD'
print(s.lower())
```
Kết quả
> hello world

### Phương thức upper()
Đây là phương thức được dùng để chuyển 1 chuỗi về dạng in hoa:
```python=
s = 'hello world'
print(s.upper())
```
Kết quả
> HELLO WORLD

### Phương thức isalnum()
Đây là phương thức được dùng để kiểm tra xem một xâu có chỉ chứa các ký tự chữ và số hay không. 
* Ví dụ:
```python=
s = "Helloworld2023"
print(s.isalnum())
s = "Hello world 2023"
# Kết quả sẽ là False do chuỗi s chứa ký tự .
print(s.isalnum())
```
Kết quả
> True
> False

### Phương thức isalpha()
Phương thức này được dùng để kiểm tra xem một chuỗi có chứa toàn các ký tự chữ không:
```python=
s = 'Helloworld'
print(s.isalpha())
s = 'Helloworld2023'
# Kết quả sẽ là False do chuỗi s chứa số .
print(s.isalpha())
```
Kết quả
> True
> False

### Phương thức isnumeric()
Phương thức này dùng để kiểm tra xem một xâu có chứa toàn các ký tự số hay không:
```python=
s = "2023"
print(s.isnumeric())
s = "p2023"
print(s.isnumeric())
```
Kết quả
> True
> False

### Phương thức split()
Phương thức này được dùng để cắt một chuỗi ra thành list các chuỗi khác dựa trên một phần tử trong chuỗi đầu vào:
```python=
s = "Hello world"
print(s.split(" "))
s = "A1B1C1D1E1"
print(s.split("1"))
```
Kết quả
>['Hello', 'world']
['A', 'B', 'C', 'D', 'E', '']

### Phương thức join()
Phương thức này được dùng để nối một tập hợp thành một chuỗi sử dụng kí tự cho trước:
```python=
lst = ["Hello", "world"]
print(" ".join(lst))
lst = ["A", "B", "C"]
print("->".join(lst))
```
Kết quả
>Hello world
A->B->C

### Phương thức replace()
Phương thức này được dùng để thay thế các chuỗi con tìm thấy thành chuỗi con mới:
```python=
name = "H3llo"
print(name.replace("3", "e"))
```
Kết quả
> Hello

###
* Bạn có thể lấy ra một ký tự trong chuỗi thông qua chỉ số giống như lấy ra một phần tử trong list
* Ngoài ra, trong ngôn ngữ lập trình Python bạn còn có thể truy xuất tới chỉ số âm của chuỗi. Vị trí -1 sẽ thể hiện cho ký tự cuối cùng trong chuỗi, tương tự với -2, -3, -4, ... 
* Ví dụ
```python=
s = 'Hello Python'
# s[0] là phần tử đầu tiên trong chuỗi
print(s[0])
# s[-1] là phần tử cuối cùng trong chuỗi
print(s[-1])
# s[-2] là phần tử đứng trước phần tử cuối cùng trong chuỗi
print(s[-2])
```
Kết quả
> H
> n
> o

**Cắt chuỗi trong Python (Slice a string in Python)**

Để lấy ra một dãy các kí tự liên tiếp trong chuỗi, bạn có thể sử dụng phương pháp slicing giống như sau:
```python=
s = 'Hello Python'
print(s[0:2])
print(s[3:5])
print(s[6:])
print(s[:6])
print(s[6:-4])

```
Kết quả
>He
lo
Python
Hello 
Py


## Hàm
Hàm được hiểu đơn giản là 1 đoạn code, khi bạn gọi hàm thì thực ra là bạn đang gọi tới đoạn code này (bạn cũng có thể hiểu hàm là viết tắt của 1 đoạn code). Để khai báo một hàm bạn dùng từ khóa **def**
Python cũng cung cấp các hàm có sẵn như print(), max(), len(), type()...
```python=
def tên_hàm(tham số):
    # Khối lệnh
```
![](https://i.imgur.com/X5N6UEd.png)


* Ví dụ:
```python=
def xinchao(ten, ten1):
    print('Xin chao', ten,',', ten1)
xinchao('Ha', 'Linh')
```
Kết quả khi chạy chương trình
![](https://i.imgur.com/2lJnLXe.png)

### Return
Return trong python là một từ khóa (keyword) dùng để trả về giá trị từ hàm. Return có tác dụng kết thúc hàm và trả lại điều khiển cũng như kết quả xử lý hàm cho người gọi. 
* Ví dụ
```python=
def tong(a, b):
    sum = a + b
    return sum
m, n = 1, 2
print(tong(m, n))
```
Kết quả
![](https://i.imgur.com/3eSG4ni.png)

Ở ví dụ này nếu chúng ta không có câu lệnh return thì kết quả sẽ là **None**
![](https://i.imgur.com/YGsmG9U.png)

* Ví dụ hàm str()
   - **str()** là hàm dùng để chuyển từ int sang string trong Python.
   -  Chúng ta sử dụng hàm **str()** trong python để chuyển số thành chuỗi trong Python và tạo ra một chuỗi mới với cú pháp
```
str(int)
```

```python=
tuoi = 18
str_tuoi = str(tuoi) #chuyển số 18 thành chuỗi "18"
print(type(tuoi)) # kiểm tra kiểu dữ liệu của tuoi
print(type(str_tuoi)) # kiểm tra kiểu dữ liệu của str_tuoi
print("Toi "+ str_tuoi + " tuoi")
```
Kết quả
![](https://i.imgur.com/iYp9Yzj.png)

## Dictionary
Dictionary là kiểu dữ liệu ánh xạ và có khả năng thay đổi. Kiểu dữ liệu ánh xạ (mapping type) có ý nghĩa là các đối tượng trong đó được tạo bởi một tổ hợp key và value tương ứng, còn có khả năng thay đổi(mutable) có ý nghĩa sau khi tạo dictionary, chúng ta có thể thêm, xóa hoặc thay đổi giá trị của nó.
Để hiểu một cách đơn giản, có thể định nghĩa Dictionary là kiểu dữ liệu có phần tử là các cặp khóa-giá trị được đặt giữa cặp dấu {} và có khả năng thay đổi sau khi tạo ra.

Tạo dictionary trong python bằng cách chỉ định trực tiếp giá trị của các phần tử với cú pháp sau đây:
```python=
#{ key1 : value1 , key2 : value2,… }

{"red":"do", "blue":"xanh", "yellow":"vang"}
```
### Key
* Key trong Python phải là duy nhất. Một key không thể xuất hiện hai lần (key không được trùng nhau).
* Key phải là giá trị hashable. Một giá trị được gọi là hashable nếu nó không bao giờ thay đổi trong suốt thời gian tồn tại của nó. Cụ thể chúng ta chỉ có thể chỉ định Key trong Python bằng một trong ba đối tượng bất biến Immutable (không thể thay đổi) trong python gồm Số, Chuỗi, Tuple mà thôi.

### Value
* Ngược lại với key, bạn có thể chỉ định bất kỳ kiểu dữ liệu nào cho Value trong Python. Ngoài ra, các giá trị này có thể trùng lặp, điều đó có nghĩa có thể có nhiều Key có giá trị Value giống nhau cùng tồn tại ở dictionary trong python.

### Chỉ định khóa và lấy giá trị trong dictionary python
* Mỗi phần tử trong dictionary python là một cặp khóa và giá trị (key và value). Bằng cách chỉ định khóa cho dictionary, bạn có thể lấy được giá trị tương ứng với khóa đó:
```
dictionary[key]
```
* Ví dụ:
```python=
thongtin = {'HT':'Ho ten','QQ':'Que quan', 'NS': 'Ngay sinh'}
print(thongtin['HT'])
print(thongtin['QQ'])
print(thongtin['NS'])
```
Kết quả khi chạy chương trình
>Ho ten
Que quan
Ngay sinh

* Nếu chỉ định một khóa không tồn tại trong dictionary, lỗi **KeyError** sẽ xảy ra

