Đề Xuất 12/2022 # Kiểu Dữ Liệu Trong Python: Chuỗi, Số, List, Tuple, Set Và Dictionary / 2023 # Top 13 Like | Comforttinhdauthom.com

Đề Xuất 12/2022 # Kiểu Dữ Liệu Trong Python: Chuỗi, Số, List, Tuple, Set Và Dictionary / 2023 # Top 13 Like

Cập nhật nội dung chi tiết về Kiểu Dữ Liệu Trong Python: Chuỗi, Số, List, Tuple, Set Và Dictionary / 2023 mới nhất trên website Comforttinhdauthom.com. Hy vọng thông tin trong bài viết sẽ đáp ứng được nhu cầu ngoài mong đợi của bạn, chúng tôi sẽ làm việc thường xuyên để cập nhật nội dung mới nhằm giúp bạn nhận được thông tin nhanh chóng và chính xác nhất.

Trong phần trước, chúng ta đã làm quen với chương trình Python đầu tiên là thêm hai số và in tổng của chúng ra ngoài màn hình. Phần này, bạn sẽ học cách sử dụng Python như một chiếc máy tính, học về số, chuỗi, list và đi bước đầu tiên hướng tới lập trình Python.

Vì bài viết sẽ liệt kê những nội dung quan trọng nhất của tất cả các kiểu dữ liệu trong Python nên sẽ khá dài. Mỗi kiểu dữ liệu đều đi kèm với ví dụ cụ thể để bạn dễ hình dung.

1. Biến trong Python

Biến là một vị trí trong bộ nhớ được sử dụng để lưu trữ dữ liệu (giá trị). Biến được đặt tên duy nhất để phân biệt giữa các vị trí bộ nhớ khác nhau. Các quy tắc để viết tên một biến giống như quy tắc viết các định danh trong Python.

Trong Python, bạn không cần khai báo biến trước khi sử dụng, chỉ cần gán cho biến một giá trị và nó sẽ tồn tại. Cũng không cần phải khai báo kiểu biến, kiểu biến sẽ được nhận tự động dựa vào giá trị mà bạn đã gán cho biến.

Gán giá trị cho biến:

Để gán giá trị cho biến ta sử dụng toán tử =. Bất kỳ loại giá trị nào cũng có thể gán cho biến hợp lệ.

Ví dụ:

hoa = "Hồng" la = 3 canh = 5.5

Phía trên là 3 câu lệnh gán, “Hồng” là một chuỗi ký tự, được gán cho biến hoa, 3 là số nguyên và được gán cho la, 5.5 là số thập phân và gán cho canh.

Gán nhiều giá trị:

Trong Python bạn có thể thực hiện gán nhiều giá trị trong một lệnh như sau:

hoa, la, canh = "Hồng", 3, 5.5

Nếu muốn gán giá trị giống nhau cho nhiều biến thì có thể viết lệnh như sau:

hoa, la, canh = 3

Lệnh trên sẽ gán giá trị 3 cho cả 3 biến là hoa, la và canh.

2. Kiểu dữ liệu số trong Python

Các kiểu dữ liệu số trong Python

Python hỗ trợ số nguyên, số thập phân và số phức, chúng lần lượt được định nghĩa là các lớp int, float, complex trong Python. Số nguyên và số thập phân được phân biệt bằng sự có mặt hoặc vắng mặt của dấu thập phân. Ví dụ: 5 là số nguyên, 5.0 là số thập phân. Python cũng hỗ trợ số phức và sử dụng hậu tố j hoặc J để chỉ phần ảo. Ví dụ: 3+5j. Ngoài int và float, Python hỗ trợ thêm 2 loại số nữa là Decimal và Fraction.

Ta sẽ dùng hàm type() để kiểm tra xem biến hoặc giá trị thuộc lớp số nào và hàm isinstance() để kiểm tra xem chúng có thuộc về một class cụ thể nào không.

Số nguyên trong Python không bị giới hạn độ dài, số thập phân bị giới hạn đến 16 số sau dấu thập phân.

Những con số chúng là làm việc hàng ngày thường là hệ số 10, nhưng lập trình viên máy tính (thường là lập trình viên nhúng) cần làm việc với hệ thống số nhị phân, thập lục phân và bát phân. Để biểu diễn những hệ số này trong Python, ta đặt một tiền tố thích hợp trước số đó.

Tiền tố hệ số cho các số Python:

Đây là ví dụ về việc sử dụng các tiền tố hệ số trong Python, và khi dùng hàm print() để in giá trị của chúng ra màn hình, ta sẽ nhận được số tương ứng trong hệ số 10.

# Output: 187 print(0b10111011) # Output: 257 (250 + 7) print(0xFA + 0b111) # Output: 15 print(0o17)

Chuyển đổi giữa các kiểu số trong Python

Chúng ta có thể chuyển đổi kiểu số này sang kiểu số khác. Điều này còn được gọi là cưỡng chế (coercion). Các phép toán như cộng, trừ sẽ ngầm chuyển đổi số nguyên thành số thập phân (một cách tự động) nếu có một toán tử trong phép toán là số thập phân.

Ví dụ: Nếu bạn thực hiện phép cộng giữa số nguyên là 2 và số thập phân là 3.0, thì 2 sẽ bị cưỡng chế chuyển thành số thập phân 2.0 và kết quả trả về sẽ là số thập phân 5.0.

Ta có thể sử dụng các hàm Python tích hợp sẵn như int(), float() và complex() để chuyển đổi giữa các kiểu số một cách rõ ràng. Những hàm này thậm chí có thể chuyển đổi từ các chuỗi.

Khi chuyển đổi từ số thập phân sang số nguyên, số sẽ bị bỏ bớt, chỉ lấy phần nguyên.

Mô-đun Decimal trong Python

Class float được tích hợp trong Python có thể khiến chúng ta ngạc nhiên đôi chút. Thông thường nếu tính tổng 1.1 và 2.2 ta nghĩ kết quả sẽ là 3.3, nhưng có vẻ không phải vậy. Nếu bạn kiểm tra tính đúng sai của phép toán này trong Python, sẽ nhận được kết quả là False.

Chuyện gì xảy ra vậy?

Điều này là do, các số thập phân được thực hiện trong phần cứng máy tính dưới dạng phân số nhị phân, vì máy tính chỉ hiểu các số nhị phân (0 và 1) nên hầu hết các phân số thập phân mà chúng ta biết, không thể được lưu trữ chính xác trong máy tính.

Ví dụ, ta không thể biểu diễn phân số 1/3 dưới dạng số thập phân, vì nó là một số thập phân vô hạn tuần hoàn, với các số sau dấu thập phân dài vô hạn, nên ta chỉ có thể ước tính nó.

Khi chuyển đổi phần thập phân 0.1, sẽ dẫn đến phần nhị phân dài vô hạn của 0.000110011001100110011… và máy tính chỉ lưu trữ một phần số hữu hạn sau dấu . của nó thôi. Do đó, số được lưu trữ chỉ xấp xỉ 0.1 chứ không bao giờ bằng 0.1. Đó là lý do vì sao, phép cộng chúng ta nói đến ở trên không đưa ra kết quả như chúng ta mong đợi. Đó là giới hạn của phần cứng máy tính chứ không phải lỗi của Python.

Để khắc phục vấn đề này, chúng ta có thể sử dụng mô-đun Decimal trong Python. Trong khi số float chỉ lấy 16 số sau dấu thập phân thì mô-đun Decimal cho phép tùy chỉnh độ dài của số.

import decimal # Output: 0.1 print(0.1) # Output: 0.1000000000000000055511151231257827021181583404541015625 print(decimal.Decimal(0.1))

Mô-đun này được sử dụng khi chúng ta muốn thực hiện các phép toán ở hệ số thập phân để có kết quả như đã học ở trường.

Điều này cũng khá quan trọng, ví dụ như 25.50kg sẽ chính xác hơn 25.5kg, vì 2 chữ số thập phân vẫn chính xác hơn 1 chữ số.

from decimal import Decimal # Output: 3.3 print(Decimal('1.1') + Decimal('2.2')) # Output: 10.000 print(Decimal('4.0') * Decimal('2.50'))

Nếu muốn code ngắn gọn hơn, bạn có thể nhập mô-đun Decimal và sửa tên mô-đun thành D.

from decimal import Decimal as D # Output: 3.3 print(D('1.1') + D('2.2')) # Output: 10.000 print(D('4.0') * D('2.50'))

Trong code này ta nhập mô-đun Decimal và sửa tên nó thành D, kết quả không đổi so với code trên.

Bạn có thể thắc mắc trong phần phép nhân, tại sao không sử dụng số Decimal để nhân lại phải thêm số 0 vào sau 4 và cả 2.5. Câu trả lời là tính hiệu quả, các phép toán với số float được hiện nhanh hơn các phép toán Decimal.

Khi nào nên sử dụng Decimal thay cho float?

Ta thường sử dụng Decimal trong các trường hợp sau:

Khi tạo ứng dụng tài chính, cần biểu diễn phần thập phân chính xác.

Khi muốn kiểm soát mức độ chính xác của số.

Khi muốn thực hiện các phép toán giống như đã học ở trường.

Phân số trong Python

import fractions # Tạo phân số từ số thập phân print(fractions.Fraction(4.5)) # Output: 9/2 # Tạo phân số từ số nguyên # Code by chúng tôi print(fractions.Fraction(9)) # Output: 9 # Tạo phân số bằng cách khai báo tử, mẫu số print(fractions.Fraction(2,5)) # Output: 2/5

Đặc biệt, bạn có thể khởi tạo một phân số từ string. Đây là cách khởi tạo được ưa thích khi sử dụng số thập phân.

