Độ phức tạp thời gian của python là gì?

Sau đó, bạn sẽ học cách tính toán độ phức tạp của hàm của riêng mình bằng cách kết hợp các lớp phức tạp của các thành phần của nó. Điều này được gọi là "phân tích tĩnh"

Hướng dẫn dựa trên [nguồn] một cách lỏng lẻo nhưng nó mở rộng đáng kể với các ví dụ thực tế hơn, đoạn trích tương tác và tài liệu giải thích

Giới thiệu Big-O

Sự định nghĩa. Độ phức tạp của một hoạt động [hoặc một thuật toán cho vấn đề đó] là số lượng tài nguyên cần thiết để chạy nó [nguồn]. Tài nguyên có thể là thời gian [độ phức tạp thời gian chạy] hoặc không gian [độ phức tạp bộ nhớ]

Vì vậy, làm thế nào bạn có thể đo lường độ phức tạp của một thuật toán? . Nó thay đổi theo kích thước của đầu vào cho thuật toán hoặc hoạt động

Ví dụ: phương thức danh sách

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

3 có một đối số đầu vào. đối tượng danh sách được sắp xếp. Độ phức tạp thời gian chạy không phải là hằng số, nó tăng lên khi tăng kích thước của danh sách. Nếu có nhiều phần tử được sắp xếp, thời gian chạy của thuật toán sẽ tăng lên

Chức năng phức tạp

Với kích thước đầu vào

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

4, bạn có thể mô tả độ phức tạp của thuật toán của mình bằng một chức năng của đầu vào

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

5 xác định số lượng “đơn vị tài nguyên” [e. g. , thời gian, bộ nhớ] cần thiết để hoàn thành nó [trường hợp xấu nhất hoặc trường hợp trung bình]

Giả sử, bạn có ba cách triển khai để sắp xếp danh sách.

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

6,

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

0,

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

1

Hình vẽ cho thấy ba chức năng phức tạp. Trục x đo kích thước đầu vào [trong ví dụ của chúng tôi, nó sẽ là kích thước danh sách]. Trục y đo độ phức tạp đối với đầu vào này

• d = {1: [3, 1, 2, 4],
       2: [4, 4, 1, 9]}
  
  lst = d.get[1]
  lst.sort[]
  print[lst]
  # [1, 2, 3, 4]

  6 có hàm phức tạp bậc hai f[n] = n²

• d = {1: [3, 1, 2, 4],
       2: [4, 4, 1, 9]}
  
  lst = d.get[1]
  lst.sort[]
  print[lst]
  # [1, 2, 3, 4]

  0 có hàm phức tạp bậc hai f[n] = 2n²

• d = {1: [3, 1, 2, 4],
       2: [4, 4, 1, 9]}
  
  lst = d.get[1]
  lst.sort[]
  print[lst]
  # [1, 2, 3, 4]

  1 có hàm phức tạp logarit f[n] = n log[n]

Bạn có thể xem mã chúng tôi đã sử dụng để tạo cốt truyện này tại đây

import matplotlib.pyplot as plt
import math

implementation_1 = [n**2 for n in range[1, 100, 10]]
implementation_2 = [2*n**2 for n in range[1, 100, 10]]
implementation_3 = [n*math.log[n] for n in range[1, 100, 10]]

plt.plot[implementation_1, '--.', label='implementation 1']
plt.plot[implementation_2, '-o', label='implementation 2']
plt.plot[implementation_3, '-x', label='implementation 3']

plt.legend[]
plt.xlabel['Input [ex: List Size]']
plt.ylabel['Complexity [ex: Runtime]']
plt.grid[]
plt.show[]

Tất nhiên, thật tốt khi lãng phí càng ít tài nguyên càng tốt để hàm phức tạp logarit vượt trội hơn so với các hàm phức tạp bậc hai

Ký hiệu Big-O

