[::4 có nghĩa là gì trong Python?

Khi sử dụng toán tử lát cắt [start:stop:step] để chỉ thu thập một tập hợp con dữ liệu từ danh sách hoặc chuỗi gốc, thì [:] làm gì?

Toán tử lát cắt không chứa giá trị nào cho các vị trí start và

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

0 trả về một bản sao hoàn chỉnh của chuỗi hoặc danh sách gốc. Điều này hữu ích khi bạn muốn thực hiện một bản sao nông của danh sách của mình

Bên cạnh việc sử dụng phương pháp danh sách tích hợp sẵn

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

1, bạn có thể sử dụng toán tử lát tắt này [ít hơn toàn bộ 4 ký tự] ở vị trí của nó

Python Nhận ký tự đầu tiên từ Str

Vui lòng bật JavaScript

Python Nhận ký tự đầu tiên từ chuỗi

Hãy xem một ví dụ

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> a_list[0] = 100
>>> print[b_list]
[100, 2, 3]

Suy nghĩ ban đầu cho những người mới viết mã sẽ là. Tôi nghĩ rằng tôi chỉ đang sao chép

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

2 sang một biến mới

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

3 trước khi biến

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

2 được sửa đổi, tại sao

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

3 cũng thay đổi?

Điều này liên quan đến cách các biến được lưu trữ trong bộ nhớ. Một cách để chứng minh điều này là xem xét hàm tích hợp sẵn

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

6 và toán tử dành riêng

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

7

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

Từ ví dụ trên, bạn có thể thấy rằng hàm

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

6 tích hợp trả về một số tham chiếu cho từng biến và số id cho cả hai biến là như nhau

Điều này có nghĩa là hai biến đang trỏ đến cùng một đối tượng trong bộ nhớ và tương đương nhau. Toán tử

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

7 thực hiện kiểm tra này về tính tương đương và trả về

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> a_list[0] = 10
>>> b_list[1] = 20
>>> print[a_list]
[10, 20, 3]
>>> print[b_list]
[10, 20, 3]
>>> id[a_list]
4369259008
>>> id[b_list]
4369259008

0 vì cả hai biến đều trỏ đến cùng một tham chiếu đối tượng

Do đó, vấn đề được đưa ra là bởi vì mỗi biến trỏ đến cùng một đối tượng nếu bạn sửa đổi đối tượng thông qua một trong hai biến, điều đó có nghĩa là biến kia cũng thay đổi

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> a_list[0] = 10
>>> b_list[1] = 20
>>> print[a_list]
[10, 20, 3]
>>> print[b_list]
[10, 20, 3]
>>> id[a_list]
4369259008
>>> id[b_list]
4369259008

Như bạn có thể thấy cả hai biến đều trả về cùng một kết quả vì cả hai đều trỏ đến cùng một đối tượng

Nhưng nếu bạn không muốn điều này thì sao?

Cách tạo một bản sao nông của một danh sách

Một cách để làm điều này là tạo một bản sao nông của danh sách của bạn bằng cách sử dụng toán tử lát cắt [:]

Hãy xem lại ví dụ trước của chúng ta, nhưng lần này sẽ sử dụng toán tử lát vào thời điểm thích hợp

>>> a_list = [1, 2, 3]
>>> b_list = a_list[:]
>>> a_list[0] = 100
>>> print[a_list]
[100, 2, 3]
>>> print[b_list]
[1, 2, 3]
>>> id[a_list]
4369256192
>>> id[b_list]
4369259008
>>> a_list is b_list
False

Nhận thấy sự khác biệt ở đây?

Trong ví dụ mã ở trên,

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

2 được tạo và

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

3 được tạo dưới dạng bản sao của

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

2 trước khi có bất kỳ thay đổi nào đối với danh sách

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

2 ban đầu. Sau đó, khi một thay đổi được thực hiện thành

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

2 thì nó không thay đổi

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

3 và chúng ta có thể kiểm tra xem chúng có khác nhau không bằng cách kiểm tra các tham chiếu id đối tượng của chúng, cả hai đều khác nhau

"Bản sao nông" là gì?

Một bản sao nông thực hiện một bản sao của danh sách gốc, nhưng giữ nguyên các tham chiếu id từ danh sách gốc. Nếu bạn kiểm tra id của từng đối tượng trong danh sách, chúng sẽ trả về id duy nhất của chúng

>>> a_list = [{'a': 1}, 2]
>>> id[a_list[0]]
4368574528
>>> id[a_list[1]]
4365461840
>>> id[a_list]
4369259008

Như bạn có thể thấy danh sách có một id duy nhất và mỗi thành phần trong danh sách có id duy nhất của riêng nó. Khi bạn tạo một bản sao nông của danh sách này bằng cách sử dụng toán tử lát cắt [:], bạn đang giữ tất cả các tham chiếu giống như bản gốc

>>> b_list = a_list[:]
>>> id[b_list[0]]
4368574528
>>> id[b_list[1]]
4365461840
>>> id[b_list]
4365778496
>>> a_list is b_list
False

Sự khác biệt duy nhất ở trên với ví dụ ban đầu của

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

2 là tham chiếu id của

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

3 khác. Mặc dù cả hai danh sách đều chứa các tham chiếu và giá trị giống hệt nhau, nhưng phép thử tương đương trả về

>>> a_list = [1, 2, 3]
>>> b_list = a_list[:]
>>> a_list[0] = 100
>>> print[a_list]
[100, 2, 3]
>>> print[b_list]
[1, 2, 3]
>>> id[a_list]
4369256192
>>> id[b_list]
4369259008
>>> a_list is b_list
False

2 vì các tham chiếu biến id không giống nhau

Nếu bạn nhìn vào từ điển được chèn vào phần tử đầu tiên của

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

2 thì điều gì sẽ xảy ra nếu điều này thay đổi?

>>> a_list[0]['a'] = 100
>>> print[b_list[0]]
{'a': 100}
>>> a_list[1] = 200
>>> print[b_list[1]]
2

Lưu ý rằng bằng cách thay đổi từ điển của phần tử đầu tiên, nó đã thay đổi phần tử đầu tiên trong

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

3, trong khi khi phần tử thứ hai được gán lại cho một giá trị mới, nó không thay đổi phần tử thứ hai trong

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

3

Đây là lý do tại sao chúng tôi gọi phương pháp sao chép tắt là [:] là sao chép nông. Có một số thành phần, chẳng hạn như từ điển, nếu thay đổi trong danh sách gốc sẽ sửa đổi các thành phần trong danh sách đã sao chép vì một bản sao nông tạo ra một biến mới, nhưng vẫn giữ nguyên id tham chiếu của danh sách gốc

Tóm lược

Một cách tắt để sao chép một danh sách hoặc một chuỗi là sử dụng toán tử lát cắt [:]. Điều này sẽ tạo một bản sao nông của danh sách gốc giữ tất cả các tham chiếu đối tượng giống nhau trong danh sách được sao chép. Điều này có thể hoạt động tốt đối với các danh sách được gán lại hoàn toàn các giá trị mới nhưng sẽ không hoạt động tốt nếu các phần tử trong danh sách ban đầu được sửa đổi và các phần tử này là từ điển

Phương thức danh sách tích hợp sẵn

>>> a_list = [1, 2, 3]
>>> b_list = a_list
>>> id[a_list]
4670898112
>>> id[b_list]
4670898112
>>> a_list is b_list
True

1 thực hiện chính xác cùng một tác vụ như toán tử lát cắt trống [:] nhưng toán tử lát cắt làm như vậy với ít ký tự hơn, do đó tại sao nó được coi là một cách tiếp cận nhanh để sao chép

có nghĩa là gì [. 3 có nghĩa là gì trong Python?

có nghĩa là gì [. 1 có nghĩa là gì trong Python?

có nghĩa là gì [

có nghĩa là gì [. 0 có nghĩa là gì trong Python?