Hãy thảo luận về những cách Pythonic nhất để hoàn thành những vấn đề này. Chúng tôi bắt đầu với năm cách để thực hiện so sánh Boolean và xem xét năm cách để thực hiện sự khác biệt đơn giản, tiếp theo
So sánh Boolean
Cách Pythonic nhất để kiểm tra xem hai danh sách được sắp xếp có giống nhau không
Xem video này trên YouTube
Câu trả lời ngắn. Cách Pythonic nhất để kiểm tra xem hai danh sách có thứ tự
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True3 và
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True4 có giống hệt nhau hay không, là sử dụng toán tử
# 1. Simple Comparison
def method_1[l1, l2]:
return l1 == l2
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_1[l1, l2]]
# False0 để so sánh từng phần tử. Nếu tất cả các phần tử đều bằng nhau và độ dài của các danh sách giống nhau, thì giá trị trả về là l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True5
Vấn đề. Đưa ra là hai danh sách
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True3 và
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True4. Bạn muốn thực hiện So sánh Boolean. So sánh danh sách theo từng phần tử và trả về
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True5 nếu chỉ số so sánh của bạn trả về
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True5 cho tất cả các cặp phần tử và nếu không thì trả về
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True7
ví dụ
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True
Hãy thảo luận về những cách Pythonic nhất để giải quyết vấn đề này. Dưới đây là tổng quan về mã tương tác nhanh
Bài tập. Lướt qua tất cả các phương thức và chạy mã. Những câu hỏi đến với tâm trí?
Đọc tiếp để tìm hiểu chi tiết về từng phương pháp
Phương pháp 1. So sánh đơn giản
Không phải lúc nào phương pháp đơn giản nhất cũng là phương pháp tốt nhất. Nhưng đối với vấn đề cụ thể này, nó là. Toán tử đẳng thức
# 1. Simple Comparison
def method_1[l1, l2]:
return l1 == l2
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_1[l1, l2]]
# False7 so sánh phần tử danh sách một cách khôn ngoan—nhiều lập trình viên Python không biết điều này# 1. Simple Comparison
def method_1[l1, l2]:
return l1 == l2
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_1[l1, l2]]
# FalseVì vậy, nếu bạn chỉ muốn tìm hiểu về cách Pythonic nhất để giải quyết vấn đề này, thì không cần tìm đâu xa
Nhưng nếu bạn muốn đi sâu vào thế giới tuyệt vời của Python, tìm hiểu về các hàm Python thú vị và mạnh mẽ khác nhau, hãy đọc tiếp
Phương pháp 2. Đơn giản cho vòng lặp
Phương pháp sau đây là những gì bạn sẽ thấy từ một lập trình viên đến từ một ngôn ngữ lập trình khác hoặc từ một người mới bắt đầu không biết về toán tử đẳng thức trong danh sách [xem Phương pháp 1]
# 2. Simple For Loop
def method_2[l1, l2]:
for i in range[min[len[l1], len[l2]]]:
if l1[i] != l2[i]:
return False
return len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_2[l1, l2]]
# False
Trong mã, bạn lặp lại tất cả các chỉ số từ 0 đến vị trí cuối cùng của danh sách nhỏ nhất được xác định bởi phần
# 1. Simple Comparison
def method_1[l1, l2]:
return l1 == l2
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_1[l1, l2]]
# False8. Sau đó, bạn kiểm tra xem cả hai yếu tố ở cùng một vị trí có khác nhau không. Nếu chúng khác nhau, tôi. e. , # 1. Simple Comparison
def method_1[l1, l2]:
return l1 == l2
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_1[l1, l2]]
# False9, bạn có thể trả lại ngay l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True7 vì các danh sách cũng khác nhau
Nếu bạn đã đi qua toàn bộ vòng lặp mà không quay lại
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True7, thì các phần tử danh sách sẽ tương tự. Nhưng một danh sách vẫn có thể dài hơn. Vì vậy, bằng cách trả về
# 2. Simple For Loop
def method_2[l1, l2]:
for i in range[min[len[l1], len[l2]]]:
if l1[i] != l2[i]:
return False
return len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_2[l1, l2]]
# False
2, bạn đảm bảo chỉ trả về l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True5 nếu [1] tất cả các phần tử đều bằng nhau và [2] các danh sách có cùng độ dài
Rất nhiều mã để thực hiện một điều đơn giản như vậy. Hãy xem một lập trình viên giỏi hơn sẽ tận dụng hàm
# 2. Simple For Loop
def method_2[l1, l2]:
for i in range[min[len[l1], len[l2]]]:
if l1[i] != l2[i]:
return False
return len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_2[l1, l2]]
# False
4 như thế nào để giảm độ phức tạp của mãPhương pháp 3. zip[] + Đối với vòng lặp
Hàm zip lấy một số lần lặp và tổng hợp chúng thành một lần duy nhất bằng cách kết hợp các giá trị thứ i của mỗi lần lặp thành một bộ cho mỗi lần lặp i.
Hãy xem cách bạn có thể sử dụng hàm này để làm cho mã trước đó ngắn gọn hơn
# 3. Zip + For Loop
def method_3[l1, l2]:
for x, y in zip[l1, l2]:
if x != y:
return False
return len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_3[l1, l2]]
# False
Thay vì lặp qua các chỉ số, giờ đây bạn lặp qua các cặp phần tử [các phần tử được nén lại với nhau]. Nếu các danh sách có kích thước khác nhau, các phần tử còn lại trong danh sách dài hơn sẽ bị bỏ qua. Bằng cách này, việc so sánh từng phần tử trở nên đơn giản hơn và không yêu cầu các lược đồ lập chỉ mục phức tạp. Tránh các chỉ mục bằng hàm
# 2. Simple For Loop
def method_2[l1, l2]:
for i in range[min[len[l1], len[l2]]]:
if l1[i] != l2[i]:
return False
return len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_2[l1, l2]]
# False
4 chắc chắn là một cách Pythonic hơnPhương pháp 4. tổng[] + zip[] + len[]
Nhưng các lập trình viên Python thực sự thường sẽ tránh vòng lặp for và thay vào đó sử dụng biểu thức trình tạo
- Trước tiên, bạn tạo một giá trị Boolean có thể lặp lại bằng cách sử dụng biểu thức trình tạo
# 2. Simple For Loop def method_2[l1, l2]: for i in range[min[len[l1], len[l2]]]: if l1[i] != l2[i]: return False return len[l1] == len[l2] l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] print[method_2[l1, l2]] # False6 - Sau đó, bạn tính tổng các giá trị Boolean [một thủ thuật khác của pro coder] để tìm số phần tử giống nhau và lưu vào biến
# 2. Simple For Loop def method_2[l1, l2]: for i in range[min[len[l1], len[l2]]]: if l1[i] != l2[i]: return False return len[l1] == len[l2] l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] print[method_2[l1, l2]] # False7 - Cuối cùng, bạn so sánh điều này với độ dài của cả hai danh sách. Nếu cả ba giá trị đều giống nhau, thì cả hai danh sách đều có các phần tử giống nhau và độ dài của chúng cũng giống nhau. Họ đều bình đẳng
# 4. Sum + Zip + Len
def method_4[l1, l2]:
num_equal = sum[x == y for x, y in zip[l1, l2]]
return num_equal == len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_4[l1, l2]]
# False
print[method_4[[1, 2], [1, 2]]]
# True
Từ các phương thức ngoại trừ phương thức đầu tiên sử dụng toán tử
# 1. Simple Comparison
def method_1[l1, l2]:
return l1 == l2
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_1[l1, l2]]
# False7, đây là cách Pythonic nhất do sử dụng các hàm trợ giúp Python hiệu quả như # 2. Simple For Loop
def method_2[l1, l2]:
for i in range[min[len[l1], len[l2]]]:
if l1[i] != l2[i]:
return False
return len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_2[l1, l2]]
# False
9 và các biểu thức trình tạo để làm cho mã ngắn gọn hơn và dễ đọc hơnBạn cũng có thể viết điều này trong một dòng mã
sum[x == y for x, y in zip[l1, l2]] == len[l1] == len[l2]
Nếu bạn yêu thích Python one-liners, hãy xem cuốn sách mới Python One-liners của tôi với nhà xuất bản nổi tiếng quốc tế NoStarch press. [Liên kết Amazon]
Phương pháp 5. map[] + giảm[] + len[]
Phương pháp cuối cùng chỉ là rèn luyện kỹ năng lập trình chức năng của bạn
# 5. map[] + reduce[] + len[]
from functools import reduce
def method_5[l1, l2]:
equal = map[lambda x, y: x == y, l1, l2]
result = reduce[lambda x, y: x and y, equal]
return result and len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_5[l1, l2]]
# False
print[method_5[[1, 2, 3], [1, 2, 3]]]
# True
Hàm
# 3. Zip + For Loop
def method_3[l1, l2]:
for x, y in zip[l1, l2]:
if x != y:
return False
return len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_3[l1, l2]]
# False
0 kết hợp tất cả các cặp phần tử thành giá trị Boolean [hai phần tử có bằng nhau không?]. Hàm ____20_______1 kết hợp tất cả các giá trị Boolean thực hiện phép toán # 3. Zip + For Loop
def method_3[l1, l2]:
for x, y in zip[l1, l2]:
if x != y:
return False
return len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_3[l1, l2]]
# False
2. Chắc chắn rồi, bạn cũng có thể sử dụng biến thể ngắn gọn hơn bằng cách sử dụng hàm # 3. Zip + For Loop
def method_3[l1, l2]:
for x, y in zip[l1, l2]:
if x != y:
return False
return len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_3[l1, l2]]
# False
3Phương pháp 6. bản đồ[] + tất cả[]
Phương pháp này giống như phương pháp trước—nhưng sử dụng hàm
# 3. Zip + For Loop
def method_3[l1, l2]:
for x, y in zip[l1, l2]:
if x != y:
return False
return len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_3[l1, l2]]
# False
3 thay vì # 3. Zip + For Loop
def method_3[l1, l2]:
for x, y in zip[l1, l2]:
if x != y:
return False
return len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_3[l1, l2]]
# False
5 để kết hợp tất cả các giá trị Boolean trong toàn cục và phép toán# 6. map[] + all[]
def method_6[l1, l2]:
result = all[map[lambda x, y: x == y, l1, l2]]
return result and len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_5[l1, l2]]
# False
print[method_5[[1, 2, 3], [1, 2, 3]]]
# TrueNếu bạn muốn học điều gì đó mới mỗi ngày, hãy tham gia chuỗi email Python miễn phí của tôi để không ngừng cải thiện Python và khoa học máy tính
Bài báo gốc. Cách Pythonic nhất để kiểm tra xem hai danh sách được sắp xếp có giống nhau không
Sự khác biệt
Câu trả lời ngắn. Cách Pythonic nhất để tính toán sự khác biệt giữa hai danh sách
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True3 và
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True4 là câu lệnh hiểu danh sách
# 3. Zip + For Loop
def method_3[l1, l2]:
for x, y in zip[l1, l2]:
if x != y:
return False
return len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_3[l1, l2]]
# False
8. Điều này hoạt động ngay cả khi bạn có các mục nhập danh sách trùng lặp, nó duy trì thứ tự danh sách ban đầu và nó hiệu quả do độ phức tạp thời gian chạy liên tục của thao tác thành viên đã đặtCách tốt nhất để tính toán sự khác biệt giữa hai danh sách trong Python là gì?
a = [5, 4, 3, 2, 1] b = [4, 5, 6, 7] # a - b == [3, 2, 1] # b - a == [6, 7]
Hãy có một cái nhìn tổng quan trong vỏ mã tương tác sau đây
Bài tập. Chạy mã và suy nghĩ về cách ưa thích của bạn
Hãy đi sâu vào từng phương pháp để tìm ra phương pháp Pythonic nhất cho kịch bản cụ thể của bạn
Phương pháp 1. Đặt sự khác biệt
Cách tiếp cận đơn giản để giải quyết vấn đề này là chuyển đổi cả hai danh sách thành các tập hợp và sử dụng phép toán tập trừ [hoặc tập hợp]
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True0
Cách tiếp cận này thanh lịch vì nó dễ đọc, hiệu quả và ngắn gọn
Tuy nhiên, có một số thuộc tính duy nhất của phương pháp này mà bạn nên biết
- Kết quả là một tập hợp và không phải là một danh sách. Bạn có thể chuyển đổi nó trở lại danh sách bằng cách sử dụng hàm tạo
# 3. Zip + For Loop def method_3[l1, l2]: for x, y in zip[l1, l2]: if x != y: return False return len[l1] == len[l2] l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] print[method_3[l1, l2]] # False9 - Tất cả các mục nhập danh sách trùng lặp sẽ bị xóa trong quy trình vì các bộ không thể có các phần tử trùng lặp
- Thứ tự của danh sách ban đầu bị mất vì các bộ không duy trì thứ tự của các phần tử
Nếu cả ba thuộc tính đều được bạn chấp nhận, thì đây là cách tiếp cận hiệu quả nhất được đánh giá ở phần sau của bài viết này
Tuy nhiên, làm thế nào bạn có thể duy trì thứ tự của các phần tử danh sách ban đầu trong khi vẫn cho phép trùng lặp?
Phương pháp 2. Danh sách hiểu
Hiểu danh sách là một cách nhỏ gọn để tạo danh sách. Công thức đơn giản là
# 4. Sum + Zip + Len
def method_4[l1, l2]:
num_equal = sum[x == y for x, y in zip[l1, l2]]
return num_equal == len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_4[l1, l2]]
# False
print[method_4[[1, 2], [1, 2]]]
# True
0- Sự diễn đạt. Phải làm gì với từng phần tử danh sách?
- Định nghĩa bài văn. Những yếu tố để lựa chọn?
Bạn có thể sử dụng khả năng hiểu danh sách để xem qua tất cả các phần tử trong danh sách đầu tiên nhưng bỏ qua chúng nếu chúng nằm trong danh sách thứ hai
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True1
Chúng tôi đã sử dụng một cách tối ưu hóa nhỏ nhưng hiệu quả để chuyển đổi danh sách thứ hai
# 4. Sum + Zip + Len
def method_4[l1, l2]:
num_equal = sum[x == y for x, y in zip[l1, l2]]
return num_equal == len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_4[l1, l2]]
# False
print[method_4[[1, 2], [1, 2]]]
# True
3 thành một tập hợp đầu tiên. Lý do là việc kiểm tra tư cách thành viên # 4. Sum + Zip + Len
def method_4[l1, l2]:
num_equal = sum[x == y for x, y in zip[l1, l2]]
return num_equal == len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_4[l1, l2]]
# False
print[method_4[[1, 2], [1, 2]]]
# True
4 đối với bộ nhanh hơn nhiều so với đối với danh sách. Tuy nhiên, về mặt ngữ nghĩa, cả hai biến thể đều giống hệt nhauDưới đây là các thuộc tính đặc biệt của phương pháp này
- Kết quả của câu lệnh hiểu danh sách là một danh sách
- Thứ tự của danh sách ban đầu được duy trì
- Các yếu tố trùng lặp được duy trì
Nếu bạn dựa vào những đảm bảo mạnh mẽ hơn này, hãy sử dụng phương pháp hiểu danh sách vì đó là phương pháp Pythonic nhất
Phương pháp 3. Đơn giản cho vòng lặp
Đáng ngạc nhiên là một số hướng dẫn trực tuyến khuyên bạn nên sử dụng vòng lặp for lồng nhau [e. g. , những chàng trai ấy]
l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 5, 4] # compare[l1, l2] --> False l1 = [1, 2, 3, 4, 5] l2 = [1, 2, 3, 4, 5] # compare[l1, l2] --> True2
Theo tôi, cách tiếp cận này sẽ chỉ được sử dụng bởi những người mới bắt đầu hoặc lập trình viên đến từ các ngôn ngữ lập trình khác như C ++ hoặc Java và không biết các tính năng thiết yếu của Python như hiểu danh sách. Bạn có thể tối ưu hóa phương pháp này bằng cách chuyển đổi danh sách
# 4. Sum + Zip + Len
def method_4[l1, l2]:
num_equal = sum[x == y for x, y in zip[l1, l2]]
return num_equal == len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_4[l1, l2]]
# False
print[method_4[[1, 2], [1, 2]]]
# True
3 thành một tập hợp trước tiên để tăng tốc độ kiểm tra # 4. Sum + Zip + Len
def method_4[l1, l2]:
num_equal = sum[x == y for x, y in zip[l1, l2]]
return num_equal == len[l1] == len[l2]
l1 = [1, 2, 3, 4, 5]
l2 = [1, 2, 3]
print[method_4[l1, l2]]
# False
print[method_4[[1, 2], [1, 2]]]
# True
6 lên một mức đáng kểBài báo gốc. Liệt kê sự khác biệt. Cách Pythonic nhất
Đi đâu từ đây?
Đủ lý thuyết. Hãy thực hành một số
Các lập trình viên được trả sáu con số trở lên vì họ có thể giải quyết vấn đề hiệu quả hơn bằng cách sử dụng trí thông minh máy móc và tự động hóa
Để trở nên thành công hơn trong việc viết mã, hãy giải quyết nhiều vấn đề thực tế hơn cho người thực. Đó là cách bạn trau dồi những kỹ năng bạn thực sự cần trong thực tế. Rốt cuộc, việc sử dụng lý thuyết học tập mà không ai cần là gì?
Bạn xây dựng các kỹ năng mã hóa có giá trị cao bằng cách làm việc trên các dự án viết mã thực tế
Bạn có muốn ngừng học với các dự án đồ chơi và tập trung vào các dự án mã thực tế giúp bạn kiếm tiền và giải quyết các vấn đề thực sự cho mọi người không?
🚀 Nếu câu trả lời của bạn là CÓ. , cân nhắc trở thành nhà phát triển Python tự do. Đó là cách tốt nhất để tiếp cận nhiệm vụ cải thiện kỹ năng Python của bạn—ngay cả khi bạn là người mới hoàn toàn
Nếu bạn chỉ muốn tìm hiểu về cơ hội làm việc tự do, vui lòng xem hội thảo trên web miễn phí của tôi “Cách xây dựng kỹ năng Python có thu nhập cao của bạn” và tìm hiểu cách tôi phát triển công việc viết mã của mình trực tuyến cũng như cách bạn có thể làm được—từ sự thoải mái của bạn
Tham gia hội thảo trên web miễn phí ngay bây giờ
Chris
Trong khi làm việc với tư cách là nhà nghiên cứu về các hệ thống phân tán, Dr. Christian Mayer tìm thấy tình yêu của mình với việc dạy sinh viên khoa học máy tính
Để giúp sinh viên đạt được mức độ thành công Python cao hơn, anh ấy đã thành lập trang web giáo dục lập trình Finxter. com. Ông là tác giả của cuốn sách lập trình nổi tiếng Python One-Liners [NoStarch 2020], đồng tác giả của loạt sách tự xuất bản Coffee Break Python, người đam mê khoa học máy tính, cộng tác viên tự do và chủ sở hữu của một trong 10 blog Python lớn nhất thế giới
Niềm đam mê của anh ấy là viết, đọc và mã hóa. Nhưng niềm đam mê lớn nhất của anh ấy là phục vụ các lập trình viên đầy tham vọng thông qua Finxter và giúp họ nâng cao kỹ năng của mình. Bạn có thể tham gia học viện email miễn phí của anh ấy tại đây