Xin chào! Chào mừng. Nếu bạn đang học Python, thì bài viết này là dành cho bạn. Bạn sẽ tìm thấy mô tả kỹ lưỡng về cú pháp Python và rất nhiều ví dụ về mã để hướng dẫn bạn trong suốt hành trình viết mã của mình. Nội dung chúng ta sẽ đề cập: * Định nghĩa biến trong Python * Xin chào, Thế giới! Chương trình

Bạn đang xem: hướng dẫn python cho người mới bắt đầu với các ví dụ

Xin chào! Chào mừng. Nếu bạn đang học Python, thì bài viết này là dành cho bạn. Bạn sẽ tìm thấy mô tả kỹ lưỡng về cú pháp Python và rất nhiều ví dụ về mã để hướng dẫn bạn trong suốt hành trình viết mã của mình.

Nội dung chúng tôi sẽ đề cập:

Bạn đã sẵn sàng chưa? Hãy bắt đầu nào! 🔅

💡 Mẹo: trong suốt bài viết này, tôi sẽ sử dụng & lt; & gt; để chỉ ra rằng phần này của cú pháp sẽ được thay thế bằng phần tử được mô tả bởi văn bản. Ví dụ: & lt; var & gt; có nghĩa là biến này sẽ được thay thế bằng một biến khi chúng tôi viết mã.

🔹 Biến Các định nghĩa trong Python

Khối xây dựng cơ bản nhất của bất kỳ ngôn ngữ lập trình nào là khái niệm về một biến, tên và vị trí trong bộ nhớ mà chúng ta dự trữ cho một giá trị.

Trong Python, chúng tôi sử dụng cú pháp này để tạo một biến và gán giá trị cho biến này:

  & lt; var_name & gt; = & lt; value & gt;  

Ví dụ:

  age = 56  
  name = "Nora " 
  color =" Blue " 
  Grade = [67, 100, 87, 56]  < / pre> 

Nếu tên của một biến có nhiều hơn một từ, thì Hướng dẫn về văn phong cho mã Python khuyên bạn nên tách các từ bằng dấu gạch dưới "nếu cần để cải thiện khả năng đọc".

Ví dụ:

  my_list = [1, 2, 3, 4, 5]  

💡 Mẹo: Hướng dẫn phong cách cho mã Python (PEP 8) có những gợi ý tuyệt vời mà bạn nên làm theo để viết mã Python rõ ràng.

🔸 Hello, World! Chương trình bằng Python

Trước khi chúng ta bắt đầu đi sâu vào các kiểu dữ liệu và cấu trúc dữ liệu mà bạn có thể sử dụng trong Python, hãy xem cách bạn có thể viết chương trình Python đầu tiên của mình.

Bạn chỉ cần gọi hàm print () và viết "Hello, World!" trong ngoặc đơn:

 < code class = "language-python"> print ("Hello, World!")  

Bạn sẽ thấy thông báo này sau khi chạy chương trình:

  " Hello, World! " 

💡 Mẹo: Viết chương trình " Hello, World! " là một truyền thống trong cộng đồng nhà phát triển. Hầu hết các nhà phát triển bắt đầu học cách viết mã bằng cách viết chương trình này.

Tuyệt vời. Bạn vừa viết chương trình Python đầu tiên của mình. Bây giờ chúng ta hãy bắt đầu tìm hiểu về các kiểu dữ liệu và cấu trúc dữ liệu tích hợp mà bạn có thể sử dụng trong Python.

🔹 Kiểu dữ liệu và cấu trúc dữ liệu tích hợp trong Python

Chúng tôi có một số kiểu dữ liệu cơ bản và cấu trúc dữ liệu tích hợp mà chúng tôi có thể làm việc với các chương trình của mình. Mỗi cái đều có những ứng dụng cụ thể của riêng nó. Hãy cùng xem chúng một cách chi tiết.

Các kiểu dữ liệu số trong Python: Integers, Floats và Complex

Đây là các kiểu số mà bạn có thể làm việc trong Python:

Số nguyên

Số nguyên là số không có số thập phân. Bạn có thể kiểm tra xem một số có phải là số nguyên hay không bằng hàm type () . Nếu đầu ra là & lt; class 'int' & gt; , thì số là số nguyên.

Ví dụ:

  & gt; & gt; & gt; loại 1)
& lt; lớp 'int' & gt;

& gt; & gt; & gt; loại (15)
& lt; lớp 'int' & gt;

& gt; & gt; & gt; loại (0)
& lt; lớp 'int' & gt;

& gt; & gt; & gt; loại (-46)
& lt; class 'int' & gt;  

Floats

Floats là các số có số thập phân. Bạn có thể phát hiện chúng một cách trực quan bằng cách xác định vị trí dấu thập phân. Nếu chúng ta gọi type () để kiểm tra kiểu dữ liệu của các giá trị này, chúng ta sẽ thấy đây là đầu ra:

  & lt; class 'float' & gt;  

Ở đây chúng tôi có một số ví dụ:

  & gt; & gt; & gt; loại (4,5)
& lt; lớp 'float' & gt;

& gt; & gt; & gt; loại (5,8)
& lt; lớp 'float' & gt;

& gt; & gt; & gt; loại (2342423424.3)
& lt; lớp 'float' & gt;

& gt; & gt; & gt; loại (4.0)
& lt; lớp 'float' & gt;

& gt; & gt; & gt; loại (0.0)
& lt; lớp 'float' & gt;

& gt; & gt; & gt; loại (-23,5)
& lt; class 'float' & gt;  

Complex

Số phức có một phần thực và một phần ảo được ký hiệu bằng j . Bạn có thể tạo số phức trong Python với complex () . Đối số đầu tiên sẽ là phần thực và đối số thứ hai sẽ là phần ảo.

Đây là một số ví dụ:

 & gt; & gt; & gt; phức tạp (4, 5)
(4 + 5j)

& gt; & gt; & gt; phức hợp (6, 8)
(6 + 8j)

& gt; & gt; & gt; phức tạp (3,4, 3,4)
(3,4 + 3,4j)

& gt; & gt; & gt; phức tạp (0, 0)
0j

& gt; & gt; & gt; phức tạp (5)
(5 + 0j)

& gt; & gt; & gt; phức tạp (0, 4)
4j  

Chuỗi trong Python

Các chuỗi cực kỳ hữu ích trong Python. Chúng chứa một chuỗi các ký tự và chúng thường được dùng để biểu thị văn bản trong mã.

Ví dụ:

  "Hello, World!"   
  'Hello, World!'  

Chúng ta có thể sử dụng cả dấu ngoặc kép '' hoặc dấu ngoặc kép "" để xác định một chuỗi. Chúng đều hợp lệ và tương đương, nhưng bạn nên chọn một trong số chúng và sử dụng nó nhất quán trong suốt chương trình.

💡 Mẹo: Có! Bạn đã sử dụng một chuỗi khi viết chương trình "Hello, World!" . Bất cứ khi nào bạn thấy một giá trị được bao quanh bởi dấu ngoặc đơn hoặc dấu ngoặc kép trong Python, đó là một chuỗi.

Chuỗi có thể chứa bất kỳ ký tự nào mà chúng ta có thể nhập vào bàn phím của mình, bao gồm số, ký hiệu và các ký tự đặc biệt khác. < / p>

Ví dụ:

  "45678"  
  "my_email@email.com"   
  "#IlovePython"  

💡 Mẹo: Dấu cách cũng được tính là các ký tự trong một chuỗi.

Dấu ngoặc kép trong chuỗi

Nếu chúng ta xác định một chuỗi có dấu ngoặc kép "" , thì chúng ta có thể sử dụng dấu ngoặc kép trong chuỗi. Ví dụ:

  "Tôi 20 tuổi"  

Nếu chúng ta xác định một chuỗi bằng dấu ngoặc kép '' , thì chúng ta có thể sử dụng dấu ngoặc kép trong chuỗi. Ví dụ:

  'Cuốn sách yêu thích của tôi là "Sense and Sensibility"'  

String Indexing

Chúng tôi có thể sử dụng các chỉ số để truy cập các ký tự của một chuỗi trong chương trình Python của chúng tôi. Chỉ mục là một số nguyên đại diện cho một vị trí cụ thể trong chuỗi. Chúng được liên kết với nhân vật ở vị trí đó.

Đây là sơ đồ của chuỗi "Hello" :

  Chuỗi: H e l l o
Chỉ mục: 0 1 2 3 4  

💡 Mẹo: Các chỉ số bắt đầu từ 0 và chúng được tăng dần theo 1 cho mỗi ký tự ở bên phải.

Ví dụ:

  & gt; & gt; & gt; my_string = "Xin chào"

& gt; & gt; & gt; my_string [0]
'H'

& gt; & gt; & gt; my_string [1]
'e'

& gt; & gt; & gt; my_string [2]
'l'

& gt; & gt; & gt; my_string [3]
'l'

& gt; & gt; & gt; my_string [4]
'o'  

Chúng tôi cũng có thể sử dụng các chỉ số phủ định để truy cập các ký tự sau:

  & gt; & gt; & gt; my_string = "Xin chào"

& gt; & gt; & gt; my_string [-1]
'o'

& gt; & gt; & gt; my_string [-2]
'l'

& gt; & gt; & gt; my_string [-3]
'l'

& gt; & gt; & gt; my_string [-4]
'e'

& gt; & gt; & gt; my_string [-5]
'H'  

💡 Mẹo: chúng tôi thường sử dụng -1 để truy cập ký tự cuối cùng của chuỗi.

< h4 id = "string-sliceing"> String Slicing

Chúng ta cũng có thể cần lấy một phần của một chuỗi hoặc một tập hợp con các ký tự của nó. Chúng ta có thể làm như vậy với việc cắt chuỗi.

Đây là cú pháp chung:

  & lt; string_variable & gt; [start: stop: step]  

< p> start là chỉ số của ký tự đầu tiên sẽ được đưa vào lát cắt. Theo mặc định, nó là 0 .

  • stop là chỉ mục của ký tự cuối cùng trong lát (ký tự này sẽ không < / strong> được bao gồm). Theo mặc định, đây là ký tự cuối cùng trong chuỗi (nếu chúng tôi bỏ qua giá trị này, ký tự cuối cùng cũng sẽ được bao gồm).
  • step là số lượng chúng tôi sẽ thêm vào chỉ mục hiện tại để đến chỉ mục tiếp theo.

Chúng tôi có thể chỉ định hai tham số để sử dụng giá trị mặc định của step , là 1 >. Điều này sẽ bao gồm tất cả các ký tự giữa start stop (không bao gồm):

  & lt; string_variable & gt; [start: stop]  

Ví dụ:

  & gt; & gt; & gt; freecodecamp = "freeCodeCamp"

& gt; & gt; & gt; freecodecamp [2: 8]
'eeCode'

& gt; & gt; & gt; freecodecamp [0: 3]
'tự do'

& gt; & gt; & gt; freecodecamp [0: 4]
'tự do'

& gt; & gt; & gt; freecodecamp [4: 7]
'Cod'

& gt; & gt; & gt; freecodecamp [4: 8]
'Mã số'

& gt; & gt; & gt; freecodecamp [8:11]
'Cam'

& gt; & gt; & gt; freecodecamp [8:12]
'Cắm trại'

& gt; & gt; & gt; freecodecamp [8:13]
'Camp'  

💡 Mẹo: Lưu ý rằng nếu giá trị của một tham số vượt ra ngoài phạm vi chỉ số hợp lệ, phần này sẽ vẫn được trình bày. Đây là cách những người tạo ra Python triển khai tính năng cắt chuỗi này.

Nếu chúng tôi tùy chỉnh bước , chúng tôi sẽ "nhảy" từ chỉ mục này sang chỉ mục tiếp theo theo giá trị này.

Ví dụ:

 & gt; & gt; & gt; freecodecamp = "freeCodeCamp"

& gt; & gt; & gt; freecodecamp [0: 9: 2]
'feCdC'

& gt; & gt; & gt; freecodecamp [2: 10: 3]
'eoC'

& gt; & gt; & gt; freecodecamp [1: 12: 4]
'roa'

& gt; & gt; & gt; freecodecamp [4: 8: 2]
'Đĩa CD'

& gt; & gt; & gt; freecodecamp [3: 9: 2]
'eoe'

& gt; & gt; & gt; freecodecamp [1: 10: 5]
'rd'  

Chúng tôi cũng có thể sử dụng bước phủ định để đi từ phải sang trái:

  & gt; & gt; & gt; freecodecamp = "freeCodeCamp"

& gt; & gt; & gt; freecodecamp [10: 2: -1]
'maCedoCe'

& gt; & gt; & gt; freecodecamp [11: 4: -2]
'paeo'

& gt; & gt; & gt; freecodecamp [5: 2: -4]
'o'  

Và chúng ta có thể bỏ qua một tham số để sử dụng giá trị mặc định của nó. Chúng ta chỉ cần thêm dấu hai chấm tương ứng (: ) nếu bỏ qua start , stop hoặc cả hai:

 < code class = "language-python"> & gt; & gt; & gt; freecodecamp = "freeCodeCamp"

# Bắt đầu và bước mặc định
& gt; & gt; & gt; freecodecamp [: 8]
'freeCode'

# Kết thúc và bước mặc định
& gt; & gt; & gt; freecodecamp [4:]
'CodeCamp'

# Bắt đầu mặc định
& gt; & gt; & gt; freecodecamp [: 8: 2]
'feCd'

# Điểm dừng mặc định
& gt; & gt; & gt; freecodecamp [4 :: 3]
'Cem'

# Bắt đầu và dừng mặc định
& gt; & gt; & gt; freecodecamp [:: - 2]
'paeoer'

# Bắt đầu và dừng mặc định
& gt; & gt; & gt; freecodecamp [:: - 1]
'pmaCedoCeerf'  

💡 Mẹo: Ví dụ cuối cùng là một trong những cách phổ biến nhất để đảo ngược một chuỗi.

f-Strings

Trong Python 3.6 và các phiên bản mới hơn, chúng ta có thể sử dụng một loại chuỗi được gọi là f-string giúp chúng ta định dạng các chuỗi của mình dễ dàng hơn nhiều.

Để xác định chuỗi f, chúng ta chỉ cần thêm f trước dấu nháy đơn hoặc kép. Sau đó, trong chuỗi, chúng ta đặt các biến hoặc biểu thức bằng dấu ngoặc nhọn {} . Điều này thay thế giá trị của chúng trong chuỗi khi chúng tôi chạy chương trình.

Ví dụ:

  first_name = "Nora"
favourite_language = "Python"

print (f "Xin chào, tôi là {first_name}. Tôi đang học {favourite_language}.")
 

Đầu ra là:

  Xin chào, tôi là Nora. Tôi đang học Python.  

Ở đây chúng tôi có một ví dụ trong đó chúng tôi tính giá trị của một biểu thức và thay thế kết quả trong chuỗi:

  value = 5

print (f "{value} nhân với 2 là: {value * 2}")  

Các giá trị được thay thế trong đầu ra:

  5 nhân với 2 là: 10  

Chúng ta cũng có thể gọi các phương thức trong dấu ngoặc nhọn và giá trị trả về sẽ được thay thế trong chuỗi khi chúng ta chạy chương trình:

  freecodecamp = "FREECODECAMP"

print (f "{freecodecamp.lower ()}")  

Kết quả là:

  freecodecamp  

Phương thức chuỗi

Chuỗi có các phương thức, đại diện cho chức năng phổ biến đã được các nhà phát triển Python triển khai, vì vậy chúng tôi có thể sử dụng nó trực tiếp trong các chương trình của mình. Chúng rất hữu ích để thực hiện các hoạt động thông thường.

Đây là cú pháp chung để gọi một phương thức chuỗi:

  & lt; string_variable & gt;. & lt; method_name & gt; (& lt; objects & gt;)  

Ví dụ:

  & gt; & gt; & gt; freecodecamp = "freeCodeCamp"

& gt; & gt; & gt; freecodecamp.capitalize ()
'Freecodecamp'

& gt; & gt; & gt; freecodecamp.count ("C")
2

& gt; & gt; & gt; freecodecamp.find ("e")
2

& gt; & gt; & gt; freecodecamp.index ("p")
11

& gt; & gt; & gt; freecodecamp.isalnum ()
ĐÚNG VẬY

& gt; & gt; & gt; freecodecamp.isalpha ()
ĐÚNG VẬY

& gt; & gt; & gt; freecodecamp.isdecimal ()
Sai

& gt; & gt; & gt; freecodecamp.isdigit ()
Sai

& gt; & gt; & gt; freecodecamp.isidentifier ()
ĐÚNG VẬY

& gt; & gt; & gt; freecodecamp.islower ()
Sai

& gt; & gt; & gt; freecodecamp.isnumeric ()
Sai

& gt; & gt; & gt; freecodecamp.isprintable ()
ĐÚNG VẬY

& gt; & gt; & gt; freecodecamp.isspace ()
Sai

& gt; & gt; & gt; freecodecamp.istitle ()
Sai

& gt; & gt; & gt; freecodecamp.isupper ()
Sai

& gt; & gt; & gt; freecodecamp.lower ()
'freecodecamp'

& gt; & gt; & gt; freecodecamp.lstrip ("f")
'reeCodeCamp'

& gt; & gt; & gt; freecodecamp.rstrip ("p")
'freeCodeCam'

& gt; & gt; & gt; freecodecamp.replace ("e", "a")
'fraaCodaCamp'

& gt; & gt; & gt; freecodecamp.split ("C")
['miễn phí', 'ode', 'amp']

& gt; & gt; & gt; freecodecamp.swapcase ()
'FREEcODEcAMP'

& gt; & gt; & gt; freecodecamp.title ()
'Freecodecamp'

& gt; & gt; & gt; freecodecamp.upper ()
'FREECODECAMP'  