Đối với các đầu vào lớn, hành vi thời gian chạy sẽ bị chi phối bởi một phần của hàm phức tạp phát triển nhanh nhất. Ví dụ: hàm phức tạp thời gian chạy bậc hai f[n] = 1000n² + 100000n + 999 sẽ tốt hơn nhiều so với hàm phức tạp thời gian chạy bậc ba g[n] = 0. 1n³

Tại sao?

Trên thực tế, bạn có thể lập luận rằng phần quan trọng duy nhất của hàm phức tạp là phần phát triển nhanh nhất khi kích thước đầu vào tăng

Đây chính xác là ý nghĩa của ký hiệu Big-O

Ký hiệu Big O mô tả các chức năng theo tốc độ tăng trưởng của chúng. các chức năng khác nhau có cùng tốc độ tăng trưởng có thể được biểu diễn bằng cùng một ký hiệu O. [wiki]

Nói một cách đại khái, bạn loại bỏ mọi thứ trừ thuật ngữ phát triển nhanh nhất khỏi hàm phức tạp. Điều này cho phép bạn nhanh chóng so sánh các thuật toán khác nhau với nhau

Để chứng minh điều này, hãy xem hai ví dụ của chúng tôi

• Hàm phức tạp f[n] = 1000n² + 100000n + 999 tăng như O[n²]
• Hàm phức tạp g[n] = 0. 1n³ phát triển như O[n³]

Bằng cách giảm hàm phức tạp về mức tăng trưởng tiệm cận của nó, bạn có thể thấy ngay rằng cái trước vượt trội hơn cái sau về độ phức tạp thời gian chạy — mà không bị phân tâm bởi tất cả các yếu tố không đổi trước các thành phần hoặc các thành phần có tăng trưởng tiệm cận nhỏ hơn

Ví dụ Big-O của các hàm phức tạp

Vì vậy, đây là một vài ví dụ về các hàm phức tạp và sự tăng trưởng tiệm cận của chúng trong ký hiệu Big-O

Hàm phức tạp Tăng trưởng tiệm cậnf[n] = 10000O[1]f[n] = n + 1000000O[n]f[n] = 33n + log[n]O[n]f[n] = 33n + 4n * log[n] . 000000001n³ + 4n² + 100000n + 999O[n³]f[n] = 10 * n³ + 33nO[n³]

Bạn có thể thấy rằng sự tăng trưởng tiệm cận của một hàm [trong ký hiệu Big-O] bị chi phối bởi số hạng tăng nhanh nhất trong phương trình hàm

Độ phức tạp của hoạt động Python

Hãy khám phá sự phức tạp của các thao tác Python—được phân loại theo cấu trúc dữ liệu mà bạn thực hiện các thao tác đó. Một lập trình viên giỏi sẽ luôn sử dụng cấu trúc dữ liệu phù hợp nhất với nhu cầu của họ

Nói chung, cấu trúc dữ liệu danh sách hỗ trợ nhiều thao tác hơn cấu trúc dữ liệu tập hợp vì nó lưu giữ thông tin về thứ tự của các phần tử—với chi phí phức tạp tính toán cao hơn

Độ phức tạp của danh sách Python

Giả sử rằng độ dài của kiểu dữ liệu được định nghĩa là

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

4 [nghĩa là—

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

6]. Bây giờ bạn có thể phân loại độ phức tạp tiệm cận của các hàm phức tạp khác nhau như sau

OperationExampleComplexityIndex

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

7O[1]Store

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

8O[1]Length

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

9O[1]Append

# Operation 1: Dictionary Creation --> O[n]
d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

# Operation 2: Dictionary Get --> O[1]
lst = d.get[1]

# Operation 3: List Sorting --> O[n log n]
lst.sort[]

# Operation 4: Print List --> O[n]
print[lst]

0O[1]Pop

# Operation 1: Dictionary Creation --> O[n]
d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

# Operation 2: Dictionary Get --> O[1]
lst = d.get[1]

# Operation 3: List Sorting --> O[n log n]
lst.sort[]

# Operation 4: Print List --> O[n]
print[lst]

1O[1]Clear

# Operation 1: Dictionary Creation --> O[n]
d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

