Danh sách sửa đổi Python

Các hàm của Python (cả hàm tích hợp và hàm tùy chỉnh do chúng tôi tự viết) là những công cụ quan trọng để làm việc với dữ liệu. Nhưng những gì họ làm với dữ liệu của chúng tôi có thể hơi khó hiểu và nếu chúng tôi không biết chuyện gì đang xảy ra, điều đó có thể gây ra lỗi nghiêm trọng trong quá trình phân tích của chúng tôi

Trong hướng dẫn này, chúng ta sẽ xem xét kỹ cách Python xử lý các loại dữ liệu khác nhau khi chúng được thao tác bên trong các hàm và tìm hiểu cách đảm bảo rằng dữ liệu của chúng ta chỉ được thay đổi khi chúng ta muốn nó được thay đổi.

Cách ly bộ nhớ trong chức năng

Để hiểu cách Python xử lý các biến toàn cục bên trong các hàm, hãy làm một thử nghiệm nhỏ. Chúng ta sẽ tạo hai biến toàn cục, number_1 và number_2, và gán chúng cho các số nguyên 5 và 10. Sau đó, chúng ta sẽ sử dụng các biến toàn cục đó làm đối số trong một hàm thực hiện một số phép toán đơn giản. Chúng tôi cũng sẽ sử dụng tên biến làm tên tham số của hàm. Sau đó, chúng ta sẽ xem liệu tất cả việc sử dụng biến bên trong hàm của chúng ta có ảnh hưởng đến giá trị toàn cầu của các biến này hay không

number_1 = 5
number_2 = 10

def multiply_and_add(number_1, number_2):
    number_1 = number_1 * 10
    number_2 = number_2 * 10
    return number_1 + number_2

a_sum = multiply_and_add(number_1, number_2)
print(a_sum)
print(number_1)
print(number_2)

150
5
10

Như chúng ta có thể thấy ở trên, hàm hoạt động chính xác và giá trị của các biến toàn cục

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

0 và

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

1 không thay đổi, mặc dù chúng ta đã sử dụng chúng làm đối số và tên tham số trong hàm của mình. Điều này là do Python lưu trữ các biến từ một hàm ở một vị trí bộ nhớ khác với các biến toàn cục. Họ bị cô lập. Do đó, biến

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

0 có thể có một giá trị (5) trên toàn cục và một giá trị khác (50) bên trong hàm, nơi nó được tách biệt

(Nhân tiện, nếu bạn bối rối về sự khác biệt giữa tham số và đối số, tài liệu của Python về chủ đề này khá hữu ích. )

Điều gì về danh sách và từ điển?

danh sách

Chúng ta đã thấy rằng những gì chúng ta làm với một biến như

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

0 ở trên bên trong một hàm không ảnh hưởng đến giá trị toàn cầu của nó. Nhưng

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

0 là một số nguyên, là một kiểu dữ liệu khá cơ bản. Điều gì xảy ra nếu chúng ta thử cùng một thử nghiệm với một loại dữ liệu khác, chẳng hạn như danh sách?

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

[1, 2, 3, 3]
[1, 2, 3, 3]

Như chúng ta có thể thấy, ở đây giá trị toàn cục của

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

6 đã được cập nhật, mặc dù giá trị của nó chỉ được thay đổi bên trong hàm

từ điển

Bây giờ, hãy viết một hàm lấy từ điển làm đối số để xem liệu biến từ điển toàn cục có bị sửa đổi khi nó cũng được thao tác bên trong hàm không

Để làm cho điều này thực tế hơn một chút, chúng tôi sẽ sử dụng dữ liệu từ bộ dữ liệu

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

7 được sử dụng trong khóa học Nguyên tắc cơ bản về Python của chúng tôi (dữ liệu có sẵn để tải xuống tại đây)

