Python chuyển đổi danh sách tuple thành danh sách chuỗi

Chương trước chúng ta đã giới thiệu các kiểu dựng sẵn của Python là

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
0,
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
1 và
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
2, và chúng ta đã tình cờ gặp được
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
3

Số nguyên và số float là các kiểu số, có nghĩa là chúng chứa các số. Chúng ta có thể sử dụng các toán tử số mà chúng ta đã thấy ở chương trước với chúng để tạo các biểu thức số. Trình thông dịch Python sau đó có thể đánh giá các biểu thức này để tạo ra các giá trị số, làm cho Python trở thành một máy tính rất mạnh

Các chuỗi, danh sách và bộ dữ liệu đều là các loại trình tự, được gọi như vậy vì chúng hoạt động giống như một trình tự - một tập hợp các đối tượng được sắp xếp theo thứ tự

Các loại chuỗi khác nhau về chất so với các loại số vì chúng là các loại dữ liệu phức hợp - nghĩa là chúng được tạo thành từ các phần nhỏ hơn. Trong trường hợp chuỗi, chúng được tạo thành từ các chuỗi nhỏ hơn, mỗi chuỗi chứa một ký tự. Ngoài ra còn có chuỗi rỗng, không chứa ký tự nào cả

Trong trường hợp danh sách hoặc bộ dữ liệu, chúng được tạo thành từ các phần tử, là giá trị của bất kỳ kiểu dữ liệu Python nào, bao gồm các danh sách và bộ dữ liệu khác

Danh sách được đặt trong dấu ngoặc vuông (

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
4 và
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
5) và bộ giá trị trong dấu ngoặc đơn (
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
6 và
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
7)

Một danh sách không chứa phần tử nào được gọi là danh sách rỗng và một bộ không có phần tử nào được gọi là một bộ trống

________số 8

Ví dụ đầu tiên là danh sách năm số nguyên và tiếp theo là danh sách ba chuỗi. Thứ ba là một bộ chứa bốn số nguyên, tiếp theo là một bộ chứa bốn chuỗi. Cái cuối cùng là một danh sách chứa ba bộ dữ liệu, mỗi bộ chứa một cặp chuỗi

Tùy thuộc vào những gì chúng tôi đang làm, chúng tôi có thể muốn coi một loại dữ liệu phức hợp là một thứ duy nhất hoặc chúng tôi có thể muốn truy cập các phần của nó. Sự mơ hồ này là hữu ích

Ghi chú

Có thể bỏ dấu ngoặc đơn khi chỉ định bộ và chỉ sử dụng danh sách giá trị được phân tách bằng dấu phẩy

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)

Ngoài ra, bắt buộc phải bao gồm dấu phẩy khi chỉ định một bộ chỉ có một phần tử

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
0

Ngoại trừ trường hợp của bộ dữ liệu trống, nó thực sự là dấu phẩy, không phải dấu ngoặc đơn, cho Python biết đó là bộ dữ liệu

3. 2. Làm việc với các phần của chuỗi¶

Các loại trình tự chia sẻ một tập hợp các hoạt động chung

3. 2. 1. Lập chỉ mục¶

Toán tử lập chỉ mục (

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
4
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
5) chọn một phần tử từ một chuỗi. Biểu thức bên trong ngoặc được gọi là chỉ mục và phải là một giá trị nguyên. Chỉ mục cho biết phần tử nào cần chọn, do đó tên của nó

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
3

Biểu thức

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
40 chọn ký tự có chỉ số
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
41 từ
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
42 và tạo một chuỗi mới chỉ chứa một ký tự này, mà bạn có thể ngạc nhiên khi thấy đó là
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
43

Bạn có thể mong đợi để xem

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
44, nhưng các nhà khoa học máy tính thường bắt đầu đếm từ số không, không phải một. Hãy nghĩ về chỉ mục như những con số trên thước đo số lượng phần tử bạn đã di chuyển vào chuỗi ngay từ đầu. Cả thước kẻ và chỉ số đều bắt đầu từ
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
45

3. 2. 2. Chiều dài¶

Chap trước các bạn đã thấy hàm

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
46 dùng để lấy số ký tự trong một chuỗi

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
1

Với danh sách và bộ dữ liệu,

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
46 trả về số lượng phần tử trong chuỗi

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
3