import fractions # Khởi tạo phân số từ float print(fractions.Fraction(0.1)) # Output: 3602879701896397/36028797018963968 # Khởi tạo phân số từ string # Code by chúng tôi print(fractions.Fraction('0.1')) # Output: 1/10

Kiểu dữ liệu phân số hỗ trợ đầy đủ các phép toán cơ bản như cộng, trừ, nhân, chia, logic:

Toán học trong Python

from fractions import Fraction as F import math # Output: 3.141592653589793 print(math.pi) # Output: -1.0 print(math.cos(math.pi)) # Output: 22026.465794806718 print(math.exp(10)) # Output: 2.0 print(math.log2(4)) # Output: 1.1752011936438014 print(math.sinh(1)) # Output: 40320 print(math.factorial(8))

Sử dụng trình thông dịch như máy tính bỏ túi

Trình thông dịch hoạt động như một máy tính đơn giản: Bạn có thể nhập vào một phép tính và nó sẽ viết ra giá trị. Cú pháp biểu thức khá đơn giản: các toán tử như +, -, * và / làm việc giống như trong hầu hết các ngôn ngữ lập trình khác (Pascal, C), dấu ngoặc đơn () có thể được sử dụng để nhóm. Ví dụ:

Với Python, bạn có thể sử dụng toán tử ** để tính số mũ:

Dấu bằng = được sử dụng để gán giá trị cho 1 biến. Sau đó, không có kết quả nào được hiển thị trước dấu nhắc lệnh tiếp theo:

Nếu một biến không được định nghĩa (gán giá trị), cố gắng sử dụng biến đó, bạn sẽ nhận được lỗi sau:

Python hỗ trợ đầy đủ cho dấu chấm động, phép tính có cả số nguyên và số thập phân thì kết quả sẽ trả về số dưới dạng thập phân (nguyên văn: toán tử với toán hạng kiểu hỗn hợp chuyển đổi toán hạng số nguyên sang số thập phân):

Trong chế độ tương tác, biểu thức được in ra cuối cùng sẽ được gán cho biến _, giúp dễ dàng thực hiện các phép tính tiếp theo hơn. Ví dụ:

Bạn nên coi biến này là read-only, đừng gán giá trị cho nó – vì nếu tạo ra một biến cùng tên nó sẽ chiếm mất biến mặc định này và không còn làm được những thứ hay ho như trên nữa.

3. Chuỗi (string)

String trong Python là một dãy các ký tự. Máy tính không xử lý các ký tự, chúng chỉ làm việc với số nhị phân. Dù bạn có thể nhìn thấy các ký tự trên màn hình, nhưng chúng được lưu trữ và xử lý nội bộ dưới dạng kết hợp của số 0 và 1. Việc chuyển đổi ký tự thành số được gọi là mã hóa và quá trình ngược lại được gọi là giải mã. ASCII và Unicode là 2 trong số những mã hóa phổ biến thường được sử dụng.

Trong Python, string là một dãy các ký tự Unicode. Unicode bao gồm mọi ký tự trong tất cả các ngôn ngữ và mang lại tính đồng nhất trong mã hóa.

Cách tạo string trong Python

Bên cạnh số, Python cũng có thể thao tác với chuỗi, được biểu diễn bằng nhiều cách. Chúng có thể được để trong dấu nháy đơn ('...') hoặc kép ("...") với cùng một kết quả. được sử dụng để “trốn (escape)” 2 dấu nháy này.

Trong trình thông dịch tương tác, chuỗi kết quả bao gồm phần trong dấu ngoặc kép và các ký tự đặc biệt “trốn” được nhờ sử dụng . Dù đầu ra trông có vẻ hơi khác với đầu vào (dấu nháy kèm theo có thể thay đổi) nhưng hai chuỗi này là tương đương. Chuỗi được viết trong dấu ngoặc kép khi chuỗi chứa dấu nháy đơn và không có dấu nháy kép), ngược lại nó sẽ được viết trong dấu nháy đơn. Hàm print() tạo chuỗi đầu ra dễ đọc hơn, bằng cách bỏ qua dấu nháy kèm theo và in các ký tự đặc biệt, đã “trốn” được dấu nháy:

Nếu không muốn các ký tự được thêm vào bởi được trình thông dịch hiểu là ký tự đặc biệt thì sử dụng chuỗi raw bằng cách thêm r vào trước dấu nháy đầu tiên:

Chuỗi ký tự dạng chuỗi có thể viết trên nhiều dòng bằng cách sử dụng 3 dấu nháy: """...""" hoặc '''...'''. Kết thúc dòng tự động bao gồm trong chuỗi, nhưng có thể ngăn chặn điều này bằng cách thêm vào cuối dòng. Ví dụ:

print(""" Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to """)

Đây là kết quả (dòng mới ban đầu không được tính):

Đây là danh sách tất cả các ký tự thoát (escape sequence) được Python hỗ trợ:

Cách truy cập vào phần tử của chuỗi

Các chuỗi có thể được lập chỉ mục với ký tự đầu tiên được đánh số 0. Không có kiểu ký tự riêng biệt, mỗi ký tự đơn giản là một con số:

Chỉ số cũng có thể là số âm, bắt đầu đếm từ bên phải:

Lưu ý rằng vì -0 cũng tương tự như 0, nên các chỉ số âm bắt đầu từ -1.

Ngoài việc đánh số, thì cắt lát cũng được hỗ trợ. Trong khi index được sử dụng để lấy các ký tự riêng lẻ thì cắt lát sẽ cho phép bạn lấy chuỗi con:

Hãy để ý đến cách các ký tự được giữ lại và loại trừ. Nó luôn đảm bảo rằng s[:i] + s[i:] bằng s:

Các chỉ số trong cắt chuỗi có thiết lập mặc định khá hữu ích, có 2 chỉ số bị bỏ qua theo mặc định, là 0 và kích thước của chuỗi được cắt.

Một cách khác để ghi nhớ cách thức cắt chuỗi làm việc là hình dung các chỉ số như là vách ngăn giữa các ký tự, với ký tự ngoài cùng bên trái được đánh số 0. Khi đó, ký tự cuối cùng bên phải, trong chuỗi n ký tự sẽ có chỉ số n, ví dụ:

Hàng đầu tiên của số mang đến vị trí của chỉ số từ 0 đến 6 trong chuỗi. Hàng thứ hai là các chỉ số âm tương ứng. Khi cắt từ i đến j sẽ bao gồm tất cả các ký tự nằm giữa i và j, tương ứng.

Đối với các chỉ số không âm, chiều dài của một lát cắt là sự chênh lệch của các chỉ số, nếu cả hai đều nằm trong giới hạn. Ví dụ, chiều dài của word[1:3] là 2.

Cố gắng sử dụng một chỉ mục quá lớn sẽ trả về kết quả lỗi:

Tuy nhiên, các chỉ mục bên ngoài phạm vi lát cắt vẫn được xử lý gọn gàng khi được sử dụng để cắt:

Thay đổi hoặc xóa chuỗi

Các chuỗi Python không thể thay đổi – chúng là cố định. Vì vậy, nếu cứ cố tình gán một ký tự nào đó cho vị trí đã được lập chỉ mục thì bạn sẽ nhận được thông báo lỗi:

Nếu cần một chuỗi khác, cách tốt nhất là tạo mới:

Bạn không thể xóa hay loại bỏ ký tự khỏi chuỗi, nhưng giống như tuple, bạn có thể xóa toàn bộ chuỗi, bằng cách sử dụng từ khóa del:

qtm_string = 'quantrimang.com' del qtm_string # Output: NameError: name 'qtm_string' is not defined qtm_string

Nối chuỗi

Các chuỗi có thể được nối với nhau bằng toán tử + và thay thế bằng *:

Hai hoặc nhiều ký tự dạng chuỗi (tức là ký tự trong dấu nháy) cạnh nhau được nối tự động.

Tính năng trên chỉ làm việc với chuỗi dạng chuỗi (literal), không áp dụng với biến hay biểu thức:

Nếu muốn ghép nối các biến với nhau hoặc biến với chuỗi hãy sử dụng dấu +:

Tính năng này đặc biệt hữu ích khi muốn bẻ các chuỗi dài thành chuỗi ngắn hơn:

Nếu muốn nối các chuỗi trong nhiều dòng khác nhau, hãy sử dụng dấu ngoặc đơn:

Lặp và kiểm tra phần tử của chuỗi

count = 0 for letter in 'Quantrimang.com': if(letter == 'i'): count += 1 # Output: Có 1 chữ i được tìm thấy print('Có', count,'chữ i được tìm thấy')

Để kiểm tra một chuỗi con có trong chuỗi hay chưa, hãy dùng từ khóa in, như sau:

Hàm Python tích hợp sẵn để làm việc với chuỗi

Có 2 hàm thường dùng nhất khi làm việc với string trong Python là enumerate() và len().

Hàm len() được tích hợp trong Python, sẽ trả về độ dài của chuỗi:

Hàm enumerate() trả về đối tượng liệt kê, chứa cặp giá trị và index của phần tử trong string, khá hữu ích trong khi lặp.

qtm_str = 'Python' # enumerate() qtm_enum = list(enumerate(qtm_str)) # Output: list(enumerate(qtm_str) = [(0, 'P'), (1, 'y'), (2, 't'), (3, 'h'), (4, 'o'), (5, 'n')] print('list(enumerate(qtm_str) = ', qtm_enum)

Phương thức format() để định dạng chuỗi