Để tìm hiểu thêm về các phương thức Python, tôi khuyên bạn nên đọc bài viết này từ tài liệu Python.

💡 Mẹo: Tất cả các phương thức chuỗi đều trả về các bản sao của chuỗi. Họ không sửa đổi chuỗi vì chuỗi là bất biến trong Python.

Booleans trong Python

Giá trị boolean là True False trong Python. Chúng phải bắt đầu bằng chữ hoa để được nhận dạng là giá trị boolean.

Ví dụ:

  & gt; & gt; & gt; loại (Đúng)
& lt; lớp 'bool' & gt;

& gt; & gt; & gt; loại (Sai)
& lt; lớp 'bool' & gt; 

Nếu chúng tôi viết chúng bằng chữ thường, chúng tôi sẽ gặp lỗi:

  & gt; & gt; & gt; loại (đúng)
Traceback (cuộc gọi gần đây nhất cuối cùng):
  Tệp "& lt; pyshell # 92 & gt;", dòng 1, trong & lt; mô-đun & gt;
    loại (đúng)
NameError: tên 'true' không được xác định

& gt; & gt; & gt; loại (sai)
Traceback (cuộc gọi gần đây nhất cuối cùng):
  Tệp "& lt; pyshell # 93 & gt;", dòng 1, trong & lt; mô-đun & gt;
    loại (sai)
NameError: name 'false' không được xác định  

Danh sách trong Python

Bây giờ chúng ta đã đề cập đến các kiểu dữ liệu cơ bản trong Python, chúng ta hãy bắt đầu bao gồm các cấu trúc dữ liệu được tích hợp sẵn. Đầu tiên, chúng tôi có danh sách.

Để xác định danh sách, chúng tôi sử dụng dấu ngoặc vuông [] với các phần tử được phân tách bằng dấu phẩy.

💡 Mẹo: Bạn nên thêm dấu cách sau mỗi dấu phẩy để làm cho mã dễ đọc hơn.

Ví dụ: ở đây chúng tôi có các ví dụ về danh sách:

  [ 1, 2, 3, 4, 5]  
  ["a", "b", "c", "d"]  

< pre> [3.4, 2.4, 2.6, 3.5]

Danh sách có thể chứa các giá trị của các kiểu dữ liệu khác nhau, vì vậy đây sẽ là danh sách hợp lệ trong Python:

  [1, "Emily", 3.4]  

Chúng tôi cũng có thể gán danh sách cho một biến:

  my_list = [1, 2, 3, 4, 5]  
  letter = ["a", "b", "c", "d"]  

Danh sách lồng nhau

Danh sách có thể chứa các giá trị thuộc bất kỳ kiểu dữ liệu nào, ngay cả các danh sách khác. Các danh sách bên trong này được gọi là danh sách lồng nhau .

  [[1, 2, 3], [4, 5, 6]] < / code> 

Trong ví dụ này, [1, 2, 3] [4, 5, 6] là danh sách lồng nhau.

Ở đây chúng tôi có các ví dụ hợp lệ khác:

  [["a", "b", "c"], ["d", "e "," f "], [" g "," h "," i "]]  
  [1, [2, 3, 4], [5, 6, 7], 3.4]  

Chúng tôi có thể truy cập các danh sách lồng nhau bằng cách sử dụng chỉ mục tương ứng của chúng:

  & gt; & gt; & gt; my_list = [[1, 2, 3], [4, 5, 6]]

& gt; & gt; & gt; my_list [0]
[1, 2, 3]

& gt; & gt; & gt; my_list [1]
[4, 5, 6]  

Các danh sách lồng nhau có thể được sử dụng để thể hiện, ví dụ: cấu trúc của một bảng trò chơi 2D đơn giản trong đó mỗi số có thể đại diện cho một phần tử hoặc ô khác nhau:

  # Bảng mẫu trong đó:
# 0 = Ô trống
# 1 = Đồng xu
# 2 = Kẻ thù
# 3 = Mục tiêu
bảng = [[0, 0, 1],
         [0, 2, 0],
         [1, 0, 3]]  

Độ dài danh sách

Chúng ta có thể sử dụng hàm len () để lấy độ dài của danh sách (số phần tử trong danh sách).

Ví dụ:

  & gt; & gt; & gt; my_list = [1, 2, 3, 4]

& gt; & gt; & gt; len (my_list)
4  

Chúng tôi có thể cập nhật giá trị tại một chỉ mục cụ thể bằng cú pháp sau:

  & lt; list_variable & gt; [& lt; index & gt ;] = & lt; value & gt;  

Ví dụ:

  & gt; & gt; & gt; chữ cái = ["a", "b", "c", "d"]

& gt; & gt; & gt; chữ cái [0] = "z"

& gt; & gt; & gt; bức thư
['z', 'b', 'c', 'd']  

Thêm giá trị vào danh sách < / h4>

Chúng tôi có thể thêm một giá trị mới vào cuối danh sách bằng phương thức .append () .

Ví dụ:

  & gt; & gt; & gt; my_list = [1, 2, 3, 4]

& gt; & gt; & gt; my_list.append (5)

& gt; & gt; & gt; danh sách của tôi
[1, 2, 3, 4, 5]  

Xóa giá trị khỏi danh sách

Chúng tôi có thể xóa giá trị khỏi danh sách bằng phương thức .remove () .

Ví dụ:

  & gt; & gt; & gt; my_list = [1, 2, 3, 4]

& gt; & gt; & gt; my_list.remove (3)

& gt; & gt; & gt; danh sách của tôi
[1, 2, 4]  

💡 Mẹo: Điều này sẽ chỉ xóa lần xuất hiện đầu tiên của phần tử. Ví dụ: nếu chúng tôi cố gắng xóa số 3 khỏi danh sách có hai số 3, số thứ hai sẽ không bị xóa:

  & gt; & gt; & gt ; my_list = [1, 2, 3, 3, 4]

& gt; & gt; & gt; my_list.remove (3)

& gt; & gt; & gt; danh sách của tôi
[1, 2, 3, 4]  

List Indexing

Chúng tôi có thể lập chỉ mục một danh sách giống như chúng ta lập chỉ mục các chuỗi, với các chỉ số bắt đầu từ 0 :

  & gt; & gt; & gt; chữ cái = ["a", "b", "c", "d"]

& gt; & gt; & gt; chữ cái [0]
'một'

& gt; & gt; & gt; chữ cái [1]
'b'

& gt; & gt; & gt; chữ cái [2]
'c'

& gt; & gt; & gt; chữ cái [3]
'd'  

List Slicing

Chúng tôi cũng có thể lấy một phần danh sách bằng cách sử dụng cùng một cú pháp mà chúng tôi đã sử dụng với chuỗi và chúng tôi có thể bỏ qua các tham số để sử dụng các giá trị mặc định của chúng. Bây giờ, thay vì thêm các ký tự vào lát, chúng tôi sẽ thêm các phần tử của danh sách.

  & lt; list_variable & gt; [start: stop: step]  

Ví dụ:

 & gt; & gt; & gt; my_list = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]

& gt; & gt; & gt; my_list [2: 6: 2]
['c', 'e']

& gt; & gt; & gt; my_list [2: 8]
['c', 'd', 'e', ​​'f', 'g', 'h']

& gt; & gt; & gt; my_list [1:10]
['b', 'c', 'd', 'e', ​​'f', 'g', 'h', 'i']

& gt; & gt; & gt; my_list [4: 8: 2]
['ví dụ']

& gt; & gt; & gt; my_list [:: - 1]
['i', 'h', 'g', 'f', 'e', ​​'d', 'c', 'b', 'a']

& gt; & gt; & gt; my_list [:: - 2]
['i', 'g', 'e', ​​'c', 'a']

& gt; & gt; & gt; my_list [8: 1: -1]
['i', 'h', 'g', 'f', 'e', ​​'d', 'c']  

Phương thức danh sách < / h4>

Python cũng có các phương thức danh sách đã được triển khai để giúp chúng tôi thực hiện các hoạt động danh sách phổ biến. Dưới đây là một số ví dụ về các phương thức danh sách được sử dụng phổ biến nhất:

  & gt; & gt; & gt; my_list = [1, 2, 3, 3, 4]

& gt; & gt; & gt; my_list.append (5)
& gt; & gt; & gt; danh sách của tôi
[1, 2, 3, 3, 4, 5]

& gt; & gt; & gt; my_list.extend ([6, 7, 8])
& gt; & gt; & gt; danh sách của tôi
[1, 2, 3, 3, 4, 5, 6, 7, 8]

& gt; & gt; & gt; my_list.insert (2, 15)
& gt; & gt; & gt; danh sách của tôi
[1, 2, 15, 3, 3, 4, 5, 6, 7, 8, 2, 2]

& gt; & gt; & gt; my_list.remove (2)
& gt; & gt; & gt; danh sách của tôi
[1, 15, 3, 3, 4, 5, 6, 7, 8, 2, 2]

& gt; & gt; & gt; my_list.pop ()
2

& gt; & gt; & gt; my_list.index (6)
6

& gt; & gt; & gt; my_list.count (2)
1

& gt; & gt; & gt; my_list.sort ()
& gt; & gt; & gt; danh sách của tôi
[1, 2, 3, 3, 4, 5, 6, 7, 8, 15]

& gt; & gt; & gt; my_list.reverse ()
& gt; & gt; & gt; danh sách của tôi
[15, 8, 7, 6, 5, 4, 3, 3, 2, 1]

& gt; & gt; & gt; my_list.clear ()
& gt; & gt; & gt; danh sách của tôi
[]  

Để tìm hiểu thêm về các phương pháp danh sách, tôi khuyên bạn nên đọc bài viết này từ tài liệu Python.

Tuples trong Python

Để xác định một tuple trong Python, chúng tôi sử dụng dấu ngoặc đơn () và phân tách các phần tử bằng dấu phẩy. Bạn nên thêm dấu cách sau mỗi dấu phẩy để làm cho mã dễ đọc hơn.

  (1, 2, 3, 4, 5)  < / pre> 
  ("a", "b", "c", "d")  
  (3.4, 2.4, 2.6, 3.5)  

Chúng ta có thể gán bộ giá trị cho các biến:

  my_tuple = (1, 2, 3, 4, 5)  

Tuple Indexing

Chúng tôi có thể truy cập từng phần tử của một tuple với chỉ mục tương ứng của nó :

  & gt; & gt; & gt; my_tuple = (1, 2, 3, 4)

& gt; & gt; & gt; my_tuple [0]
1

& gt; & gt; & gt; my_tuple [1]
2

& gt; & gt; & gt; my_tuple [2]
3

& gt; & gt; & gt; my_tuple [3]
4  

Chúng tôi cũng có thể sử dụng các chỉ số phủ định:

  & gt; & gt; & gt; my_tuple = (1, 2, 3, 4)

& gt; & gt; & gt; my_tuple [-1]
4

& gt; & gt; & gt; my_tuple [-2]
3

& gt; & gt; & gt; my_tuple [-3]
2

& gt; & gt; & gt; my_tuple [-4]
1  

Tuple Length

Để tìm độ dài của một tuple, chúng ta sử dụng hàm len () , truyền tuple dưới dạng đối số:

  & gt; & gt; & gt; my_tuple = (1, 2, 3, 4)

& gt; & gt; & gt; len (my_tuple)
4  

Bộ dữ liệu lồng nhau

Bộ mã số có thể chứa các giá trị của bất kỳ kiểu dữ liệu nào, ngay cả danh sách và các bộ giá trị khác. Các bộ giá trị bên trong này được gọi là các bộ giá trị lồng nhau .

  ([1, 2, 3], (4, 5, 6)) < / code> 

Trong ví dụ này, chúng ta có một tuple (4, 5, 6) lồng nhau và một danh sách. Bạn có thể truy cập các cấu trúc dữ liệu lồng nhau này bằng chỉ mục tương ứng của chúng.

Ví dụ:

  & gt; & gt; & gt; my_tuple = ([1, 2, 3], (4, 5, 6))

& gt; & gt; & gt; my_tuple [0]
[1, 2, 3]

& gt; & gt; & gt; my_tuple [1]
(4, 5, 6)  

Tuple Slicing

Chúng ta có thể cắt một bộ tuple giống như chúng ta cắt các danh sách và chuỗi. Nguyên tắc và quy tắc tương tự cũng được áp dụng.

Đây là cú pháp chung:

  & lt; tuple_variable & gt; [start: stop: step]  

Ví dụ:

  & gt; & gt; & gt; my_tuple = (4, 5, 6, 7, 8, 9, 10)

& gt; & gt; & gt; my_tuple [3: 8]
(7, 8, 9, 10)

& gt; & gt; & gt; my_tuple [2: 9: 2]
(6, 8, 10)

& gt; & gt; & gt; my_tuple [: 8]
(4, 5, 6, 7, 8, 9, 10)

& gt; & gt; & gt; my_tuple [: 6]
(4, 5, 6, 7, 8, 9)

& gt; & gt; & gt; my_tuple [: 4]
(4, 5, 6, 7)

& gt; & gt; & gt; my_tuple [3:]
(7, 8, 9, 10)

& gt; & gt; & gt; my_tuple [2: 5: 2]
(6, 8)

& gt; & gt; & gt; my_tuple [:: 2]
(4, 6, 8, 10)

& gt; & gt; & gt; my_tuple [:: - 1]
(10, 9, 8, 7, 6, 5, 4)

& gt; & gt; & gt; my_tuple [4: 1: -1]
(8, 7, 6)  

Tuple Method

Có hai phương thức tuple tích hợp trong Python:

< pre> & gt; & gt; & gt; my_tuple = (4, 4, 5, 6, 6, 7, 8, 9, 10)

& gt; & gt; & gt; my_tuple.count (6)
2

& gt; & gt; & gt; my_tuple.index (7)
5

💡 Mẹo: các bộ giá trị là bất biến. Chúng không thể được sửa đổi, vì vậy chúng tôi không thể thêm, cập nhật hoặc xóa các phần tử khỏi bộ tuple. Nếu chúng ta cần làm như vậy, thì chúng ta cần tạo một bản sao mới của tuple.

Tuple Assignment

Trong Python, chúng tôi có một tính năng thực sự thú vị được gọi là Phép gán Tuple. Với kiểu gán này, chúng ta có thể gán giá trị cho nhiều biến trên cùng một dòng.

Các giá trị được gán cho các biến tương ứng theo thứ tự xuất hiện của chúng. Ví dụ: trong a, b = 1, 2 giá trị 1 được gán cho biến a và giá trị 2 được gán cho biến b .

Ví dụ:

  # Tuple Assignment
& gt; & gt; & gt; a, b = 1, 2

& gt; & gt; & gt; một
1

& gt; & gt; & gt; b
2  

💡 Mẹo: Phép gán tuple thường được sử dụng để hoán đổi giá trị của hai biến:

  & gt; & gt; & gt; a = 1

& gt; & gt; & gt; b = 2

# Hoán đổi các giá trị
& gt; & gt; & gt; a, b = b, a

& gt; & gt; & gt; một
2

& gt; & gt; & gt; b
1  

Từ điển bằng Python

Bây giờ chúng ta hãy bắt đầu tìm hiểu từ điển. Cấu trúc dữ liệu tích hợp này cho phép chúng tôi tạo các cặp giá trị trong đó một giá trị được liên kết với một giá trị khác.

Để xác định từ điển bằng Python, chúng tôi sử dụng dấu ngoặc nhọn {} với các cặp khóa-giá trị được phân tách bằng dấu phẩy.

Khóa được phân tách khỏi giá trị bằng dấu hai chấm : , như sau:

  {"a" : 1, "b": 2, "c"; 3}  

Bạn có thể gán từ điển cho một biến:

  my_dict = {"a": 1, "b ": 2," c "; 3}  

Các khóa của từ điển phải thuộc loại dữ liệu bất biến. Ví dụ: chúng có thể là chuỗi, số hoặc bộ dữ liệu nhưng không phải là danh sách vì danh sách có thể thay đổi.

  • Chuỗi: {"City 1": 456, "City 2": 577, "City 3": 678}
  • Các số: {1: "Di chuyển sang trái", 2: "Di chuyển sang phải", 3: "Di chuyển lên", 4: "Di chuyển xuống"}
  • Tuples: {( 0, 0): "Bắt đầu", (2, 4): "Mục tiêu"}

Các giá trị của từ điển có thể thuộc bất kỳ kiểu dữ liệu nào, vì vậy chúng tôi có thể chỉ định chuỗi, số, danh sách, bộ, bộ và thậm chí các từ điển khác dưới dạng các giá trị. Dưới đây là một số ví dụ:

  {"product_id": 4556, "components": ["cà chua", "pho mát", "nấm"], "price": 10,67}  
  {"product_id": 4556, "thành phần": ("cà chua", "phô mai", "nấm"), "giá": 10,67} < / code> 
  {"id": 567, "tên": "Emily", "điểm": {"Toán học": 80, "Sinh học": 74, "Tiếng Anh": 97}}  

Độ dài từ điển

Để nhận số lượng cặp khóa-giá trị, chúng tôi sử dụng < code> len () function:

  & gt; & gt; & gt; my_dict = {"a": 1, "b": 2, "c": 3, "d": 4}

& gt; & gt; & gt; len (my_dict)
4  

Lấy giá trị trong từ điển

Để lấy giá trị trong từ điển, chúng tôi sử dụng khóa của nó với cú pháp sau:

  & lt; variable_with_dictionary & gt; [& lt; key & gt;]  

Biểu thức này sẽ được thay thế bằng giá trị tương ứng với khóa.

Ví dụ:

  my_dict = {"a": 1, "b": 2, "c": 3, "d": 4}

print (my_dict ["a"])  

Đầu ra là giá trị được liên kết với "a" :

  1 < / code> 

Để cập nhật giá trị được liên kết với khóa hiện có, chúng tôi sử dụng cùng một cú pháp nhưng bây giờ chúng tôi thêm toán tử gán và giá trị:

  & lt; variable_with_dictionary & gt; [& lt; key & gt;] = & lt; value & gt;  

