Nối 0 vào danh sách Python

❮ Liệt kê các phương thức

Thí dụ

Thêm một phần tử vào danh sách fruits

trái cây = ['táo', 'chuối', 'anh đào']
hoa quả. nối thêm ("màu cam")

Định nghĩa và cách sử dụng

Phương thức append() nối một phần tử vào cuối danh sách

cú pháp

Giá trị tham số

Thêm ví dụ

Thí dụ

Thêm danh sách vào danh sách

a = ["táo", "chuối", "anh đào"]
b = ["Ford", "BMW", "Volvo"]
a. nối thêm (b)

❮ Liệt kê các phương thức

Làm thế nào bạn có thể thêm nhiều yếu tố hơn vào một danh sách nhất định? . Hướng dẫn này cho bạn thấy mọi thứ bạn cần biết để giúp bạn nắm vững một phương thức thiết yếu của kiểu dữ liệu vùng chứa cơ bản nhất trong ngôn ngữ lập trình Python

Định nghĩa và cách sử dụng

Phương thức

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Đây là một ví dụ ngắn

>>> l = []
>>> l.append(42)
>>> l
[42]
>>> l.append(21)
>>> l
[42, 21]

Trong dòng đầu tiên của ví dụ, bạn tạo danh sách

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Những bài viết liên quan

• Hướng dẫn cơ bản về danh sách Python

cú pháp

Bạn có thể gọi phương thức này trên từng đối tượng danh sách trong Python. Đây là cú pháp

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Tranh luận

câu đố mật mã

Bây giờ bạn đã biết những điều cơ bản. Hãy nâng cao hiểu biết của bạn bằng câu đố mã ngắn—bạn có giải được không?

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Bạn có thể kiểm tra giải pháp trên ứng dụng Finxter. (Tôi biết nó khó. )

Đây là bảng cheat PDF miễn phí của bạn hiển thị cho bạn tất cả các phương pháp liệt kê Python trên một trang đơn giản. Nhấp vào hình ảnh để tải xuống tệp PDF có độ phân giải cao, in và dán lên tường văn phòng của bạn

Tải xuống PDF tức thì [MIỄN PHÍ 100%]

ví dụ

Hãy đi sâu vào một vài ví dụ nữa

>>> lst = [2, 3]
>>> lst.append(3)
>>> lst.append([1,2])
>>> lst.append((3,4))
>>> lst
[2, 3, 3, [1, 2], (3, 4)]

Bạn có thể thấy rằng phương thức

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Danh sách Python nối thêm () Khi bắt đầu

Điều gì sẽ xảy ra nếu bạn muốn sử dụng phương thức append() ngay từ đầu. bạn muốn “chắp thêm” một phần tử ngay trước phần tử đầu tiên của danh sách

Chà, bạn nên làm việc với thuật ngữ của mình để bắt đầu. Nhưng nếu bạn khăng khăng, bạn có thể sử dụng phương pháp

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

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

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Phương thức

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

Danh sách Python append() Nhiều hoặc Tất cả các phần tử

Nhưng nếu bạn muốn nối thêm không chỉ một mà nhiều phần tử thì sao? . Bạn có thể làm điều đó với

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

Câu trả lời là không—bạn không thể nối nhiều phần tử vào một danh sách bằng cách sử dụng phương thức

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

Bạn gọi phương thức

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

Danh sách Python chắp thêm () so với mở rộng ()

Tôi đã quay một video nhỏ giải thích sự khác biệt và phương pháp nào nhanh hơn

Danh sách Python nối thêm () so với mở rộng () - Sự khác biệt về ngữ nghĩa và tốc độ

Phương thức

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Phương thức

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Sự khác biệt giữa

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

Bạn có thể thấy điều này trong ví dụ sau

>>> l = []
>>> l.append(1)
>>> l.append(2)
>>> l
[1, 2]
>>> l.extend([3, 4, 5])
>>> l
[1, 2, 3, 4, 5]

Trong đoạn mã này, trước tiên bạn thêm các phần tử số nguyên 1 và 2 vào danh sách bằng hai lệnh gọi phương thức

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

Phương pháp nào nhanh hơn — mở rộng() so với nối thêm()?

Để trả lời câu hỏi này, tôi đã viết một đoạn script ngắn để kiểm tra hiệu suất thời gian chạy của việc tạo các danh sách lớn có kích thước tăng dần bằng cách sử dụng các phương thức

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Luận điểm của chúng tôi là phương thức

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

Tôi đã sử dụng máy tính xách tay của mình với Intel(R) Core(TM) i7-8565U 1. Bộ xử lý 8GHz (với Turbo Boost lên đến 4. 6 GHz) và 8 GB RAM