# Operation 2: Dictionary Get --> O[1]
lst = d.get[1]

# Operation 3: List Sorting --> O[n log n]
lst.sort[]

# Operation 4: Print List --> O[n]
print[lst]

2O[1]Slicing

# Operation 1: Dictionary Creation --> O[n]
d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

# Operation 2: Dictionary Get --> O[1]
lst = d.get[1]

# Operation 3: List Sorting --> O[n log n]
lst.sort[]

# Operation 4: Print List --> O[n]
print[lst]

3O[b-a]Extend

# Operation 1: Dictionary Creation --> O[n]
d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

# Operation 2: Dictionary Get --> O[1]
lst = d.get[1]

# Operation 3: List Sorting --> O[n log n]
lst.sort[]

# Operation 4: Print List --> O[n]
print[lst]

4O[len[l1]+len[l2]]Constructor

# Operation 1: Dictionary Creation --> O[n]
d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

# Operation 2: Dictionary Get --> O[1]
lst = d.get[1]

# Operation 3: List Sorting --> O[n log n]
lst.sort[]

# Operation 4: Print List --> O[n]
print[lst]

5O[len[iter]]Equal

# Operation 1: Dictionary Creation --> O[n]
d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

# Operation 2: Dictionary Get --> O[1]
lst = d.get[1]

# Operation 3: List Sorting --> O[n log n]
lst.sort[]

# Operation 4: Print List --> O[n]
print[lst]