Phương thức format() rất linh hoạt và đầy sức mạnh khi dùng để định dạng chuỗi. Định dạng chuỗi chứa dấu {} làm trình giữ chỗ hoặc trường thay thế để nhận giá trị thay thế. Bạn cũng có thể sử dụng đối số vị trí hoặc từ khóa để chỉ định thứ tự.

Ta có kết quả khi chạy code trên như sau:

Định dạng chuỗi kiểu cũ:

Bạn có thể định dạng chuỗi trong Python về phong cách sprintf() được sử dụng trong ngôn ngữ lập trình C bằng toán tử %.

Phương thức thường được sử dụng trong string

Có rất nhiều phương thức được tích hợp sẵn trong Python để làm việc với string. Ngoài format() được đề cập bên trên còn có lower(), upper(), join(), split(), find(), replace(), v.v….

4. Danh sách (list)

Python cung cấp một loạt các dữ liệu phức hợp, thường được gọi là các chuỗi (sequence), sử dụng để nhóm các giá trị khác nhau. Đa năng nhất là danh sách (list).

Cách tạo list trong Python

Trong Python, list được biểu diễn bằng dãy các giá trị, được phân tách nhau bằng dấu phẩy, nằm trong dấu []. Các danh sách có thể chứa nhiều mục với kiểu khác nhau, nhưng thông thường là các mục có cùng kiểu.

List không giới hạn số lượng mục, bạn có thể có nhiều kiểu dữ liệu khác nhau trong cùng một list, như chuỗi, số nguyên, số thập phân,…

list1 = [] # list rỗng list2 = [1, 2, 3] # list số nguyên list3 = [1, "Hello", 3.4] # list với kiểu dữ liệu hỗn hợp

Bạn cũng có thể tạo các list lồng nhau (danh sách chứa trong danh sách), ví dụ:

a = ['a', 'b', 'c'] n = [1, 2, 3] x = [a, n] print (x) # Output: [['a', 'b', 'c'], [1, 2, 3]] print (x[0]) # Output: ['a', 'b', 'c'] print(x[0][1]) # Output: b

Hoặc khai báo list lồng nhau từ đầu:

list4 = [mouse", [8, 4, 6], ['a']]

Truy cập vào phần tử của list

Có nhiều cách khác nhau để truy cập vào phần tử của một danh sách:

Index (chỉ mục) của list:

Sử dụng toán tử index [] để truy cập vào một phần tử của list. Index bắt đầu từ 0, nên một list có 5 phần tử sẽ có index từ 0 đến 4. Truy cập vào phần tử có index khác index của list sẽ làm phát sinh lỗi IndexError. Index phải là một số nguyên, không thể sử dụng float, hay kiểu dữ liệu khác, sẽ tạo lỗi TypeError.

qtm_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m'] # TypeError: list indices must be integers or slices, not float # TypeError: index của list phải là số nguyên hoặc slice, không phải số thập phân qtm_list[2.0]

List lồng nhau có thể truy cập bằng index lồng nhau:

qtm_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m'] # Output: q print(qtm_list[0]) # Output: a print(qtm_list[2]) # Output: t print(qtm_list[4]) # List lồng nhau ln_list = ["Happy", [1,3,5,9]] # Index lồng nhau # Output: a print(ln_list[0][1]) # Output: 9 print(ln_list[1][3])

Index âm:

Python cho phép lập chỉ mục âm cho các chuỗi. Index -1 là phần tử cuối cùng, -2 là phần tử thứ 2 từ cuối cùng lên. Nói đơn giản là index âm dùng khi bạn đếm phần tử của chuỗi ngược từ cuối lên đầu.

qtm_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m'] # Code by chúng tôi # Output: m print(qtm_list[-1]) # Output: i print(qtm_list[-9])

Cắt lát (slice) list trong Python

Python cho phép truy cập vào một dải phần tử của list bằng cách sử dụng toán tử cắt lát : (dấu hai chấm). Mọi hành động cắt list đều trả về list mới chứa những yếu tố được yêu cầu.

qtm_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m'] # Code by chúng tôi # Output: ['u', 'a', 'n', 't'] print(qtm_list[1:5]) # Output: ['q', 'u', 'a', 'n', 't', 'r', 'i'] print(qtm_list[:-8]) # Output: ['n', 'g', '.', 'c', 'o', 'm'] print(qtm_list[9:])

Để cắt lát list, bạn chỉ cần sử dụng dấu : giữa 2 index cần lấy các phần tử. [1:5] sẽ lấy phần tử 1 đến 5, [:-8] lấy từ 0 đến phần tử -8,…

Nếu thực hiện hành động cắt sau thì nó sẽ trả về một list mới là bản sao của list ban đầu:

qtm_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m'] # Output: ['q', 'u', 'a', 'n', 't', 'r', 'i', 'm', 'a', 'n', 'g', '.', 'c', 'o', 'm'] print(qtm_list[:])

Thay đổi hoặc thêm phần tử vào list

List cũng hỗ trợ các hoạt động như nối list:

Không giống như chuỗi, bị gán cố định, list là kiểu dữ liệu có thể thay đổi. Ví dụ, bạn có thể thay đổi các mục trong list:

Bạn cũng có thể cho thêm mục mới vào cuối list bằng cách sử dụng các phương thức, chẳng hạn như append():

Việc gán cho lát cũng có thể thực hiện và thậm chí có thể thay đổi cả kích thước của list hay xóa nó hoàn toàn:

Hàm len() cũng có thể áp dụng với list:

Xóa hoặc loại bỏ phần tử khỏi list trong Python

Bạn có thể xóa một hoặc nhiều phần tử khỏi list sử dụng từ khóa del, có thể xóa hoàn toàn cả list.

my_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m'] # xóa phần tử có index là 2 del my_list[2] # Output: ['q', 'u', 'n', 't', 'r', 'i', 'm', 'a', 'n', 'g', '.', 'c', 'o', 'm'] print(my_list) # xóa phần tử có index từ 1 đến 7 del my_list[1:7] # Output: ['q', 'a', 'n', 'g', '.', 'c', 'o', 'm'] print(my_list) # xóa toàn bộ list my_list del my_list # Error: NameError: name 'my_list' is not defined print(my_list)

Bạn cũng có thể sử dụng remove() để loại bỏ những phần tử đã cho hoặc pop() để loại bỏ phần tử tại một index nhất định. pop() loại bỏ phần tử và trả về phần tử cuối cùng nếu index không được chỉ định. Điều này giúp triển khai list dưới dạng stack (ngăn xếp) (cấu trúc dữ liệu first in last out – vào đầu tiên, ra cuối cùng).

Ngoài ra, phương thức clear() cũng được dùng để làm rỗng một list (xóa tất cả các phần tử trong list).

my_list = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m'] my_list.remove('.') # Output: ['q', 'u', 'a', 'n', 't', 'r', 'i', 'm', 'a', 'n', 'g', 'c', 'o', 'm'] print(my_list) # Output: n print(my_list.pop(3)) # Output: ['q', 'u', 'a', 't', 'r', 'i', 'm', 'a', 'n', 'g', 'c', 'o', 'm'] print(my_list) # Output: m print(my_list.pop()) # Output: ['q', 'u', 'a', 't', 'r', 'i', 'm', 'a', 'n', 'g', 'c', 'o'] print(my_list) my_list.clear() # Output: [] (list rỗng) print(my_list)

Cách cuối cùng để xóa các phần tử trong một list là gán một list rỗng cho các lát phần tử.

Phương thức list trong Python

Những phương thức có sẵn cho list trong Python gồm:

append(): Thêm phần tử vào cuối list.

extend(): Thêm tất cả phần tử của list hiện tại vào list khác.

insert(): Chèn một phần tử vào index cho trước.

remove(): Xóa phần tử khỏi list.

pop(): Xóa phần tử khỏi list và trả về phần tử tại index đã cho.

clear(): Xóa tất cả phần tử của list.

index(): Trả về index của phần tử phù hợp đầu tiên.

count(): Trả về số lượng phần tử đã đếm được trong list như một đối số.

sort(): Sắp xếp các phần tử trong list theo thứ tự tăng dần.

reverse(): Đảo ngược thứ tự các phần tử trong list.

copy(): Trả về bản sao của list.

Ví dụ:

QTM = [9,8,7,6,8,5,8] # Output: 2 print(QTM.index(7)) # Output: 3 print(QTM.count(8)) QTM.sort() # Output: [5, 6, 7, 8, 8, 8, 9] print(QTM) QTM.reverse() # Output: [9, 8, 8, 8, 7, 6, 5] print(QTM)

Ví dụ 2:

QTM = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m'] # Output: 3 print(QTM.index('n')) # Output: 2 print(QTM.count('a')) QTM.sort() # Output: ['.', 'a', 'a', 'c', 'g', 'i', 'm', 'm', 'n', 'n', 'o', 'q', 'r', 't', 'u'] print(QTM) QTM.reverse() # Output: ['u', 't', 'r', 'q', 'o', 'n', 'n', 'm', 'm', 'i', 'g', 'c', 'a', 'a', '.'] print(QTM)

List comprehension: Cách tạo list mới ngắn gọn

List comprehension là một biểu thức đi kèm với lệnh for được đặt trong cặp dấu ngoặc vuông [].

Ví dụ:

cub3 = [3 ** x for x in range(9)] # Output: [1, 3, 9, 27, 81, 243, 729, 2187, 6561] print(cub3)

Code trên tương đương với:

cub3 = [] for x in range (9): cub3.append(3**x) print(cub3)

Kiểm tra phần tử có trong list không

Sử dụng keyword in để kiểm tra xem một phần tử đã có trong list hay chưa. Nếu phần tử đã tồn tại, kết quả trả về là True, và ngược lại sẽ trả về False.

QTM = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m'] # Output: True print('q' in QTM) # Output: True print('.' in QTM) # Output: False print('z' in QTM)

Vòng lặp for trong list

for ngon_ngu in ['Python','Java','C']: print("Tôi thích lập trình",ngon_ngu)

Kết quả trả về sẽ như sau:

Tôi thích lập trình Python Tôi thích lập trình Java Tôi thích lập trình C

Các hàm Python tích hợp với list

Các hàm Python tích hợp sẵn như all(), any(), enumerate(), len(), max(), min(), list(), sorted(),… thường được sử dụng với list để thực hiện những nhiệm vụ khác nhau.

all(): Trả về giá trị True nếu tất cả các phần tử của list đều là true hoặc list rỗng.

any(): Trả về True khi bất kỳ phần tử nào trong list là true. Nếu list rỗng hàm trả về giá trị False.

enumerate(): Trả về đối tượng enumerate, chứa index và giá trị của tất cả các phần tử của list dưới dạng tuple.

len(): Trả về độ dài (số lượng phần tử) của list.

list(): Chuyển đổi một đối tượng có thể lặp (tuple, string, set, dictionary) thành list.

max(): Trả về phần tử lớn nhất trong list.

min(): Trả về phần tử nhỏ nhất trong list.

sorted(): Trả về list mới đã được sắp xếp.

sum(): Trả về tổng của tất cả các phần tử trong list.

5. Tuple

Tuple trong Python là một chuỗi các phần tử có thứ tự giống như list. Sự khác biệt giữa list và tuple là chúng ta không thể thay đổi các phần tử trong tuple khi đã gán, nhưng trong list thì các phần tử có thể thay đổi.

Tuple thường được sử dụng cho các dữ liệu không cho phép sửa đổi và nhanh hơn list vì nó không thể thay đổi tự động. Một tuple được định nghĩa bằng dấu ngoặc đơn (), các phần tử trong tuple cách nhau bằng dấu phẩy (,).

Ví dụ:

t = (10, "quan tri mang", 2j)

Bạn có thể sử dụng toán tử cắt [] để trích xuất phần tử trong tuple nhưng không thể thay đổi giá trị của nó.

t = (10, "quan tri mang", 2j) #t[0:2] = (10, 'quan tri mang') print("t[0:2] = ", t[0:2])

Chạy code trên ta được kết quả:

t[0:2] = (10, 'quan tri mang')

Tuple hơn list ở điểm nào?

Vì tuple và list khá giống nhau, nên chúng thường được sử dụng trong những tình huống tương tự nhau. Tuy nhiên, tuple vẫn có những lợi thế nhất định so với list, như:

Tuple thường được sử dụng cho các kiểu dữ liệu không đồng nhất (khác nhau) và list thường sử dụng cho các kiểu dữ liệu (đồng nhất) giống nhau.

Vì tuple không thể thay đổi, việc lặp qua các phần tử của tuple nhanh hơn so với list. Vì vậy, trong trường hợp này tuple chiếm ưu thế về hiệu suất hơn list một chút.

Tuple chứa những phần tử không thay đổi, có thể được sử dụng như key cho dictionary. Với list, điều này không thể làm được.

Nếu có dữ liệu không thay đổi việc triển khai nó như một tuple sẽ đảm bảo rằng dữ liệu đó được bảo vệ chống ghi (write-protected).

Tạo một tuple

Tuple được tạo bằng cách đặt tất cả các phần tử của nó trong dấu ngoặc đơn (), phân tách bằng dấu phẩy. Bạn có thể bỏ dấu ngoặc đơn nếu muốn, nhưng nên thêm nó vào cho code rõ ràng hơn.

Tuple không bị giới hạn số lượng phần tử và có thể có nhiều kiểu dữ liệu khác nhau như số nguyên, số thập phân, list, string,…

# Tuple rỗng # Output: () my_tuple = () print(my_tuple) # tuple số nguyên # Output: (2, 4, 16, 256) my_tuple = (2, 4, 16, 256) print(my_tuple) # tuple có nhiều kiểu dữ liệu # Output: (10, "Quantrimang.com", 3.5) my_tuple = (10, "Quantrimang.com", 3.5) print(my_tuple) # tuple lồng nhau # Output: ("QTM", [2, 4, 6], (3, 5, 7)) my_tuple = ("QTM", [2, 4, 6], (3, 5, 7)) print(my_tuple) # tuple có thể được tạo mà không cần dấu () # còn gọi là đóng gói tuple # Output: (10, "Quantrimang.com", 3.5) my_tuple = 10, "Quantrimang.com", 3.5 print(my_tuple) # mở gói (unpacking) tuple cũng có thể làm được # Output: # 10 # chúng tôi # 3.5 a, b, c = my_tuple print(a) print(b) print(c)

Tạo tuple chỉ có một phần tử hơi phức tạp chút, nếu bạn tạo theo cách thông thường là cho phần tử đó vào trong cặp dấu () là chưa đủ, cần phải thêm dấu phẩy để chỉ ra rằng, đây là tuple.

Truy cập vào các phần tử của tuple

Có nhiều cách khác nhau để truy cập vào các phần tử của một tuple, khá giống với list, nên mình không lấy ví dụ cụ thể, các bạn có thể xem lại phần list nha.

Index: Sử dụng toán tử index [] để truy cập vào phần tử trong tuple với index bắt đầu bằng 0. Nghĩa là nếu tuple có 6 phần tử thì index của nó sẽ bắt đầu từ 0 đến 5. Nếu cố gắn truy cập đến index 6, 7 thì sẽ tạo lỗi IndexError. Index bắt buộc phải là số nguyên, mà không thể là số thập phân hay bất kỳ kiểu dữ liệu nào khác, nếu không sẽ tạo lỗi TypeError. Những tuple lồng nhau được truy cập bằng cách sử dụng index lồng nhau:

# tuple lồng nhau n_tuple = ("Quantrimang.com", [2, 6, 8], (1, 2, 3)) # index lồng nhau # Output: 'r' print(n_tuple[0][5]) # index lồng nhau # Output: 8 print(n_tuple[1][2])

Index âm: Python cho phép lập chỉ mục âm cho các đối tượng dạng chuỗi. Index -1 tham chiếu đến phần tử cuối cùng, -2 là thứ 2 tính từ cuối tính lên.

Cắt lát: Có thể truy cập đến một loạt phần tử trong tuple bằng cách sử dụng toán tử cắt lát : (dấu 2 chấm).

Thay đổi một tuple

Không giống như list, tuple không thể thay đổi. Điều này có nghĩa là các phần tử của một tuple không thể thay đổi một khi đã được gán. Nhưng, nếu bản thân phần tử đó là một kiểu dữ liệu có thể thay đổi (như list chẳng hạn) thì các phần tử lồng nhau có thể được thay đổi. Chúng ta cũng có thể gán giá trị khác cho tuple (gọi là gán lại – reassignment).

my_tuple = (1, 3, 5, [7, 9]) # không thể thay đổi phần tử của tuple # Nếu bạn bỏ dấu # ở dòng 8 # Bạn sẽ nhận được lỗi: # TypeError: 'tuple' object does not support item assignment #my_tuple[1] = 9 # Nhưng phần tử có index 3 trong tuple là list # list có thể thay đổi, nên phần tử đó có thể thay đổi # Output: (1, 3, 5, [8, 9]) my_tuple[3][0] = 8 print(my_tuple) # Nếu cần thay đổi tuple hãy gán lại giá trị cho nó # Output: ('q', 'u', 'a', 'n', 't', 'r', 'i', 'm', 'a', 'n', 'g') my_tuple = ('q', 'u', 'a', 'n', 't', 'r', 'i', 'm', 'a', 'n', 'g') print(my_tuple)

Bạn có thể dùng toán tử + để nối 2 tuple, toán tử * để lặp lại tuple theo số lần đã cho. Cả + và * đều cho kết quả là một tuple mới.

# Nối 2 tuple # Output: (2, 4, 6, 3, 5, 7) print((2, 4, 6) + (3, 5, 7)) # Lặp lại tuple # Output: ('Quantrimang.com', 'Quantrimang.com', 'Quantrimang.com') print(("Quantrimang.com",) * 3)

Xóa tuple

QTM = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m'] # Không thể xóa phần tử của tuple # Nếu bạn bỏ dấu # ở dòng 8, # sẽ tạo ra lỗi: # TypeError: 'tuple' object doesn't support item deletion #del QTM[3] # Có thể xóa toàn bộ tuple # Kết quả chạy code sẽ hiện ra lỗi: # NameError: name 'my_tuple' is not defined del QTM QTM

Phương thức và hàm dùng với tuple trong Python

Phương thức thêm phần tử và xóa phần tử không thể sử dụng với tuple, chỉ có 2 phương thức sau là dùng được:

count(x): Đếm số phần tử x trong tuple.

index(x): Trả về giá trị index của phần tử x đầu tiên mà nó gặp trong tuple.

QTM = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m'] # Count # Output: 2 print(QTM.count('m')) # Index # Output: 3 print(QTM.index('n'))

Các hàm dùng trong tuple khá giống với list, gồm có:

all(): Trả về giá trị True nếu tất cả các phần tử của tuple là true hoặc tuple rỗng.

any(): Trả về True nếu bất kỳ phần tử nào của tuple là true, nếu tuple rỗng trả về False.

enumerated(): Trả về đối tượng enumerate (liệt kê), chứa cặp index và giá trị của tất cả phần tử của tuple.

len(): Trả về độ dài (số phần tử) của tuple.

max(): Trả về phần tử lớn nhất của tuple.

min(): Trả về phần tử nhỏ nhất của tuple.

sorted(): Lấy phần tử trong tuple và trả về list mới được sắp xếp (tuple không sắp xếp được).

sum(): Trả về tổng tất cả các phần tử trong tuple.

tuple(): Chuyển đổi những đối tượng có thể lặp (list, string, set, dictionary) thành tuple.

Kiểm tra phần tử trong tuple

Bạn có thể kiểm tra xem một phần tử đã tồn tại trong tuple hay chưa với từ khóa in.

QTM = ['q','u','a','n','t','r','i','m','a','n','g','.','c','o','m'] # Kiểm tra phần tử # Output: True print('a' in QTM) # Output: False print('b' in QTM) # Not in operation # Output: False print('g' not in QTM)

Lặp qua các phần tử của tuple trong Python

Sử dụng vòng lặp for để lặp qua các phần tử trong tuple.

for ngon_ngu in ('Python','C++','Web'): print("Tôi thích lập trình",ngon_ngu)

Kết quả trả về sẽ như sau:

Tôi thích lập trình Python Tôi thích lập trình C++ Tôi thích lập trình Web

6. Set

Set trong Python là tập hợp các phần tử duy nhất, không có thứ tự. Các phần tử trong set phân cách nhau bằng dấu phẩy và nằm trong dấu ngoặc nhọn {}. Nhớ kỹ rằng các phần tử trong set không có thứ tự. Nhưng các phần tử trong set có thể thay đổi, có thể thêm hoặc xóa phần tử của set. Set có thể được sử dụng để thực hiện các phép toán như tập hợp, giao,…

Cách tạo set

Set được tạo bằng cách đặt tất cả các phần tử trong dấu ngoặc nhọn, phân tách bằng dấu phẩy hoặc sử dụng hàm set(). Set không giới hạn số lượng phần tử, nó có thể chứa nhiều kiểu biến khác nhau, nhưng không thể chứa phần tử có thể thay đổi được như list, set hay dictionary.

Ví dụ về set:

Nếu thực hiện lệnh in như sau:

Bạn sẽ nhận được kết quả:

Set với nhiều kiểu dữ liệu hỗn hợp như sau:

my_set = {1.0, "Xin chào", (1, 2, 3)} #Output: QTM_Set= {'Xin chào', 1.0, (1, 2, 3)} print("QTM_Set=",my_set)

Tạo set rỗng có chút khó khăn. Cặp dấu {} sẽ tạo một dictionary trong Python. Để tạo set không có phần tử nào, ta sử dụng hàm set() mà không có đối số nào.

Làm sao để thay đổi set trong Python

Để thêm một phần tử vào set, bạn sử dụng add() và để thêm nhiều phần tử dùng update(). Update() có thể nhận tuple, list, strring và set làm đối số. Trong mọi trường hợp, Set có giá trị duy nhất, các bản sao sẽ tự động bị loại bỏ.

# Khởi tạo my_set my_set = {1,3} print(my_set) # Nếu bỏ dấu # ở dòng 9, # Bạn sẽ nhận được lỗi # TypeError: 'set' object does not support indexing #my_set[0] # Thêm phần tử # Output: {1, 2, 3} my_set.add(2) print(my_set) # Thêm nhiều phần tử vào set # Output: {1, 2, 3, 4} my_set.update([2,3,4]) print(my_set) # Thêm list và set # Output: {1, 2, 3, 4, 5, 6, 8} my_set.update([4,5], {1,6,8}) print(my_set)

Xóa phần tử khỏi set

Bạn dùng discard() và remove() để xóa phần tử cụ thể khỏi set. Khi phần tử cần xóa không tồn tại trong set thì discard() không làm gì cả, còn remove() sẽ báo lỗi.

# Khởi tạo my_set my_set = {1, 3, 4, 5, 6} print(my_set) # Xóa phần tử bằng discard() # Output: {1, 3, 5, 6} my_set.discard(4) print(my_set) # Xóa bằng remove() # Output: {1, 3, 5} my_set.remove(6) print(my_set) # Xóa phần tử không có # trong set bằng discard() # Output: {1, 3, 5} my_set.discard(2) print(my_set) # Xóa phần tử không có # trong set bằng remove() # Nếu bạn bỏ dấu # ở dòng 27, # bạn sẽ nhận được lỗi. # Output: KeyError: 2 #my_set.remove(2)

Bạn có thể xóa và trả lại một mục bằng phương thức pop(). Set không có thứ tự, không có cách nào để xác định phần tử nào sẽ bị xóa, điều này diễn ra hoàn toàn ngẫu hứng. Việc xóa hoàn toàn set được thực hiện bằng cách dùng clear().

# Khởi tạo my_set # Output: set of unique elements my_set = set("Quantrimang.com") print(my_set) # xóa phần tử bằng pop() # Output: phần tử bị xóa ngẫu nhiên print(my_set.pop()) # xóa phần tử khác bằng pop() # Output: phần tử bị xóa ngẫu nhiên my_set.pop() print(my_set) # clear my_set #Output: set() my_set.clear() print(my_set)

Các toán tử set trong Python

Set thường được sử dụng để chứa các toán tử tập hợp như hợp, giao, hiệu, bù. Có cả phương thức và toán tử để thực hiện những phép toán tập hợp này.

Giao của A và B là tập hợp những phần tử chung của A và B. Để tìm giao của A và B ta có thể dùng toán tử & hoặc hàm intersection().

# khởi tạo A và B A = {1, 2, 3, 4, 5} B = {4, 5, 6, 7, 8} # sử dụng & # Output: {4, 5} print(A & B) # sử dụng intersection() # Output: {4, 5} print(A.intersection(B)) print(B.intersection(A))

Hiệu của A và B (A-B) là tập hợp phần tử chỉ có trong A, không có trong B. Hiệu của B và A (B-A) là tập hợp phần tử chỉ có trong B không có trong A. Có thể sử dụng toán tử – hoặc hàm difference() để thực hiện phép toán tập hợp này.

# Khởi tạo A và B A = {1, 2, 3, 4, 5} B = {4, 5, 6, 7, 8} # Sử dụng toán tử - trên A # Output: {1, 2, 3} print(A - B) # Sử dụng hàm difference() trên A # Output: {1, 2, 3} print(A.difference(B)) # Sử dụng toán tử - trên B # Output: {8, 6, 7} print(B - A) # Sử dụng difference() trên B # Output: {8, 6, 7} print(B.difference(A))

Bù của A và B là tập hợp những phần tử có trong A và B nhưng không phải phần tử chung của hai tập hợp này. Bạn có thể dùng toán tử ^ hoặc hàm symmetric_difference() để thực hiện phép bù.

# Khởi tạo A và B A = {1, 2, 3, 4, 5} B = {4, 5, 6, 7, 8} # Sử dụng toán tử ^ # Output: {1, 2, 3, 6, 7, 8} print(A ^ B) # Sử dụng symmetric_difference() trên A # Output: {1, 2, 3, 6, 7, 8} print(A.symmetric_difference(B))

Các phương thức dùng trên set

add()

Thêm một phần tử vào set.

clear()

Xóa tất cả phần tử của set.

copy()

Trả về bản sao chép của set.

difference()

Trả về set mới chứa những phần tử khác nhau của 2 hay nhiều set.

difference_update()

Xóa tất cả các phần tử của set khác từ set này.

discard()

Xóa phần tử nếu nó có mặt trong set.

intersection()

Trả về set mới chứa phần tử chung của 2 set.

intersection_update()

Cập nhật set với phần tử chung của chính nó và set khác.

isdisjoint()

Trả về True nếu 2 set không có phần tử chung.

issubset()

Trả về True nếu set khác chứa set này.

issuperset()

Trả về True nếu set này chưa set khác.

pop()

Xóa và trả về phần tử ngẫu nhiên, báo lỗi KeyError nếu set rỗng.

remove()

Xóa phần tử từ set. Nếu phần tử đó không có trong set sẽ báo lỗi KeyError.

symmetric_difference()

Trả về set mới chứa những phần tử không phải là phần tử chung của 2 set.

symmetric_difference_update()

Cập nhật set với những phần tử khác nhau của chính nó và set khác.

union()

Trả về set mới là hợp của 2 set.

update()

Cập nhật set với hợp của chính nó và set khác.

Kiểm tra phần tử trong set

Bạn có thể kiểm tra một đối tượng xem nó có nằm trong set không, sử dụng từ khóa in.

# Khởi tạo my_set my_set = set("Quantrimang.com") # Kiểm tra xem Q có trong my_set không # Output: True print('Q' in my_set) # Kiểm tra xem q có trong my_set không # Output: False print('q' in my_set)

Lặp qua phần tử của set

Sử dụng vòng lặp for để lặp qua các phần tử của set.

for letter in set("Python"): print(letter)

Chạy code trên bạn nhận được kết quả như sau:

Hàm thường dùng trên set

Frozenset trong Python

Frozenset là một lớp mới, có đặc điểm của một set, nhưng phần tử của nó không thể thay đổi được sau khi gán. Để dễ hình dung thì tuple là list bất biến còn frozenset là set bất biến.

Các set có thể thay đổi được nhưng không thể băm (hash) được, do đó không thể sử dụng set để làm key cho dictionary. Nhưng frozenset có thể băm được nên có thể dùng như các key cho dictionary.

Frozenset có thể tạo bằng hàm frozenset(). Kiểu dữ liệu này hỗ trợ các phương thức như copy(), difference(), intersection(), isdisjoint(), issubset(), issuperset(), symmetric_difference() và union(). Vì không thể thay đổi nên phương thức add() hay remove() không sử dụng được trên frozenset.

7. Dictionary

Dictionary là tập hợp các cặp khóa giá trị không có thứ tự. Nó thường được sử dụng khi chúng ta có một số lượng lớn dữ liệu. Các dictionary được tối ưu hóa để trích xuất dữ liệu với điều kiện bạn phải biết được khóa để lấy giá trị.

Cách tạo dictionary trong Python

Trong Python, dictionary được định nghĩa trong dấu ngoặc nhọn {} với mỗi phần tử là một cặp theo dạng key:value. Key và value này có thể là bất kỳ kiểu dữ liệu nào. Bạn cũng có thể tạo dictionary bằng cách sử dụng hàm dict() được tích hợp sẵn.

Ví dụ:

dict1 = {} #dictionary rỗng #dict2 là dictionary với các khóa nguyên dict2 = {1: 'Quantrimang.com',2: 'Công nghệ'} #Tạo dictionary với khóa hỗn hợp dict3 = {'tên': 'QTM', 1: [1, 3, 5]} #Tạo dictionary bằng dict() dict4 = dict({1:'apple', 2:'ball'}) #Tạo dictionary từ chuỗi với mỗi mục là một cặp dict5 = dict([(1,'QTM'), (2,'CN')])

Khi thực hiện kiểm tra kiểu dữ liệu của d ta được kết quả:

Truy cập phần tử của dictionary

Các kiểu dữ liệu lưu trữ khác sử dụng index để truy cập vào các giá trị thì dictionary sử dụng các key. Key có thể được sử dụng trong cặp dấu ngoặc vuông hoặc sử dụng get().

Sử dụng khóa để trích xuất dữ liệu:

#khai báo và gán giá trị dict2 dict2 = {1: 'Quantrimang.com','quantrimang': 'Công nghệ'} print(type(dict2)) #in kiểu dữ liệu của dict2 #trích xuất dữ liệu bằng khóa rồi in print("dict2[1] = ", dict2[1]) print("dict2[quantrimang] = ",dict2['quantrimang'])

Chạy đoạn code trên ta sẽ được kết quả:

Thay đổi, thêm phần tử cho dictionary

Dictionary có thể thay đổi, nên có thể thêm phần tử mới hoặc thay đổi giá trị của các phần tử hiện có bằng cách sử dụng toán tử gán. Nếu key đã có, giá trị sẽ được cập nhật, nếu là một cặp key: value mới thì sẽ được thêm thành phần tử mới.

dict2 = {1: 'Quantrimang.com','quantrimang': 'Công nghệ'} #cập nhật giá trị dict2['quantrimang'] = 'Quản trị mạng' #output: {1: 'Quantrimang.com', 'quantrimang': 'Quản trị mạng'} print(dict2) #thêm phần tử mới dict2[2] = 'Python' #output: {1: 'Quantrimang.com', 'quantrimang': 'Quản trị mạng', 2: 'Python'} print(dict2)

Xóa phần tử từ dictionary

Bạn có thể xóa phần tử cụ thể của dictionary bằng cách sử dụng pop(), nó sẽ phần tử có key đã cho và trả về giá trị của phần tử. popitem() có thể xóa và trả về một phần tử tùy ý dưới dạng (key, value). Tất cả các phần tử trong dictionary có thể bị xóa cùng lúc bằng cách dùng clear(). Ngoài ra, từ khóa del cũng có thể dùng để xóa một phần tử hoặc toàn bộ dictionary.

# tạo dictionary binh_phuong = {1:1, 2:4, 3:9, 4:16, 5:25} # xóa phần tử số 4 # Output: 16 print(binh_phuong.pop(4)) # Output: {1: 1, 2: 4, 3: 9, 5: 25} print(binh_phuong) # xóa phần tử cụ thể del binh_phuong[2] # output: {1: 1, 3: 9, 5: 25} print(binh_phuong) # xóa phần tử bất kỳ # Output: (5, 25) print(binh_phuong.popitem()) # Output: {1: 1, 3: 9} print(binh_phuong) # xóa tất cả phần tử binh_phuong.clear() # output: {} print(binh_phuong) # xóa dictionary binh_phuong del binh_phuong # tạo lỗi nếu bỏ # ở lệnh sau # print(squares)

Các phương thức và hàm cho dictionary

Đây là những phương thức thường dùng với dictionary:

clear()

Xóa tất cả phần tử của dictionary.

copy()

Trả về một bản sao shollow copy của dictionary.

fromkeys(seq[,v])

Trả về dictionary mới với key từ seq và value bằng v (default là None).

get(key[,d])

Trả về giá trị của key, nếu key không tồn tại, trả về d. (default là None).

items()

Trả lại kiểu xem mới của các phần tử trong dictionary (key, value).

keys()

Trả về kiểu xem mới của các key trong dictionary.

pop(key[,d])

Xóa phần tử bằng key và trả về giá trị hoặc d nếu key không tìm thấy. Nếu d không được cấp, key không tồn tại thì sẽ tạo lỗi KeyError.

popitem()

Xóa và trả về phần tử bất kỳ ở dạng (key, value). Tạo lỗi KeyError nếu dictionary rỗng.

setdefault(key,[,d])

Nếy key tồn tại trả về value của nó, nếu không thêm key với value là d và trả về d (default là None).

update([other])

Cập nhật dictionary với cặp key/value từ other, ghi đè lên các key đã có.

values()

Trả về kiểu view mới của value trong dictionary.

Các hàm tích hợp như all(), any(), len(), cmp(), sorted(),… thường được sử dụng với dictionary để thực hiện những nhiệm vụ khác nhau.

Dictionary comprehension trong Python

lap_phuong = {x: x*x*x for x in range(6)} # Output: {0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 5: 125} print(lap_phuong)

Chương trình trên tương đương với

lap_phuong = {} for x in range(6): lap_phuong[x] = x*x*x print(lap_phuong) lap_phuong_chan = {x: x*x*x for x in range (10) if x%2==0} # output: {0: 0, 2: 8, 4: 64, 6: 216, 8: 512} print(lap_phuong_chan)

Kiểm tra và lặp qua phần tử trong dictionary

Bạn chỉ có thể kiểm tra key của phần tử đã có trong dictionary hay chưa bằng cách dùng in, và không thể làm điều đó với value.

lap_phuong = {0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 5: 125} #output: True print (2 in lap_phuong) #output: False print (9 in lap_phuong) #output: False print (5 not in lap_phuong)

Bạn có thể sử dụng vòng lặp for để lặp qua key của các phần tử trong dictionary.

lap_phuong = {0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 5: 125} for i in lap_phuong print(lap_phuong[i])

Chạy code trên, các giá trị tương ứng với từng key sẽ được in ra màn hình theo thứ tự của key.

8. Chuyển đổi giữa các kiểu dữ liệu

Chúng ta có thể chuyển đổi giữa các kiểu dữ liệu khác nhau bằng cách sử dụng hàm chuyển đổi kiểu khác nhau như int() (kiểu số nguyên), float() số thập phân, str() chuỗi,…

Chuyển đổi từ kiểu float sang kiểu int sẽ bị giảm giá trị (làm cho nó gần với số không hơn).

Ví dụ:

Chuyển đổi từ string sang hoặc ngược lại phải có các giá trị tương thích.

Bạn có thể thực hiện chuyển đổi chuỗi này sang chuỗi khác:

9. Bước đầu tiên hướng tới lập trình

Tất nhiên, chúng ta có thể sử dụng Python cho những tác vụ phức tạp hơn là thêm vài phần tử vào chuỗi. Ví dụ, có thể viết một chuỗi con của dãy Fibonacci (dãy vô hạn các số tự nhiên bắt đầu bằng hai phần tử 0 và 1 hoặc 1 và 1, các phần tử sau đó được thiết lập bằng cách cộng hai phần tử trước nó lại) như sau:

Ví dụ này giới thiệu một số tính năng mới:

Dòng đầu tiên chứa một phép gán kép: Biến a và b đồng thời nhận được giá trị 0 và 1. Dòng cuối cùng, nó được sử dụng lại, thể hiện rằng các biểu thức ở phía bên phải sẽ được tính (ở đây là cộng tổng a và b) trước khi bất kỳ hành động gán nào được diễn ra. Biểu thức bên phải được tính từ trái sang phải

Thân của vòng lặp được viết thụt vào trong: Thụt đầu dòng là cách mà Python nhóm các lệnh. Tại dấu nhắc lệnh, bạn có thể nhấn tab hoặc phím cách để thụt lề. Một trình soạn thảo code sẽ hỗ trợ tốt hơn cho việc nhập những đoạn code Python phức tạp, thông thường các trình soạn thảo này đề có thụt lề tự động. Khi nhập một khối lệnh bạn phải chèn thêm một dòng trống ở cuối cùng để kết thúc khối lệnh (vì trình phân tích cú pháp không thể phân tích khi nào bạn hoàn tất dòng lệnh cuối cùng trong khối). Lưu ý là mỗi dòng trong một khối lệnh cơ bản phải được thụt vào cùng một khoảng giống nhau.

Hàm print() viết ra giá trị của các đối số mà nó được cung cấp: Nó khác với việc chỉ viết những biểu thức bạn muốn viết (như trong ví dụ dùng Python như một chiếc máy tính) theo cách xử lý nhiều đối số, số lượng dấu chấm động và chuỗi. Các chuỗi được in sẽ không có dấu ngoặc kép, một khoảng trắng được chèn vào giữa các mục, do đó, bạn có thể định dạng chúng theo ý thích, giống như thế này:

Có thể sử dụng thêm đối số end cho hàm print() để tránh thêm dòng mới trong kết quả đầu ra hoặc kết thúc kết quả với một chuỗi khác:

Bài tiếp: Lệnh if, if…else, chúng tôi trong Python

Bài trước: Tìm hiểu chương trình Python đầu tiên

Kiểu Dữ Liệu Set Trong Python / 2023

Dẫn nhập

Trong các bài trước, Kteam đã giới thiệu đến bạn một số container của Python.

Ở bài này Kteam sẽ giới thiệu tới bạn một container khác đó chính KIỂU DỮ LIỆU SET trong Python.

Nội dung

Để đọc hiểu bài này tốt nhất bạn cần:

Trong bài này, chúng ta sẽ cùng tìm hiểu các vấn đề

Giới thiệu về Set trong Python

Cách khởi tạo Set

Một số toán tử với Tuple trong Python

Indexing và cắt Set trong Python

Các phương thức của Set

Set không phải là một hash object

Giới thiệu về Set trong Python

Set là một container, tuy nhiên không được sử dụng nhiều bằng LIST hay TUPLE.

Một Set gồm các yếu tố sau:

Được giới hạn bởi cặp ngoặc

{}

, tất cả những gì nằm trong đó là những phần tử của Set.

Các phần tử của Set được phân cách nhau ra bởi dấu phẩy (

,

).

Set không chứa nhiều hơn 1 phần tử trùng lặp

Set chỉ có thể chứa các hashable object nhưng chính nó không phải là một hashable object. Do đó, bạn không thể chứa một set trong một set.

Ví dụ: 

>>> set_1 {96, 69} >>> type(set_1) # kiểu set thuộc lớp set >>> set_2 = {'How Kteam'} >>> set_2 {'How Kteam'} >>> set_3 = {(69, 'Free Education'), (1, 2, 3)} >>> set_3 {(69, 'Free Education'), (1, 2, 3)} >>> set_4 = {[1, 2], [3, 4]} Traceback (most recent call last): TypeError: unhashable type: 'list' >>> set_5 = {(1, 2, ['How Kteam'])} Traceback (most recent call last): TypeError: unhashable type: 'list' >>> set_6 = {1, 2, {'HowKteam'}} Traceback (most recent call last): TypeError: unhashable type: 'set'

Cách khởi tạo Set

Sử dụng cặp  dấu ngoặc {} và đặt giá  trị bên trong

Cú pháp:

Lưu ý: Khi khởi tạo bằng cách này, ít nhất phải có một giá trị.

Ví dụ:

>>> set_ {1, 2, 3, 4} >>> set_1 = {1, 1, 1} # các giá trị trùng lặp bị loại bỏ >>> set_1 {1} >>> empty_set = {} # thử khởi tạo set rỗng >>> empty_set {} >>> type(empty_set) # không phải là set

Sử dụng Set Comprehension

>>> set_1 {0, 1, 2}

Sử dụng constructor Set

Cú pháp:

set(iterable)

Công dụng: Giống hoàn toàn với việc bạn sử dụng constructor List. Khác biệt duy nhất là constructor Set sẽ tạo ra một Set.

Ví dụ: 

>>> set_1 {1, 2, 3} >>> set_2 = set('How Kteam') >>> set_2 # set không quan tâm đến vị trí của các phần tử {'o', ' ', 'a', 'm', 'H', 'K', 't', 'w', 'e'} >>> set_3 = set('aaaaaaaaa') >>> set_3 {'a'} >>> set_4 = set([1, 6, 8, 3, 1, 1, 3, 6]) {8, 1, 3, 6} >>> empty_set = set() # cách bạn tạo được empty set >>> empty_set set()

Một số toán tử với Set trong Python

Nhằm giúp các bạn dễ hiểu hơn về các toán tử với Set trong Python, Kteam minh họa các set dưới dạng biểu đồ Venn, với S1, S2 tương ứng các Set1, Set2 chứa các phần tử.

Toán tử in

Cú pháp:

Công dụng: Kết quả trả về là True nếu value xuất hiện trong Set. Ngược lại sẽ là False

Ví dụ:

True >>> 4 in {'a', 'How Kteam', 5} False

Toán tử –

Cú pháp:

Công dụng: Kết quả trả về là một Set gồm các phần tử chỉ tồn tại trong Set1 mà không tồn tại trong Set2

Ví dụ:

{1} >>> {1, 2, 3} - {4} {1, 2, 3} >>> {1, 2, 3} - {1, 2, 3} set() >>> {1, 2, 3} - {1, 2, 3, 4} set()

Toán tử &

Cú pháp:

Công dụng: Kết quả trả về là một Set chứa các phần tử vừa tồn tại trong Set1 vừa tồn tại trong Set2

Ví dụ:

set() >>> {1, 2, 3} & {1, 4, 5} {1} >>> {1, 2, 3} & {1, 2, 3} {1, 2, 3}

Cú pháp:

Công dụng:  Kết quả trả về là một Set chứa tất cả các phần tử tồn tại trong hai Set

Ví dụ:

{1, 2, 3} {1, 2, 3, 4, 5}

Toán tử ^

Cú pháp:

Công dụng:  Kết quả trả về là một Set chứa tất cả các phần tử chỉ tồn tại ở một trong hai Set

Ví dụ:

{1, 2, 3, 4, 5} >>> {1, 2, 3} ^ {1, 2, 3} set() >>> {1, 2, 3} ^ {1, 4} {2, 3, 4}

Indexing và cắt Set trong Python

Ở trên Kteam đã đề cập về việc set không quan tâm đến vị trí của phần tử nằm trong set. Nên, việc indexing và cắt set trong Python không được hỗ trợ.

Các phương thức của Set

Set cũng có khá nhiều phương thức. Nhưng Kteam chỉ giới thiệu một số phương thức cơ bản.

Phương thức clear

Cú pháp:

Công dụng: Loại bỏ hết tất cả các phần tử có trong Set

Ví dụ:

>>> set_1.clear() >>> set_1 set()

Phương thức pop

Cú pháp:

Công dụng: Kết quả trả về một giá trị được lấy ra từ Set, đồng thời loại bỏ giá trị đã lấy ra khỏi Set ban đầu

Nếu là set rỗng, sẽ có lỗi

Ví dụ:

>>> set_1.pop() 1 >>> set_1 {2} >>> set_1.pop() 2 >>> set_1 set() >>> set_1.pop() Traceback (most recent call last): KeyError: 'pop from an empty set'

Phương thức remove

Cú pháp:

Công dụng: Loại bỏ giá trị value ở trong Set. Nếu như value không ở trong Set, thông báo lên lỗi KeyError.

Ví dụ:

>>> a.remove(1) >>> a {2} >>> a.remove(3) Traceback (most recent call last): KeyError: 3

Phương thức discard

Cú pháp:

Công dụng: Loại bỏ giá trị value ở trong Set. Nếu như value không ở trong Set, thì sẽ bỏ qua.

Ví dụ:

>>> a.discard(1) >>> a {2} >>> a.discard(4) >>> a {2}

Phương thức copy

Cú pháp:

Công dụng: Trả về một bản sao của Set

Ví dụ:

>>> b = a.copy() >>> b {1, 2} >>> a {1, 2}

Phương thức add

Cú pháp:

Công dụng: Thêm value vào trong set. Nếu như value đã có trong Set thì bỏ qua.

Ví dụ:

>>> a.add(3) >>> a {1, 2, 3} >>> a.add(2) >>> a {1, 2, 3}

Set không phải là một hash object

Đúng như vậy! Điều đó có thể chứng minh theo hai cách:

Ở ví dụ dưới, bạn cũng thấy, ta đã thay đổi nội dung của set nhưng id của set vẫn là id ban đầu

Ví dụ:

>>> id(a) 52255360 >>> a.add(3) >>> id(a) 52255360

Thêm nữa, set không thể chứa một set khác

>>> b = {a} Traceback (most recent call last): TypeError: unhashable type: 'set'

Củng cố bài học

Câu hỏi củng cố

Giải thích lí do tại sao lại có sự thay đổi ở set a? Cho giải pháp khắc phục?

>>> b = a >>> b.clear() >>> a # tại sao lại trở thành set rỗng? set()

Đáp án của phần này sẽ được trình bày ở bài tiếp theo. Tuy nhiên, Kteam khuyến khích bạn tự trả lời các câu hỏi để củng cố kiến thức cũng như thực hành một cách tốt nhất! 

Kết luận

Bài viết này đã giới thiệu cho các bạn KIỂU DỮ LIỆU SET TRONG PYTHON.

Ở bài sau, Kteam sẽ nói về một kiểu dữ liệu khác của Python chính là KIỂU DỮ LIỆU DICT (DICTIONARY).

Tải xuống

Tài liệu

Nhằm phục vụ mục đích học tập Offline của cộng đồng, Kteam hỗ trợ tính năng lưu trữ nội dung bài học Kiểu dữ liệu Set trong Python dưới dạng file PDF trong link bên dưới.

Ngoài ra, bạn cũng có thể tìm thấy các tài liệu được đóng góp từ cộng đồng ở mục TÀI LIỆU trên thư viện Howkteam.com

Nếu bạn có bất kỳ khó khăn hay thắc mắc gì về khóa học, đừng ngần ngại đặt câu hỏi trong phần bên dưới hoặc trong mục HỎI & ĐÁP trên thư viện chúng tôi để nhận được sự hỗ trợ từ cộng đồng.

Cấu Trúc Dữ Liệu Trong Python / 2023

Các kiểu dữ liệu cơ bản trong Python bao gồm kiểu số nguyên (int), kiểu số thực (float), kiểu chuỗi (string) và kiểu logic (boolean). Với các kiểu dữ liệu cơ bản này, chúng ta có thể viết các ứng dụng đơn giản với Python.

Với các ứng dụng có số lượng các biến nhiều, dữ liệu lớn chúng ta cần tới các cấu trúc dữ liệu giúp cho việc viết code ngắn gọn và hiệu quả. Trong Python có 4 kiểu cấu trúc dữ liệu là List, Tuple, Set và Dictionary.

Tại sao cấu trúc dữ liệu cần thiết

Cấu trúc dữ liệu được sử dụng trong các chương trình để dễ dàng hơn trong việc định vị thông tin và lấy thông tin. Cấu trúc dữ liệu là cách các ngôn ngữ lập trình thể hiện các giá trị cơ bản, chúng chứa các kiểu dữ liệu cơ bản như số, chuỗi, boolean…, nó đưa ra cách thức lưu trữ nhiều giá trị trong một biến số.

Cấu trúc dữ liệu cũng được sử dụng để phân nhóm và tổ chức cho các cấu trúc khác.

1.1 Định nghĩa và cách sử dụng List

List là một tập dữ liệu đơn giản nhất trong Python, một List là một danh sách các thành phần dữ liệu được phân cách bởi dấu phẩy và được bao ngoài bởi dấu ngoặc vuông. List có thể chứa các con số hoặc các chuỗi.

Chú ý: Một danh sách có thể chứa nhiều loại dữ liệu khác nhau nếu bạn thấy cần thiết, tuy nhiên nên dừng một loại dữ liệu thống nhất cho các phần tử trong danh sách.

members = ["Dung",25,"Duc"]

1.2 Truy xuất phần tử trong List

Mỗi phần tử trong List sẽ có một vị trí nhất định tương ứng với một con số, bắt đầu từ số 0 và tăng dần. Chúng ta có thể truy xuất đến các phần tử trong danh sách với cú pháp:

Trong ví dụ trên, để truy xuất đến tên Van, chúng ta thực hiện như sau:

Chú ý: Nếu bạn truy xuất đến một phần tử không có trong danh sách, một lỗi sẽ xuất hiện có dạng “index out of range”.

1.3 Danh sách đa chiều

Mỗi phần tử trong danh sách của Python có thể là một danh sách, ví dụ như danh sách sau đây, mỗi phần tử là một danh sách gồm tên và tuổi của bạn bè.

Trong Python không giới hạn số chiều của danh sách cũng như số phần tử danh sách có thể chứa, nó chỉ phụ thuộc vào dung lượng bộ nhớ máy tính bạn dùng để chạy ứng dụng.

Chú ý, với các danh sách dài, chúng ta nên trình bày mỗi phần tử trên một dòng, như vậy code chương trình sẽ dễ đọc hơn, ví dụ:

Trong quá trình thao tác với danh sách, chúng ta cần: kiểm tra xem danh sách có chứa một phần tử nào đó không, đếm số phần tử hoặc thêm , xóa, sửa phần tử trong danh sách… Các yêu cầu này đều có toán tử hoặc các phương thức được xây dựng sẵn trong đối tượng List.

1.4.1 Toán tử in

Toán tử in cho phép bạn kiểm tra một phần tử có nằm trong một danh sách hay không. Ví dụ: Kiểm tra xem “Dung” có trong danh sách members không?

1.4.2 Hàm len()

Hàm len() trả về số phần tử có trong một danh sách.

1.4.3 Một số phương thức trên Model List

.append() thêm một phần tử vào vị trí cuối cùng trong List:

.insert(position, item) chèn một phần tử vào List tại vị trí cho trước.

Các phần tử phía sau sẽ có vị trí tăng lên 1, cần chú ý khi truy xuất giá trị các phần tử này.

listname[index]=newvalue Thay đổi giá trị một phần tử có vị trí index trong List.

.extend() Kết hợp danh sách với một List khác.

.remove() Loại bỏ một phần tử khỏi List.

.pop(index) Loại bỏ phần tử ở vị trí index cho trước trong List.

del Xóa một phần tử hoặc toàn bộ danh sách

.clear() Xóa sạch các phần tử trong danh sách

Chú ý, .clear() khác với del, .clear() xóa toàn bộ các phần tử trong List, còn del xóa luôn cả biến List.

.count() Đếm số lần một phần tử xuất hiện trong List.

.index() Trả về vị trí phần tử trong List

.sort() sắp xếp các phần tử trong List.

Mặc định sắp xếp tăng dần với dữ liệu chuỗi sẽ sắp xếp a-z, A-Z, với số 0-9. Để sắp xếp giảm dần sử dụng tham số reverse = True.

reverse() Đảo ngược thứ tự các phần tử trong List.

.copy() Copy toàn bộ List.

Python hỗ trợ một cấu trúc dữ liệu cũng tương tự với List có tên là Tuple, chỉ có một khác biệt Tuple là danh sách bất biến, không thể thay đổi nội dung. Tức là ngay sau khi định nghĩa Tuple, bạn không thể thay đổi nó.

2.1 Khai báo Tuple

Định nghĩa một Tuple cũng giống như định nghĩa một List trong Python, chỉ khác là thay vì sử dụng ngoặc vuông chúng ta sử dụng ngoặc tròn.

Python cho phép định nghĩa Tuple mà không cần sử dụng dấu ngoặc thường. Ví dụ:

Thậm chí Tuple chỉ có một phần tử:

Chú ý dấu phẩy, nếu không có dấu phẩy thì đây là định nghĩa một chuỗi.

2.2 Thao tác với Tuple

Tuple là một danh sách đặc biệt, không thể thay đổi khi đã tạo ra, do đó bạn có thể sử dụng tất cả các kỹ thuật, các hàm như với List nhưng loại trừ những hàm tác động thay đổi nội dung.

Ví dụ, bạn có thể sử dụng toán tử in, hàm len() với Tuple:

Tất cả các phương thức .append(), .extend(), .clear(), .copy(), .insert(), .pop(), .remove(), .reverse(), .sort() không sử dụng được với cấu trúc dữ liệu Tuple.

Chú ý: Không thể thay đổi Tuple nhưng có thể tạo ra một Tuple từ hai Tuple, ví dụ :

2.3 Tại sao sử dụng Tuple

Tuple có những hạn chế là khi tạo ra không thể thay đổi được tuy nhiên Tuple lại có những ưu điểm sau:

Tuple có tốc độ xử lý nhanh hơn List, do Tuple được lưu trữ một khối bộ nhớ xác định còn List thì thường xuyên phải thay đổi không gian lưu trữ. Nếu bạn định nghĩa một tập các giá trị là hằng số thì nên chọn Tuple.

Sử dụng Tuple giúp code an toàn hơn, khi đó chế độ “write-protect” giúp cho dữ liệu không thể thay đổi. Do vậy nên lựa chọn cho những dữ liệu dạng hằng số, dữ liệu không thay đổi theo thời gian.

Tuple còn được sử dụng làm khóa trong Dictionary do nó chứa các giá trị không đổi, List không được sử dụng làm khóa cho Dictionary.

All Rights Reserved

Kiểu Dữ Liệu, Toán Tử Và Cấu Trúc Lập Trình Trong Java / 2023

Đối với những người mới học lập trình java thì việc hiểu những kiến thức về kiểu dữ liệu, toán tử và cấu trúc lập trình trong java là hết sức cần thiết và quan trọng. Nó quyết định đến việc liệu bạn có thể trở thành một lập trình viên java trong tương lai hay không. Do vậy các bạn khi hiểu các khái niệm tôi đưa ra trong bài viết này thì các bạn hãy dành thời gian để thực hành để hiểu rõ bản chất hơn nữa.

Khai báo biến trong Java

Khai báo biến là việc chỉ ra cho máy tính cần cấp phát một vùng nhớ để lưu trữ thông tin phục vụ công việc, tính toán của người lập trình.

Ví dụ:

Kiểu dữ liệu trong java

Các kiểu dữ liệu trong java khác nhau ở việc kích thước cấp phát vùng nhớ để lưu trữ thông tin. Tùy theo từng mục đích công việc, cách thức lưu trữ mà người lập trình có thể sử dụng các kiểu dữ liệu khác nhau như sau:

Cấu trúc điều kiện if else trong java

Là cấu trúc kiểm tra điều kiện nếu biểu thức điều kiện đúng thì thực hiện trong if ngược lại nếu có else thì thực hiện trong else.

+ Nếu hôm nay trời mưa thì ở nhà còn không sẽ đi chơi hồ hoàn kiếm

+ Nếu tôi kiếm được nhiều tiền tôi sẽ mua nhà ở hà nội

Với ngôn ngữ này con người chúng ta hoàn toàn có thể hiểu được. Tuy nhiên máy tính sẽ chỉ được hiểu được khi chúng ta mô tả như sau:

if(trời mưa)

{

//Công việc: Ở nhà

}

else

{

//Công việc: Đi chơi hồ hoàn kiếm

}

if(tôi kiếm được nhiều tiền)

{

//Công việc: Tôi sẽ mua nhà ở hà nội

}

Bạn đang đọc nội dung bài viết Kiểu Dữ Liệu Trong Python: Chuỗi, Số, List, Tuple, Set Và Dictionary / 2023 trên website Comforttinhdauthom.com. Hy vọng một phần nào đó những thông tin mà chúng tôi đã cung cấp là rất hữu ích với bạn. Nếu nội dung bài viết hay, ý nghĩa bạn hãy chia sẻ với bạn bè của mình và luôn theo dõi, ủng hộ chúng tôi để cập nhật những thông tin mới nhất. Chúc bạn một ngày tốt lành!