Ví dụ:

  & gt; & gt; & gt; my_dict = {"a": 1, "b": 2, "c": 3, "d": 4}

& gt; & gt; & gt; my_dict ["b"] = 6  

Bây giờ từ điển là:

  {'a': 1, 'b ': 6,' c ': 3,' d ': 4}  

Thêm khóa- Ghép nối giá trị với từ điển

Các khóa của từ điển phải là duy nhất. Để thêm cặp khóa-giá trị mới, chúng tôi sử dụng cùng một cú pháp mà chúng tôi sử dụng để cập nhật giá trị, nhưng bây giờ khóa phải mới.

  & lt; variable_with_dictionary & gt ; [& lt; new_key & gt;] = & lt; value & gt;  

Ví dụ:

  & gt; & gt; & gt; my_dict = {"a": 1, "b": 2, "c": 3, "d": 4}

& gt; & gt; & gt; my_dict ["e"] = 5  

Bây giờ từ điển có một cặp khóa-giá trị mới:

  {'a ': 1,' b ': 2,' c ': 3,' d ': 4,' e ': 5}  

Xóa Cặp Khóa-Giá trị trong Từ điển

Để xóa một cặp khóa-giá trị, chúng tôi sử dụng câu lệnh del :

< pre> del & lt; dictionary_variable & gt; [& lt; key & gt;]

Ví dụ:

  & gt; & gt; & gt; my_dict = {"a": 1, "b": 2, "c": 3, "d": 4}

& gt; & gt; & gt; del my_dict ["c"]  

Bây giờ từ điển là:

  {'a': 1, 'b' : 2, 'd': 4}  

Dictionary Method

Đây là một số ví dụ về các phương thức từ điển được sử dụng phổ biến nhất:

  & gt; & gt; & gt; my_dict = {"a": 1, "b": 2, "c": 3, "d": 4}

& gt; & gt; & gt; my_dict.get ("c")
3

& gt; & gt; & gt; my_dict.items ()
dict_items ([('a', 1), ('b', 2), ('c', 3), ('d', 4)])

& gt; & gt; & gt; my_dict.keys ()
dict_keys (['a', 'b', 'c', 'd'])

& gt; & gt; & gt; my_dict.pop ("d")
4

& gt; & gt; & gt; my_dict.popitem ()
('c', 3)

& gt; & gt; & gt; my_dict.setdefault ("a", 15)
1

& gt; & gt; & gt; my_dict
{'a': 1, 'b': 2}

& gt; & gt; & gt; my_dict.setdefault ("f", 25)
25

& gt; & gt; & gt; my_dict
{'a': 1, 'b': 2, 'f': 25}

& gt; & gt; & gt; my_dict.update ({"c": 3, "d": 4, "e": 5})

& gt; & gt; & gt; my_dict.values ​​()
dict_values ​​([1, 2, 25, 3, 4, 5])

& gt; & gt; & gt; my_dict.clear ()

& gt; & gt; & gt; my_dict
{}  

Để tìm hiểu thêm về các phương pháp từ điển, tôi khuyên bạn nên đọc bài viết này từ tài liệu.

🔸 Toán tử Python

Tuyệt vời. Bây giờ bạn đã biết cú pháp của các kiểu dữ liệu cơ bản và cấu trúc dữ liệu tích hợp trong Python, vì vậy hãy bắt đầu tìm hiểu các toán tử trong Python. Chúng rất cần thiết để thực hiện các phép toán và để tạo biểu thức.

Arithmetic Operator in Python

Các toán tử này là:

Addition: +

  & gt; & gt; & gt; 5 + 6
11

& gt; & gt; & gt; 0 + 6
6

& gt; & gt; & gt; 3,4 + 5,7
9.1

& gt; & gt; & gt; "Xin chào" + "," + "Thế giới"
'Chào thế giới'

& gt; & gt; & gt; Đúng + Sai
1  

💡 Mẹo: Hai ví dụ cuối cùng khiến bạn tò mò, phải không? Toán tử này hoạt động khác nhau dựa trên kiểu dữ liệu của các toán hạng.

Khi chúng là chuỗi, toán tử này nối các chuỗi và khi chúng là giá trị Boolean, nó sẽ thực hiện một phép toán cụ thể.

Trong Python, True tương đương với 1 False tương đương với 0 . Đây là lý do tại sao kết quả là 1 + 0 = 1

Subtraction: -

  & gt; & gt; & gt; 5 - 6
-1

& gt; & gt; & gt; 10 - 3
7

& gt; & gt; & gt; 5 - 6
-1

& gt; & gt; & gt; 4,5 - 5,6 - 2,3
-3.3999999999999995

& gt; & gt; & gt; 4,5 - 7
-2,5

& gt; & gt; & gt; - 7,8 - 6,2
-14.0  

Phép nhân: *

  & gt; & gt; & gt; 5 * 6
30

& gt; & gt; & gt; 6 * 7
42

& gt; & gt; & gt; 10 * 100
1000

& gt; & gt; & gt; 4 * 0
0

& gt; & gt; & gt; 3,4 * 6,8
23.119999999999997

& gt; & gt; & gt; 4 * (-6)
-24

& gt; & gt; & gt; (-6) * (-8)
48

& gt; & gt; & gt; "Xin chào" * 4
'Xin chao xin chao xin chao xin chao'

& gt; & gt; & gt; "Xin chào" * 0
''

& gt; & gt; & gt; "Xin chào" * -1
''  

💡 Mẹo: bạn có thể "nhân" một chuỗi với một số nguyên để lặp lại chuỗi với một số lần nhất định.

Luỹ thừa: **

  & gt; & gt; & gt; 6 ** 8
1679616

& gt; & gt; & gt; 5 ** 2
25

& gt; & gt; & gt; 4 ** 0
1

& gt; & gt; & gt; 16 ** (1/2)
4.0

& gt; & gt; & gt; 16 ** (0,5)
4.0

& gt; & gt; & gt; 125 ** (1/3)
4,999999999999999

& gt; & gt; & gt; 4,5 ** 2,3
31.7971929089206

& gt; & gt; & gt; 3 ** (-1)
0,3333333333333333  

Division: /

  & gt; & gt; & gt; 25/5
5.0

& gt; & gt; & gt; 3/6
0,5

& gt; & gt; & gt; 0/5
0,0

& gt; & gt; & gt; 2467/4673
0,5279263856195163

& gt; & gt; & gt; 1/2
0,5

& gt; & gt; & gt; 4,5 / 3,5
1.2857142857142858

& gt; & gt; & gt; 6/7
0,8571428571428571

& gt; & gt; & gt; -3 / -4
0,75

& gt; & gt; & gt; 3 / -4
-0,75

& gt; & gt; & gt; -3/4
-0,75  

💡 Mẹo: toán tử này trả về kết quả là float , ngay cả khi phần thập phân là .0

Nếu bạn cố gắng chia cho 0 , bạn sẽ nhận được ZeroDivisionError :

  & gt; & gt; & gt; 5/0
Traceback (cuộc gọi gần đây nhất cuối cùng):
  Tệp "& lt; pyshell # 109 & gt;", dòng 1, trong & lt; mô-đun & gt;
    5/0
ZeroDivisionError: chia cho không  

Integer Division: //

Toán tử này trả về một số nguyên nếu các toán hạng là số nguyên. Nếu chúng là float, kết quả sẽ là float với .0 là phần thập phân vì nó cắt bớt phần thập phân.

  & gt ; & gt; & gt; 5 // 6
0

& gt; & gt; & gt; 8 // 2
4

& gt; & gt; & gt; -4 // -5
0

& gt; & gt; & gt; -5 // 8
-1

& gt; & gt; & gt; 0 // 5
0

& gt; & gt; & gt; 156773 // 356
440  

Modulo:%

  & gt; & gt; & gt; 1% 5
1

& gt; & gt; & gt; 2% 5
2

& gt; & gt; & gt; 3% 5
3

& gt; & gt; & gt; 4% 5
4

& gt; & gt; & gt; 5% 5
0

& gt; & gt; & gt; 5% 8
5

& gt; & gt; & gt; 3% 1
0

& gt; & gt; & gt; 15% 3
0

& gt; & gt; & gt; 17% 8
1

& gt; & gt; & gt; 2568% 4
0

& gt; & gt; & gt; 245% 15
5

& gt; & gt; & gt; 0% 6
0

& gt; & gt; & gt; 3,5% 2,4
1.1

& gt; & gt; & gt; 6,7% -7,8
-1.0999999999999996

& gt; & gt; & gt; 2,3% 7,5
2.3  

Các toán tử so sánh

Các toán tử này là:

  • Lớn hơn: & gt;
  • Lớn hơn hoặc bằng: & gt; =
  • Nhỏ hơn: & lt;
  • Nhỏ hơn hoặc bằng: & lt; =
  • Bằng: ==
  • Không Bằng: ! =

Các toán tử so sánh này tạo các biểu thức đánh giá thành True hoặc False . Dưới đây là một số ví dụ:

  & gt; & gt; & gt; 5 & ​​gt; 6
Sai

& gt; & gt; & gt; 10 & gt; số 8
ĐÚNG VẬY

& gt; & gt; & gt; 8 & gt; số 8
Sai

& gt; & gt; & gt; 8 & gt; = 5
ĐÚNG VẬY

& gt; & gt; & gt; 8 & gt; = 8
ĐÚNG VẬY

& gt; & gt; & gt; 5 & ​​lt; 6
ĐÚNG VẬY

& gt; & gt; & gt; 10 & lt; số 8
Sai

& gt; & gt; & gt; 8 & lt; số 8
Sai

& gt; & gt; & gt; 8 & lt; = 5
Sai

& gt; & gt; & gt; 8 & lt; = 8
ĐÚNG VẬY

& gt; & gt; & gt; 8 & lt; = 10
ĐÚNG VẬY

& gt; & gt; & gt; 56 == 56
ĐÚNG VẬY

& gt; & gt; & gt; 56 == 78
Sai

& gt; & gt; & gt; 34! = 59
ĐÚNG VẬY

& gt; & gt; & gt; 67! = 67
Sai  

Chúng tôi cũng có thể sử dụng chúng để so sánh các chuỗi dựa trên thứ tự bảng chữ cái của chúng:

  & gt; & gt; & gt; "Xin chào" & gt; "Thế giới"
Sai
& gt; & gt; & gt; "Xin chào" & gt; = "Thế giới"
Sai
& gt; & gt; & gt; "Xin chào" & lt; "Thế giới"
ĐÚNG VẬY
& gt; & gt; & gt; "Xin chào" & lt; = "Thế giới"
ĐÚNG VẬY
& gt; & gt; & gt; "Xin chào" == "Thế giới"
Sai
& gt; & gt; & gt; "Xin chào"! = "Thế giới"
Đúng  

Chúng tôi thường sử dụng chúng để so sánh giá trị của hai hoặc nhiều biến:

  & gt; & gt; & gt; a = 1
& gt; & gt; & gt; b = 2

& gt; & gt; & gt; một & lt; b
ĐÚNG VẬY

& gt; & gt; & gt; a & lt; = b
ĐÚNG VẬY

& gt; & gt; & gt; một & gt; b
Sai

& gt; & gt; & gt; a & gt; = b
Sai

& gt; & gt; & gt; a == b
Sai

& gt; & gt; & gt; a! = b
Đúng  

💡 Mẹo: lưu ý rằng toán tử so sánh là == trong khi toán tử gán là < mã> = . Tác dụng của chúng là khác nhau. == trả về True hoặc False trong khi = chỉ định giá trị cho một biến.

Chuỗi toán tử so sánh

Trong Python, chúng ta có thể sử dụng một thứ gọi là "chuỗi toán tử so sánh" trong đó chúng ta xâu chuỗi các toán tử so sánh để thực hiện nhiều so sánh ngắn gọn hơn.

Ví dụ: điều này sẽ kiểm tra xem a có nhỏ hơn b và nếu b nhỏ hơn c < / code>:

  a & lt; b & lt; c  

Ở đây chúng tôi có một số ví dụ:

  & gt; & gt; & gt; a = 1
& gt; & gt; & gt; b = 2
& gt; & gt; & gt; c = 3

& gt; & gt; & gt; một & lt; b & lt; c
ĐÚNG VẬY

& gt; & gt; & gt; một & gt; b & gt; c
Sai

& gt; & gt; & gt; a & lt; = b & lt; = c
ĐÚNG VẬY

& gt; & gt; & gt; a & gt; = b & gt; = c
Sai

& gt; & gt; & gt; a & gt; = b & gt; c
Sai

& gt; & gt; & gt; a & lt; = b & lt; c
Đúng  

Toán tử logic

Có ba toán tử logic trong Python: , hoặc < / code> và không . Mỗi một trong những toán tử này có bảng chân trị riêng và chúng rất cần thiết để làm việc với các điều kiện.

Toán tử :

  & gt; & gt; & gt; Đúng và Đúng
ĐÚNG VẬY

& gt; & gt; & gt; Đúng và sai
Sai

& gt; & gt; & gt; Sai và Đúng
Sai

& gt; & gt; & gt; Sai và Sai
Sai  

Toán tử hoặc :

  & gt; & gt; & gt; Đúng hay Đúng
ĐÚNG VẬY

& gt; & gt; & gt; Đúng hay sai
ĐÚNG VẬY

& gt; & gt; & gt; Sai hay Đúng
ĐÚNG VẬY

& gt; & gt; & gt; Sai hay Sai
Sai  

Toán tử not :

  & gt; & gt; & gt; không đúng
Sai

& gt; & gt; & gt; không sai
True  

Toán tử này được sử dụng để tạo thành các biểu thức phức tạp hơn kết hợp các toán tử và biến khác nhau.

Ví dụ:

  & gt; & gt; & gt; a = 6
& gt; & gt; & gt; b = 3

& gt; & gt; & gt; một & lt; 6 hoặc b & gt; 2
ĐÚNG VẬY

& gt; & gt; & gt; a & gt; = 3 và b & gt; = 1
ĐÚNG VẬY

& gt; & gt; & gt; (a + b) == 9 và b & gt; 1
ĐÚNG VẬY

& gt; & gt; & gt; ((a% 3) & lt; 2) và ((a + b) == 3)
Sai  

Assignment Operations

Các toán tử gán được sử dụng để gán một giá trị cho một biến.

Chúng là: = , + = , - = , * = , < mã>% = , / = , // = , ** =

  • Toán tử = gán giá trị cho biến.
  • Các toán tử khác thực hiện thao tác với giá trị hiện tại của biến và giá trị mới và gán kết quả cho cùng một biến.

Ví dụ:

  & gt; & gt; & gt; x = 3
& gt; & gt; & gt; x
3

& gt; & gt; & gt; x + = 15
& gt; & gt; & gt; x
18

& gt; & gt; & gt; x - = 2
& gt; & gt; & gt; x
16

& gt; & gt; & gt; x * = 2
& gt; & gt; & gt; x
32

& gt; & gt; & gt; x% = 5
& gt; & gt; & gt; x
2

& gt; & gt; & gt; x / = 1
& gt; & gt; & gt; x
2.0

& gt; & gt; & gt; x // = 2
& gt; & gt; & gt; x
1,0

& gt; & gt; & gt; x ** = 5
& gt; & gt; & gt; x
1.0  

💡 Mẹo: các toán tử này thực hiện các phép toán bitwise trước khi gán kết quả cho biến: & amp; = , | = , ^ = , & gt; & gt; = , & lt; & lt; = .

Thành viên Điều hành viên

Bạn có thể kiểm tra xem một phần tử có trong một chuỗi hay không bằng các toán tử: in not in. Kết quả sẽ là True hoặc False .

Ví dụ:

  & gt; & gt; & gt; 5 trong [1, 2, 3, 4, 5]
ĐÚNG VẬY

& gt; & gt; & gt; 8 trong [1, 2, 3, 4, 5]
Sai

& gt; & gt; & gt; 5 in (1, 2, 3, 4, 5)
ĐÚNG VẬY

& gt; & gt; & gt; 8 in (1, 2, 3, 4, 5)
Sai

& gt; & gt; & gt; "a" trong {"a": 1, "b": 2}
ĐÚNG VẬY

& gt; & gt; & gt; "c" trong {"a": 1, "b": 2}
Sai

& gt; & gt; & gt; "h" trong "Xin chào"
Sai

& gt; & gt; & gt; "H" trong "Xin chào"
ĐÚNG VẬY

& gt; & gt; & gt; 5 không có trong [1, 2, 3, 4, 5]
Sai

& gt; & gt; & gt; 8 không trong (1, 2, 3, 4, 5)
ĐÚNG VẬY

& gt; & gt; & gt; "a" không có trong {"a": 1, "b": 2}
Sai

& gt; & gt; & gt; "c" không có trong {"a": 1, "b": 2}
ĐÚNG VẬY

& gt; & gt; & gt; "h" không có trong "Xin chào"
ĐÚNG VẬY

& gt; & gt; & gt; "H" không có trong "Xin chào"
Sai  

Chúng tôi thường sử dụng chúng với các biến lưu trữ chuỗi, như trong ví dụ sau:

  & gt; & gt; & gt; message = "Xin chào, Thế giới!"

& gt; & gt; & gt; "e" trong tin nhắn
Đúng  

🔹 Điều kiện trong Python

Bây giờ, hãy xem cách chúng ta có thể viết điều kiện để chạy một số phần mã nhất định ( hay không) dựa trên việc một điều kiện là True hay False .

if < / code> câu lệnh trong Python

Đây là cú pháp của câu lệnh if cơ bản:

  if & lt; condition & gt ;:
    & lt; code & gt;  

Nếu điều kiện là True , mã sẽ chạy. Ngoài ra, nếu là False , mã sẽ không chạy.