Sau đó, tôi đã tạo 100 danh sách bằng cả hai phương pháp,

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Đây là mã tôi đã sử dụng để đo lường và vẽ kết quả. phương pháp nào nhanh hơn—

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

import time


def list_by_append(n):
    '''Creates a list & appends n elements'''
    lst = []
    for i in range(n):
        lst.append(n)
    return lst


def list_by_extend(n):
    '''Creates a list & extends it with n elements'''
    lst = []
    lst.extend(range(n))
    return lst


# Compare runtime of both methods
list_sizes = [i * 10000 for i in range(100)]
append_runtimes = []
extend_runtimes = []

for size in list_sizes:

    # Get time stamps
    time_0 = time.time()
    list_by_append(size)
    time_1 = time.time()
    list_by_extend(size)
    time_2 = time.time()

    # Calculate runtimes
    append_runtimes.append((size, time_1 - time_0))
    extend_runtimes.append((size, time_2 - time_1))


# Plot everything
import matplotlib.pyplot as plt
import numpy as np

append_runtimes = np.array(append_runtimes)
extend_runtimes = np.array(extend_runtimes)

print(append_runtimes)
print(extend_runtimes)

plt.plot(append_runtimes[:,0], append_runtimes[:,1], label='append()')
plt.plot(extend_runtimes[:,0], extend_runtimes[:,1], label='extend()')

plt.xlabel('list size')
plt.ylabel('runtime (seconds)')

plt.legend()
plt.savefig('append_vs_extend.jpg')
plt.show()

Mã bao gồm ba phần cấp cao

• Trong phần đầu tiên của mã, bạn xác định hai hàm

  import time
  
  
  def list_by_append(n):
      '''Creates a list & appends n elements'''
      lst = []
      for i in range(n):
          lst.append(n)
      return lst
  
  
  def list_by_extend(n):
      '''Creates a list & extends it with n elements'''
      lst = []
      lst.extend(range(n))
      return lst
  
  
  # Compare runtime of both methods
  list_sizes = [i * 10000 for i in range(100)]
  append_runtimes = []
  extend_runtimes = []
  
  for size in list_sizes:
  
      # Get time stamps
      time_0 = time.time()
      list_by_append(size)
      time_1 = time.time()
      list_by_extend(size)
      time_2 = time.time()
  
      # Calculate runtimes
      append_runtimes.append((size, time_1 - time_0))
      extend_runtimes.append((size, time_2 - time_1))
  
  
  # Plot everything
  import matplotlib.pyplot as plt
  import numpy as np
  
  append_runtimes = np.array(append_runtimes)
  extend_runtimes = np.array(extend_runtimes)
  
  print(append_runtimes)
  print(extend_runtimes)
  
  plt.plot(append_runtimes[:,0], append_runtimes[:,1], label='append()')
  plt.plot(extend_runtimes[:,0], extend_runtimes[:,1], label='extend()')
  
  plt.xlabel('list size')
  plt.ylabel('runtime (seconds)')
  
  plt.legend()
  plt.savefig('append_vs_extend.jpg')
  plt.show()

  0 và

  import time
  
  
  def list_by_append(n):
      '''Creates a list & appends n elements'''
      lst = []
      for i in range(n):
          lst.append(n)
      return lst
  
  
  def list_by_extend(n):
      '''Creates a list & extends it with n elements'''
      lst = []
      lst.extend(range(n))
      return lst
  
  
  # Compare runtime of both methods
  list_sizes = [i * 10000 for i in range(100)]
  append_runtimes = []
  extend_runtimes = []
  
  for size in list_sizes:
  
      # Get time stamps
      time_0 = time.time()
      list_by_append(size)
      time_1 = time.time()
      list_by_extend(size)
      time_2 = time.time()
  
      # Calculate runtimes
      append_runtimes.append((size, time_1 - time_0))
      extend_runtimes.append((size, time_2 - time_1))
  
  
  # Plot everything
  import matplotlib.pyplot as plt
  import numpy as np
  
  append_runtimes = np.array(append_runtimes)
  extend_runtimes = np.array(extend_runtimes)
  
  print(append_runtimes)
  print(extend_runtimes)
  
  plt.plot(append_runtimes[:,0], append_runtimes[:,1], label='append()')
  plt.plot(extend_runtimes[:,0], extend_runtimes[:,1], label='extend()')
  
  plt.xlabel('list size')
  plt.ylabel('runtime (seconds)')
  
  plt.legend()
  plt.savefig('append_vs_extend.jpg')
  plt.show()

  1 lấy đối số đầu vào là kích thước danh sách số nguyên

  import time
  
  
  def list_by_append(n):
      '''Creates a list & appends n elements'''
      lst = []
      for i in range(n):
          lst.append(n)
      return lst
  
  
  def list_by_extend(n):
      '''Creates a list & extends it with n elements'''
      lst = []
      lst.extend(range(n))
      return lst
  
  
  # Compare runtime of both methods
  list_sizes = [i * 10000 for i in range(100)]
  append_runtimes = []
  extend_runtimes = []
  
  for size in list_sizes:
  
      # Get time stamps
      time_0 = time.time()
      list_by_append(size)
      time_1 = time.time()
      list_by_extend(size)
      time_2 = time.time()
  
      # Calculate runtimes
      append_runtimes.append((size, time_1 - time_0))
      extend_runtimes.append((size, time_2 - time_1))
  
  
  # Plot everything
  import matplotlib.pyplot as plt
  import numpy as np
  
  append_runtimes = np.array(append_runtimes)
  extend_runtimes = np.array(extend_runtimes)
  
  print(append_runtimes)
  print(extend_runtimes)
  
  plt.plot(append_runtimes[:,0], append_runtimes[:,1], label='append()')
  plt.plot(extend_runtimes[:,0], extend_runtimes[:,1], label='extend()')
  
  plt.xlabel('list size')
  plt.ylabel('runtime (seconds)')
  
  plt.legend()
  plt.savefig('append_vs_extend.jpg')
  plt.show()

  2 và tạo danh sách các phần tử số nguyên tăng dần liên tiếp bằng cách sử dụng các phương thức

  >>> lst = [1, 2, 3]
  >>> lst.insert(0, 99)
  >>> lst
  [99, 1, 2, 3]

  0 và

  >>> l = [1, 2, 3]
  >>> l.extend([1, 2, 3])
  >>> l
  [1, 2, 3, 1, 2, 3]

  1 tương ứng
