Kết hợp hai danh sách theo chỉ mục Python
Python được tạo ra bởi Guido van Rossum vào đầu những năm 90s. Ngày nay nó là một trong những ngôn ngữ phổ biến nhất còn tồn tại. Tôi thích Python vì sự rõ ràng, trong sáng về mặt cú pháp. Về cơ bản, Python có thể coi như một loại mã giả (pseudocode) có thể thực thi được. Mọi phản hồi đều sẽ được tích cực ghi nhận! Bạn có thể liên lạc với tôi qua Twitter @louiedinh hoặc louiedinh [at] [google’s email service] Lưu ý: Bài viết này áp dụng riêng cho Python 3. Truy cập vào đây nếu bạn muốn học phiên bản cũ Python 2.7 # Dòng bình luận (comment) bắt đầu bằng dấu thăng (#) """ Những chuỗi ký tự (string) nằm trên nhiều dòng
có thể được viết bằng cách dùng 3 dấu nháy " và thường
được dùng trong quá trình viết tài liệu (documentation).
""" ####################################################
## 1. Các kiểu dữ liệu cơ bản và Các phép toán
#################################################### # Bạn có những con số
3 # => 3 # Tính toán với những con số là những điều có thể bạn sẽ làm
1 + 1 # => 2
8 - 1 # => 7
10 * 2 # => 20
35 / 5 # => 7.0 # Kết quả của phép chia số nguyên sẽ được làm tròn xuống cho cả số dương và số âm
5 // 3 # => 1
5.0 // 3.0 # => 1.0 # phép chia số nguyên cũng áp dụng được cho kiểu dữ liệu float biểu diễn số thực
-5 // 3 # => -2
-5.0 // 3.0 # => -2.0 # Kết quả của phép chia luôn là số thực
10.0 / 3 # => 3.3333333333333335 # Phép toán lấy phần dư (modulo)
7 % 3 # => 1 # Phép lũy thừa (x**y, x lũy thừa y)
2**3 # => 8 # Áp đặt thứ tự tính toán bằng dấu ngoặc
(1 + 3) * 2 # => 8 # Kiểu Boolean cũng là một kiểu dữ liệu cơ bản (Lưu ý: ký tự đầu tiên viết hoa)
True
False # Phủ định bằng từ khóa 'not'
not True # => False
not False # => True # Các phép toán với kiểu Boolean
# Lưu ý từ khóa "and" và "or" là case-sensitive
True and False # => False
False or True # => True # Lưu ý khi sử dụng các phép toán của kiểu Boolean với số nguyên 'int'
# False là 0 và True là 1
# Đừng nhầm lẫn các phép toán Boolean cho số nguyên và các phép toán and/or trên bit (& và |)
0 and 2 # => 0
-5 or 0 # => -5
0 == False # => True
2 == True # => False
1 == True # => True
-5 != False != True #=> True # So sánh bằng với ==
1 == 1 # => True
2 == 1 # => False # So sánh không bằng với !=
1 != 1 # => False
2 != 1 # => True # Các phép so sánh khác
1 < 10 # => True
1 > 10 # => False
2 <= 2 # => True
2 >= 2 # => True # Các phép so sánh có thể xâu chuỗi với nhau!
1 < 2 < 3 # => True
2 < 3 < 2 # => False # (is vs. ==) từ khóa is kiểm tra xem 2 biến có cùng tham chiếu một đối tượng, còn == kiếm tra
# xem hai đối tượng có cùng giá trị hay không.
a = [1, 2, 3, 4] # a trỏ tới một danh sách (list) mới, [1, 2, 3, 4]
b = a # b trỏ tới nơi mà a cũng đang trỏ tới
b is a # => True, a và b cùng trỏ tới một đối tượng
b == a # => True, đối tượng mà a và b trỏ tới có cùng giá trị
b = [1, 2, 3, 4] # b trỏ tới một danh sách mới, [1, 2, 3, 4]
b is a # => False, a và b không cùng trỏ tới một đối tượng
b == a # => True, đối tượng mà a và b trỏ tới không có cùng giá trị # Chuỗi ký tự được tạo ra bằng dấu nháy kép " hoặc nháy đơn '
"Đây là một chuỗi ký tự."
'Đây cũng là một chuỗi ký tự.' # Chuỗi ký tự có thể được cộng với nhau can be added too! Tuy nhiên nên tránh làm như vậy
"Xin " + "chào!" # => "Xin chào!"
# Các chuỗi ký tự không phải là biến (literals) có thể được nối với nhau mà không cần dùng phép cộng '+'
"Xin " "chào!" # => "Xin chào!" # Một chuỗi ký tự có thể xem như một danh sách (list) các ký tự
"Đây là một chuỗi ký tự"[0] # => 'Đ' # Bạn có thể tìm chiều dài một chuỗi
len("Đây là một chuỗi") # => 16 # .format có thể được dùng để định dạng chuỗi, ví dụ như:
"{} có thể được {}".format("Chuỗi ký tự", "định dạng") # => "Chuỗi ký tự có thể được định dạng" # Bạn có thể lặp lại đối số (arguments) khi định dạnh để không phải gõ nhiều lần
"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
# => "Jack be nimble, Jack be quick, Jack jump over the candle stick" # Bạn có thể dùng từ khóa nếu bạn không muốn đếm
"{name} wants to eat {food}".format(name="Bob", food="lasagna") # => "Bob wants to eat lasagna" # Nếu code Python 3 của bạn cần phải chạy với Python 2.5 hoặc các bản cũ hơn, bạn cũng có thể
# dùng cách định dạng cũ:
"%s can be %s the %s way" % ("Strings", "interpolated", "old") # => "Strings can be interpolated the old way" # None là một đối tượng
None # => None # Đừng dùng so sánh bằng "==" để so sánh đối tượng với None
# Thay vào đó dùng is. Nó sẽ kiểm tra xem một đối tượng có đồng nhất với None hay không.
"etc" is None # => False
None is None # => True # None, 0, và chuỗi/danh sách (list)/từ điển (dict)/tuple rỗng khi chuyển về kiểu Boolean đều có giá trị là False.
# Tất cả những giá trị khác đều là True
bool(0) # => False
bool("") # => False
bool([]) # => False
bool({}) # => False
bool(()) # => False ####################################################
## 2. Biến và Các kiểu dữ liệu gộp (Collections)
#################################################### # Hàm print trong Python
print("Tôi là Python. Rất hân hạnh được làm quen!") # => Tôi là Python. Rất hân hạnh được làm quen! # Hàm print mặc định in thêm ký tự xuống dòng
# Dùng đối số tùy chọn (optional argument) để thay đổi cách kết thúc chuỗi.
print("Hello, World", end="!") # => Hello, World! # Một cách đơn giản để lấy dữ liệu vào từ bàn phím
input_string_var = input("Nhập dữ liệu: ") # Trả về dữ liệu vào là một chuỗi
# Lưu ý: Trong những phiên bản cũ của Python input() có tên là raw_input() # Không cần phải khai báo biến mà chỉ có gán giá trị cho biến.
# Quy ước là sử dụng chữ_viết_thường_có_dấu_gạch_dưới
some_var = 5
some_var # => 5 # Truy cập một biến chưa được gán trước đó sẽ tạo ra biệt lệ (exception).
# Đọc mục Luồng điều khiển để hiểu thêm về việc giải quyết các biệt lệ (exception handling)
some_unknown_var # Sinh ra một biệt lệ kiểu NameError # if có thể dùng như một biểu thức
# Tương đương với phép toán ba ngôi trong C: '?:'
"yahoo!" if 3 > 2 else 2 # => "yahoo!" # Kiểu danh sách (list) lưu trữ chuỗi đối tượng tuần tự
li = []
# Bạn có thể bắt đầu với một danh sách đã có sãn các phần tử
other_li = [4, 5, 6] # Thêm phần tử vào cuối danh sách bằng phương thức append
li.append(1) # li bây giờ là [1]
li.append(2) # li bây giờ là [1, 2]
li.append(4) # li bây giờ là [1, 2, 4]
li.append(3) # li bây giờ là [1, 2, 4, 3]
# Xóa phần tử cuối cùng bằng phương thức pop
li.pop() # => 3 and li is now [1, 2, 4]
# Sau đó ta có thể đưa đối tượng trở lại danh sách
li.append(3) # li trở lại là [1, 2, 4, 3]. # Truy cập một danh sách như bạn làm với một mảng (array)
li[0] # => 1
# Truy cập phần tử cuối cùng
li[-1] # => 3 # Truy cập ngoài giới hạn sẽ tạo ra biệt lệ IndexError
li[4] # Sinh ra một biệt lệ kiểu IndexError # Bạn có thể truy cập một đoạn bằng phép cắt (slice).
# Chỉ mục bắt đầu được tính làm điểm bắt đầu còn chỉ mục kết thúc thì không, mà là chỉ mục của phần tử tiếp theo phần tử kết thúc
# (Về mặt toán học thì đây là một đoạn đóng/mở, hay nửa đoạn)
li[1:3] # => [2, 4]
# Lấy từ vị trí thứ 3 đến hết
li[2:] # => [4, 3]
# Lấy từ đầu đến vị trí thứ 3
li[:3] # => [1, 2, 4]
# Lấy những phần tử có chỉ mục chẵn
li[::2] # =>[1, 4]
# Trả về bản sao của danh sách bị đảo ngược
li[::-1] # => [3, 4, 2, 1]
# Kết hợp 3 tham số để làm những phép cắt phức tạp hơn
# li[start:end:step] # Tạo ra một bản sao sâu (deep copy) bằng phép cắt
li2 = li[:] # => li2 = [1, 2, 4, 3] but (li2 is li) will result in false. # Xóa phần tử nào đó của danh sách bằng "del"
del li[2] # li is now [1, 2, 3] # Xóa đi phần tử đầu tiên mang một giá trị nhất định
li.remove(2) # li bây giờ là [1, 3]
li.remove(2) # Sinh ra biệt lệ kiểu ValueError vì 2 không tồn tại trong danh sách # Chèn một phần tử vào một vị trí cụ thể
li.insert(1, 2) # li bây giờ lại là [1, 2, 3] # Tìm chỉ mục của của phần tử đầu tiên mang một giá trị nhất định
li.index(2) # => 1
li.index(4) # Sinh ra biệt lệ a ValueError as 4 is not in the list # Bạn có thể cộng dồn các danh sách
# Lưu ý: giá trị của li và other_li không đổi
li + other_li # => [1, 2, 3, 4, 5, 6] # Nối danh sách bằng "extend()"
li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6] # Kiểm tra sự tồn tại của một phần tử trong danh sách bằng "in"
1 in li # => True # Xác định độ dài bằng "len()"
len(li) # => 6 # Tuple cũng giống như danh sách nhưng không thể thay đổi giá trị được (immutable)
tup = (1, 2, 3)
tup[0] # => 1
tup[0] = 3 # Sinh ra biệt lệ kiểu TypeError # Lưu ý rằng tuple có độ dài là 1 phải có dấu phẩy theo sau phần tử cuối
# nhưng tuples có độ dài khác, ngay cả tuple rỗng, thì không cần như vậy
type((1)) # => Got a suggestion? A correction, perhaps? Open an Issue on the Github Repo, or make a pull request yourself! |