💡 Mẹo: có dấu hai chấm (: ) ở cuối dòng đầu tiên và mã được thụt vào. Đây là điều cần thiết trong Python để làm cho mã thuộc về điều kiện.

Ở đây chúng tôi có một số ví dụ:

Điều kiện sai

  x = 5

nếu x & gt; 9:
    print ("Hello, World!")  

Điều kiện là x & gt; 9 và mã là print ("Hello, World!") .

Trong trường hợp này, điều kiện là False , vì vậy không có đầu ra.

True Condition

< p> Ở đây chúng tôi có một ví dụ khác. Bây giờ điều kiện là True :

  color = "Blue"

nếu màu == "Xanh lam":
    print ("Đây là màu yêu thích của tôi")  

Kết quả là:

  "Đây là màu yêu thích của tôi"  

Mã sau điều kiện

Ở đây chúng tôi có một ví dụ với mã chạy sau khi điều kiện đã hoàn thành. Lưu ý rằng dòng cuối cùng không được thụt lề, có nghĩa là dòng đó không thuộc dòng điều kiện.

  x = 5

nếu x & gt; 9:
    print ("Xin chào!")

print ("End")  

Trong ví dụ này, điều kiện x & gt; 9 False , vì vậy câu lệnh in đầu tiên không chạy nhưng câu lệnh in cuối cùng chạy vì nó không phải là một phần của điều kiện, vì vậy đầu ra là:

  End  

Tuy nhiên, nếu điều kiện là True , như trong ví dụ này:

  x = 15

nếu x & gt; 9:
    print ("Xin chào!")

print ("End")  

Kết quả đầu ra sẽ là:

  Xin chào!
End  

Ví dụ về Điều kiện

Đây là một ví dụ khác về điều kiện:

  favourite_season = "Mùa hè"

if favourite_season == "Mùa hè":
    print ("Đó cũng là mùa yêu thích của tôi!")  

Trong trường hợp này, kết quả đầu ra sẽ là:

  That cũng là mùa yêu thích của tôi!  

Nhưng nếu chúng tôi thay đổi giá trị của favourite_season :

  favourite_season = "Mùa đông"

if favourite_season == "Mùa hè":
    print ("Đó cũng là mùa yêu thích của tôi!")  

Sẽ không có đầu ra vì điều kiện sẽ là False .

if / else câu lệnh trong Python

Chúng ta có thể thêm mệnh đề else vào điều kiện nếu chúng ta cần chỉ định điều gì sẽ xảy ra khi điều kiện False .

Đây là cú pháp chung:

  if & lt; điều kiện & gt ;:
    & lt; mã & gt;
khác:
    & lt; code & gt;  

💡 Mẹo: lưu ý rằng hai khối mã được thụt vào ( if else ). Đây là điều cần thiết để Python có thể phân biệt giữa mã thuộc chương trình chính và mã thuộc về điều kiện.

Hãy xem ví dụ với mệnh đề else :

Điều kiện đúng

  x = 15

nếu x & gt; 9:
    print ("Xin chào!")
khác:
    print ("Tạm biệt!")

print ("End")  

Kết quả đầu ra là:

  Xin chào!
Kết thúc  

Khi điều kiện của mệnh đề if True , mệnh đề này sẽ chạy. Mệnh đề else không chạy.

Điều kiện Sai

Bây giờ là elseMệnh đề chạy vì điều kiện False .

  x = 5

nếu x & gt; 9:
    print ("Xin chào!")
khác:
    print ("Tạm biệt!")

print ("End")  

Bây giờ kết quả đầu ra là:

  Bye!
Kết thúc  

if / elif / else câu lệnh bằng Python

Để tùy chỉnh các điều kiện của chúng tôi hơn nữa, chúng tôi có thể thêm một hoặc nhiều mệnh đề elif để kiểm tra và xử lý nhiều điều kiện. Chỉ mã của điều kiện đầu tiên được đánh giá là True sẽ chạy.

💡 Mẹo: elif phải được viết sau if và trước else . < / p>

Điều kiện đầu tiên Đúng

  x = 5

nếu x & lt; 9:
    print ("Xin chào!")
elif x & lt; 15:
    print ("Thật vui khi gặp bạn")
khác:
    print ("Tạm biệt!")

print ("End")  

Chúng ta có hai điều kiện x & lt; 9 x & lt; 15 . Chỉ khối mã từ điều kiện đầu tiên là True từ trên xuống dưới mới được thực thi.

Trong trường hợp này, kết quả đầu ra là:

  Xin chào!
Kết thúc  

Vì điều kiện đầu tiên là True : x & lt; 9 .

Điều kiện thứ hai Đúng

Nếu điều kiện đầu tiên là Sai , thì điều kiện thứ hai sẽ được kiểm tra.

Trong ví dụ này, điều kiện đầu tiên x & lt; 9 False nhưng điều kiện thứ hai x & lt; 15 True , vì vậy mã thuộc mệnh đề này sẽ chạy.

  x = 13

nếu x & lt; 9:
    print ("Xin chào!")
elif x & lt; 15:
    print ("Thật vui khi gặp bạn")
khác:
    print ("Tạm biệt!")

print ("End")  

Kết quả đầu ra là:

  Thật vui khi gặp bạn
Kết thúc  

Tất cả các điều kiện đều sai

Nếu tất cả các điều kiện False , thì < mệnh đề code> else sẽ chạy:

  x = 25

nếu x & lt; 9:
    print ("Xin chào!")
elif x & lt; 15:
    print ("Thật vui khi gặp bạn")
khác:
    print ("Tạm biệt!")

print ("End")  

Kết quả đầu ra sẽ là:

  Bye!
Kết thúc  

Nhiều mệnh đề elif

Chúng tôi có thể thêm nhiều mệnh đề elif nếu cần. Đây là ví dụ về điều kiện có hai mệnh đề elif :

  if favourite_season == "Winter":
    print ("Đó cũng là mùa yêu thích của tôi")
elif favourite_season == "Mùa hè":
    print ("Mùa hè thật tuyệt vời")
elif favourite_season == "Mùa xuân":
    print ("Tôi yêu mùa xuân")
khác:
    print ("Mùa thu là mùa yêu thích của mẹ tôi")  

Mỗi điều kiện sẽ được kiểm tra và chỉ khối mã của điều kiện đầu tiên được đánh giá là True sẽ chạy. Nếu không có mệnh đề nào trong số chúng là True , mệnh đề else sẽ chạy.

🔸 For Loops in Python

Bây giờ bạn đã biết cách viết điều kiện bằng Python, vì vậy hãy bắt đầu tìm hiểu các vòng lặp. Vòng lặp for là cấu trúc lập trình tuyệt vời mà bạn có thể sử dụng để lặp lại một khối mã một số lần cụ thể.

Đây là cú pháp cơ bản để viết vòng lặp for trong Python:

  for & lt; loop_variable & gt; trong & lt; có thể lặp lại & gt ;:
    & lt; code & gt;  

Có thể lặp lại có thể là một danh sách, tuple, từ điển, chuỗi, chuỗi được trả về bởi dải ô, một tệp hoặc bất kỳ kiểu lặp nào khác trong Python. Chúng ta sẽ bắt đầu với range () .

Hàm range () trong Python < / h3>

Hàm này trả về một chuỗi các số nguyên mà chúng ta có thể sử dụng để xác định số lần lặp (lặp lại) của vòng lặp sẽ được hoàn thành. Vòng lặp sẽ hoàn thành một lần lặp cho mỗi số nguyên.

💡 Mẹo: Mỗi số nguyên được gán cho biến vòng lặp tại một thời điểm cho mỗi lần lặp.

Đây là cú pháp chung để viết một vòng lặp for với range () :

  cho & lt; loop_variable & gt; trong phạm vi (& lt; bắt đầu & gt ;, & lt; dừng & gt ;, & lt; bước & gt;):
    & lt; code & gt;  

Như bạn có thể thấy, hàm range có ba tham số:

  • start : trong đó chuỗi của số nguyên sẽ bắt đầu. Theo mặc định, nó là 0 .
  • stop : nơi chuỗi các số nguyên sẽ dừng lại (không bao gồm giá trị này).
  • step : giá trị sẽ được thêm vào mỗi phần tử để lấy phần tử tiếp theo trong dãy. Theo mặc định, nó là 1 .

Bạn có thể chuyển 1, 2 hoặc 3 đối số cho range () :

  • Với 1 đối số, giá trị là được gán cho tham số stop và các giá trị mặc định cho hai tham số còn lại được sử dụng.
  • Với 2 đối số, các giá trị được gán cho các tham số start stop và giá trị mặc định cho step được sử dụng .
  • Với 3 đối số, các giá trị được gán cho startCác tham số , stop step (theo thứ tự).

Dưới đây chúng tôi có một số ví dụ với một tham số :

  cho tôi trong phạm vi (5):
    print (i)  

Đầu ra:

  0
1
2
3
4  

💡 Mẹo: biến vòng lặp được cập nhật tự động.

  & gt; & gt; & gt; cho j trong phạm vi (15):
    print (j * 2)  

Đầu ra:

  0
2
4
6
số 8
10
12
14
16
18
20
22
24
26
28  

Trong ví dụ dưới đây, chúng tôi lặp lại một chuỗi nhiều lần như được chỉ ra bởi giá trị của biến vòng lặp:

  & gt; & gt; & gt; cho num trong phạm vi (8):
print ("Xin chào" * num)  

Đầu ra:

  Xin chào
Xin chào
Xin chào xin chào xin chào
Xin chao xin chao xin chao xin chao
Chào chào chào chào chào
Xin chào xin chào xin chào xin chào xin chào xin chào
HelloHelloHelloHelloHelloHelloHello  

Chúng tôi cũng có thể sử dụng các vòng lặp cho các cấu trúc dữ liệu tích hợp sẵn như danh sách:

  & gt; & gt; & gt ; my_list = ["a", "b", "c", "d"]

& gt; & gt; & gt; cho tôi trong phạm vi (len (my_list)):
print (my_list [i])
 

Đầu ra:

  a
b
c
d  

💡 Mẹo: khi bạn sử dụng range (len (& lt; seq & gt;)) , bạn sẽ nhận được một dãy số đi từ 0 lên đến len (& lt; seq & gt;) - 1 . Điều này thể hiện chuỗi các chỉ số hợp lệ.

Đây là một số ví dụ có hai tham số :

  & gt; & gt ; & gt; cho tôi trong phạm vi (2, 10):
print (i)  

Đầu ra:

  2
3
4
5
6
7
số 8
9  

Mã:

  & gt; & gt; & gt; cho j trong phạm vi (2, 5):
print ("Python" * j)  

Đầu ra:

  PythonPython
PythonPythonPython
PythonPythonPythonPython  

Mã:

  & gt; & gt; & gt; my_list = ["a", "b", "c", "d"]

& gt; & gt; & gt; cho tôi trong phạm vi (2, len (my_list)):
print (my_list [i])  

Đầu ra:

  c
d  

Mã:

  & gt; & gt; & gt; my_list = ["a", "b", "c", "d"]

& gt; & gt; & gt; cho tôi trong phạm vi (2, len (my_list) -1):
my_list [i] * = i  

Bây giờ danh sách là: ['a', 'b', 'cc', 'd']

Đây là một số ví dụ với ba tham số :

  & gt; & gt; & gt; cho tôi trong phạm vi (3, 16, 2):
print (i)  

Đầu ra:

  3
5
7
9
11
13
15  

Mã:

  & gt; & gt; & gt; cho j trong phạm vi (10, 5, -1):
print (j)  

Đầu ra:

  10
9
số 8
7
6  

Mã:

  & gt; & gt; & gt; my_list = ["a", "b", "c", "d", "e", "f", "g"]

& gt; & gt; & gt; cho tôi trong phạm vi (len (my_list) -1, 2, -1):
print (my_list [i])  

Đầu ra:

  g
f
e
d  

Cách Lặp lại các Lặp lại trong Python

Chúng tôi có thể lặp trực tiếp qua các tệp lặp như vậy dưới dạng danh sách, bộ giá trị, từ điển, chuỗi và tệp sử dụng vòng lặp for. Chúng tôi sẽ lấy từng phần tử một trong số chúng tại một thời điểm cho mỗi lần lặp. Điều này rất hữu ích khi làm việc trực tiếp với họ.

Hãy xem một số ví dụ:

Lặp lại trên một chuỗi

Nếu chúng ta lặp lại một chuỗi, các ký tự của nó sẽ được gán cho từng biến vòng lặp (bao gồm cả dấu cách và ký hiệu).

  & gt; & gt; & gt; message = "Xin chào, Thế giới!"

& gt; & gt; & gt; cho char trong tin nhắn:
in (ký tự)


H
e
l
l
o
,
 
W
o
r
l
d
!  

Chúng tôi cũng có thể lặp lại các bản sao đã sửa đổi của chuỗi bằng cách gọi một phương thức chuỗi mà chúng tôi chỉ định có thể lặp lại trong vòng lặp for. Thao tác này sẽ chỉ định bản sao của chuỗi dưới dạng có thể lặp lại sẽ được sử dụng cho các lần lặp, như sau:

  & gt; & gt; & gt; word = "Xin chào"

& gt; & gt; & gt; for char trong word.lower (): # gọi phương thức chuỗi
in (ký tự)


h
e
l
l
o  
  & gt; & gt; & gt; word = "Xin chào"

& gt; & gt; & gt; for char trong word.upper (): # gọi phương thức chuỗi
in (ký tự)


H
E
L
L
O  

Lặp lại qua các danh sách và Tuples

  & gt; & gt ; & gt; my_list = [2, 3, 4, 5]

& gt; & gt; & gt; cho num trong my_list:
print (num)  

Kết quả là:

  2
3
4
5  

Mã:

  & gt; & gt; & gt; my_list = (2, 3, 4, 5)

& gt; & gt; & gt; cho num trong my_list:
nếu num% 2 == 0:
print ("Chẵn")
khác:
print ("Lẻ")  

Đầu ra:

  Chẵn
Số lẻ
Thậm chí
Kỳ quặc  

Lặp lại các cặp khóa, giá trị và khóa-giá trị của từ điển

Chúng tôi có thể lặp lại các khóa, giá trị và các cặp khóa-giá trị của từ điển bằng cách gọi các phương thức từ điển cụ thể. Hãy xem cách thực hiện.

Để lặp lại các phím , chúng tôi viết:

  cho & lt; var & gt; trong & lt; dictionary_variable & gt ;:
    & lt; code & gt;  

Chúng tôi chỉ viết tên của biến lưu trữ từ điển dưới dạng có thể lặp lại.

💡 Mẹo: bạn có thể cũng viết & lt; dictionary_variable & gt; .keys () nhưng viết trực tiếp tên của biến sẽ ngắn gọn hơn và nó hoạt động giống hệt nhau.

Ví dụ:

  & gt; & gt; & gt; my_dict = {"a": 1, "b": 2, "c": 3}

& gt; & gt; & gt; cho khóa trong my_dict:
in (phím)


một
b
c  

💡 Mẹo: bạn có thể gán bất kỳ tên hợp lệ nào cho biến vòng lặp.

Để lặp lại giá trị , chúng tôi sử dụng:

  cho & lt; var & gt; trong & lt; dictionary_variable & gt; .values ​​():
    & lt; code & gt;  

Ví dụ:

  & gt; & gt; & gt; my_dict = {"a": 1, "b": 2, "c": 3}

& gt; & gt; & gt; cho giá trị trong my_dict.values ​​():
in (giá trị)


1
2
3  

Để lặp lại các cặp khóa-giá trị , chúng tôi sử dụng:

  cho & lt; key & gt ;, & lt; value & gt; trong & lt; dictionary_variable & gt; .items ():
    & lt; code & gt;  

💡 Mẹo: chúng tôi đang xác định hai biến vòng lặp vì chúng tôi muốn gán khóa và giá trị cho các biến mà chúng tôi có thể sử dụng trong vòng lặp .

  & gt; & gt; & gt; my_dict = {"a": 1, "b": 2, "c": 3}

& gt; & gt; & gt; cho khóa, giá trị trong my_dict.items ():
in (khóa, giá trị)


một 1
b 2
c 3  

Nếu chúng tôi chỉ xác định một biến lặp, biến này sẽ chứa một bộ giá trị với cặp khóa-giá trị:

  & gt; & gt; & gt; my_dict = {"a": 1, "b": 2, "c": 3}
& gt; & gt; & gt; cho cặp trong my_dict.items ():
in (cặp)


('a', 1)
('b', 2)
('c', 3)  

Break and Continue trong Python

Bây giờ bạn đã biết cách lặp lại trình tự trong Python. Chúng tôi cũng có các câu lệnh điều khiển vòng lặp để tùy chỉnh những gì sẽ xảy ra khi vòng lặp chạy: break continue .

Câu lệnh Break

Câu lệnh break được sử dụng để dừng vòng lặp ngay lập tức.

Khi tìm thấy câu lệnh break , vòng lặp sẽ dừng và chương trình trở lại thực thi bình thường sau vòng lặp.

Trong ví dụ dưới đây, chúng ta dừng vòng lặp khi một phần tử chẵn được tìm thấy.

  & gt; & gt; & gt; my_list = [1, 2, 3, 4, 5]

& gt; & gt; & gt; cho elem trong my_list:
nếu elem% 2 == 0:
print ("Chẵn:", elem)
print ("break")
phá vỡ
khác:
print ("Odd:", elem)


Lẻ: 1
Chẵn: 2
break  

Câu lệnh Tiếp tục

Câu lệnh continue được sử dụng để bỏ qua phần còn lại của câu lệnh hiện tại sự lặp lại.

Khi nó được tìm thấy trong quá trình thực hiện vòng lặp, lần lặp hiện tại sẽ dừng lại và một lần lặp mới bắt đầu với giá trị cập nhật của biến vòng lặp.