• Trong phần thứ hai của mã, bạn so sánh thời gian chạy của cả hai hàm bằng cách sử dụng 100 giá trị khác nhau cho kích thước danh sách

  import time
  
  
  def list_by_append(n):
      '''Creates a list & appends n elements'''
      lst = []
      for i in range(n):
          lst.append(n)
      return lst
  
  
  def list_by_extend(n):
      '''Creates a list & extends it with n elements'''
      lst = []
      lst.extend(range(n))
      return lst
  
  
  # Compare runtime of both methods
  list_sizes = [i * 10000 for i in range(100)]
  append_runtimes = []
  extend_runtimes = []
  
  for size in list_sizes:
  
      # Get time stamps
      time_0 = time.time()
      list_by_append(size)
      time_1 = time.time()
      list_by_extend(size)
      time_2 = time.time()
  
      # Calculate runtimes
      append_runtimes.append((size, time_1 - time_0))
      extend_runtimes.append((size, time_2 - time_1))
  
  
  # Plot everything
  import matplotlib.pyplot as plt
  import numpy as np
  
  append_runtimes = np.array(append_runtimes)
  extend_runtimes = np.array(extend_runtimes)
  
  print(append_runtimes)
  print(extend_runtimes)
  
  plt.plot(append_runtimes[:,0], append_runtimes[:,1], label='append()')
  plt.plot(extend_runtimes[:,0], extend_runtimes[:,1], label='extend()')
  
  plt.xlabel('list size')
  plt.ylabel('runtime (seconds)')
  
  plt.legend()
  plt.savefig('append_vs_extend.jpg')
  plt.show()

  2
• Trong phần thứ ba của mã, bạn vẽ mọi thứ bằng thư viện matplotlib của Python

Đây là biểu đồ kết quả so sánh thời gian chạy của hai phương thức append() và extension(). Trên trục x, bạn có thể thấy kích thước danh sách từ 0 đến 1.000.000 phần tử. Trên trục y, bạn có thể thấy thời gian chạy tính bằng giây cần thiết để thực thi các chức năng tương ứng

Biểu đồ kết quả cho thấy cả hai phương pháp đều cực kỳ nhanh đối với vài chục nghìn phần tử. Trên thực tế, chúng nhanh đến mức hàm

import time


def list_by_append(n):
    '''Creates a list & appends n elements'''
    lst = []
    for i in range(n):
        lst.append(n)
    return lst


def list_by_extend(n):
    '''Creates a list & extends it with n elements'''
    lst = []
    lst.extend(range(n))
    return lst


# Compare runtime of both methods
list_sizes = [i * 10000 for i in range(100)]
append_runtimes = []
extend_runtimes = []