3. 2. 3. Truy cập phần tử ở cuối dãy¶

Thông thường trong lập trình máy tính cần truy cập các phần tử ở cuối chuỗi. Bây giờ bạn đã thấy hàm

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
46, bạn có thể muốn thử một cái gì đó như thế này

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!

Điều đó sẽ không làm việc. Nó gây ra lỗi thời gian chạy

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
49. Lý do là vì
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
70 trả về số phần tử trong danh sách, 16, nhưng không có phần tử nào ở vị trí chỉ mục 16 trong
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
71

Kể từ khi chúng tôi bắt đầu đếm từ số 0, mười sáu chỉ số được đánh số từ 0 đến 15. Để lấy phần tử cuối cùng, chúng ta phải trừ 1 từ độ dài

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
4

Đây là một mẫu phổ biến đến mức Python cung cấp một ký hiệu viết tay ngắn cho nó, lập chỉ mục phủ định, đếm ngược từ cuối chuỗi

Biểu thức

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
72 mang lại phần tử cuối cùng,
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
73 mang lại phần tử thứ hai cho đến cuối cùng, v.v.

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
7

3. 2. 4. Truyền tải và vòng lặp >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0] >>> last = seq[len(seq)] # ERROR! 74¶

Rất nhiều tính toán liên quan đến việc xử lý một chuỗi một phần tử tại một thời điểm. Mẫu phổ biến nhất là bắt đầu từ đầu, chọn lần lượt từng phần tử, thực hiện thao tác nào đó với phần tử đó và tiếp tục cho đến khi kết thúc. Mô hình xử lý này được gọi là truyền tải

Vòng lặp

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
74 của Python giúp việc truyền tải dễ dàng diễn đạt

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
5

Ghi chú

Chúng ta sẽ thảo luận về vòng lặp chi tiết hơn trong chương tiếp theo. Bây giờ chỉ cần lưu ý rằng dấu hai chấm (. ) ở cuối dòng đầu tiên và thụt đầu dòng trên dòng thứ hai đều bắt buộc để câu lệnh này đúng về mặt cú pháp

3. 3. ______276¶

Khi vòng lặp

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
74 tiêu chuẩn đi qua một chuỗi, nó sẽ gán từng giá trị trong chuỗi cho biến vòng lặp theo thứ tự xảy ra trong chuỗi. Đôi khi, thật hữu ích khi có cả giá trị và chỉ mục của từng phần tử. Hàm
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
76 cung cấp cho chúng ta điều này

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
0

3. 3. 1. Slice¶

Một dãy con của một dãy được gọi là một lát cắt và thao tác trích xuất một dãy con được gọi là cắt. Giống như lập chỉ mục, chúng tôi sử dụng dấu ngoặc vuông (

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
4
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
5) làm toán tử lát, nhưng thay vì một giá trị số nguyên bên trong, chúng tôi có hai giá trị, được phân tách bằng dấu hai chấm (
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
51)

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
1

Toán tử

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
52 trả về một phần của chuỗi từ phần tử thứ n đến phần tử thứ m, bao gồm phần tử đầu tiên nhưng không bao gồm phần tử cuối cùng. Hành vi này là phản trực giác;

Python chuyển đổi danh sách tuple thành danh sách chuỗi

Nếu bạn bỏ qua chỉ mục đầu tiên (trước dấu hai chấm), thì lát bắt đầu ở đầu chuỗi. Nếu bạn bỏ qua chỉ mục thứ hai, lát cắt sẽ đi đến cuối chuỗi. Như vậy

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
2

Bạn nghĩ

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
53 có nghĩa là gì?

Chỉ mục tiêu cực cũng được cho phép, vì vậy

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
3

Mẹo

Phát triển một sự hiểu biết vững chắc về cách thức hoạt động của việc cắt lát là rất quan trọng. Tiếp tục tạo “thí nghiệm” của riêng bạn với các chuỗi và lát cho đến khi bạn có thể dự đoán một cách nhất quán kết quả của thao tác cắt trước khi chạy nó

Khi bạn cắt một chuỗi, chuỗi con kết quả luôn có cùng loại với chuỗi mà từ đó nó được dẫn xuất. Điều này thường không đúng với lập chỉ mục, ngoại trừ trường hợp chuỗi

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
4

