Python kiểm tra xem hai danh sách có bằng nhau không?

Trong phân tích dữ liệu python, chúng ta có thể gặp tình huống khi cần so sánh hai danh sách và tìm hiểu xem chúng có giống nhau về ý nghĩa có cùng các phần tử hay không

Thí dụ

Bản thử trực tiếp

listA = ['Mon','Tue','Wed','Thu']
listB = ['Mon','Wed','Tue','Thu']
# Given lists
print("Given listA: ",listA)
print("Given listB: ",listB)
# Sort the lists
listA.sort()
listB.sort()

# Check for equality
if listA == listB:
   print("Lists are identical")
else:
   print("Lists are not identical")

đầu ra

Chạy đoạn mã trên cho chúng ta kết quả sau -

Given listA: ['Mon', 'Tue', 'Wed', 'Thu']
Given listB: ['Mon', 'Wed', 'Tue', 'Thu']
Lists are identical

Với Bộ đếm

Chức năng Counter từ mô-đun bộ sưu tập có thể giúp chúng tôi tìm số lần xuất hiện của từng mục trong danh sách. Trong ví dụ dưới đây, chúng tôi cũng lấy hai phần tử trùng lặp. Nếu tần số của mỗi phần tử trong cả hai danh sách bằng nhau, chúng tôi coi các danh sách là giống hệt nhau

Python cung cấp nhiều cách để so sánh hai danh sách. So sánh là quá trình kiểm tra các mục dữ liệu của một mục dữ liệu khác trong danh sách, xem chúng có giống nhau hay không

Các phương pháp so sánh hai danh sách được đưa ra dưới đây

• Hàm cmp()
• Hàm set() và toán tử ==
• Hàm sort() và toán tử ==
• Bộ sưu tập. hàm truy cập ()
• Hàm reduce() và map()

Hàm cmp()

Hàm cmp() trong Python so sánh hai đối tượng Python và trả về các giá trị nguyên -1, 0, 1 theo phép so sánh

Lưu ý - Nó không sử dụng trong Python 3. phiên bản x

Hàm set() và toán tử ==

Hàm set() trong Python thao tác danh sách vào tập hợp mà không cần quan tâm đến thứ tự các phần tử. Ngoài ra, chúng ta sử dụng toán tử bằng (==) để so sánh các phần tử dữ liệu của danh sách. Hãy hiểu ví dụ sau

Thí dụ -

đầu ra

The list1 and list2 are equal

Giải trình

Trong ví dụ trên, chúng tôi đã khai báo hai danh sách được so sánh với nhau. Chúng tôi đã chuyển đổi các danh sách đó thành tập hợp và so sánh từng phần tử với sự trợ giúp của toán tử ==. Tất cả các phần tử đều bằng nhau trong cả hai danh sách, sau đó nếu khối được thực thi và in kết quả

Phương thức sort() với toán tử ==

Hàm sort() trong Python dùng để sắp xếp danh sách. Các phần tử của cùng một danh sách có cùng vị trí chỉ mục;

Lưu ý - Trong phương thức sort(), chúng ta có thể chuyển các mục trong danh sách theo bất kỳ thứ tự nào vì chúng ta đang sắp xếp danh sách trước khi so sánh

Hãy hiểu ví dụ sau -

Thí dụ -

đầu ra

The list1 and list3 are not the same
The list1 and list2 are not the same

Bộ sưu tập. hàm truy cập ()

Mô-đun bộ sưu tập cung cấp bộ đếm (), so sánh danh sách một cách hiệu quả. Nó lưu trữ dữ liệu ở định dạng từ điển. và đếm tần suất xuất hiện của các mục trong danh sách

Lưu ý - Thứ tự của các phần tử trong danh sách không quan trọng trong chức năng này

Thí dụ -

đầu ra

The lists list1 and list2 are not the same
The lists list1 and list3 are the same

Giảm () và bản đồ ()

Hàm map() chấp nhận một hàm và đối tượng lặp Python (danh sách, bộ dữ liệu, chuỗi, v.v.) làm đối số và trả về một đối tượng bản đồ. Hàm thực hiện cho từng phần tử của danh sách và kết quả là trả về một trình vòng lặp

Bên cạnh đó, phương thức reduce() triển khai hàm đã cho cho đối tượng có thể lặp lại theo cách đệ quy