Trong ví dụ dưới đây, chúng tôi bỏ qua lần lặp hiện tại nếu phần tử là chẵn và chúng tôi chỉ in giá trị nếu phần tử là lẻ:

  & gt; & gt; & gt; my_list = [1, 2, 3, 4, 5]

& gt; & gt; & gt; cho elem trong my_list:
nếu elem% 2 == 0:
print ("tiếp tục")
tiếp tục
print ("Odd:", elem)


Lẻ: 1
tiếp tục
Lẻ: 3
tiếp tục
Kỳ lạ: 5  

Hàm zip () trong Python

zip () là một hàm tích hợp tuyệt vời mà chúng ta có thể sử dụng trong Python để lặp lại nhiều chuỗi cùng một lúc, nhận các phần tử tương ứng của chúng trong mỗi lần lặp.

Chúng ta chỉ cần chuyển các chuỗi dưới dạng đối số cho hàm zip () và sử dụng kết quả này trong vòng lặp.

Ví dụ:

  & gt; & gt; & gt; my_list1 = [1, 2, 3, 4]
& gt; & gt; & gt; my_list2 = [5, 6, 7, 8]

& gt; & gt; & gt; cho elem1, elem2 trong zip (my_list1, my_list2):
in (elem1, elem2)


1 5
2 6
3 7
4 8  

Hàm enumerate () trong Python

Bạn cũng có thể theo dõi bộ đếm trong khi vòng lặp chạy với hàm enum () . Nó thường được sử dụng để lặp lại một chuỗi và lấy chỉ mục tương ứng.

💡 Mẹo: Theo mặc định, bộ đếm bắt đầu ở 0 .

Ví dụ:

  & gt; & gt; & gt; my_list = [5, 6, 7, 8]

& gt; & gt; & gt; đối với tôi, elem in enumerate (my_list):
in (i, elem)


0 5
1 6
2 7
3 8  
 & gt; & gt; & gt; word = "Xin chào"

& gt; & gt; & gt; đối với tôi, char trong liệt kê (từ):
print (i, char)


0 giờ
1 e
2 l
3 l
4 o  

Nếu bạn bắt đầu bộ đếm từ 0 , bạn có thể sử dụng chỉ mục và giá trị hiện tại trong cùng một lần lặp để sửa đổi trình tự:

  & gt; & gt; & gt; my_list = [5, 6, 7, 8]

& gt; & gt; & gt; cho chỉ mục, num trong liệt kê (my_list):
my_list [index] = num * 3

& gt; & gt; & gt; danh sách của tôi
[15, 18, 21, 24]  

Bạn có thể bắt đầu bộ đếm từ một số khác bằng cách chuyển đối số thứ hai tới enumerate () :

  & gt; & gt; & gt; word = "Xin chào"

& gt; & gt; & gt; đối với tôi, char trong liệt kê (từ, 2):
print (i, char)


2 giờ
3 e
4 l
5 l
6 o  

Mệnh đề else

Vòng lặp for cũng có mệnh đề else . Bạn có thể thêm mệnh đề này vào vòng lặp nếu bạn muốn chạy một khối mã cụ thể khi vòng lặp hoàn thành tất cả các lần lặp của nó mà không tìm thấy câu lệnh break .

💡 Mẹo : nếu break được tìm thấy, mệnh đề else không chạy và nếu break không được tìm thấy, thì else Mệnh đề chạy.

Trong ví dụ dưới đây, chúng tôi cố gắng tìm một phần tử lớn hơn 6 trong danh sách. Phần tử đó không được tìm thấy, vì vậy break không chạy và mệnh đề else chạy.

  my_list = [1, 2, 3, 4, 5]

cho elem trong my_list:
    nếu elem & gt; 6:
        print ("Đã tìm thấy")
        phá vỡ
khác:
    print ("Không Tìm thấy")  

Kết quả đầu ra là:

  Không tìm thấy  

Tuy nhiên, nếu < câu lệnh code> break chạy, mệnh đề else không chạy. Chúng ta có thể thấy điều này trong ví dụ bên dưới:

  my_list = [1, 2, 3, 4, 5, 8] # Bây giờ danh sách có giá trị 8

cho elem trong my_list:
    nếu elem & gt; 6:
        print ("Đã tìm thấy")
        phá vỡ
khác:
    print ("Không tìm thấy")  

Kết quả đầu ra là:

  Đã tìm thấy  

🔹 Vòng lặp While trong Python

Vòng lặp while tương tự như vòng lặp for ở điểm chúng cho phép chúng ta lặp lại một khối mã. Sự khác biệt là các vòng lặp while chạy trong khi một điều kiện là True .

Trong vòng lặp while, chúng tôi xác định điều kiện chứ không phải số lần lặp. Vòng lặp dừng khi điều kiện False .

Đây là cú pháp chung của vòng lặp while:

  trong khi & lt; điều kiện & gt ;:
    & lt; code & gt;  

💡 Mẹo: trong vòng lặp while, bạn phải cập nhật các biến là một phần của điều kiện để đảm bảo rằng điều kiện cuối cùng sẽ trở thành < code> False .

Ví dụ:

  & gt; & gt; & gt; x = 6

& gt; & gt; & gt; trong khi x & lt; 15:
print (x)
x + = 1


6
7
số 8
9
10
11
12
13
14  
  & gt; & gt; & gt; x = 4

& gt; & gt; & gt; trong khi x & gt; = 0:
print ("Xin chào" * x)
x - = 1


Xin chao xin chao xin chao xin chao
Xin chào xin chào xin chào
Xin chào
Xin chào  
  & gt; & gt; & gt; num = 5

& gt; & gt; & gt; trong khi num & gt; = 1:
print ("*" * num)
num - = 2


*****
***
*  

Ngắt và Tiếp tục

Chúng ta cũng có thể sử dụng break continue với các vòng lặp while và cả hai đều hoạt động hoàn toàn giống nhau:

  • break dừng vòng lặp while ngay lập tức.
  • continue dừng lần lặp hiện tại và bắt đầu lần lặp tiếp theo.

Ví dụ:

  & gt; & gt; & gt; x = 5

& gt; & gt; & gt; trong khi x & lt; 15:
nếu x% 2 == 0:
print ("Chẵn:", x)
phá vỡ
print (x)
x + = 1
    

5
Chẵn: 6  
  & gt; & gt; & gt; x = 5

& gt; & gt; & gt; trong khi x & lt; 15:
nếu x% 2 == 0:
x + = 1
tiếp tục
print ("Lẻ:", x)
x + = 1


Lẻ: 5
Lẻ: 7
Lẻ: 9
Lẻ: 11
Kỳ lạ: 13  

Mệnh đề else

Chúng tôi cũng có thể thêm mệnh đề khác cho một vòng lặp while. Nếu break được tìm thấy, mệnh đề else không chạy nhưng nếu không tìm thấy câu lệnh break , thì else mệnh đề chạy.

Trong ví dụ dưới đây, không tìm thấy câu lệnh break vì không có số nào là số chẵn trước khi điều kiện trở thành False , vì vậy mệnh đề else chạy.

  x = 5

trong khi x & lt; 15:
nếu x% 2 == 0:
print ("Tìm thấy số chẵn")
phá vỡ
print (x)
x + = 2
khác:
print ("Tất cả các số đều là số lẻ")  

Đây là kết quả:

  5
7
9
11
13
Tất cả các số đều là số lẻ  

Nhưng trong phiên bản này của ví dụ, câu lệnh break được tìm thấy và mệnh đề else không chạy :

 x = 5

trong khi x & lt; 15:
nếu x% 2 == 0:
print ("Tìm thấy số chẵn")
phá vỡ
print (x)
x + = 1 # Bây giờ chúng ta đang tăng giá trị lên 1
khác:
print ("Tất cả các số đều là số lẻ")  

Kết quả đầu ra là:

  5
Số chẵn được tìm thấy  

Vòng lặp While vô hạn

Khi chúng ta viết và làm việc với các vòng lặp while, chúng ta có thể có một cái gì đó được gọi là" vô hạn vòng." Nếu điều kiện không bao giờ là False , thì vòng lặp sẽ không bao giờ dừng lại nếu không có sự can thiệp từ bên ngoài.

Điều này thường xảy ra khi các biến trong điều kiện không được cập nhật đúng cách trong quá trình thực hiện vòng lặp.

💡 Mẹo: bạn phải thực hiện các cập nhật cần thiết các biến này để đảm bảo rằng điều kiện cuối cùng sẽ đánh giá thành False .

Ví dụ:

  & gt ; & gt; & gt; x = 5

& gt; & gt; & gt; trong khi x & gt; 2:
print (x)


5
5
5
5
5
5
5
5
5
.
.
.
# Đầu ra tiếp tục vô thời hạn  

💡 Mẹo: để dừng quá trình này, hãy nhập CTRL + C . Bạn sẽ thấy thông báo KeyboardInterrupt .

🔸 Nested Loops trong Python

Chúng ta có thể viết cho các vòng lặp trong vòng lặp for và vòng lặp while trong vòng lặp while. Các vòng bên trong này được gọi là các vòng lồng nhau.

💡 Mẹo: vòng lặp bên trong chạy cho mỗi lần lặp lại của vòng lặp bên ngoài.

lồng nhau Đối với vòng lặp trong Python

  & gt; & gt; & gt; cho tôi trong phạm vi (3):
cho j trong phạm vi (2):
in (i, j)


0 0
0 1
1 0
1 1
2 0
2 1  

Nếu chúng tôi thêm các câu lệnh in, chúng tôi có thể thấy những gì đang xảy ra đằng sau hậu trường:

  & gt; & gt; & gt; cho tôi trong phạm vi (3):
print ("=== & gt; Vòng ngoài")
print (f "i = {i}")
cho j trong phạm vi (2):
print ("Vòng lặp bên trong")
print (f "j = {j}")


=== & gt; Vòng ngoài
i = 0
Vòng trong
j = 0
Vòng trong
j = 1
=== & gt; Vòng ngoài
i = 1
Vòng trong
j = 0
Vòng trong
j = 1
=== & gt; Vòng ngoài
i = 2
Vòng trong
j = 0
Vòng trong
j = 1  

Vòng lặp bên trong hoàn thành hai lần lặp cho mỗi lần lặp của vòng lặp bên ngoài. Các biến vòng lặp được cập nhật khi một lần lặp mới bắt đầu.

Đây là một ví dụ khác:

  & gt; & gt; & gt; num_rows = 5

& gt; & gt; & gt; cho tôi trong phạm vi (5):
cho num_cols trong dải ô (num_rows-i):
print ("*", end = "")
in()


*****
****
***
**
*  

Các vòng lặp While lồng nhau trong Python

Ở đây chúng tôi có một ví dụ về các vòng lặp while lồng nhau. Trong trường hợp này, chúng tôi phải cập nhật các biến là một phần của mỗi điều kiện để đảm bảo rằng các vòng lặp sẽ dừng lại.

  & gt; & gt; & gt; i = 5

& gt; & gt; & gt; trong khi tôi & gt; 0:
j = 0
trong khi j & lt; 2:
in (i, j)
j + = 1
i - = 1


5 0
5 1
4 0
4 1
3 0
3 1
2 0
2 1
1 0
1 1  

💡 Mẹo: chúng ta cũng có thể có vòng lặp for trong vòng lặp while và vòng lặp while trong vòng lặp for.

🔹 Các hàm trong Python

Trong Python, chúng ta có thể xác định các hàm để làm cho mã của chúng ta có thể tái sử dụng, dễ đọc hơn và có tổ chức. Đây là cú pháp cơ bản của một hàm Python:

  def & lt; function_name & gt; (& lt; param1 & gt ;, & lt; param2 & gt ;, ...):
    & lt; code & gt;  

💡 Mẹo: một hàm có thể có 0, một hoặc nhiều tham số.

Hàm không có tham số trong Python

Một hàm không có tham số có một cặp dấu ngoặc đơn trống sau tên của nó trong định nghĩa hàm. Ví dụ:

  def print_pattern ():
    kích thước = 4
    cho tôi trong phạm vi (kích thước):
        print ("*" * size)  

Đây là kết quả đầu ra khi chúng ta gọi hàm:

  & gt; & gt; & gt; print_pattern ()
****
****
****
****  

💡 Mẹo: Bạn phải viết một cặp dấu ngoặc đơn trống sau tên của hàm để gọi nó.

Hàm có một tham số trong Python

Một hàm có một hoặc nhiều tham số có danh sách các tham số được bao quanh bởi dấu ngoặc đơn sau tên của nó trong hàm định nghĩa:

  def welcome_student (name):
    print (f "Xin chào, {name}! Chào mừng đến với lớp học.")  

Khi chúng ta gọi hàm, chúng ta chỉ cần chuyển một giá trị làm đối số và giá trị đó sẽ được thay thế ở vị trí chúng ta sử dụng tham số trong định nghĩa hàm:

  & gt; & gt; & gt; welcome_student ("Nora")
Chào, Nora! Chào mừng bạn đến với lớp học.  

Ở đây chúng ta có một ví dụ khác - một hàm in một mẫu có dấu hoa thị. Bạn phải chỉ định số hàng bạn muốn in:

  def print_pattern (num_rows):
    cho tôi trong phạm vi (num_rows):
        cho num_cols trong dải ô (num_rows-i):
            print ("*", end = "")
        print ()  

Bạn có thể thấy các kết quả đầu ra khác nhau cho các giá trị khác nhau của num_rows :

  & gt; & gt; & gt; print_pattern (3)
***
**
*

& gt; & gt; & gt; print_pattern (5)
*****
****
***
**
*

& gt; & gt; & gt; print_pattern (8)
********
*******
******
*****
****
***
**
*  

Các hàm có hai hoặc nhiều tham số trong Python

Để xác định hai hoặc nhiều tham số hơn, chúng tôi chỉ tách chúng bằng dấu phẩy:

  def print_sum (a, b):
    print (a + b)
 

Bây giờ khi gọi hàm, chúng ta phải chuyển hai đối số:

  & gt; & gt; & gt; print_sum (4, 5)
9

& gt; & gt; & gt; print_sum (8, 9)
17

& gt; & gt; & gt; print_sum (0, 0)
0

& gt; & gt; & gt; print_sum (3, 5)
8  

Chúng ta có thể điều chỉnh hàm mà chúng ta vừa thấy với một tham số để hoạt động với hai tham số và in một mẫu có ký tự tùy chỉnh:

  def print_pattern (num_rows, char):
cho tôi trong phạm vi (num_rows):
cho num_cols trong dải ô (num_rows-i):
print (char, end = "")
print ()  

Bạn có thể thấy đầu ra với ký tự tùy chỉnh mà chúng tôi gọi là hàm truyền hai đối số:

  & gt; & gt; & gt; print_pattern (5, "A")
AAAAA
AAAA
AAA
AA
Một

& gt; & gt; & gt; print_pattern (8, "%")
%%%%%%%%
%%%%%%%
%%%%%%
%%%%%
%%%%
%%%
%%
%

& gt; & gt; & gt; print_pattern (10, "#")
##########
#########
########
#######
######
#####
####
###
##
#  

Cách trả lại giá trị trong Python

Tuyệt vời. Bây giờ bạn đã biết cách định nghĩa một hàm, vì vậy hãy xem cách bạn có thể làm việc với các câu lệnh trả về.

Chúng tôi thường sẽ cần trả về một giá trị từ một hàm. Chúng ta có thể làm điều này với câu lệnh return trong Python. Chúng ta chỉ cần viết điều này trong định nghĩa hàm:

  return & lt; value_to_return & gt;  

💡 Mẹo: hàm dừng ngay lập tức khi tìm thấy return và giá trị được trả về.

Ở đây chúng tôi có một ví dụ:

  def get_rectangle_area (length, width):
    return length * width  

Bây giờ chúng ta có thể gọi hàm và gán kết quả cho một biến vì kết quả được trả về bởi hàm:

  & gt; & gt; & gt; area = get_rectangle_area (4, 5)
& gt; & gt; & gt; diện tích
20  

Chúng tôi cũng có thể sử dụng return với một điều kiện để trả về một giá trị dựa trên việc một điều kiện là True hay False .

Trong ví dụ này, hàm trả về phần tử chẵn đầu tiên được tìm thấy trong chuỗi:

  def get_first_even (seq) :
    cho elem trong seq:
        nếu elem% 2 == 0:
            trả lại elem
    khác:
        trả về Không có gì  

Nếu gọi hàm, chúng ta có thể thấy kết quả mong đợi:

  & gt; & gt; & gt; value1 = get_first_even ([2, 3, 4, 5])
& gt; & gt; & gt; value1
2  
  & gt; & gt; & gt; value2 = get_first_even ([3, 5, 7, 9])
& gt; & gt; & gt; in (value2)
Không có  

💡 Mẹo: nếu một hàm không có câu lệnh return hoặc không tìm thấy câu lệnh nào trong khi thực thi, thì trả về Không theo mặc định.

Hướng dẫn về kiểu cho mã Python khuyên bạn nên sử dụng các câu lệnh trả về một cách nhất quán. Nó đề cập rằng chúng ta nên:

Nhất quán trong các câu lệnh trả về. Tất cả các câu lệnh trả về trong một hàm phải trả về một biểu thức hoặc không có câu nào trong số chúng nên trả về. Nếu bất kỳ câu lệnh trả về nào trả về một biểu thức, thì bất kỳ câu lệnh trả về nào không có giá trị nào được trả về phải nêu rõ điều này là trả về Không có và một câu lệnh trả về rõ ràng phải có ở cuối hàm (nếu có thể truy cập được)

Các đối số mặc định trong Python

Chúng ta có thể gán các đối số mặc định cho các tham số của hàm của chúng ta. Để thực hiện việc này, chúng ta chỉ cần viết & lt; parameter & gt; = & lt; value & gt; trong danh sách các tham số.

💡 Mẹo: < span> Hướng dẫn kiểu cho mã Python đề cập rằng chúng ta không nên "sử dụng khoảng trắng xung quanh dấu = khi được sử dụng để biểu thị đối số từ khóa."