for size in list_sizes:

    # Get time stamps
    time_0 = time.time()
    list_by_append(size)
    time_1 = time.time()
    list_by_extend(size)
    time_2 = time.time()

    # Calculate runtimes
    append_runtimes.append((size, time_1 - time_0))
    extend_runtimes.append((size, time_2 - time_1))


# Plot everything
import matplotlib.pyplot as plt
import numpy as np

append_runtimes = np.array(append_runtimes)
extend_runtimes = np.array(extend_runtimes)

print(append_runtimes)
print(extend_runtimes)

plt.plot(append_runtimes[:,0], append_runtimes[:,1], label='append()')
plt.plot(extend_runtimes[:,0], extend_runtimes[:,1], label='extend()')

plt.xlabel('list size')
plt.ylabel('runtime (seconds)')

plt.legend()
plt.savefig('append_vs_extend.jpg')
plt.show()

Nhưng khi bạn tăng kích thước của danh sách lên hàng trăm nghìn phần tử, phương pháp

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

Đối với các danh sách lớn có một triệu phần tử, thời gian chạy của phương thức

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Lý do là việc gộp từng hoạt động nối thêm đã được đề cập

Tuy nhiên, hiệu ứng chỉ diễn ra đối với các danh sách rất lớn. Đối với danh sách nhỏ, bạn có thể chọn một trong hai phương pháp. Chà, để mã của bạn rõ ràng, bạn vẫn nên ưu tiên

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Danh sách Python append() so với insert()

Sự khác biệt giữa phương pháp

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

• phương thức

  >>> l = [1, 2, 3]
  >>> l.append(99)
  >>> l
  [1, 2, 3, 99]
  >>> l.insert(2, 42)
  >>> l
  [1, 2, 42, 3, 99]

  4 thêm phần tử mới

  >>> lst = [1, 2, 3]
  >>> lst.insert(0, 99)
  >>> lst
  [99, 1, 2, 3]

  2 vào cuối danh sách và
• phương thức

  >>> l = [1, 2, 3]
  >>> l.append([4, 5, 6])
  >>> l
  [1, 2, 3, [4, 5, 6]]

  4 thêm phần tử mới

  >>> lst = [1, 2, 3]
  >>> lst.insert(0, 99)
  >>> lst
  [99, 1, 2, 3]

  2 tại vị trí

  >>> l = [1, 2, 3]
  >>> l.append([4, 5, 6])
  >>> l
  [1, 2, 3, [4, 5, 6]]

  6 trong danh sách. Nó dịch chuyển tất cả các phần tử tiếp theo sang phải một vị trí

Đây là một ví dụ cho thấy cả hai phương thức

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

>>> l = [1, 2, 3]
>>> l.append(99)
>>> l
[1, 2, 3, 99]
>>> l.insert(2, 42)
>>> l
[1, 2, 42, 3, 99]

Cả hai phương pháp đều giúp bạn thêm các phần tử mới vào danh sách. Nhưng bạn có thể hỏi

Cái nào nhanh hơn, nối() hoặc chèn()?

Tất cả mọi thứ đều bình đẳng, phương pháp

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

Đây là một tập lệnh nhỏ cho thấy rằng phương thức

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

import time

l1 = []
l2 = []

t1 = time.time()

for i in range(100000):
    l1.append(i)

t2 = time.time()

for i in range(100000):
    l2.insert(0,i)

t3 = time.time()


print("append(): " + str(t2 - t1) + " seconds")
print("insert(): " + str(t3 - t2) + " seconds")

# OUTPUT:
# append(): 0.015607357025146484 seconds
# insert(): 1.5420396327972412 seconds

Các thử nghiệm đã được thực hiện trên máy tính xách tay của tôi với Intel(R) Core(TM) i7-8565U 1. Bộ xử lý 8GHz (với Turbo Boost lên đến 4. 6 GHz) và 8 GB RAM

Danh sách Python chắp thêm () so với nối

Vì vậy, bạn có hai hoặc nhiều danh sách và bạn muốn dán chúng lại với nhau. Điều này được gọi là nối danh sách. Làm thế nào bạn có thể làm điều đó?

Làm cách nào để nối các danh sách trong Python?

Đây là sáu cách nối danh sách (hướng dẫn chi tiết tại đây)

1. Toán tử nối danh sách

   import time
   
   l1 = []
   l2 = []
   
   t1 = time.time()
   
   for i in range(100000):
       l1.append(i)
   
   t2 = time.time()
   
   for i in range(100000):
       l2.insert(0,i)
   
   t3 = time.time()
   
   
   print("append(): " + str(t2 - t1) + " seconds")
   print("insert(): " + str(t3 - t2) + " seconds")
   
   # OUTPUT:
   # append(): 0.015607357025146484 seconds
   # insert(): 1.5420396327972412 seconds

   5