Mặc dù các thành phần của danh sách (hoặc bộ) có thể thuộc bất kỳ loại nào, bất kể bạn cắt nó như thế nào, một lát của danh sách là một danh sách

3. 3. 2. Toán tử >>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0] >>> last = seq[len(seq)] # ERROR! 55¶

Toán tử

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
55 trả về liệu một phần tử đã cho có được chứa trong danh sách hay bộ dữ liệu hay không

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
5

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
55 hoạt động hơi khác với chuỗi. Nó đánh giá là
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
58 nếu một chuỗi là chuỗi con của chuỗi khác

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
6

Lưu ý rằng một chuỗi là chuỗi con của chính nó và chuỗi trống là chuỗi con của bất kỳ chuỗi nào khác. (Cũng lưu ý rằng các lập trình viên máy tính muốn suy nghĩ khá cẩn thận về các trường hợp cạnh này. )

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
7

3. 4. Đối tượng và phương thức¶

Các chuỗi, danh sách và bộ dữ liệu là các đối tượng, có nghĩa là chúng không chỉ chứa các giá trị mà còn có các hành vi tích hợp được gọi là các phương thức, tác động lên các giá trị trong đối tượng

Hãy xem xét một số phương thức chuỗi đang hoạt động để xem nó hoạt động như thế nào

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
8

Bây giờ chúng ta hãy học cách mô tả những gì chúng ta vừa thấy. Mỗi chuỗi trong các ví dụ trên được theo sau bởi toán tử dấu chấm, tên phương thức và danh sách tham số, có thể trống

Trong ví dụ đầu tiên, chuỗi

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
59 được theo sau bởi toán tử dấu chấm và sau đó là phương thức
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
00, phương thức này có danh sách tham số trống. Chúng ta nói rằng phương thức “
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
00 được gọi trên chuỗi,
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
59. Gọi phương thức gây ra một hành động diễn ra bằng cách sử dụng giá trị mà phương thức được gọi. Hành động tạo ra kết quả, trong trường hợp này là giá trị chuỗi
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
03. Chúng ta nói rằng phương thức
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
00 trả về chuỗi
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
03 khi nó được gọi trên (hoặc được gọi trên) chuỗi
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
59

Trong ví dụ thứ tư, phương thức

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
07 (một lần nữa với danh sách tham số trống) được gọi trên chuỗi
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
08. Vì mỗi ký tự trong chuỗi đại diện cho một chữ số, phương thức
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
07 trả về giá trị boolean
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
58. Gọi
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
07 trên
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
12 tạo ra
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
13

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
14 loại bỏ khoảng trắng ở đầu và cuối

3. 5. Hàm >>> thing = 2, 4, 6, 8 >>> type(thing) >>> thing (2, 4, 6, 8) 15 và chuỗi tài liệu¶

Phần trước đã giới thiệu một số phương thức của đối tượng chuỗi. Để tìm tất cả các phương thức mà chuỗi có, chúng ta có thể sử dụng hàm

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
16 tích hợp sẵn của Python

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
9

Chúng ta sẽ hoãn nói về những từ bắt đầu bằng hai dấu gạch dưới (

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
17) cho đến sau này. Bạn có thể tìm hiểu thêm về từng phương pháp này bằng cách in ra các chuỗi tài liệu của chúng. Ví dụ, để tìm hiểu những gì phương pháp
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
18 làm, chúng tôi làm điều này

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
00

Sử dụng thông tin này, chúng tôi có thể thử sử dụng phương pháp thay thế để xác minh rằng chúng tôi biết cách thức hoạt động của nó

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
01

Ví dụ đầu tiên thay thế tất cả các lần xuất hiện của ________ 919 bằng ________ 920. Thứ hai thay thế ký tự đơn

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
21 bằng hai ký tự
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
22. Ví dụ thứ ba thay thế hai lần xuất hiện đầu tiên của ________ 923 bằng chuỗi rỗng

3. 6. ______924 và >>> thing = 2, 4, 6, 8 >>> type(thing) >>> thing (2, 4, 6, 8) 25 phương pháp¶

Có hai phương thức chung cho cả ba loại trình tự.

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
24 và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
25. Hãy nhìn vào docstrings của họ để xem những gì họ làm

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
02

Chúng ta sẽ khám phá các chức năng này trong các bài tập