Trong đoạn mã bên dưới, chúng tôi đang bắt đầu với một từ điển chứa số lượng ứng dụng với từng xếp hạng độ tuổi trong tập dữ liệu (do đó, có 4.433 ứng dụng được xếp hạng “4+”, 987 ứng dụng được xếp hạng “9+”, v.v. ). Hãy tưởng tượng chúng ta muốn tính tỷ lệ phần trăm cho mỗi xếp hạng độ tuổi, vì vậy chúng ta có thể biết được xếp hạng độ tuổi nào phổ biến nhất trong số các ứng dụng trong App Store

Để làm điều này, chúng ta sẽ viết một hàm có tên là

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

8 sẽ lấy một từ điển làm đối số và chuyển đổi số đếm thành tỷ lệ phần trăm. Chúng tôi sẽ cần bắt đầu đếm từ 0 và sau đó lặp lại từng giá trị trong từ điển, thêm chúng vào số đếm để chúng tôi nhận được tổng số xếp hạng. Sau đó, chúng tôi sẽ lặp lại từ điển một lần nữa và thực hiện một số phép toán cho từng giá trị để tính tỷ lệ phần trăm

150
5
10

3

Trước khi xem kết quả, hãy nhanh chóng xem lại những gì đang xảy ra ở trên. Sau khi gán từ điển xếp hạng độ tuổi của ứng dụng cho biến

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

9, chúng tôi tạo một hàm mới có tên là

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

8 nhận một đối số duy nhất.

[1, 2, 3, 3]
[1, 2, 3, 3]

1

Để tính tỷ lệ phần trăm ứng dụng rơi vào từng xếp hạng độ tuổi, chúng tôi cần biết tổng số ứng dụng, vì vậy, trước tiên, chúng tôi đặt một biến mới có tên là

[1, 2, 3, 3]
[1, 2, 3, 3]

2 đến

[1, 2, 3, 3]
[1, 2, 3, 3]

3, sau đó lặp qua từng khóa trong

[1, 2, 3, 3]
[1, 2, 3, 3]

1, thêm nó vào

[1, 2, 3, 3]
[1, 2, 3, 3]

2

Khi đã xong, tất cả những gì chúng ta cần làm là lặp lại

[1, 2, 3, 3]
[1, 2, 3, 3]

1, chia mỗi mục cho tổng và sau đó nhân kết quả với 100. Điều này sẽ cung cấp cho chúng tôi một từ điển với tỷ lệ phần trăm

Nhưng điều gì sẽ xảy ra khi chúng ta sử dụng

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

9 toàn cục của mình làm đối số cho hàm mới này?

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

3____24

Giống như chúng ta đã thấy với các danh sách, biến toàn cục

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

9 của chúng ta đã bị thay đổi, mặc dù nó chỉ được sửa đổi bên trong hàm

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

8 mà chúng ta đã tạo

Vì vậy, những gì đang thực sự xảy ra ở đây?

Các kiểu dữ liệu có thể thay đổi và không thể thay đổi

Trong Python, kiểu dữ liệu có thể là mutable (có thể thay đổi) hoặc immutable (không thể thay đổi). Và trong khi hầu hết các kiểu dữ liệu mà chúng ta đã làm việc trong phần giới thiệu Python là bất biến (bao gồm số nguyên, số float, chuỗi, Boolean và bộ dữ liệu), danh sách và từ điển có thể thay đổi. Điều đó có nghĩa là một danh sách toàn cầu hoặc từ điển có thể được thay đổi ngay cả khi nó được sử dụng bên trong một hàm, giống như chúng ta đã thấy trong các ví dụ ở trên

Để hiểu sự khác biệt giữa có thể thay đổi (có thể thay đổi) và không thể thay đổi (không thể thay đổi), thật hữu ích khi xem cách Python thực sự xử lý các biến này

Hãy bắt đầu bằng cách xem xét một phép gán biến đơn giản

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

7

Tên biến

150
5
10

30 đóng vai trò như một con trỏ hướng tới

150
5
10

31 và nó giúp chúng ta truy xuất

150
5
10

31 bất cứ khi nào chúng ta muốn

150
5
10

31 là số nguyên và số nguyên là kiểu dữ liệu không thay đổi. Nếu một loại dữ liệu là bất biến, điều đó có nghĩa là nó không thể được cập nhật sau khi được tạo. Nếu chúng tôi thực hiện