2. Danh sách phương pháp

   >>> lst = [1, 2, 3]
   >>> lst.insert(0, 99)
   >>> lst
   [99, 1, 2, 3]

   0
3. Danh sách phương pháp

   >>> l = [1, 2, 3]
   >>> l.extend([1, 2, 3])
   >>> l
   [1, 2, 3, 1, 2, 3]

   1
4. Toán tử dấu hoa thị

   import time
   
   l1 = []
   l2 = []
   
   t1 = time.time()
   
   for i in range(100000):
       l1.append(i)
   
   t2 = time.time()
   
   for i in range(100000):
       l2.insert(0,i)
   
   t3 = time.time()
   
   
   print("append(): " + str(t2 - t1) + " seconds")
   print("insert(): " + str(t3 - t2) + " seconds")
   
   # OUTPUT:
   # append(): 0.015607357025146484 seconds
   # insert(): 1.5420396327972412 seconds

   8

5. import time
   
   l1 = []
   l2 = []
   
   t1 = time.time()
   
   for i in range(100000):
       l1.append(i)
   
   t2 = time.time()
   
   for i in range(100000):
       l2.insert(0,i)
   
   t3 = time.time()
   
   
   print("append(): " + str(t2 - t1) + " seconds")
   print("insert(): " + str(t3 - t2) + " seconds")
   
   # OUTPUT:
   # append(): 0.015607357025146484 seconds
   # insert(): 1.5420396327972412 seconds

   9
6. hiểu danh sách

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

đầu ra

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Cách tốt nhất để nối hai danh sách là gì?

Nếu bạn đang bận, bạn có thể muốn biết câu trả lời tốt nhất ngay lập tức. Đây rồi

Để nối hai danh sách

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Để nối nhiều hơn hai danh sách, hãy sử dụng toán tử giải nén (dấu hoa thị)

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Tuy nhiên, bạn nên tránh sử dụng phương thức append() để nối danh sách vì nó không hiệu quả cũng như không ngắn gọn và dễ đọc.

Danh sách Python append() Nếu không tồn tại

Một câu hỏi phổ biến là như sau

Làm cách nào bạn có thể thêm hoặc nối một phần tử vào danh sách nhưng chỉ khi phần tử đó chưa tồn tại trong danh sách?

Khi bỏ qua bất kỳ vấn đề hiệu suất nào, câu trả lời rất đơn giản. sử dụng điều kiện if kết hợp với phép toán thành viên

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Thí dụ. Giả sử, bạn muốn thêm tất cả các phần tử từ 0 đến 9 vào danh sách ba phần tử. Nhưng bạn không muốn có bất kỳ bản sao nào. Đây là cách bạn có thể làm điều này

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

danh sách kết quả

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Bạn thêm tất cả các phần tử từ 0 đến 9 vào danh sách nhưng chỉ khi chúng chưa có. Do đó, danh sách kết quả không chứa các bản sao

Nhưng có một vấn đề. phương pháp này rất kém hiệu quả

Trong mỗi lần lặp vòng lặp, đoạn mã

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

import time


def list_by_append(n):
    '''Creates a list & appends n elements'''
    lst = []
    for i in range(n):
        lst.append(n)
    return lst


def list_by_extend(n):
    '''Creates a list & extends it with n elements'''
    lst = []
    lst.extend(range(n))
    return lst


# Compare runtime of both methods
list_sizes = [i * 10000 for i in range(100)]
append_runtimes = []
extend_runtimes = []

for size in list_sizes:

    # Get time stamps
    time_0 = time.time()
    list_by_append(size)
    time_1 = time.time()
    list_by_extend(size)
    time_2 = time.time()

    # Calculate runtimes
    append_runtimes.append((size, time_1 - time_0))
    extend_runtimes.append((size, time_2 - time_1))


# Plot everything
import matplotlib.pyplot as plt
import numpy as np

append_runtimes = np.array(append_runtimes)
extend_runtimes = np.array(extend_runtimes)

print(append_runtimes)
print(extend_runtimes)

plt.plot(append_runtimes[:,0], append_runtimes[:,1], label='append()')
plt.plot(extend_runtimes[:,0], extend_runtimes[:,1], label='extend()')

plt.xlabel('list size')
plt.ylabel('runtime (seconds)')

plt.legend()
plt.savefig('append_vs_extend.jpg')
plt.show()

Bạn có thể làm tốt hơn không?