3. 7. Danh sách có thể thay đổi¶

Unlike strings and tuples, which are immutable objects, lists are mutable, which means we can change their elements. Sử dụng toán tử dấu ngoặc ở bên trái của phép gán, chúng ta có thể cập nhật một trong các phần tử

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
03

Toán tử dấu ngoặc được áp dụng cho danh sách có thể xuất hiện ở bất kỳ đâu trong biểu thức. Khi nó xuất hiện ở phía bên trái của một phép gán, nó sẽ thay đổi một trong các phần tử trong danh sách, vì vậy phần tử đầu tiên của

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
42 đã được thay đổi từ
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
29 thành
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
30 và phần tử cuối cùng từ
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
31 thành
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
32. Phép gán cho một phần tử của danh sách được gọi là phép gán mục. Mục gán không hoạt động cho chuỗi

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
04

nhưng nó làm cho danh sách

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
05

Với toán tử lát, chúng ta có thể cập nhật một số phần tử cùng một lúc

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
06

Chúng tôi cũng có thể xóa các phần tử khỏi danh sách bằng cách gán danh sách trống cho chúng

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
07

Và chúng ta có thể thêm các phần tử vào danh sách bằng cách ép chúng vào một lát trống ở vị trí mong muốn

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
08

3. 8. Xóa danh sách¶

Sử dụng các lát cắt để xóa các thành phần danh sách có thể gây khó xử và do đó dễ bị lỗi. Python cung cấp một giải pháp thay thế dễ đọc hơn

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
33 xóa phần tử khỏi danh sách

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
09

Như bạn có thể mong đợi,

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
33 xử lý các chỉ mục tiêu cực và gây ra lỗi thời gian chạy nếu chỉ mục nằm ngoài phạm vi

Bạn có thể sử dụng một lát làm chỉ mục cho

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
33

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
30

Như thường lệ, các lát cắt chọn tất cả các phần tử, nhưng không bao gồm, chỉ mục thứ hai

3. 9. Liệt kê các phương thức¶

Ngoài

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
24 và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
25, danh sách có một số phương pháp hữu ích. Vì các danh sách có thể thay đổi, các phương thức này sửa đổi danh sách mà chúng được gọi, thay vì trả về một danh sách mới

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
31

Phương thức

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
38 đặc biệt hữu ích, vì nó giúp Python dễ dàng sắp xếp dữ liệu mà bạn đã đưa vào danh sách

3. 10. Tên và giá trị có thể thay đổi¶

Nếu chúng ta thực hiện các câu lệnh gán này,

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
32

chúng tôi biết rằng các tên

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
39 và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
40 sẽ đề cập đến một danh sách có các số
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
41,
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
42 và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
43. Nhưng chúng tôi chưa biết liệu chúng có trỏ đến cùng một danh sách hay không

Có hai trạng thái có thể xảy ra

Python chuyển đổi danh sách tuple thành danh sách chuỗi

hoặc

Python chuyển đổi danh sách tuple thành danh sách chuỗi

Trong một trường hợp,

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
39 và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
40 đề cập đến hai thứ khác nhau có cùng giá trị. Trong trường hợp thứ hai, chúng đề cập đến cùng một đối tượng

Chúng tôi có thể kiểm tra xem hai tên có cùng giá trị hay không bằng cách sử dụng

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
46

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
33

Chúng ta có thể kiểm tra xem hai tên có tham chiếu đến cùng một đối tượng hay không bằng cách sử dụng toán tử is

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
34

Điều này cho chúng ta biết rằng cả

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
39 và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
40 đều không đề cập đến cùng một đối tượng và đó là biểu đồ đầu tiên trong hai biểu đồ trạng thái mô tả mối quan hệ

3. 11. Răng cưa¶

Vì các biến tham chiếu đến các đối tượng, nếu chúng ta gán một biến cho một biến khác, thì cả hai biến đều tham chiếu đến cùng một đối tượng

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
35

Trong trường hợp này, đây là biểu đồ thứ hai trong hai biểu đồ trạng thái mô tả mối quan hệ giữa các biến

Bởi vì cùng một danh sách có hai tên khác nhau,

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
39 và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
40, chúng tôi nói rằng nó được đặt bí danh. Vì danh sách có thể thay đổi nên những thay đổi được thực hiện với một bí danh sẽ ảnh hưởng đến bí danh kia

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
36