Trong ví dụ này, chúng tôi chỉ định giá trị mặc định 5 thành tham số b . Nếu chúng ta bỏ qua giá trị này khi gọi hàm, giá trị mặc định sẽ được sử dụng.

  def print_product (a, b = 5):
    print (a * b)  

Nếu chúng ta gọi hàm mà không có đối số này, bạn có thể thấy kết quả đầu ra:

  & gt ; & gt; & gt; print_product (4)
20  

Chúng tôi xác nhận rằng đối số mặc định 5 đã được sử dụng trong hoạt động này.

Nhưng chúng tôi cũng có thể chỉ định giá trị tùy chỉnh cho b bằng cách chuyển đối số thứ hai:

  & gt; & gt ; & gt; print_product (3, 4)
12  

💡 Mẹo: tham số có đối số mặc định phải được xác định ở cuối danh sách tham số. Nếu không, bạn sẽ thấy lỗi này: SyntaxError: đối số không mặc định theo sau đối số mặc định .

Ở đây chúng tôi có một ví dụ khác với hàm mà chúng tôi đã viết để in một mẫu. Chúng tôi gán giá trị mặc định "*" cho tham số char .

  def print_pattern (num_rows, char = "*"):
cho tôi trong phạm vi (num_rows):
cho num_cols trong dải ô (num_rows-i):
print (char, end = "")
print ()  

Giờ đây, chúng tôi có tùy chọn sử dụng giá trị mặc định hoặc tùy chỉnh giá trị đó:

  & gt; & gt; & gt ; print_pattern (5)
*****
****
***
**
*

& gt; & gt; & gt; print_pattern (6, "& amp;")
& amp; & amp; & amp; & amp; & amp; & amp;
& amp; & amp; & amp; & amp; & amp;
& amp; & amp; & amp; & amp;
& amp; & amp; & amp;
& amp; & amp;
& amp;  

🔸 Đệ quy trong Python

Một hàm đệ quy là một hàm gọi chính nó. Các hàm này có một trường hợp cơ sở để dừng quá trình đệ quy và một trường hợp đệ quy tiếp tục quy trình đệ quy bằng cách thực hiện một lệnh gọi đệ quy khác.

Dưới đây chúng tôi có một số ví dụ trong Python:

  def factorial (n):
    nếu n == 0 hoặc n == 1:
        trả lại 1
    khác:
        trả về n * giai thừa (n-1)  

Hàm giai thừa đệ quy

  def fibonacci (n):
    nếu n == 0 hoặc n == 1:
        trả lại n
    khác:
        trả về fibonacci (n-1) + fibonacci (n-2)  

Hàm Fibonacci

  def find_power (a, b):
    nếu b == 0:
        trả lại 1
    khác:
        trả về a * find_power (a, b-1)  

Tìm Power đệ quy

🔹 Xử lý ngoại lệ trong Python

Lỗi hoặc sự kiện không mong muốn xảy ra trong khi chương trình đang chạy được gọi là ngoại lệ . Nhờ các yếu tố mà chúng ta sẽ thấy trong giây lát, chúng ta có thể tránh việc kết thúc chương trình đột ngột khi điều này xảy ra.

Hãy xem các loại ngoại lệ trong Python và cách chúng ta có thể xử lý chúng.

Các ngoại lệ phổ biến trong Python