150
5
10

34, chúng tôi không thực sự cập nhật

150
5
10

31 thành

150
5
10

36. Trong hình ảnh động dưới đây, chúng ta có thể thấy rằng

• Ban đầu

  150
  5
  10

  30 hướng về phía

  150
  5
  10

  31

• 150
  5
  10

  34 được chạy và điều này di chuyển con trỏ từ

  150
  5
  10

  31 đến

  150
  5
  10

  36, nó không thực sự thay đổi số

  150
  5
  10

  31

Các loại dữ liệu có thể thay đổi như danh sách và từ điển hoạt động khác nhau. Chúng có thể được cập nhật. Vì vậy, ví dụ, hãy tạo một danh sách rất đơn giản

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

1

Nếu chúng tôi thêm một

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

33 vào cuối danh sách này, chúng tôi không chỉ trỏ

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

34 tới một danh sách khác, mà chúng tôi đang trực tiếp cập nhật danh sách hiện có

Ngay cả khi chúng ta tạo nhiều biến danh sách, miễn là chúng trỏ đến cùng một danh sách, tất cả chúng sẽ được cập nhật khi danh sách đó thay đổi, như chúng ta có thể thấy trong đoạn mã bên dưới

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

4

150
5
10

0

Đây là hình ảnh động về những gì đang thực sự xảy ra trong đoạn mã trên

Điều này giải thích tại sao các biến toàn cầu của chúng tôi đã bị thay đổi khi chúng tôi thử nghiệm với các danh sách và từ điển trước đó. Vì danh sách và từ điển có thể thay đổi nên việc thay đổi chúng (thậm chí bên trong một hàm) sẽ thay đổi chính danh sách hoặc từ điển, đây không phải là trường hợp đối với các kiểu dữ liệu không thể thay đổi

Giữ các kiểu dữ liệu có thể thay đổi không thay đổi

Nói chung, chúng ta không muốn các hàm của mình thay đổi các biến toàn cục, ngay cả khi chúng chứa các kiểu dữ liệu có thể thay đổi như danh sách hoặc từ điển. Đó là bởi vì trong các phân tích và chương trình phức tạp hơn, chúng ta có thể thường xuyên sử dụng nhiều chức năng khác nhau. Nếu tất cả họ đang thay đổi danh sách và từ điển mà họ đang làm việc, thì việc theo dõi những gì đang thay đổi những gì có thể trở nên khá khó khăn.

Rất may, có một cách dễ dàng để giải quyết vấn đề này. chúng ta có thể tạo một bản sao của danh sách hoặc từ điển bằng phương thức Python tích hợp có tên là

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

35

Nếu bạn chưa tìm hiểu về các phương pháp, đừng lo lắng. Chúng được đề cập trong khóa học Python trung cấp của chúng tôi, nhưng đối với hướng dẫn này, tất cả những gì bạn cần biết là

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

35 hoạt động giống như

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

37

150
5
10

1

Hãy xem lại hàm mà chúng ta đã viết cho danh sách và cập nhật nó để những gì xảy ra bên trong hàm của chúng ta không thay đổi

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

6. Tất cả những gì chúng ta cần làm là thay đổi đối số mà chúng ta truyền vào hàm của mình từ

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

6 thành

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

40

150
5
10

2____13

Như chúng ta có thể thấy, điều này đã khắc phục vấn đề của chúng ta. Đây là lý do tại sao. sử dụng

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

35 tạo một bản sao riêng của danh sách, để thay vì trỏ đến chính

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

6,

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

43 trỏ đến một danh sách mới bắt đầu bằng một bản sao của

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

6. Bất kỳ thay đổi nào được thực hiện đối với

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

43 sau thời điểm đó đều được thực hiện cho danh sách riêng biệt đó, chứ không phải chính

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

6, do đó, giá trị toàn cầu của

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

6 không thay đổi

Tuy nhiên, giải pháp này vẫn chưa hoàn hảo vì chúng ta sẽ phải nhớ thêm

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