Mặc dù hành vi này có thể hữu ích, nhưng đôi khi nó không mong muốn hoặc không mong muốn. Nói chung, tránh răng cưa sẽ an toàn hơn khi bạn đang làm việc với các đối tượng có thể thay đổi. Tất nhiên, đối với các đối tượng bất biến thì không có vấn đề gì, vì chúng không thể thay đổi sau khi chúng được tạo.

3. 12. Danh sách nhân bản¶

Nếu chúng tôi muốn sửa đổi một danh sách và cũng giữ một bản sao của bản gốc, chúng tôi cần có khả năng tạo một bản sao của chính danh sách đó, không chỉ tài liệu tham khảo. Quá trình này đôi khi được gọi là nhân bản, để tránh sự mơ hồ của từ sao chép

Cách dễ nhất để sao chép danh sách là sử dụng toán tử lát

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
37

Lấy bất kỳ phần nào của

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
39 sẽ tạo một danh sách mới. Trong trường hợp này, lát xảy ra bao gồm toàn bộ danh sách

Giờ đây, chúng tôi có thể tự do thực hiện các thay đổi đối với _______ 940 mà không phải lo lắng về ________ 939

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
38

3. 13. Danh sách lồng nhau¶

Danh sách lồng nhau là danh sách xuất hiện dưới dạng một phần tử trong danh sách khác. Trong danh sách này, phần tử có chỉ số 3 là danh sách lồng nhau

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
39

Nếu chúng tôi in

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
54, chúng tôi nhận được
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
55. Để trích xuất một phần tử từ danh sách lồng nhau, chúng ta có thể tiến hành theo hai bước

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
10

Hoặc chúng ta có thể kết hợp chúng

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
11

Các toán tử khung đánh giá từ trái sang phải, vì vậy biểu thức này lấy phần tử thứ ba của

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
56 và trích xuất phần tử thứ nhất từ ​​nó

3. 14. Chuỗi và danh sách¶

Python có một số công cụ kết hợp danh sách chuỗi thành chuỗi và tách chuỗi thành danh sách chuỗi

Lệnh

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
57 lấy một kiểu trình tự làm đối số và tạo một danh sách từ các phần tử của nó. Khi áp dụng cho một chuỗi, bạn sẽ nhận được một danh sách các ký tự

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
12

The

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
58 method invoked on a string and separates the string into a list of strings, breaking it apart whenever a substring called the delimiter occurs. Dấu phân cách mặc định là khoảng trắng, bao gồm dấu cách, tab và dòng mới

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
13

Ở đây chúng ta có

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
59 làm dấu phân cách

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
14

Lưu ý rằng dấu phân cách không xuất hiện trong danh sách

Phương pháp ________ 960 thực hiện gần như ngược lại với phương pháp ________ 958. Nó lấy một danh sách các chuỗi làm đối số và trả về một chuỗi gồm tất cả các phần tử danh sách được nối với nhau

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
15

Giá trị chuỗi mà phương thức

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
60 được gọi hoạt động như một dấu phân cách được đặt giữa mỗi phần tử trong danh sách trong chuỗi được trả về

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
16

Dấu phân cách cũng có thể là chuỗi rỗng

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
17

3. 15. Gán tuple¶

Once in a while, it is useful to swap the values of two variables. Với các câu lệnh gán thông thường, chúng ta phải sử dụng một biến tạm thời. Ví dụ: để hoán đổi

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
39 và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
40

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
18

Nếu chúng ta phải làm điều này thường xuyên, cách tiếp cận này trở nên cồng kềnh. Python cung cấp một dạng gán bộ giải quyết vấn đề này một cách gọn gàng

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
19

Phía bên trái là một bộ biến; . Mỗi giá trị được gán cho biến tương ứng của nó. Tất cả các biểu thức ở phía bên phải được đánh giá trước bất kỳ nhiệm vụ nào. Tính năng này làm cho phép gán tuple khá linh hoạt

Đương nhiên, số biến bên trái và số giá trị bên phải phải bằng nhau

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
30

3. 16. Giá trị Boolean¶

Bây giờ chúng ta sẽ xem xét một loại giá trị mới - giá trị boolean - được đặt tên theo nhà toán học người Anh, George Boole. Ông đã tạo ra toán học mà chúng ta gọi là đại số Boolean, là cơ sở của tất cả các số học máy tính hiện đại