Chắc chắn rồi, nhưng bạn cần nhìn xa hơn kiểu dữ liệu danh sách. Các bộ Python là sự trừu tượng phù hợp ở đây. Nếu bạn cần làm mới kiến ​​thức cơ bản của mình về loại dữ liệu tập hợp, hãy xem hướng dẫn tập hợp chi tiết của tôi (với các ví dụ về Harry Potter) trên blog Finxter

Tại sao các bộ Python tuyệt vời cho việc này? . một tập hợp là một tập hợp duy nhất các phần tử không có thứ tự. Và độ phức tạp thời gian chạy của hoạt động thành viên không tuyến tính về số lượng phần tử (như trường hợp của danh sách) mà là hằng số

Thí dụ. Giả sử, bạn muốn thêm tất cả các phần tử từ 0 đến 9 vào một bộ ba phần tử. Nhưng bạn không muốn có bất kỳ bản sao nào. Đây là cách bạn có thể làm điều này với các bộ

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

tập hợp kết quả

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Tập hợp không cho phép nhập trùng lặp nên các phần tử 1, 2 và 3 không được thêm hai lần vào tập hợp

Bạn thậm chí có thể làm cho mã này ngắn gọn hơn

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

đầu ra

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Phương thức kết hợp tạo một tập hợp mới bao gồm tất cả các phần tử trong cả hai toán hạng

Bây giờ, bạn có thể muốn có một danh sách chứ không phải một tập hợp. Giải pháp rất đơn giản. chuyển đổi tập hợp kết quả thành danh sách bằng cách sử dụng phương pháp chuyển đổi

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Vấn đề. Nếu bạn muốn duy trì thông tin đơn đặt hàng và vẫn thêm tất cả các yếu tố chưa có trong danh sách thì sao?

Vấn đề với cách tiếp cận trước đó là bằng cách chuyển đổi danh sách thành tập hợp, thứ tự của danh sách bị mất. Trong trường hợp này, tôi khuyên bạn nên làm như sau. sử dụng hai cấu trúc dữ liệu, một danh sách và một tập hợp. Bạn sử dụng danh sách để thêm các yếu tố mới và giữ thông tin đơn đặt hàng. Bạn sử dụng bộ để kiểm tra tư cách thành viên (không đổi thay vì độ phức tạp thời gian chạy tuyến tính). Đây là mã

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

danh sách kết quả

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Bạn có thể thấy rằng danh sách kết quả không chứa bất kỳ bản sao nào nhưng thông tin đơn hàng vẫn được duy trì. Đồng thời, độ phức tạp thời gian chạy của mã là tuyến tính vì mỗi lần lặp lại vòng lặp có thể được hoàn thành trong thời gian không đổi

Sự đánh đổi là bạn phải duy trì hai cấu trúc dữ liệu dẫn đến tăng gấp đôi chi phí bộ nhớ. Điều này thể hiện độc đáo mối quan hệ nghịch đảo chung giữa bộ nhớ và chi phí thời gian chạy

Danh sách Python append() Trả về danh sách mới

Nếu bạn sử dụng phép toán

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

Câu trả lời đơn giản là sử dụng thao tác nối danh sách

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Đây là một ví dụ cho thấy phương thức append() chỉ sửa đổi một danh sách hiện có

>>> lst = [2, 3]
>>> lst.append(3)
>>> lst.append([1,2])
>>> lst.append((3,4))
>>> lst
[2, 3, 3, [1, 2], (3, 4)]

Và đây là ví dụ cho thấy cách tạo danh sách mới khi bạn thêm phần tử mới 4 vào danh sách

>>> lst = [2, 3]
>>> lst.append(3)
>>> lst.append([1,2])
>>> lst.append((3,4))
>>> lst
[2, 3, 3, [1, 2], (3, 4)]

Bằng cách sử dụng thao tác nối danh sách, bạn có thể tạo danh sách mới thay vì nối thêm phần tử vào danh sách hiện có

Danh sách Python append() Độ phức tạp về thời gian, bộ nhớ và hiệu quả

Thời gian phức tạp. Phương thức

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Độ phức tạp không gian. Phương thức

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Cân nhắc hiệu quả. Phương pháp

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Danh sách Python append() tại Index

Bạn có muốn nối thêm một phần tử tại một vị trí nhất định không? . Tất cả các phần tử tiếp theo sẽ được chuyển sang bên phải (chỉ số của chúng tăng thêm một). Độ phức tạp về thời gian của phương pháp

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

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

>>> lst = [2, 3]
>>> lst.append(3)
>>> lst.append([1,2])
>>> lst.append((3,4))
>>> lst
[2, 3, 3, [1, 2], (3, 4)]