6O[n

Bộ dữ liệu tương tự như danh sách—với một vài ngoại lệ. bạn không thể sửa đổi một tuple vì chúng là bất biến

Hãy xem xét một cấu trúc dữ liệu quan trọng khác

Độ phức tạp của bộ Python

Giả sử rằng độ dài của kiểu dữ liệu được định nghĩa là

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

4 [nghĩa là—

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

6]. Nếu có hai bộ trong một thao tác đơn lẻ, chẳng hạn như

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

02, thì độ dài được đưa ra bởi các biến

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

03 và

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

04. Bây giờ bạn có thể phân loại độ phức tạp tiệm cận của các hàm phức tạp khác nhau như sau

Hoạt độngVí dụĐộ phức tạpChiều dài

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

05O[1]Thêm

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

06O[1]Tư cách thành viên

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

07 /

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

08O[1]Xóa

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

09O[1]Pop

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

80O[1]Xóa

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

81O[1]Người xây dựng

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

82O[n]Bình đẳng

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

02 /

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

84O[phút[n1, n2]]Liên minh_______385O[n]Giao lộ____O[n1+___n]

Tôi đã đánh dấu các thao tác tập hợp hiệu quả hơn các thao tác danh sách tương ứng. Lý do cho những thứ đó là O[1] chứ không phải O[n] là vì cấu trúc dữ liệu danh sách cũng duy trì thứ tự của các phần tử, điều này phát sinh thêm chi phí

Độ phức tạp của từ điển Python

Bây giờ, hãy xem độ phức tạp về thời gian của các hoạt động từ điển Python

OperationExampleComplexityIndex [Get]

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

31O[1]Store

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

32O[1]Length

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

33O[1]Delete

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

34O[1]Pop

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

35O[1]Clear

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

36O[1]Keys

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

37O[1]Construction

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

38O[n]Iteration

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

39O[n]

Hầu hết các hoạt động là O[1] vì từ điển Python chia sẻ nhiều thuộc tính của bộ Python [chẳng hạn như hoạt động thành viên nhanh]

Soạn các lớp phức tạp

Bây giờ, bạn đã biết sự phức tạp của các hoạt động khác nhau. Nhưng làm thế nào để bạn có được độ phức tạp của thuật toán của bạn?

Khái niệm này là đơn giản. bạn chia vấn đề lớn [biết mức độ phức tạp của toàn bộ thuật toán] thành một loạt các vấn đề nhỏ hơn [biết mức độ phức tạp của các hoạt động riêng lẻ]

Sau đó, bạn kết hợp lại sự phức tạp của hoạt động riêng lẻ để có được giải pháp cho vấn đề lớn

Làm sao? . trước tiên bạn lấy một danh sách từ từ điển các giá trị danh sách. Sau đó, bạn sắp xếp danh sách

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

Hãy tự mình thử trong trình bao mã tương tác của chúng tôi [nhấp vào “chạy” để thực thi mã]

Bạn có bốn thao tác trong đoạn mã. Hãy chú thích từng hoạt động với một lớp phức tạp

# Operation 1: Dictionary Creation --> O[n]
d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

# Operation 2: Dictionary Get --> O[1]
lst = d.get[1]

# Operation 3: List Sorting --> O[n log n]
lst.sort[]

# Operation 4: Print List --> O[n]
print[lst]

Biết các lớp phức tạp của các hoạt động khác nhau, bạn có thể kết hợp lại như sau

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

9

Bạn thấy trong Phương trình

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

40 cái mà bạn có thể gọi là “quy tắc dây chuyền của phép phân tích độ phức tạp”.

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

41

Bạn có thể thấy trong Phương trình

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

42 rằng ký hiệu Big-O chỉ tập trung vào số hạng tăng trưởng lớn nhất. Trong trường hợp của chúng tôi,

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

43 phát triển nhanh hơn

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

44

Đây là hai ví dụ quan trọng về sự tái hợp Big-O

• d = {1: [3, 1, 2, 4],
       2: [4, 4, 1, 9]}
  
  lst = d.get[1]
  lst.sort[]
  print[lst]
  # [1, 2, 3, 4]

  45. Nói cách khác, Thực thi một thao tác với số lần không đổi [cố định] không làm thay đổi độ phức tạp tổng thể của thuật toán

• d = {1: [3, 1, 2, 4],
       2: [4, 4, 1, 9]}
  
  lst = d.get[1]
  lst.sort[]
  print[lst]
  # [1, 2, 3, 4]

  46 nếu hàm phức tạp

  d = {1: [3, 1, 2, 4],
       2: [4, 4, 1, 9]}
  
  lst = d.get[1]
  lst.sort[]
  print[lst]
  # [1, 2, 3, 4]

  47 phát triển nhanh hơn

  d = {1: [3, 1, 2, 4],
       2: [4, 4, 1, 9]}
  
  lst = d.get[1]
  lst.sort[]
  print[lst]
  # [1, 2, 3, 4]

  48. Một ví dụ là

  d = {1: [3, 1, 2, 4],
       2: [4, 4, 1, 9]}
  
  lst = d.get[1]
  lst.sort[]
  print[lst]
  # [1, 2, 3, 4]

  49

Trong lập trình, bạn cũng có thể thực thi có điều kiện

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

0

Bạn có thể kết hợp lại lớp phức tạp của đoạn mã tổng thể như sau.

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

50. Nói một cách đại khái, [nếu điều kiện có thể đúng], độ phức tạp của việc thực hiện điều kiện là tối đa của cả hai khối

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

47 hoặc

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

48

Thí dụ

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

8

Độ phức tạp là

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

43 vì nó phát triển nhanh hơn

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

54 — độ phức tạp của khối trong câu lệnh khác

Một khả năng khác là lặp đi lặp lại việc thực thi một chức năng nào đó [e. g. , trong vòng lặp for]

Nếu bạn lặp lại hàm

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

47

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

56 lần, độ phức tạp tính toán là

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

57. Nếu

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

56 là một hằng số, độ phức tạp tính toán sẽ đơn giản hóa thành

d = {1: [3, 1, 2, 4],
     2: [4, 4, 1, 9]}

lst = d.get[1]
lst.sort[]
print[lst]
# [1, 2, 3, 4]

59

Đ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

Độ phức tạp về thời gian và không gian trong Python là gì?

Python phức tạp Big O là gì?

Độ phức tạp thời gian nhanh nhất là gì?

Độ phức tạp về thời gian của chỉ mục trong Python là gì?