Ghi chú

Đó là khả năng của máy tính để thay đổi luồng thực thi của nó tùy thuộc vào việc giá trị boolean là đúng hay sai khiến máy tính có mục đích chung không chỉ là một máy tính

Chỉ có hai giá trị boolean,

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
58 và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
13

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
31

Viết hoa là quan trọng, vì

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
67 và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
68 không phải là giá trị boolean trong Python

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
32

3. 17. Biểu thức Boolean¶

Một biểu thức boolean là một biểu thức đánh giá một giá trị boolean

Toán tử

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
46 so sánh hai giá trị và tạo ra một giá trị boolean

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
33

Trong câu lệnh đầu tiên, hai toán hạng bằng nhau, vì vậy biểu thức ước tính là

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
58;

Toán tử

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
46 là một trong sáu toán tử so sánh phổ biến;

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
34

Mặc dù các thao tác này có thể quen thuộc với bạn, nhưng các ký hiệu Python khác với các ký hiệu toán học. Một lỗi phổ biến là sử dụng một dấu bằng đơn (_______973) thay vì dấu bằng kép (

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
46). Hãy nhớ rằng
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
73 là toán tử gán và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
46 là toán tử so sánh. Ngoài ra, không có thứ gọi là
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
77 hoặc
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
78

3. 18. Toán tử logic¶

Có ba toán tử logic.

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
79,
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
80 và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
81. Ngữ nghĩa (nghĩa) của các toán tử này tương tự như nghĩa của chúng trong tiếng Anh. Ví dụ,
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
82 chỉ đúng nếu
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
83 lớn hơn 0 và đồng thời, x nhỏ hơn 10

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
84 là đúng nếu một trong hai điều kiện là đúng, nghĩa là nếu số đó chia hết cho 2 hoặc chia hết cho 3

Cuối cùng, toán tử

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
81 phủ định một biểu thức boolean, vì vậy
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
86 là true nếu
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
87 là false, nghĩa là, nếu
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
83 nhỏ hơn hoặc bằng
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
89

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
35

3. 19. Đánh giá ngắn mạch¶

Biểu thức Boolean trong Python sử dụng đánh giá ngắn mạch, có nghĩa là chỉ đối số đầu tiên của biểu thức

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
79 hoặc
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
80 được đánh giá khi giá trị của nó đủ để xác định giá trị của toàn bộ biểu thức

Điều này có thể khá hữu ích trong việc ngăn ngừa lỗi thời gian chạy. Hãy tưởng tượng bạn muốn kiểm tra xem số thứ năm trong bộ số nguyên có tên là

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
92 có phải là số chẵn không

Biểu thức sau sẽ hoạt động

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
36

tất nhiên trừ khi không có 5 yếu tố trong

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
92, trong trường hợp đó bạn sẽ nhận được

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
37

Đánh giá ngắn mạch giúp tránh được vấn đề này

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
38

Vì vế trái của biểu thức

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
79 này là sai, nên Python không cần đánh giá vế phải để xác định rằng toàn bộ biểu thức là sai. Vì nó sử dụng đánh giá ngắn mạch, nên nó không sử dụng và tránh được lỗi thời gian chạy

3. 20. “Sự thật”¶

Tất cả các giá trị Python đều có "độ đúng" hoặc "độ sai" có nghĩa là chúng có thể được sử dụng ở những nơi yêu cầu giá trị boolean. Đối với các loại số và chuỗi chúng ta đã thấy cho đến nay, tính trung thực được định nghĩa như sau

các loại số

Các giá trị bằng 0 là sai, tất cả các giá trị khác là đúng

các loại trình tự

Chuỗi rỗng là sai, chuỗi không trống là đúng

Kết hợp khái niệm về tính trung thực này với sự hiểu biết về đánh giá ngắn mạch giúp bạn có thể hiểu Python đang làm gì trong các biểu thức sau

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
39

3. 21. Bảng thuật ngữ¶

bí danh

Nhiều biến chứa tham chiếu đến cùng một đối tượng

giá trị boolean

Có chính xác hai giá trị boolean.

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
58 và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
13. Giá trị boolean là kết quả khi một biểu thức boolean được đánh giá bởi trình thông dịch Python. Họ có loại
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
97