Đây là danh sách các ngoại lệ phổ biến trong Python và tại sao chúng xảy ra:

  • < strong> ZeroDivisionError: được đưa ra khi đối số thứ hai của một phép chia hoặc phép toán mô-đun bằng không.
    • & gt; & gt; & gt; 5/0
      Traceback (cuộc gọi gần đây nhất cuối cùng):
      Tệp "& lt; pyshell # 0 & gt;", dòng 1, trong & lt; mô-đun & gt;
      5/0
      ZeroDivisionError: chia cho 0

      & gt; & gt; & gt; 7 // 0
      Traceback (cuộc gọi gần đây nhất cuối cùng):
      Tệp "& lt; pyshell # 1 & gt;", dòng 1, trong & lt; mô-đun & gt;
      7 // 0
      ZeroDivisionError: chia số nguyên hoặc modulo bằng 0

      & gt; & gt; & gt; 8% 0
      Traceback (cuộc gọi gần đây nhất cuối cùng):
      Tệp "& lt; pyshell # 2 & gt;", dòng 1, trong & lt; mô-đun & gt;
      8% 0
      ZeroDivisionError: phép chia số nguyên hoặc modulo bằng 0

      • IndexError: được đưa ra khi chúng tôi cố gắng sử dụng một chỉ mục không hợp lệ để truy cập vào một phần tử của một chuỗi.
        & gt; & gt; & gt; my_list = [3, 4, 5, 6]
      
      & gt; & gt; & gt; my_list [15]
      Traceback (cuộc gọi gần đây nhất cuối cùng):
        Tệp "& lt; pyshell # 4 & gt;", dòng 1, trong & lt; mô-đun & gt;
          my_list [15]
      IndexError: liệt kê chỉ mục nằm ngoài phạm vi  
      • KeyError: được nâng lên khi chúng tôi cố gắng truy cập vào một cặp khóa-giá trị không tồn tại vì khóa là không có trong từ điển.
        & gt; & gt; & gt; my_dict = {"a": 1, "b": 2, "c": 3}
      
      & gt; & gt; & gt; my_dict ["d"]
      Traceback (cuộc gọi gần đây nhất cuối cùng):
        Tệp "& lt; pyshell # 6 & gt;", dòng 1, trong & lt; mô-đun & gt;
          my_dict ["d"]
      KeyError: 'd'  
      • NameError: xuất hiện khi chúng tôi sử dụng một biến chưa được xác định trước đó.

      < pre> & gt; & gt; & gt; b
      Traceback (cuộc gọi gần đây nhất cuối cùng):
      Tệp "& lt; pyshell # 8 & gt;", dòng 1, trong & lt; mô-đun & gt;
      b
      NameError: tên 'b' không được xác định

      • RecursionError: nâng lên khi trình thông dịch phát hiện ra rằng độ sâu đệ quy tối đa bị vượt quá. Điều này thường xảy ra khi quá trình không bao giờ đạt đến trường hợp cơ sở.

      Trong ví dụ dưới đây, chúng ta sẽ nhận được RecursionError . Hàm giai thừa được triển khai đệ quy nhưng đối số được truyền cho lệnh gọi đệ quy là n thay vì n-1 . Trừ khi giá trị đã là 0 hoặc 1 , trường hợp cơ sở sẽ không đạt được vì đối số không được giảm dần, vì vậy quá trình sẽ tiếp tục và chúng tôi sẽ gặp lỗi này.

       & gt; & gt; & gt; def factorial (n):
      nếu n == 0 hoặc n == 1:
      trả lại 1
      khác:
      trả về n * giai thừa (n)
      
      
      & gt; & gt; & gt; giai thừa (5)
      Traceback (cuộc gọi gần đây nhất cuối cùng):
        Tệp "& lt; pyshell # 6 & gt;", dòng 1, trong & lt; mô-đun & gt;
          giai thừa (5)
        Tệp "& lt; pyshell # 5 & gt;", dòng 5, theo giai thừa
          trả về n * giai thừa (n)
        Tệp "& lt; pyshell # 5 & gt;", dòng 5, theo giai thừa
          trả về n * giai thừa (n)
        Tệp "& lt; pyshell # 5 & gt;", dòng 5, theo giai thừa
          trả về n * giai thừa (n)
        [Dòng trước lặp lại 1021 lần nữa]
        Tệp "& lt; pyshell # 5 & gt;", dòng 2, trong giai thừa
          nếu n == 0 hoặc n == 1:
      RecursionError: đã vượt quá độ sâu đệ quy tối đa khi so sánh  

      💡 Mẹo: để tìm hiểu thêm về những ngoại lệ này, tôi khuyên bạn nên đọc bài viết này từ tài liệu hướng dẫn.

      thử / ngoại trừ bằng Python

      Chúng tôi có thể dùng thử / Ngoại trừ trong Python để nắm bắt các ngoại lệ khi chúng xảy ra và xử lý chúng một cách thích hợp. Bằng cách này, chương trình có thể kết thúc một cách thích hợp hoặc thậm chí khôi phục từ trường hợp ngoại lệ.

      Đây là cú pháp cơ bản:

        try:
          & lt; code_that_may_raise_an_exception & gt;
      ngoại trừ:
          & lt; code_to_handle_the_exception_if_it_occurs & gt;
       

      Ví dụ: nếu chúng tôi sử dụng thông tin đầu vào của người dùng để truy cập một phần tử trong danh sách, đầu vào có thể không phải là một chỉ mục hợp lệ, vì vậy có thể đưa ra một ngoại lệ:

        index = int (input ("Nhập chỉ mục:"))
      
      thử:
          my_list = [1, 2, 3, 4]
          print (my_list [index])
      ngoại trừ:
          print ("Vui lòng nhập chỉ mục hợp lệ.")  

      Nếu chúng ta nhập giá trị không hợp lệ như 15, kết quả đầu ra sẽ là:

        Vui lòng nhập chỉ mục hợp lệ.  

      Vì mệnh đề ngoại trừ chạy. Tuy nhiên, nếu giá trị hợp lệ, mã trong try sẽ chạy như mong đợi.

      Ở đây chúng ta có một ví dụ khác:

        a = int (input ("Nhập a:"))
      b = int (input ("Nhập b:"))
      
      thử:
          phép chia = a / b
          in (chia)
      ngoại trừ:
          print ("Vui lòng nhập các giá trị hợp lệ.")  

      Kết quả đầu ra là:

        Nhập a: 5
      Nhập b: 0
      
      Vui lòng nhập các giá trị hợp lệ.  

      Cách nắm bắt một loại ngoại lệ cụ thể trong Python < / h3>

      Thay vì bắt và xử lý tất cả các ngoại lệ có thể xảy ra trong mệnh đề try , chúng tôi có thể bắt và xử lý một loại ngoại lệ cụ thể. Chúng ta chỉ cần chỉ định loại ngoại lệ sau từ khóa exception :

        try:
          & lt; code_that_may_raise_an_exception & gt;
      ngoại trừ & lt; exception_type & gt ;:
          & lt; code_to_handle_an_exception_if_it_occurs & gt;
       

      Ví dụ:

        index = int (input ("Nhập chỉ mục:"))
      
      thử:
          my_list = [1, 2, 3, 4]
          print (my_list [index])
      ngoại trừ IndexError: # chỉ định loại
          print ("Vui lòng nhập chỉ mục hợp lệ.")  
        a = int (input ("Nhập a:"))
      b = int (input ("Nhập b:"))
      
      thử:
          phép chia = a / b
          in (chia)
      ngoại trừ ZeroDivisionError: # chỉ định loại
          print ("Vui lòng nhập các giá trị hợp lệ.")  

      Cách chỉ định Đặt tên cho đối tượng ngoại lệ trong Python

      Chúng ta có thể chỉ định tên cho đối tượng ngoại lệ bằng cách gán nó cho một biến mà chúng ta có thể sử dụng trong mệnh đề exception . Điều này sẽ cho phép chúng tôi truy cập mô tả và các thuộc tính của nó.

      Chúng tôi chỉ cần thêm dưới dạng & lt; name & gt; , như sau:

        hãy thử:
          & lt; code_that_may_raise_an_exception & gt;
      ngoại trừ & lt; exception_type & gt; dưới dạng & lt; tên & gt ;:
          & lt; code_to_handle_an_exception_if_it_occurs & gt;
       

      Ví dụ:

        index = int (input ("Nhập chỉ mục:"))
      
      thử:
          my_list = [1, 2, 3, 4]
          print (my_list [index])
      ngoại trừ IndexError as e:
          print ("Ngoại lệ được nâng lên:", e)  

      Đây là kết quả đầu ra nếu chúng ta nhập 15 làm chỉ mục:

        Nhập chỉ số: 15
      Ngoại lệ được nêu ra: danh sách chỉ mục nằm ngoài phạm vi  

      Đây là một ví dụ khác:

        a = int (input ("Nhập a : "))
      b = int (input ("Nhập b:"))
      
      thử:
          phép chia = a / b
          in (chia)
      ngoại trừ ZeroDivisionError as err:
          print ("Vui lòng nhập các giá trị hợp lệ.", err)
       

      Đây là đầu ra nếu chúng ta nhập giá trị 0 cho b :

        Vui lòng nhập các giá trị hợp lệ. phép chia cho không  

      try / ngoại trừ / else < / code> trong Python

      Chúng ta có thể thêm mệnh đề else vào cấu trúc này sau ngoại trừ nếu chúng ta muốn chọn điều gì sẽ xảy ra khi không có ngoại lệ nào xảy ra trong thực thi mệnh đề try :

       hãy thử:
          & lt; code_that_may_raise_an_exception & gt;
      ngoại trừ:
          & lt; code_to_handle_an_exception_if_it_occurs & gt;
      khác:
          & lt; code_that_only_runs_if_no_exception_in_try & gt;
       

      Ví dụ:

        a = int (input ("Nhập a:"))
      b = int (input ("Nhập b:"))
      
      thử:
          phép chia = a / b
          in (chia)
      ngoại trừ ZeroDivisionError as err:
          print ("Vui lòng nhập các giá trị hợp lệ.", err)
      khác:
          print ("Cả hai giá trị đều hợp lệ.")  

      Nếu chúng tôi nhập các giá trị 5 0 cho a b tương ứng, kết quả đầu ra là:

        Vui lòng nhập các giá trị hợp lệ. phép chia cho không  

      Nhưng nếu cả hai giá trị đều hợp lệ, ví dụ: 5 4 cho a b tương ứng, mệnh đề else chạy sau khi try hoàn tất và chúng tôi thấy:

        1,25
      Cả hai giá trị đều hợp lệ.  

      thử / ngoại trừ / < mã> khác / cuối cùng trong Python

      Chúng ta cũng có thể thêm mệnh đề cuối cùng nếu chúng ta cần chạy mã luôn chạy, ngay cả khi một ngoại lệ được đưa ra trong try .

      Ví dụ:

        a = int (input (" Nhập: "))
      b = int (input ("Nhập b:"))
      
      thử:
          phép chia = a / b
          in (chia)
      ngoại trừ ZeroDivisionError as err:
          print ("Vui lòng nhập các giá trị hợp lệ.", err)
      khác:
          print ("Cả hai giá trị đều hợp lệ.")
      cuối cùng:
          print ("Cuối cùng!")  

      Nếu cả hai giá trị đều hợp lệ, kết quả đầu ra là kết quả của phép chia và:

        Cả hai giá trị đều hợp lệ.
      Cuối cùng!  

      Và nếu một ngoại lệ được đưa ra vì b 0 , chúng ta sẽ thấy:

        Vui lòng nhập các giá trị hợp lệ. chia cho số không
      Cuối cùng!  

      Mệnh đề last luôn chạy.

      💡 Mẹo: mệnh đề này có thể được sử dụng, để ví dụ: để đóng tệp ngay cả khi mã ném ra một ngoại lệ.

      🔸 Object-Oriented Programming in Python

      In Object -Oriented Programming (OOP), chúng tôi định nghĩa các lớp hoạt động như bản thiết kế để tạo các đối tượng trong Python với các thuộc tính và phương thức (chức năng được liên kết với các đối tượng).

      Đây là cú pháp chung để định nghĩa một lớp:

        class & lt; ClassName & gt ;:
      
          & lt; class_attribute_name & gt; = & lt; giá trị & gt;
      
          def __init __ (self, & lt; param1 & gt ;, & lt; param2 & gt ;, ...):
              bản thân. & lt; attr1 & gt; = & lt; param1 & gt;
              bản thân. & lt; attr2 & gt; = & lt; param2 & gt;
              .
              .
              .
              # Nhiều thuộc tính nếu cần
          
         def & lt; method_name & gt; (self, & lt; param1 & gt ;, ...):
             & lt; mã & gt;
             
         # Nhiều phương thức nếu cần  

      💡 Mẹo: self đề cập đến một thể hiện của lớp (một đối tượng được tạo bằng bản thiết kế lớp ).

      Như bạn thấy, một lớp có thể có nhiều phần tử khác nhau, vì vậy hãy phân tích chúng một cách chi tiết:

      Class Header

      Dòng đầu tiên của định nghĩa lớp có từ khóa class và tên của lớp:

        class Dog:  
        class House:
       
        class Ball:  

      💡 Mẹo: Nếu lớp kế thừa các thuộc tính và phương thức từ một lớp khác, chúng tôi sẽ thấy tên của lớp trong dấu ngoặc đơn:

        class Poodle (Dog):  
        class Truck (Xe):  
        class Mom (FamilyMember):  

      Trong Python, chúng ta viết tên lớp trong Upper Camel Case (còn được gọi là Pascal Case), trong đó mỗi từ bắt đầu bằng một chữ cái viết hoa. Ví dụ: FamilyMember

      __init__ và thuộc tính phiên bản

      Chúng ta sẽ để sử dụng lớp để tạo đối tượng trong Python, giống như chúng ta xây dựng những ngôi nhà thực sự từ các bản thiết kế.

      Các đối tượng sẽ có các thuộc tính mà chúng ta xác định trong lớp. Thông thường, chúng tôi khởi tạo các thuộc tính này trong __init__ . Đây là một phương thức chạy khi chúng ta tạo một thể hiện của lớp.

      Đây là cú pháp chung:

        def __init __ (self, & lt; parameter1 & gt ;, & lt; parameter2 & gt ;, ...):
              bản thân. & lt; thuộc tính1 & gt; = & lt; tham số1 & gt; # Thuộc tính phiên bản
              bản thân. & lt; thuộc tính2 & gt; = & lt; tham số2 & gt; # Thuộc tính phiên bản
              .
              .
              .
              # Có nhiều thuộc tính phiên bản nếu cần  

      Chúng tôi chỉ định nhiều tham số nếu cần để tùy chỉnh các giá trị của thuộc tính của đối tượng sẽ được tạo.

      Đây là một ví dụ về lớp Dog với phương thức này:

        class Dog:
      
          def __init __ (tự, tên, tuổi):
              self.name = tên
              self.age = age  

      💡 Mẹo: để ý dấu gạch dưới kép ở đầu và cuối trong tên __init__ .

      Cách tạo phiên bản

      Để tạo một cá thể của Dog , chúng ta cần chỉ định tên và tuổi của cá thể chó để gán các giá trị này cho các thuộc tính:

        my_dog = Dog ("Nora", 10)  

      Tuyệt vời. Bây giờ chúng ta đã có thể hiện sẵn sàng để sử dụng trong chương trình.

      Một số lớp sẽ không yêu cầu bất kỳ đối số nào để tạo thể hiện. Trong trường hợp đó, chúng ta chỉ viết các dấu ngoặc đơn trống. Ví dụ:

        class Circle:
      
          def __init __ (bản thân):
              self.radius = 1  

      Để tạo một phiên bản:

        & gt; & gt; & gt; my_circle = Circle ()  

      💡 Mẹo: self giống như một tham số hoạt động "đằng sau hậu trường", vì vậy ngay cả khi bạn hãy xem nó trong định nghĩa phương thức, bạn không nên xem xét nó khi chuyển các đối số.

      Đối số mặc định

      Chúng tôi cũng có thể chỉ định giá trị mặc định cho các thuộc tính và cung cấp tùy chọn cho người dùng nếu họ muốn tùy chỉnh giá trị.

      Trong trường hợp này, chúng tôi sẽ viết & lt; thuộc tính & gt; = & lt; value & gt; trong danh sách các tham số.

      Đây là một ví dụ:

        class Circle:
      
          def __init __ (self, radius = 1):
              self.radius = radius  

      Bây giờ chúng ta có thể tạo một cá thể Circle với giá trị mặc định cho bán kính bằng cách bỏ qua giá trị hoặc tùy chỉnh nó bằng cách chuyển một giá trị: < / p>

        # Giá trị mặc định
      & gt; & gt; & gt; my_circle1 = Vòng kết nối ()
      
      # Giá trị tùy chỉnh
      & gt; & gt; & gt; my_circle2 = Circle (5)  

      Cách lấy thuộc tính phiên bản

      Để truy cập thuộc tính phiên bản , chúng tôi sử dụng cú pháp này:

        & lt; object_variable & gt;. & lt; property & gt;  

      Ví dụ:

        # Định nghĩa lớp
      & gt; & gt; & gt; lớp chó:
      
          def __init __ (tự, tên, tuổi):
              self.name = tên
              self.age = tuổi
      
      # Tạo phiên bản
      & gt; & gt; & gt; my_dog = Con chó ("Nora", 10)
      
      # Nhận thuộc tính
      & gt; & gt; & gt; my_dog.name
      'Nora'
      
      & gt; & gt; & gt; my_dog.age
      10  

      Để cập nhật thuộc tính phiên bản, chúng tôi sử dụng cú pháp sau:

        & lt; object_variable & gt;. & Lt; property & gt; = & lt; new_value & gt;  

      Ví dụ:

        & gt; & gt; & gt; lớp chó:
      
          def __init __ (tự, tên, tuổi):
              self.name = tên
              self.age = tuổi
      
              
      & gt; & gt; & gt; my_dog = Con chó ("Nora", 10)
      
      & gt; & gt; & gt; my_dog.name
      'Nora'
      
      # Cập nhật thuộc tính
      & gt; & gt; & gt; my_dog.name = "Norita"
      
      & gt; & gt; & gt; my_dog.name
      'Norita'  

      Cách xóa thuộc tính phiên bản

      Để xóa thuộc tính phiên bản, chúng tôi sử dụng cú pháp này:

        del & lt; object_variable & gt;. & lt; property & gt;  

      Ví dụ:

        & gt; & gt; & gt; lớp chó:
      
          def __init __ (tự, tên, tuổi):
              self.name = tên
              self.age = tuổi
      
              
      & gt; & gt; & gt; my_dog = Con chó ("Nora", 10)
      
      & gt; & gt; & gt; my_dog.name
      'Nora'
      
      # Xóa thuộc tính này
      & gt; & gt; & gt; del my_dog.name
      
      & gt; & gt; & gt; my_dog.name
      Traceback (cuộc gọi gần đây nhất cuối cùng):
        Tệp "& lt; pyshell # 77 & gt;", dòng 1, trong & lt; mô-đun & gt;
          my_dog.name
      AttributeError: Đối tượng 'Dog' không có thuộc tính 'name'  

      Cách xóa phiên bản

      Tương tự, chúng ta có thể xóa một phiên bản bằng cách sử dụng del :

        & gt; & gt; & gt; lớp chó:
      
          def __init __ (tự, tên, tuổi):
              self.name = tên
              self.age = tuổi
      
              
      & gt; & gt; & gt; my_dog = Con chó ("Nora", 10)
      
      & gt; & gt; & gt; my_dog.name
      'Nora'
      
      # Xóa phiên bản
      & gt; & gt; & gt; del my_dog
      
      & gt; & gt; & gt; con chó của tôi
      Traceback (cuộc gọi gần đây nhất cuối cùng):
        Tệp "& lt; pyshell # 79 & gt;", dòng 1, trong & lt; mô-đun & gt;
          con chó của tôi
      NameError: name 'my_dog' không được xác định  

      Public so với Non-Public Attributes trong Python

      Trong Python, chúng tôi không có các công cụ sửa đổi quyền truy cập để hạn chế quyền truy cập vào các thuộc tính cá thể, vì vậy chúng tôi dựa vào các quy ước đặt tên để chỉ định điều này.

      Ví dụ: bằng cách thêm dấu gạch dưới ở đầu, chúng tôi có thể báo hiệu cho các nhà phát triển khác rằng một thuộc tính được coi là không công khai.

      Ví dụ:

        class Dog:
      
          def __init __ (tự, tên, tuổi):
              self.name = name # Thuộc tính công khai
              self._age = age # Thuộc tính không công khai  

      Tài liệu Python đề cập đến:

      Chỉ sử dụng một dấu gạch dưới ở đầu cho các phương thức không công khai và biến phiên bản.

      Luôn quyết định xem các phương thức và biến cá thể của một lớp (gọi chung: "thuộc tính") nên công khai hay không công khai. Nếu nghi ngờ, hãy chọn không công khai; sau này đặt thuộc tính công khai dễ dàng hơn là đặt thuộc tính công khai không công khai.

      Thuộc tính không công khai là những thuộc tính không được bên thứ ba sử dụng; bạn không đảm bảo rằng các thuộc tính không công khai sẽ không thay đổi hoặc thậm chí bị xóa. - nguồn

      Tuy nhiên, như tài liệu cũng đề cập:

      Chúng tôi không sử dụng thuật ngữ "riêng tư" ở đây, vì không có thuộc tính nào thực sự là riêng tư trong Python (không có số lượng công việc thường không cần thiết). - source

      💡 Mẹo: về mặt kỹ thuật, chúng tôi vẫn có thể truy cập và sửa đổi thuộc tính nếu chúng tôi thêm dấu gạch dưới ở đầu vào tên của nó, nhưng chúng tôi không nên ' t.

      Class Attribute trong Python

      Các thuộc tính class được chia sẻ bởi tất cả các trường hợp của lớp. Tất cả họ đều có quyền truy cập vào thuộc tính này và họ cũng sẽ bị ảnh hưởng bởi bất kỳ thay đổi nào được thực hiện đối với các thuộc tính này.

        class Dog:
      
          # Thuộc tính lớp
          vương quốc = "Animalia"
          loài = "Canis lupus"
      
          def __init __ (tự, tên, tuổi):
              self.name = tên
              self.age = age  

      💡 Mẹo: thông thường, chúng được viết trước phương thức __init__ .

      Cách Lấy Thuộc tính Lớp

      Để nhận giá trị của thuộc tính lớp, chúng ta sử dụng cú pháp sau:

       < mã> & lt; class_name & gt;. & lt; thuộc tính & gt;  

      Ví dụ:

        & gt; & gt; & gt; lớp chó:
      
          vương quốc = "Animalia"
      
          def __init __ (tự, tên, tuổi):
              self.name = tên
              self.age = tuổi
      
              
      & gt; & gt; & gt; Dog.kingdom
      'Animalia'  

      💡 Mẹo: Bạn cũng có thể sử dụng cú pháp này trong lớp.

      Để cập nhật thuộc tính lớp, chúng tôi sử dụng cú pháp này:

        & lt; class_name & gt;. & lt; thuộc tính & gt; = & lt; value & gt;  

      Ví dụ:

        & gt; & gt; & gt; lớp chó:
      
          vương quốc = "Animalia"
      
          def __init __ (tự, tên, tuổi):
              self.name = tên
              self.age = tuổi
      
              
      & gt; & gt; & gt; Dog.kingdom
      'Animalia'
      
      & gt; & gt; & gt; Dog.kingdom = "Vương quốc mới"
      
      & gt; & gt; & gt; Dog.kingdom
      'Vương quốc mới'  

      Cách xóa thuộc tính lớp

      Chúng tôi sử dụng del < / code> để xóa một thuộc tính lớp. Ví dụ:

        & gt; & gt; & gt; lớp chó:
      
          vương quốc = "Animalia"
      
          def __init __ (tự, tên, tuổi):
              self.name = tên
              self.age = tuổi
      
      & gt; & gt; & gt; Dog.kingdom
      'Animalia'
              
      # Xóa thuộc tính lớp
      & gt; & gt; & gt; del Dog.kingdom
      
      & gt; & gt; & gt; Dog.kingdom
      Traceback (cuộc gọi gần đây nhất cuối cùng):
        Tệp "& lt; pyshell # 88 & gt;", dòng 1, trong & lt; mô-đun & gt;
          Dog.kingdom
      AttributeError: nhập đối tượng 'Con chó' không có thuộc tính 'vương quốc'  

      Cách xác định phương thức

      Các phương thức đại diện cho chức năng của các thể hiện của lớp.

      💡 Mẹo: Các phương thức đối tượng có thể hoạt động với các thuộc tính của thể hiện đang gọi phương thức nếu chúng ta viết self. & lt; thuộc tính & gt ; trong định nghĩa phương thức.

      Đây là cú pháp cơ bản của một phương thức trong một lớp. Chúng thường nằm bên dưới __init__ :

        class & lt; ClassName & gt ;:
      
          # Thuộc tính lớp
      
          # __trong đó__
      
          def & lt; method_name & gt; (self, & lt; param1 & gt ;, ...):
              & lt; code & gt;  

      Chúng có thể không có, một hoặc nhiều tham số nếu cần (giống như các hàm!) nhưng các phương thức phiên bản phải luôn có self làm đầu tiên tham số.

      Ví dụ, đây là một phương thức shell không có tham số (ngoài self ):

        class Dog:
      
          def __init __ (tự, tên, tuổi):
              self.name = tên
              self.age = tuổi
      
          def vỏ (bản thân):
              print (f "woof-woof. Tôi là {self.name}")  

      Để gọi phương thức này, chúng tôi sử dụng cú pháp sau:

        & lt ; object_variable & gt;. & lt; method & gt; (& lt; objects & gt;)  

      Ví dụ:

        # Tạo phiên bản
      & gt; & gt; & gt; my_dog = Con chó ("Nora", 10)
      
      # Gọi phương thức
      & gt; & gt; & gt; my_dog.bark ()
      gâu gâu. Tôi là Nora  

      Ở đây chúng tôi có một lớp Player với phương thức increment_speed với một tham số:

        class Player:
      
          def __init __ (tự, tên):
              self.name = tên
              self.speed = 50
      
          def increment_speed (self, value):
              self.speed + = value  

      Để gọi phương thức:

        # Tạo phiên bản
      & gt; & gt; & gt; my_player = Người chơi ("Nora")
      
      # Kiểm tra tốc độ ban đầu để xem sự thay đổi
      & gt; & gt; & gt; my_player.speed
      50
      
      # Tăng tốc độ
      & gt; & gt; & gt; my_player.increment_speed (5)
      
      # Xác nhận thay đổi
      & gt; & gt; & gt; my_player.speed
      55  

      💡 Mẹo: để thêm các tham số khác, chỉ cần phân tách chúng bằng dấu phẩy. Bạn nên thêm dấu cách sau dấu phẩy.

      Thuộc tính, Getters và Setters trong Python

      Getters và setters là các phương thức mà chúng ta có thể xác định để lấy và đặt giá trị của một phiên bản thuộc tính tương ứng. Chúng hoạt động như những người trung gian để "bảo vệ" các thuộc tính khỏi những thay đổi trực tiếp.

      Trong Python, chúng tôi thường sử dụng thuộc tính thay vì getters và setters. Hãy xem chúng ta có thể sử dụng chúng như thế nào.

      Để xác định một thuộc tính, chúng ta viết một phương thức với cú pháp sau:

        @property
      def & lt; property_name & gt; (self):
          return self. & lt; thuộc tính & gt;  

      Phương thức này sẽ hoạt động như một getter, vì vậy nó sẽ được gọi khi chúng tôi cố gắng truy cập vào giá trị của thuộc tính.

      Bây giờ , chúng tôi cũng có thể muốn xác định một bộ định mức:

        @ & lt; property_name & gt; .setter
      def & lt; property_name & gt; (self, & lt; param & gt;):
          bản thân. & lt; thuộc tính & gt; = & lt; param & gt;  

      Và dấu xóa để xóa thuộc tính:

        @ & lt; property_name & gt; .deleter
      def & lt; property_name & gt; (self):
          del self. & lt; thuộc tính & gt;  

      💡 Mẹo: bạn có thể viết bất kỳ mã nào bạn cần trong các phương pháp này để lấy, đặt và xóa một thuộc tính. Bạn nên giữ chúng càng đơn giản càng tốt.

      Đây là ví dụ:

        class Dog:
      
          def __init __ (tự, tên):
              self._name = name
      
          @tài sản
          tên def (tự):
              trả về self._name
      
          @ name.setter
          def name (self, new_name):
              self._name = new_name
      
          @ name.deleter
          tên def (tự):
              del self._name  

      Nếu chúng tôi thêm các câu lệnh in mô tả, chúng tôi có thể thấy rằng chúng được gọi khi chúng tôi thực hiện thao tác của chúng:

        & gt; & gt; & gt; lớp chó:
      
          def __init __ (tự, tên):
              self._name = name
      
          @tài sản
          tên def (tự):
              print ("Đang gọi")
              trả về self._name
      
          @ name.setter
          def name (self, new_name):
              print ("Bộ cài đặt cuộc gọi")
              self._name = new_name
      
          @ name.deleter
          tên def (tự):
              print ("Trình xóa cuộc gọi")
              del self._name
      
              
      & gt; & gt; & gt; my_dog = Con chó ("Nora")
      
      & gt; & gt; & gt; my_dog.name
      Gọi getter
      'Nora'
      
      & gt; & gt; & gt; my_dog.name = "Norita"
      Người đặt cuộc gọi
      
      & gt; & gt; & gt; my_dog.name
      Gọi getter
      'Norita'
      
      & gt; & gt; & gt; del my_dog.name
      Gọi deleter  

      🔹 Cách làm việc với tệp trong Python

      Làm việc với tệp là rất quan trọng để tạo ra các chương trình mạnh mẽ. Hãy xem cách bạn có thể thực hiện việc này trong Python.

      How to Read Files in Python

      Trong Python, bạn nên sử dụng câu lệnh with để làm việc với các tệp vì nó chỉ mở chúng khi chúng ta cần và nó tự động đóng chúng khi quá trình hoàn tất.

      Để đọc một tệp, chúng tôi sử dụng cú pháp này:

        with open ("& lt; file_path & gt;") as & lt; file_var & gt ;:
          & lt; code & gt;  

      Chúng tôi cũng có thể chỉ định rằng chúng tôi muốn mở tệp ở chế độ đọc bằng "r" :

       < code class = "language-python"> với open ("& lt; file_path & gt;", "r") dưới dạng & lt; file_var & gt ;:
          & lt; code & gt;  

      Nhưng đây đã là chế độ mặc định để mở tệp, vì vậy chúng ta có thể bỏ qua nó như trong ví dụ đầu tiên.

      Đây là một ví dụ:

        với tệp đang mở ("nổi tiếng_quotes.txt"):
          cho dòng trong tệp:
              print (line)  

      hoặc ...

        với open ("known_quotes.txt", "r") là tập tin:
          cho dòng trong tệp:
              print (line)  

      💡 Mẹo: đúng vậy! Chúng ta có thể lặp lại các dòng của tệp bằng vòng lặp for. Đường dẫn tệp có thể liên quan đến tập lệnh Python mà chúng tôi đang chạy hoặc nó có thể là một đường dẫn tuyệt đối.

      Cách thực hiện Ghi vào tệp bằng Python

      Có hai cách để ghi vào tệp. Bạn có thể thay thế toàn bộ nội dung của tệp trước khi thêm nội dung mới hoặc nối vào nội dung hiện có.

        with open ("& lt; file_path & gt;", "w") dưới dạng & lt; file_var & gt ;:
          & lt; code & gt;  

      Để thay thế hoàn toàn nội dung, chúng tôi sử dụng chế độ "w" , vì vậy chúng tôi chuyển chuỗi này làm đối số thứ hai cho open () . Chúng tôi gọi phương thức .write () trên đối tượng tệp chuyển nội dung mà chúng tôi muốn viết dưới dạng đối số.

      Ví dụ:

        words = ["Amazing", "Green", "Python", "Code"]
      
      với mở ("nổi tiếng_quotes.txt", "w") dưới dạng tệp:
          từng từ trong từ:
              file.write (word + "\ n")  

      Khi bạn chạy chương trình, một tệp mới sẽ được tạo nếu nó chưa tồn tại trong đường dẫn mà chúng tôi đã chỉ định.

      Đây sẽ là nội dung của tệp:

        Amazing
      màu xanh lá
      Python
      Mã  

      Cách nối vào tệp bằng Python

      Tuy nhiên, nếu bạn muốn nối thêm nội dung, bạn cần sử dụng chế độ "a" :

        với open ("& lt; file_path & gt;" , "a") dưới dạng & lt; file_var & gt ;:
          & lt; mã & gt;
       

      Ví dụ:

        words = ["Amazing", "Green", "Python", "Code"]
      
      với open ("nổi tiếng_quotes.txt", "a") dưới dạng tệp:
          từng từ trong từ:
              file.write (word + "\ n")  

      Thay đổi nhỏ này sẽ giữ nguyên nội dung hiện có của tệp và nó sẽ thêm nội dung mới vào cuối.

      Nếu chúng tôi chạy lại chương trình, các chuỗi này sẽ được thêm vào cuối tệp:

        Amazing
      màu xanh lá
      Python
      Mã số
      Kinh ngạc
      màu xanh lá
      Python
      Mã số
       

      Cách xóa tệp bằng Python

      Để xóa tệp bằng tập lệnh của chúng tôi, chúng ta có thể sử dụng mô-đun os . Bạn nên kiểm tra với một điều kiện nếu tệp tồn tại trước khi gọi hàm remove () từ mô-đun này:

        import os
      
      nếu os.path.exists ("& lt; file_path & gt;"):
        os.remove ("& lt; file_path & gt;")
      khác:
        & lt; code & gt;  

      Ví dụ:

        import os
      
      nếu os.path.exists ("nổi tiếng_quotes.txt"):
        os.remove ("nổi tiếng_quotes.txt")
      khác:
        print ("Tệp này không tồn tại")  

      Bạn có thể nhận thấy dòng đầu tiên cho biết import os . Đây là một câu lệnh nhập. Hãy xem tại sao chúng hữu ích và cách bạn có thể làm việc với chúng.

      🔸 Nhập câu lệnh bằng Python

      Tổ chức mã của bạn thành nhiều khi chương trình của bạn phát triển về kích thước và độ phức tạp là một phương pháp hay. Nhưng chúng tôi cần tìm cách kết hợp các tệp này để làm cho chương trình hoạt động chính xác và đó chính xác là những gì các câu lệnh nhập thực hiện.

      Bằng cách viết câu lệnh nhập, chúng tôi có thể nhập một mô-đun (một tệp chứa Định nghĩa và câu lệnh Python) vào một tệp khác.

      Đây là các lựa chọn thay thế khác nhau cho các câu lệnh nhập:

      Thay thế đầu tiên:

       < code> import & lt; module_name & gt;  

      Ví dụ:

        import toán  

      💡 Mẹo: math là một mô-đun Python được tích hợp sẵn.

      Nếu chúng tôi sử dụng câu lệnh nhập này, chúng tôi sẽ cần thêm tên của mô-đun trước tên của hàm hoặc phần tử mà chúng tôi đang đề cập đến trong mã của mình:

        & gt; & gt; & gt; nhập toán
      & gt; & gt; & gt; math.sqrt (25)
      5.0  

      Chúng tôi đề cập rõ ràng trong mã của mình mô-đun chứa phần tử đó.

      Thay thế thứ hai:

        nhập & lt; mô-đun & gt; dưới dạng & lt; new_name & gt;  

      Ví dụ:

        nhập toán dưới dạng m  

      Trong mã của chúng tôi, chúng tôi có thể sử dụng tên mới mà chúng tôi đã gán thay cho tên ban đầu của mô-đun:

        & gt; & gt; & gt; nhập toán dưới dạng m
      & gt; & gt; & gt; m.sqrt (25)
      5.0  

      Thay thế Thứ ba:

        từ & lt; module_name & gt; import & lt; element & gt;  

      Ví dụ:

        from math import sqrt  

      Với câu lệnh nhập này, chúng tôi có thể gọi hàm trực tiếp mà không cần xác định tên của mô-đun:

        & gt; & gt; & gt; từ toán học nhập sqrt
      & gt; & gt; & gt; sqrt (25)
      5.0  

      Giải pháp thay thế thứ tư:

        từ & lt; module_name & gt; nhập & lt; phần tử & gt; dưới dạng & lt; new_name & gt;  

      Ví dụ:

        from math import sqrt dưới dạng square_root  

      Với câu lệnh nhập này, chúng ta có thể gán tên mới cho phần tử được nhập từ mô-đun:

        & gt; & gt; & gt; từ toán học nhập sqrt dưới dạng square_root
      & gt; & gt; & gt; square_root (25)
      5.0  

      Thay thế thứ năm:

        từ & lt; module_name & gt; import *  

      Câu lệnh này nhập tất cả các phần tử của mô-đun và bạn có thể tham chiếu trực tiếp đến chúng bằng tên của chúng mà không cần chỉ định tên của mô-đun.

      Ví dụ:

        & gt; & gt; & gt; từ nhập toán học *
      
      & gt; & gt; & gt; sqrt (25)
      5.0
      
      & gt; & gt; & gt; giai thừa (5)
      120
      
      & gt; & gt; & gt; tầng (4,6)
      4
      
      & gt; & gt; & gt; gcd (5, 8)
      1  

      💡 Mẹo: loại câu lệnh nhập này có thể khiến chúng tôi khó biết phần tử nào thuộc về mô-đun nào, đặc biệt khi chúng tôi nhập phần tử từ nhiều mô-đun.

      Theo Hướng dẫn về kiểu cho mã Python :

      Nhập ký tự đại diện (từ & lt; mô-đun & gt; nhập * ) nên tránh, vì chúng làm cho không rõ tên nào hiện diện trong không gian tên, gây nhầm lẫn cho cả người đọc và nhiều công cụ tự động. Danh sách và hiểu từ điển trong Python

      Một tính năng thực sự hay của Python mà bạn nên biết là khả năng hiểu danh sách và từ điển. Đây chỉ là một cách để tạo danh sách và từ điển nhỏ gọn hơn.

      Hiểu danh sách trong Python

      Cú pháp được sử dụng để xác định mức độ hiểu danh sách thông thường tuân theo một trong bốn mẫu sau:

        [& lt; value_to_include & gt; cho & lt; var & gt; trong & lt; dãy & gt;]  
        [& lt; value_to_include & gt; cho & lt; var1 & gt; trong & lt; sequence1 & gt; cho & lt; var2 & gt; trong & lt; sequence2 & gt;]  
        [& lt; value_to_include & gt; cho & lt; var & gt; trong & lt; trình tự & gt; nếu & lt; điều kiện & gt;]  
        [& lt; value & gt; cho & lt; var1 & gt; trong & lt; sequence1 & gt; cho & lt; var2 & gt; trong & lt; sequ2 & gt; if & lt; condition & gt;]  

      💡 Mẹo: bạn chỉ nên sử dụng chúng khi chúng không làm cho mã của bạn khó đọc và khó hiểu hơn.

      Dưới đây chúng tôi có một số ví dụ:

        & gt; & gt; & gt; [i for i in range (4, 15)]
      [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
      
      & gt; & gt; & gt; [chr (i) for i in range (67, 80)]
      ['C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', ' O ']
      
      & gt; & gt; & gt; [i ** 3 cho tôi trong phạm vi (2, 5)]
      [8, 27, 64]
      
      & gt; & gt; & gt; [i + j cho tôi trong phạm vi (5, 8) cho j trong phạm vi (3, 6)]
      [8, 9, 10, 9, 10, 11, 10, 11, 12]
      
      & gt; & gt; & gt; [k cho k trong phạm vi (3, 35) nếu k% 2 == 0]
      [4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34]
      
      & gt; & gt; & gt; [i * j cho tôi trong phạm vi (2, 6) cho j trong phạm vi (3, 7) nếu tôi% j == 0]
      [9, 16, 25]  

      Danh sách hiểu rõ so với Biểu thức Generator trong Python

      Phần hiểu danh sách được xác định bằng dấu ngoặc vuông [] . Điều này khác với các biểu thức trình tạo, được định nghĩa bằng dấu ngoặc đơn () . Chúng trông giống nhau nhưng chúng khá khác nhau. Hãy xem lý do tại sao.

      • Khả năng hiểu danh sách tạo toàn bộ chuỗi cùng một lúc và lưu trữ trong bộ nhớ.
      • Biểu thức trình tạo cung cấp từng phần tử một khi chúng được yêu cầu.

      Chúng tôi có thể kiểm tra điều này bằng mô-đun sys . Trong ví dụ dưới đây, bạn có thể thấy rằng kích thước của chúng trong bộ nhớ rất khác nhau:

        & gt; & gt; & gt; nhập hệ thống
      & gt; & gt; & gt; sys.getsizeof ([i for i in range (500)])
      2132
      & gt; & gt; & gt; sys.getsizeof ((tôi cho tôi trong phạm vi (500)))
      56  

      Chúng ta có thể sử dụng các biểu thức trình tạo để lặp lại trong vòng lặp for và lấy các phần tử tại một thời điểm. Nhưng nếu chúng ta cần lưu trữ các phần tử trong một danh sách, thì chúng ta nên sử dụng khả năng hiểu danh sách.

      Hiểu từ điển trong Python

      Bây giờ chúng ta hãy đi sâu vào hiểu từ điển. Cú pháp cơ bản mà chúng ta cần sử dụng để xác định khả năng hiểu từ điển là:

        {& lt; key_value & gt ;: & lt; value & gt; cho & lt; var & gt; trong & lt; dãy & gt;}  
        {& lt; key_value & gt ;: & lt; value & gt; cho & lt; var & gt; trong & lt; trình tự & gt; if & lt; condition & gt;}  

      Ở đây chúng tôi có một số ví dụ về cách hiểu từ điển:

        & gt; & gt; & gt; {num: num ** 3 cho num trong phạm vi (3, 15)}
      {3: 27, 4: 64, 5: 125, 6: 216, 7: 343, 8: 512, 9: 729, 10: 1000, 11: 1331, 12: 1728, 13: 2197, 14: 2744}
      
      & gt; & gt; & gt; {x: x + y cho x trong khoảng (4, 8) cho y trong khoảng (3, 7)}
      {4: 10, 5: 11, 6: 12, 7: 13}  

      Đây là một ví dụ có điều kiện trong đó chúng tôi lấy một từ điển hiện có và tạo một từ điển mới chỉ dành cho sinh viên đạt điểm đậu cao hơn hoặc bằng 60:

        & gt; & gt; & gt; Grade = {"Nora": 78, "Gino": 100, "Talina": 56, "Elizabeth": 45, "Lulu": 67}
      
      & gt; & gt; & gt; Appro_students = {student: điểm cho (học sinh, lớp) trong lớp.items () nếu lớp & gt; = 60}
      
      & gt; & gt; & gt; người học được chấp thuận
      {'Nora': 78, 'Gino': 100, 'Lulu': 67}  

      Tôi thực sự hy vọng bạn thích bài viết này và thấy nó hữu ích. Giờ đây, bạn đã biết cách viết và làm việc với các yếu tố quan trọng nhất của Python.

      Đăng ký kênh YouTube của tôi và theo dõi tôi trên Twitter để tìm thêm các hướng dẫn và mẹo viết mã. Hãy xem khóa học trực tuyến của tôi Bài tập Python cho người mới bắt đầu: Giải quyết hơn 100 thách thức lập trình


Xem thêm những thông tin liên quan đến chủ đề hướng dẫn python cho người mới bắt đầu với các ví dụ

Lập Trình Game Flappy Bird với Python Cho Người Mới Bắt Đầu

  • Tác giả: CodeXplore
  • Ngày đăng: 2021-08-14
  • Đánh giá: 4 ⭐ ( 1542 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: Lập Trình Game Flappy Bird với Python Cho Người Mới Bắt Đầu

    Hello Diu Túp, hôm nay chúng mình xin giới thiệu đến các bạn 1 video mới trong chuyên mục "Lập Trình Game Từ Số 0 với Python". Và chủ đề của Video hôm này đó chính là "Lập Trình Game Flappy Bird với PyGame Cho Người Mới Bắt Đầu" 🤩 !

    Flappy Bird (tạm dịch là "chú chim vỗ cánh") là một trò chơi điện tử trên điện thoại do Nguyễn Hà Đông, một lập trình viên ở Hà Nội, Việt Nam phát triển, và do dotGEARS, một studio phát triển game quy mô nhỏ, hoạt động độc lập có trụ sở tại Việt Nam phát hành vào năm 2013. Trò chơi được trình bày theo phong cách side-scroller (phong cách game với các đối tượng được nhìn thấy ở mặt bên (side-view) và di chuyển từ cạnh trái sang cạnh phải của màn hình), trong đó người chơi điều khiển một chú chim, cố gắng vượt qua các hàng ống màu xanh lá cây mà không chạm vào chúng.

    Folder Game dùng trong Video : https://github.com/CodexploreRepo/Python_Games/blob/main/5_Flappy_Bird/FileGame.rar

    ⏱ Timestamps
    [00:00:00]: Giới Thiệu Nội Dung Video "Lập Trình Game Flappy Bird với PyGame"
    [00:00:57]: Hướng Dẫn Cài đặt và Làm Quen Pygame
    [00:07:11]: Hướng Dẫn Chèn Background và Sàn của Game
    [00:17:31]: Hướng Dẫn Tạo Flappy Bird và Hệ Thống Ống
    [00:42:37]: Hướng Dẫn Xử Lý Va Chạm trong Game
    [00:52:56]: Hướng Dẫn Tạo chuyển động cho Flappy Bird
    [01:04:13]: Hướng Dẫn Tạo Hệ Thống Tính Điểm
    [01:18:55]: Hướng Dẫn Tạo Màn Hình Kết thúc
    [01:22:09]: Hướng Dẫn Xử Lý Âm Thanh

    ► Full Series "Lập Trình Python Cơ Bản": https://youtube.com/playlist?list=PLJcWUrckOCKK7tXpLTJJsl1MD98bQHHOg
    ► Full Series "Lập Trình Game Từ Số 0 với Python": https://youtube.com/playlist?list=PLJcWUrckOCKLM0vrH4TIuRQht8lYb39x6
    ► Full Series "Học Lập Trình Python qua Project": https://www.youtube.com/playlist?list=PLJcWUrckOCKI1wTYujg2EEnSTXn0QdhEE
    ► Full Series "Tự Học Data Science Cho Người Mới Bắt Đầu": https://youtube.com/playlist?list=PLJcWUrckOCKKwjjHALg6fnyQCHv8z92rs

    Group Hỏi Đáp: https://www.facebook.com/groups/204281000722812

    ------------- ✪ About CodeXplore Channel ✪ ------------
    CodeXplore là một platform chia sẻ kiến thức về Lập Trình và Trí Tuệ Nhân Tạo (AI) dành cho các bạn trẻ Việt Nam.

    Channel CodeXplore sẽ focus vào các chủ đề sau:
    ► Machine Learning (Máy Học) và Data Science (Khoa Học Dữ Liệu)
    ► Interview Preparation (Cấu Trúc Dữ Liệu và Thuật Toán & LeetCode Solutions)
    ► Lập Trình Python (Cơ Bản, Lập Trình Hướng Đối Tượng, Lập Trình Game)
    ------------------
    ✪ Business inquiries: codexplore.channel@gmail.com
    ✪ Subscribe: https://bit.ly/youtube_codexplore

    ➥ CodeXplore Social Links:
    Fanpage: https://www.facebook.com/CodeXplore.dev/
    GitHub: https://github.com/CodexploreRepo

    ----------------------------------------------/-------------
    © Bản quyền thuộc về CodeXplore
    © Copyright by CodeXplore & Do not Reup

    LậpTrìnhGame FlappyBird Pygame

Hướng dẫn lập trình Python cho người mới bắt đầu

  • Tác giả: openplanning.net
  • Đánh giá: 5 ⭐ ( 6397 lượt đánh giá )
  • Khớp với kết quả tìm kiếm:

Hướng dẫn học lập trình python cho người mới học

  • Tác giả: stanford.com.vn
  • Đánh giá: 5 ⭐ ( 2343 lượt đánh giá )
  • Khớp với kết quả tìm kiếm:

Hướng dẫn cho người mới bắt đầu: làm sao để học Python hiệu quả?

  • Tác giả: aptechbmt.edu.vn
  • Đánh giá: 5 ⭐ ( 2340 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: Làm sao để học python hiệu quả khi bạn muốn học và thành thạo ngôn ngữ lập trình này. Sau đây là 8 điều đơn giản sẽ giúp bạn thành công trong việc học

Tự học Python cho người mới bắt đầu -

  • Tác giả: vnpro.vn
  • Đánh giá: 4 ⭐ ( 2986 lượt đánh giá )
  • Khớp với kết quả tìm kiếm:

Học qua dự án Python cho người mới bắt đầu

  • Tác giả: nordiccoder.com
  • Đánh giá: 3 ⭐ ( 6810 lượt đánh giá )
  • Khớp với kết quả tìm kiếm:

Hướng dẫn tự học lập trình python từ cơ bản đến nâng cao

  • Tác giả: ironhackvietnam.edu.vn
  • Đánh giá: 4 ⭐ ( 5388 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: Tự học lập trình python có đơn giản như bạn nghĩ? Với các hướng dẫn tự học hiệu quả dưới đây, bạn sẽ thấy rằng học python trở nên dễ dàng hơn bao giờ hết.

Xem thêm các bài viết khác thuộc chuyên mục: Kiến thức lập trình

Xem Thêm  LEFT, RIGHT và SUBSTRING trong SQL Server - chuỗi con bên phải máy chủ sql

By ads_php