Đoạn code chèn phần tử số 7 vào vị trí thứ 2 của danh sách. Yếu tố 101 trước giữ vị trí 2 nay giữ vị trí 3

Nếu bạn muốn chèn một phần tử và tạo một danh sách mới bằng cách làm như vậy, tôi khuyên bạn nên sử dụng Python slice. Hãy xem hướng dẫn blog chuyên sâu này sẽ cho bạn thấy mọi thứ bạn cần biết về cách cắt lát. Bạn cũng có thể nhận cuốn sách cắt lát miễn phí “Coffee Break Python Slicing”

Đây là mã chỉ ra cách tạo một danh sách mới sau khi chèn một phần tử vào một vị trí nhất định

>>> lst = [2, 3]
>>> lst.append(3)
>>> lst.append([1,2])
>>> lst.append((3,4))
>>> lst
[2, 3, 3, [1, 2], (3, 4)]

Một lần nữa, bạn đang sử dụng phép nối danh sách để tạo một danh sách mới với phần tử 99 được chèn vào vị trí 2. Lưu ý rằng các hoạt động cắt lát

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Danh sách Python append() Lỗi

Trên thực tế, không có nhiều thứ bạn có thể làm sai khi sử dụng phương pháp

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

1) Một lỗi phổ biến xảy ra khi bạn cho rằng phương thức

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

2) Một lỗi khác có thể xảy ra nếu bạn cố thêm một phần tử vào danh sách nhưng danh sách chưa được tạo. Tất nhiên, bạn chỉ có thể gọi phương thức nếu bạn đã khởi tạo đúng đối tượng danh sách

3) Một lỗi khác xảy ra nếu bạn cố gắng sử dụng phương thức

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

Danh sách Python append() Phần tử rỗng

Bạn có muốn thêm một phần tử trống vào danh sách để có được thứ như thế này không.

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Dù sao đi nữa, cách tự nhiên nhất để thực hiện điều này là sử dụng phần tử

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

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

>>> lst = [2, 3]
>>> lst.append(3)
>>> lst.append([1,2])
>>> lst.append((3,4))
>>> lst
[2, 3, 3, [1, 2], (3, 4)]

Để dễ hiểu, tôi phải nói rằng không thể thêm phần tử trống vào danh sách, đơn giản vì thực tế là không có thứ gọi là phần tử trống trong Python

Danh sách Python append() Chủ đề an toàn

Bạn có nhiều chủ đề truy cập vào danh sách của mình cùng một lúc không?

Nói cách khác. bạn có thể gọi thao tác

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Câu trả lời là có (nếu bạn sử dụng triển khai cPython). Lý do là khóa trình thông dịch toàn cầu của Python đảm bảo rằng một chuỗi hiện đang làm việc trên mã của nó trước tiên sẽ hoàn thành hoạt động Python cơ bản hiện tại của nó như được xác định bởi quá trình triển khai cPython. Chỉ khi nó kết thúc với thao tác này thì luồng tiếp theo mới có thể truy cập tài nguyên tính toán. Điều này được đảm bảo với sơ đồ khóa tinh vi bằng cách triển khai cPython

Điều duy nhất bạn cần biết là mỗi thao tác cơ bản trong triển khai cPython là nguyên tử. Nó được thực thi toàn bộ và ngay lập tức trước khi bất kỳ luồng nào khác có cơ hội chạy trên cùng một công cụ ảo. Do đó, không có điều kiện cuộc đua. Một ví dụ cho một điều kiện chủng tộc như vậy sẽ như sau. luồng đầu tiên đọc một giá trị từ danh sách, luồng thứ hai ghi đè giá trị và luồng đầu tiên ghi đè lại giá trị làm mất hiệu lực hoạt động của luồng thứ hai

Tất cả các hoạt động của cPython đều an toàn theo luồng. Nhưng nếu bạn kết hợp các thao tác đó thành các hàm cấp cao hơn, thì các thao tác đó thường không an toàn cho luồng vì chúng bao gồm nhiều thao tác (có thể xen kẽ)

Danh sách Python chắp thêm () Đã sắp xếp

Làm cách nào để chèn một phần tử vào danh sách đã sắp xếp? . Nó chỉ nối thêm phần tử vào cuối danh sách

Thay vào đó, bạn có thể sử dụng tìm kiếm nhị phân và phương thức

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> l = [1, 2, 3]
>>> l.append([4, 5, 6])
>>> l
[1, 2, 3, [4, 5, 6]]

>>> lst = [2, 3]
>>> lst.append(3)
>>> lst.append([1,2])
>>> lst.append((3,4))
>>> lst
[2, 3, 3, [1, 2], (3, 4)]