biểu thức boolean

Một biểu thức đúng hoặc sai

dòng vô tính

Để tạo một đối tượng mới có cùng giá trị với một đối tượng hiện có. Sao chép tham chiếu đến đối tượng sẽ tạo bí danh nhưng không sao chép đối tượng

toán tử so sánh

Một trong những toán tử so sánh hai giá trị.

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
46,
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
99,
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
000,
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
001,
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
002 và
>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
003

kiểu dữ liệu ghép

Một kiểu dữ liệu trong đó các giá trị được tạo thành từ các thành phần hoặc phần tử mà chính chúng là các giá trị

yếu tố

Một trong những phần tạo nên một loại trình tự (chuỗi, danh sách hoặc bộ). Các phần tử có một giá trị và một chỉ số. Giá trị được truy cập bằng cách sử dụng toán tử chỉ mục (

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
004) trên chuỗi

kiểu dữ liệu bất biến

Một kiểu dữ liệu không thể sửa đổi. Việc gán cho các phần tử hoặc lát của các loại không thay đổi gây ra lỗi thời gian chạy

mục lục

Một biến hoặc giá trị được sử dụng để chọn một thành viên của bộ sưu tập có thứ tự, chẳng hạn như một ký tự từ một chuỗi hoặc một phần tử từ danh sách hoặc bộ

toán tử logic

Một trong những toán tử kết hợp các biểu thức boolean.

>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
79,
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
80 và
>>> thing = 2, 4, 6, 8
>>> type(thing)

>>> thing
(2, 4, 6, 8)
81

kiểu dữ liệu có thể thay đổi

Một kiểu dữ liệu có thể được sửa đổi. Tất cả các loại có thể thay đổi là loại hợp chất. Danh sách và từ điển là các kiểu dữ liệu có thể thay đổi;

danh sách lồng nhau

Một danh sách là một phần tử của một danh sách khác

lát cắt

Một phần của chuỗi (chuỗi con) được chỉ định bởi một dải chỉ số. Tổng quát hơn, có thể tạo một chuỗi con của bất kỳ loại chuỗi nào trong Python bằng cách sử dụng toán tử lát cắt (

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
008)

cỡ bước chân

Khoảng cách giữa các phần tử liên tiếp của một chuỗi tuyến tính. Đối số thứ ba (và đối số tùy chọn) của hàm

>>> seq = [1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]
>>> last = seq[len(seq)]       # ERROR!
009 được gọi là kích thước bước. Nếu không được chỉ định, nó sẽ mặc định là 1

đi qua

Để lặp qua các phần tử của một bộ sưu tập, thực hiện một thao tác tương tự trên mỗi phần tử

tuple

Một kiểu dữ liệu chứa một chuỗi các phần tử thuộc bất kỳ kiểu nào, như danh sách, nhưng không thay đổi. Các bộ dữ liệu có thể được sử dụng ở bất cứ nơi nào yêu cầu một loại bất biến, chẳng hạn như một khóa trong từ điển (xem chương tiếp theo)

phân công tuple

Một phép gán cho tất cả các phần tử trong một bộ sử dụng một câu lệnh gán duy nhất. Việc gán bộ xảy ra song song thay vì theo thứ tự, làm cho nó hữu ích cho việc hoán đổi giá trị

Chúng ta có thể chuyển đổi tuple thành danh sách không?

Phương thức danh sách Python list() lấy các loại trình tự và chuyển đổi chúng thành danh sách . Điều này được sử dụng để chuyển đổi một bộ dữ liệu đã cho thành danh sách. Lưu ý - Bộ dữ liệu rất giống với danh sách chỉ khác là giá trị phần tử của bộ dữ liệu không thể thay đổi và phần tử bộ dữ liệu được đặt giữa dấu ngoặc đơn thay vì dấu ngoặc vuông.

Làm cách nào bạn có thể lấy dạng bộ dữ liệu của một giá trị danh sách?

1) Sử dụng hàm dựng sẵn tuple() . Khi bạn muốn chuyển đổi danh sách python thành một tuple, bạn có thể chuyển toàn bộ danh sách dưới dạng tham số trong hàm tuple() và nó sẽ trả về kiểu dữ liệu tuple dưới dạng đầu ra.