35 mỗi khi truyền một đối số cho hàm của mình, nếu không sẽ có nguy cơ vô tình thay đổi giá trị chung của

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

6. Nếu chúng tôi không muốn phải lo lắng về điều đó, chúng tôi thực sự có thể tạo bản sao danh sách đó bên trong chính chức năng đó

150
5
10

4

150
5
10

3

Với cách tiếp cận này, chúng ta có thể chuyển một biến toàn cục có thể thay đổi một cách an toàn như

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

6 vào hàm của mình và giá trị toàn cục sẽ không bị thay đổi vì chính hàm đó tạo một bản sao và sau đó thực hiện các thao tác của nó trên bản sao đó

Phương pháp

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

35 cũng hoạt động với từ điển. Như với danh sách, chúng ta có thể chỉ cần thêm

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

35 vào đối số mà chúng ta chuyển hàm của mình để tạo một bản sao sẽ được sử dụng cho hàm mà không thay đổi biến ban đầu

150
5
10

6

150
5
10

7

Nhưng một lần nữa, sử dụng phương pháp đó có nghĩa là chúng ta cần nhớ thêm

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

35 mỗi khi chúng ta chuyển một từ điển vào hàm

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

8 của mình. Nếu chúng tôi sẽ sử dụng chức năng này thường xuyên, có thể tốt hơn là triển khai sao chép vào chính chức năng đó để chúng tôi không phải nhớ thực hiện việc này

Dưới đây, chúng ta sẽ sử dụng

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

35 bên trong hàm. Điều này sẽ đảm bảo rằng chúng ta có thể sử dụng nó mà không cần thay đổi các biến toàn cục mà chúng ta chuyển cho nó dưới dạng đối số và chúng ta không cần nhớ thêm

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

35 vào mỗi đối số mà chúng ta chuyển

150
5
10

8

150
5
10

7

Như chúng ta có thể thấy, việc sửa đổi chức năng của chúng ta để tạo một bản sao của từ điển và sau đó chỉ thay đổi số đếm thành tỷ lệ phần trăm trong bản sao đó đã cho phép chúng ta thực hiện thao tác chúng ta muốn mà không thực sự thay đổi

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

9

kết luận

Trong hướng dẫn này, chúng ta đã xem xét sự khác biệt giữa các loại dữ liệu có thể thay đổi, có thể thay đổi và các loại dữ liệu không thay đổi, không thể thay đổi. Chúng tôi đã học cách sử dụng phương pháp

initial_list = [1, 2, 3]

def duplicate_last(a_list):
    last_element = a_list[-1]
    a_list.append(last_element)
    return a_list

new_list = duplicate_last(a_list = initial_list)
print(new_list)
print(initial_list)

35 để tạo bản sao của các loại dữ liệu có thể thay đổi như danh sách và từ điển để chúng tôi có thể làm việc với chúng trong các hàm mà không thay đổi giá trị chung của chúng

Hướng dẫn này có hữu ích không?

Chọn con đường của bạn để tiếp tục học các kỹ năng dữ liệu có giá trị

Hướng dẫn Python

Thực hành các kỹ năng lập trình Python của bạn khi bạn làm việc với các hướng dẫn miễn phí của chúng tôi

Các khóa học khoa học dữ liệu

Cam kết học tập với các khóa học khoa học dữ liệu tương tác, trong trình duyệt của bạn bằng Python, R, SQL, v.v.

người mới bắt đầu từ điểnchức năngkiểu dữ liệu có thể thay đổidanh sáchkiểu dữ liệu có thể thay đổipythonHướng dẫn

Thông tin về các Tác giả

Charlie Custer

Charlie là sinh viên ngành khoa học dữ liệu và cũng là nhà tiếp thị nội dung tại Dataquest. Trong thời gian rảnh rỗi, anh ấy học đi xe đạp leo núi và làm video về nó

Bạn có thể sửa đổi danh sách trong Python không?

Việc sửa đổi một danh sách trong Python có nghĩa là gì?

Thao tác danh sách trong Python là gì?

Bạn có thể thay thế một mục trong danh sách Python không?