Vui lòng tìm thảo luận chi tiết hơn về thuật toán tìm kiếm nhị phân tại hướng dẫn của tôi trên blog Finxter

Từ điển danh sách append() của Python

Đây là những cách hiểu khác nhau về việc sử dụng phương thức append() với từ điển

• Nối từ điển vào danh sách
• Nối tất cả các cặp giá trị khóa từ từ điển vào danh sách
• Nối một phần tử vào danh sách được lưu trữ trong từ điển
• Thêm/Nối một cặp giá trị khóa vào từ điển

Hãy khám phá từng cái một

Nối từ điển vào danh sách. Từ điển là một đối tượng Python. Vì vậy, bạn có thể chỉ cần thêm nó vào danh sách giống như bất kỳ yếu tố nào khác

>>> lst = [2, 3]
>>> lst.append(3)
>>> lst.append([1,2])
>>> lst.append((3,4))
>>> lst
[2, 3, 3, [1, 2], (3, 4)]

Phần tử danh sách thứ tư là chính từ điển

Nối tất cả các cặp giá trị khóa từ từ điển vào danh sách. Giả sử, bạn có một cuốn từ điển với

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

>>> l = [1, 2, 3]
>>> l.extend([1, 2, 3])
>>> l
[1, 2, 3, 1, 2, 3]

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

>>> lst = [2, 3]
>>> lst.append(3)
>>> lst.append([1,2])
>>> lst.append((3,4))
>>> lst
[2, 3, 3, [1, 2], (3, 4)]

Phương thức

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Nối một phần tử vào danh sách được lưu trữ trong từ điển. cái này dễ. lấy danh sách và gọi phương thức

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [2, 3]
>>> lst.append(3)
>>> lst.append([1,2])
>>> lst.append((3,4))
>>> lst
[2, 3, 3, [1, 2], (3, 4)]

Vì danh sách là một đối tượng, nên việc sửa đổi đối tượng này (ngay cả khi nó “nằm ngoài” từ điển) sẽ ảnh hưởng đến chính đối tượng được lưu trữ trong từ điển

Thêm/nối một cặp giá trị khóa vào từ điển. Làm thế nào bạn có thể thêm một cặp

# Puzzle
nums = [1, 2, 3]
nums.append(nums[:])

print(len(nums))
# What's the output of this code snippet?

Danh sách Python append() cho vòng lặp một dòng

Bạn đang tìm vòng lặp for một dòng để thêm phần tử vào danh sách?

Đây là ví dụ nhanh để thêm tất cả các phần tử từ 0 đến 9 vào danh sách

>>> lst = [2, 3]
>>> lst.append(3)
>>> lst.append([1,2])
>>> lst.append((3,4))
>>> lst
[2, 3, 3, [1, 2], (3, 4)]

Đi đâu từ đây?

Phương thức

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

>>> lst = [1, 2, 3]
>>> lst.insert(0, 99)
>>> lst
[99, 1, 2, 3]

Bạn đã tìm hiểu thông tin chi tiết về phương pháp danh sách Python quan trọng này

Nếu bạn tiếp tục vật lộn với những lệnh Python cơ bản đó và bạn cảm thấy bế tắc trong quá trình học tập của mình, thì tôi có thứ này cho bạn. Python One-Liners (Liên kết Amazon)

Trong cuốn sách này, tôi sẽ cung cấp cho bạn tổng quan kỹ lưỡng về các chủ đề khoa học máy tính quan trọng như học máy, biểu thức chính quy, khoa học dữ liệu, NumPy và kiến ​​thức cơ bản về Python—tất cả trong một dòng mã Python

Lấy sách từ Amazon

MÔ TẢ SÁCH CHÍNH THỨC. Python One-Liners sẽ chỉ cho người đọc cách thực hiện các tác vụ hữu ích với một dòng mã Python. Sau phần giới thiệu ngắn gọn về Python, cuốn sách bao gồm các chủ đề nâng cao cần thiết như cắt, hiểu danh sách, phát sóng, hàm lambda, thuật toán, biểu thức chính quy, mạng thần kinh, hồi quy logistic, v.v. Mỗi phần trong số 50 phần của cuốn sách giới thiệu một vấn đề cần giải quyết, hướng dẫn người đọc các kỹ năng cần thiết để giải quyết vấn đề đó, sau đó cung cấp một giải pháp Python ngắn gọn với lời giải thích chi tiết

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

nối thêm 0 là gì?

Là. nối thêm O 1 bằng Python?

Bạn có thể thêm một số vào danh sách trong Python không?

Danh sách += có giống với append không?