Ở đây, chúng ta sẽ sử dụng kết hợp cả hai phương pháp. Hàm map() sẽ triển khai hàm (nó có thể là hàm do người dùng xác định hoặc hàm lambda) cho mọi đối tượng có thể lặp lại và hàm reduce() đảm nhiệm chức năng đó sẽ áp dụng theo cách đệ quy

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) --> True

3 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) --> True

4 có giống 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))
# False

0 để 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) --> True

5

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) --> True

3 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) --> True

4. 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) --> True

5 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) --> True

5 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) --> True

7

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))
# False

7 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))
# False

Vì 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)

Given listA: ['Mon', 'Tue', 'Wed', 'Thu']
Given listB: ['Mon', 'Wed', 'Tue', 'Thu']
Lists are identical

7

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 như đượ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))
# False

8. 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))
# False

9, 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) --> True

7 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 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) --> True

7, thì các phần tử danh sách cũng 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ề

Given listA: ['Mon', 'Tue', 'Wed', 'Thu']
Given listB: ['Mon', 'Wed', 'Tue', 'Thu']
Lists are identical

72, 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) --> True

5 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 cách một lập trình viên giỏi hơn sẽ tận dụng hàm

Given listA: ['Mon', 'Tue', 'Wed', 'Thu']
Given listB: ['Mon', 'Wed', 'Tue', 'Thu']
Lists are identical

74 để 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

The list1 and list2 are equal

5

Thay vì lặp qua các chỉ mục, 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. Chắc chắn tránh các chỉ mục bằng hàm

Given listA: ['Mon', 'Tue', 'Wed', 'Thu']
Given listB: ['Mon', 'Wed', 'Tue', 'Thu']
Lists are identical

74 là một cách Pythonic hơn

Phươ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

  Given listA: ['Mon', 'Tue', 'Wed', 'Thu']
  Given listB: ['Mon', 'Wed', 'Tue', 'Thu']
  Lists are identical

  76
• Sau đó, bạn tính tổng các giá trị Boolean (một thủ thuật khác của các pro coder) để tìm số phần tử giống nhau và lưu vào biến

  Given listA: ['Mon', 'Tue', 'Wed', 'Thu']
  Given listB: ['Mon', 'Wed', 'Tue', 'Thu']
  Lists are identical

  77
• 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

The list1 and list2 are equal

9

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))
# False

7, đây là cách Pythonic nhất do sử dụng các hàm trợ giúp Python hiệu quả như

Given listA: ['Mon', 'Tue', 'Wed', 'Thu']
Given listB: ['Mon', 'Wed', 'Tue', 'Thu']
Lists are identical

79 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ơn

Bạn cũng có thể viết điều này trong một dòng mã

The list1 and list3 are not the same
The list1 and list2 are not the same

2

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

The list1 and list3 are not the same
The list1 and list2 are not the same

3

Hàm

The list1 and list2 are equal

50 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 ____251 kết hợp tất cả các giá trị Boolean thực hiện phép toán

The list1 and list2 are equal

52. 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

The list1 and list2 are equal

53

Phươ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

The list1 and list2 are equal

53 thay vì

The list1 and list2 are equal

55 để kết hợp tất cả các giá trị Boolean trong một phép toán và toàn cục

The lists list1 and list2 are not the same
The lists list1 and list3 are the same

0

Nế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) --> True

3 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) --> True

4 là câu lệnh hiểu danh sách

The list1 and list2 are equal

58. Đ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 đã đặt

Cách tốt nhất để tính toán sự khác biệt giữa hai danh sách trong Python là gì?

The lists list1 and list2 are not the same
The lists list1 and list3 are the same

4

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) --> True

0

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

  The list1 and list2 are equal
  

  59
• 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à

The list1 and list2 are equal

90

• 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) --> True

1

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

The list1 and list2 are equal

93 thành danh sách đầu tiên. Lý do là việc kiểm tra tư cách thành viên

The list1 and list2 are equal

94 cho bộ nhanh hơn nhiều so với danh sách. Tuy nhiên, về mặt ngữ nghĩa, cả hai biến thể đều giống hệt nhau

Dướ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ì đây 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) --> True

2

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

The list1 and list2 are equal

93 thành một tập hợp trước tiên để tăng tốc độ kiểm tra

The list1 and list2 are equal

96 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 mã hóa 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à một nhà nghiên cứu trong 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