Danh sách số Python

Danh sách là một tập hợp các giá trị được sắp xếp theo thứ tự. Nó có thể chứa các loại giá trị khác nhau. Một danh sách là một thùng chứa có thể thay đổi. Điều này có nghĩa là chúng ta có thể thêm giá trị, xóa giá trị hoặc sửa đổi giá trị hiện có

Danh sách Python đại diện cho một khái niệm toán học về một chuỗi hữu hạn. Các giá trị của một danh sách được gọi là các phần tử hoặc các phần tử của danh sách. Một danh sách có thể chứa cùng một giá trị nhiều lần. Mỗi lần xuất hiện được coi là một mục riêng biệt

Danh sách Python đơn giản

Các phần tử danh sách có thể được truy cập bằng chỉ mục của chúng. Phần tử đầu tiên có chỉ số 0, phần tử cuối cùng có chỉ số -1

#!/usr/bin/python

# simple.py

nums = [1, 2, 3, 4, 5]

print(nums[0])
print(nums[-1])
print(nums)

Đây là một danh sách đơn giản có năm yếu tố. Danh sách được giới hạn bởi dấu ngoặc vuông

nums = [1, 2, 3, 4, 5]

51. Các phần tử của danh sách được phân tách bằng dấu phẩy. Nội dung của danh sách được in ra bàn điều khiển

nums = [1, 2, 3, 4, 5]

Phía bên phải của bài tập là một danh sách Python theo nghĩa đen. Nó tạo ra một danh sách chứa năm yếu tố

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

Danh sách có thể chứa các phần tử thuộc nhiều kiểu dữ liệu khác nhau

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

Trong ví dụ, chúng tôi tạo một danh sách đối tượng. Nó chứa các số, một giá trị boolean, một danh sách khác, một chuỗi, một bộ, một đối tượng tùy chỉnh và một từ điển

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

Khởi tạo danh sách Python

Đôi khi chúng ta cần khởi tạo trước một danh sách để có một số phần tử cụ thể

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

Trong ví dụ này, chúng tôi khởi tạo hai danh sách bằng cách sử dụng hiểu danh sách và toán tử *

n1 = [0 for i in range(15)]
n2 = [0] * 15

Hai danh sách này được khởi tạo thành mười lăm số không

________số 8

Mười giá trị đầu tiên được thay thế bằng 10 giây

$ ./initialization.py
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]

Hàm danh sách Python

Hàm

nums = [1, 2, 3, 4, 5]

52 tạo danh sách từ một đối tượng có thể lặp lại. Một iterable có thể là một chuỗi, một vùng chứa hỗ trợ phép lặp hoặc một đối tượng lặp. Nếu không có tham số nào được chỉ định, một danh sách trống mới sẽ được tạo

nums = [1, 2, 3, 4, 5]

1

Trong ví dụ, chúng tôi tạo một danh sách trống, một danh sách từ một tuple, một chuỗi và một danh sách khác

nums = [1, 2, 3, 4, 5]

0

Đây là hai cách để tạo một danh sách trống

nums = [1, 2, 3, 4, 5]

1

Dòng in

nums = [1, 2, 3, 4, 5]

53. Điều này xác nhận rằng

nums = [1, 2, 3, 4, 5]

54 và

nums = [1, 2, 3, 4, 5]

55 bằng nhau

nums = [1, 2, 3, 4, 5]

2

Chúng tôi tạo một danh sách từ một tuple Python

nums = [1, 2, 3, 4, 5]

3

Dòng này tạo ra một danh sách từ một chuỗi

nums = [1, 2, 3, 4, 5]

4

Cuối cùng, chúng tôi tạo một bản sao của danh sách các chuỗi

nums = [1, 2, 3, 4, 5]

5

Hoạt động danh sách Python

Đoạn mã sau hiển thị một số thao tác danh sách cơ bản

nums = [1, 2, 3, 4, 5]

6

Chúng tôi xác định hai danh sách các số nguyên. Chúng tôi sử dụng một vài toán tử trong các danh sách này

nums = [1, 2, 3, 4, 5]

7

Nội dung của các danh sách được so sánh với toán tử

nums = [1, 2, 3, 4, 5]

56. Dòng in

nums = [1, 2, 3, 4, 5]

57 vì các phần tử khác nhau

nums = [1, 2, 3, 4, 5]

8

Danh sách

nums = [1, 2, 3, 4, 5]

58 và

nums = [1, 2, 3, 4, 5]

59 được thêm vào để tạo thành danh sách mới. Danh sách mới có tất cả các phần tử của cả hai danh sách

nums = [1, 2, 3, 4, 5]

9

Chúng tôi sử dụng toán tử nhân trên danh sách. Nó lặp lại các phần tử n lần;

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

0

Chúng tôi sử dụng toán tử

nums = [1, 2, 3, 4, 5]

60 để tìm hiểu xem giá trị có trong danh sách hay không. Nó trả về giá trị boolean

nums = [1, 2, 3, 4, 5]

53 hoặc

nums = [1, 2, 3, 4, 5]

57

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

1

Hàm trình tự Python

Các hàm trình tự có thể được sử dụng trên bất kỳ loại trình tự nào, bao gồm cả danh sách

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

2

Trong ví dụ trên, chúng ta có bốn chức năng. ________ 163, ________ 164, ________ 165 và ________ 166

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

3

Hàm

nums = [1, 2, 3, 4, 5]

63 trả về kích thước của danh sách. Số phần tử của danh sách

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

4

Hàm

nums = [1, 2, 3, 4, 5]

64 và

nums = [1, 2, 3, 4, 5]

65 trả về giá trị lớn nhất và giá trị nhỏ nhất của danh sách

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

5

Hàm

nums = [1, 2, 3, 4, 5]

66 tính tổng các số của danh sách

nums = [1, 2, 3, 4, 5]

71

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

6

Python thêm các phần tử danh sách

Phần này sẽ chỉ ra cách các phần tử được thêm vào danh sách Python

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

7

Chúng tôi có ba phương pháp để thêm các phần tử mới vào danh sách.

nums = [1, 2, 3, 4, 5]

72,

nums = [1, 2, 3, 4, 5]

73 và

nums = [1, 2, 3, 4, 5]

74

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

8

Một danh sách trống được tạo

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

9

Phương thức

nums = [1, 2, 3, 4, 5]

72 thêm một mục vào cuối danh sách;

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

0

Phương thức

nums = [1, 2, 3, 4, 5]

73 đặt một phần tử tại một vị trí cụ thể được chỉ định bởi số chỉ mục. Chuỗi ________ 177 được chèn ở vị trí đầu tiên, chuỗi ________ 178 ở vị trí thứ ba. Lưu ý rằng các số chỉ mục danh sách bắt đầu từ số không

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

1

Phương thức

nums = [1, 2, 3, 4, 5]

74 thêm một chuỗi giá trị vào cuối danh sách. Trong trường hợp của chúng tôi, hai chuỗi của một bộ Python được thêm vào cuối danh sách của chúng tôi

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

2

Danh sách Python IndexError

nums = [1, 2, 3, 4, 5]

80 được nâng lên khi chỉ số dưới danh sách nằm ngoài phạm vi

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

3

Trong tập lệnh, chúng tôi đã xác định danh sách năm số nguyên. Các phần tử này có chỉ số 0, 1, 2, 3 và 4. Sử dụng chỉ mục lớn hơn dẫn đến lỗi

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

4

Chỉ số 6 nằm ngoài phạm vi cho danh sách của chúng tôi. Một

nums = [1, 2, 3, 4, 5]

80 được ném

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

5

Chúng tôi bắt lỗi bằng cách sử dụng mệnh đề

nums = [1, 2, 3, 4, 5]

82. Trong phần nội dung của mệnh đề, chúng tôi in thông báo lỗi

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

6

Danh sách Python TypeError

Nếu một chỉ mục của một tuple không phải là một số nguyên đơn giản thì một

nums = [1, 2, 3, 4, 5]

83 được ném ra

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

7

Ví dụ này ném một

nums = [1, 2, 3, 4, 5]

83

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

8

Chỉ mục danh sách phải là số nguyên. Các loại khác kết thúc bằng lỗi

#!/usr/bin/python

# various_types.py

class Being:
    pass

objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}]
print(objects)

9

Trong khối ngoại trừ, chúng tôi in tên của tệp, nơi ngoại lệ đã xảy ra và chuỗi thông báo

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

0

Danh sách Python loại bỏ các phần tử

Trước đây chúng tôi đã thêm các mục vào danh sách. Bây giờ chúng tôi sẽ xóa chúng khỏi danh sách

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

1

Phương thức

nums = [1, 2, 3, 4, 5]

85 loại bỏ và trả về một phần tử có chỉ mục được chỉ định hoặc phần tử cuối cùng nếu số chỉ mục không được cung cấp. Phương thức

nums = [1, 2, 3, 4, 5]

86 xóa một mục cụ thể khỏi danh sách

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

2

Chúng tôi lấy đi phần tử có chỉ số 3. Phương thức

nums = [1, 2, 3, 4, 5]

85 trả về tên của phần tử đã bị xóa;

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

3

Phần tử cuối cùng trong danh sách, cụ thể là chuỗi

nums = [1, 2, 3, 4, 5]

88, bị xóa khỏi danh sách

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

4

Dòng này xóa một chuỗi

nums = [1, 2, 3, 4, 5]

89 khỏi danh sách

nums = [1, 2, 3, 4, 5]

90

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

5

Từ đầu ra của tập lệnh, chúng ta có thể thấy tác dụng của các phương thức được mô tả

Từ khóa

nums = [1, 2, 3, 4, 5]

91 cũng có thể được sử dụng để xóa các thành phần danh sách

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

6

Chúng tôi có một danh sách các chuỗi. Chúng tôi sử dụng từ khóa

nums = [1, 2, 3, 4, 5]

91 để xóa các phần tử danh sách

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

7

Chúng tôi xóa chuỗi thứ hai khỏi danh sách. Đó là chuỗi

nums = [1, 2, 3, 4, 5]

89

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

8

Chúng tôi chỉ có thể xóa các phần tử hiện có. Nếu chúng tôi bỏ ghi chú dòng mã, chúng tôi sẽ nhận được thông báo

nums = [1, 2, 3, 4, 5]

80

$ ./various_types.py
[1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3),
    <__main__.Being instance at 0x7f653577f6c8>, {}]

9

Ở đây chúng tôi xóa tất cả các phần tử còn lại khỏi danh sách. Các ký tự

nums = [1, 2, 3, 4, 5]

95 đề cập đến tất cả các mục của danh sách

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

0

Python sửa đổi các phần tử danh sách

Trong ví dụ tiếp theo, chúng tôi sẽ sửa đổi các phần tử danh sách

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

1

Trong ví dụ này, chúng tôi sửa đổi phần tử thứ ba của danh sách langs hai lần

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

2

Một cách để sửa đổi một phần tử là loại bỏ phần tử đó và đặt một phần tử khác vào cùng một vị trí

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

3

Phương pháp khác đơn giản hơn. Chúng tôi chỉ định một phần tử mới tại một vị trí nhất định. Bây giờ lại có chuỗi

nums = [1, 2, 3, 4, 5]

96 ở vị trí thứ ba

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

4

Danh sách sao chép Python

Có một số cách để chúng ta có thể sao chép một danh sách trong Python. Chúng tôi sẽ đề cập đến một vài trong số họ

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

5

Chúng tôi có một danh sách gồm ba chuỗi. Chúng tôi tạo một bản sao của danh sách bảy lần

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

6

Chúng tôi nhập mô-đun

nums = [1, 2, 3, 4, 5]

97 có hai phương thức sao chép

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

7

Một danh sách được sao chép bằng cú pháp lát

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

8

Hàm

nums = [1, 2, 3, 4, 5]

52 tạo một bản sao của danh sách khi nó lấy danh sách làm tham số

#!/usr/bin/python

n1 = [0 for i in range(15)]
n2 = [0] * 15

print(n1)
print(n2)

n1[0:10] = [10] * 10

print(n1)

9

Phương pháp

nums = [1, 2, 3, 4, 5]

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

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

00 tạo ra một bản sao sâu của một danh sách

n1 = [0 for i in range(15)]
n2 = [0] * 15

0

Một bản sao của chuỗi được tạo bằng cách sử dụng khả năng hiểu danh sách

n1 = [0 for i in range(15)]
n2 = [0] * 15

1

Một bản sao được tạo bởi vòng lặp

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

01

n1 = [0 for i in range(15)]
n2 = [0] * 15

2

Phương pháp

nums = [1, 2, 3, 4, 5]

74 cũng có thể được sử dụng để tạo một bản sao

n1 = [0 for i in range(15)]
n2 = [0] * 15

3

Bảy bản sao của danh sách chuỗi được tạo bằng các kỹ thuật khác nhau

Các phần tử danh sách lập chỉ mục Python

Các phần tử trong danh sách Python có thể được truy cập bằng chỉ mục của chúng. Số chỉ mục là số nguyên; . Các chỉ mục có thể âm; . Mục đầu tiên trong danh sách có chỉ số 0, mục cuối cùng có -1

n1 = [0 for i in range(15)]
n2 = [0] * 15

4

Chúng ta có thể truy cập một phần tử của danh sách theo chỉ mục của nó. Chỉ mục được đặt giữa dấu ngoặc vuông

nums = [1, 2, 3, 4, 5]

51 sau tên của danh sách

n1 = [0 for i in range(15)]
n2 = [0] * 15

5

Ba dòng này in mục đầu tiên, cuối cùng và cuối cùng trừ một mục của danh sách

n1 = [0 for i in range(15)]
n2 = [0] * 15

6

Hai dòng in phần tử thứ tư và thứ sáu của danh sách

n1 = [0 for i in range(15)]
n2 = [0] * 15

7

Phương thức

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

04 tìm kiếm một phần tử cụ thể và trả về chỉ số thấp nhất của nó. Bắt đầu và kết thúc là các tham số tùy chọn giới hạn tìm kiếm trong các ranh giới nhất định

n1 = [0 for i in range(15)]
n2 = [0] * 15

8

Một ví dụ mã với phương thức

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

05

n1 = [0 for i in range(15)]
n2 = [0] * 15

9

Hai dòng này in các chỉ mục của các giá trị 1, 2 ngoài cùng bên trái của danh sách n

n1[0:10] = [10] * 10

0

Ở đây chúng tôi tìm kiếm các giá trị 1 và 2 sau các chỉ mục được chỉ định

n1[0:10] = [10] * 10

1

Ở đây chúng tôi tìm kiếm giá trị 1 giữa các giá trị có chỉ số 2 và 5

n1[0:10] = [10] * 10

2

Danh sách lát Python

Cắt danh sách là một thao tác trích xuất các phần tử nhất định từ một danh sách và tạo chúng thành một danh sách khác. Có thể với số lượng chỉ số khác nhau và phạm vi chỉ số khác nhau

Cú pháp để cắt danh sách như sau

n1[0:10] = [10] * 10

3

Các phần bắt đầu, kết thúc, bước của cú pháp là số nguyên. Mỗi người trong số họ là tùy chọn. Chúng có thể là cả tích cực và tiêu cực. Giá trị có chỉ số kết thúc không được bao gồm trong lát cắt

n1[0:10] = [10] * 10

4

Chúng tôi tạo bốn lát từ danh sách tám số nguyên

n1[0:10] = [10] * 10

5

Lát đầu tiên có các giá trị với chỉ số 1, 2, 3 và 4. Danh sách mới được tạo là [2, 3, 4, 5]

n1[0:10] = [10] * 10

6

Nếu chỉ mục bắt đầu bị bỏ qua thì giá trị mặc định được giả định là 0. Lát là [1, 2, 3, 4, 5]

n1[0:10] = [10] * 10

7

Nếu chỉ mục kết thúc bị bỏ qua, giá trị mặc định -1 được lấy. Trong trường hợp như vậy, một lát cắt đưa tất cả các giá trị vào cuối danh sách

n1[0:10] = [10] * 10

8

Thậm chí cả hai chỉ mục có thể bị bỏ qua. Cú pháp này tạo một bản sao của danh sách

n1[0:10] = [10] * 10

9

Chỉ mục thứ ba trong cú pháp lát cắt là bước. Nó cho phép chúng tôi lấy mọi giá trị thứ n từ danh sách

$ ./initialization.py
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]

0

Chúng tôi tạo bốn danh sách mới bằng cách sử dụng giá trị bước

$ ./initialization.py
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]

1

Ở đây chúng tôi tạo một lát có mọi phần tử thứ hai từ danh sách n, bắt đầu từ phần tử thứ hai, kết thúc bằng phần tử thứ tám. Danh sách mới có các yếu tố sau. [2, 4, 6, 8]

$ ./initialization.py
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]

2

Ở đây chúng tôi tạo một lát cắt bằng cách lấy mọi giá trị thứ hai từ đầu đến cuối danh sách

$ ./initialization.py
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]

3

Điều này tạo ra một bản sao của một danh sách

$ ./initialization.py
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]

4

Slice có mọi phần tử thứ ba, bắt đầu từ phần tử thứ hai đến cuối danh sách

$ ./initialization.py
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]

5

Các chỉ mục có thể là số âm. Chỉ mục tiêu cực đề cập đến các giá trị từ cuối danh sách. Phần tử cuối cùng có chỉ số -1, phần tử cuối cùng nhưng có chỉ số -2, v.v. Các chỉ mục có số âm thấp hơn phải xuất hiện trước trong cú pháp. Điều này có nghĩa là chúng ta viết [-6, -2] thay vì [-2, -6]. Cái sau trả về một danh sách trống

$ ./initialization.py
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]

6

Trong tập lệnh này, chúng tôi tạo thành năm danh sách. Chúng tôi cũng sử dụng số chỉ số âm

$ ./initialization.py
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]

7

Dòng đầu tiên trả về [5, 6, 7], dòng thứ hai trả về danh sách trống. Chỉ số thấp hơn phải đến trước chỉ số cao hơn

$ ./initialization.py
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]

8

Điều này tạo ra một danh sách đảo ngược

$ ./initialization.py
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]

9

Cú pháp được đề cập ở trên có thể được sử dụng trong các bài tập. Phải có một iterable ở phía bên phải của bài tập

nums = [1, 2, 3, 4, 5]

10

Chúng tôi có một danh sách tám số nguyên. Chúng tôi sử dụng cú pháp lát cắt để thay thế các phần tử bằng các giá trị mới

Danh sách vòng lặp Python

Phần này sẽ chỉ ra ba cách cơ bản để duyệt qua một danh sách trong Python

nums = [1, 2, 3, 4, 5]

11

Cách đầu tiên là cách đơn giản nhất để duyệt qua danh sách

nums = [1, 2, 3, 4, 5]

12

Chúng tôi có một danh sách số. Có năm số nguyên trong danh sách

nums = [1, 2, 3, 4, 5]

13

Sử dụng vòng lặp

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

01, chúng tôi duyệt từng danh sách một và in phần tử hiện tại ra bàn điều khiển

nums = [1, 2, 3, 4, 5]

14

Đây là đầu ra của kịch bản. Các số nguyên được in ra thiết bị đầu cuối

Ví dụ thứ hai dài dòng hơn một chút

nums = [1, 2, 3, 4, 5]

15

Chúng tôi đang duyệt qua danh sách bằng cách sử dụng vòng lặp

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

07

nums = [1, 2, 3, 4, 5]

16

Trước tiên, chúng ta cần xác định bộ đếm và tìm kích thước của danh sách

nums = [1, 2, 3, 4, 5]

17

Với sự trợ giúp của hai số này, chúng tôi xem qua danh sách và in từng phần tử ra thiết bị đầu cuối

Hàm tích hợp

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

08 cung cấp cho chúng ta cả chỉ mục và giá trị của danh sách trong một vòng lặp

nums = [1, 2, 3, 4, 5]

18

Trong ví dụ này, chúng tôi in các giá trị và chỉ mục của các giá trị

nums = [1, 2, 3, 4, 5]

19

Các phần tử danh sách đếm Python

Đôi khi điều quan trọng là phải đếm các phần tử danh sách. Đối với điều này, Python có phương thức

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

09

nums = [1, 2, 3, 4, 5]

00

Trong ví dụ này, chúng tôi đếm số lần xuất hiện của một vài số trong danh sách

nums = [1, 2, 3, 4, 5]

71

nums = [1, 2, 3, 4, 5]

01

Chúng tôi có một danh sách các số nguyên. Số nguyên 1 và 4 xuất hiện nhiều lần

nums = [1, 2, 3, 4, 5]

02

Dùng phương pháp

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

09 ta tìm ra sự xuất hiện của các số 4, 1, 2, 6

nums = [1, 2, 3, 4, 5]

03

Số 4 xuất hiện 3 lần, 1 lần xuất hiện, 2 lần xuất hiện và số 6 không xuất hiện trong danh sách

Danh sách lồng nhau trong Python

Có thể lồng danh sách vào danh sách khác. Với danh sách lồng nhau, một thứ nguyên mới được tạo. Để truy cập danh sách lồng nhau, người ta cần thêm dấu ngoặc vuông

nums = [1, 2, 3, 4, 5]

51

nums = [1, 2, 3, 4, 5]

04

Trong ví dụ này, chúng ta có ba danh sách lồng nhau có hai phần tử mỗi danh sách

nums = [1, 2, 3, 4, 5]

05

Ba danh sách lồng nhau của danh sách nums được in ra bàn điều khiển

nums = [1, 2, 3, 4, 5]

06

Ở đây chúng tôi in hai phần tử của danh sách lồng nhau đầu tiên.

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

13 đề cập đến danh sách lồng nhau đầu tiên;

nums = [1, 2, 3, 4, 5]

07

Dòng in 3. Mỗi danh sách lồng nhau được tính là một phần tử. Các yếu tố bên trong của nó không được tính đến

nums = [1, 2, 3, 4, 5]

08

Ví dụ thứ hai có các thứ nguyên bổ sung

nums = [1, 2, 3, 4, 5]

09

Trong ví dụ, danh sách [5, 6] được lồng vào [3, 4,. ] danh sách, [3, 4, [4, 6]] được lồng vào [1, 2,. ] danh sách cuối cùng là một phần tử của danh sách

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

15

nums = [1, 2, 3, 4, 5]

10

Ba dòng này in các danh sách lồng vào bàn điều khiển

nums = [1, 2, 3, 4, 5]

11

Ở đây ba yếu tố được truy cập. Dấu ngoặc vuông bổ sung

nums = [1, 2, 3, 4, 5]

51 là cần thiết khi đề cập đến danh sách bên trong

nums = [1, 2, 3, 4, 5]

12

Danh sách sắp xếp Python

Trong phần này, chúng tôi sắp xếp các phần tử danh sách. Python có một hàm danh sách tích hợp sẵn

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

17 và hàm

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

18 để thực hiện sắp xếp

nums = [1, 2, 3, 4, 5]

13

Trong ví dụ mã, chúng tôi có một danh sách các số nguyên chưa được sắp xếp. Chúng tôi sắp xếp các phần tử bằng phương thức

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

17. Phương thức sắp xếp các phần tử tại chỗ;

nums = [1, 2, 3, 4, 5]

14

Phương thức

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

17 sắp xếp các phần tử theo thứ tự tăng dần

nums = [1, 2, 3, 4, 5]

15

Với tham số đảo ngược được đặt thành

nums = [1, 2, 3, 4, 5]

53, danh sách được sắp xếp theo thứ tự giảm dần

nums = [1, 2, 3, 4, 5]

16

Ở đầu ra, chúng ta có thể thấy danh sách gốc, danh sách được sắp xếp theo thứ tự tăng dần và giảm dần

Nếu không muốn thay đổi danh sách ban đầu, chúng ta có thể sử dụng hàm

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

18. Hàm này tạo một danh sách được sắp xếp mới

nums = [1, 2, 3, 4, 5]

17

Trong ví dụ này, chúng tôi sử dụng hàm

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

18 để sắp xếp các phần tử của danh sách

nums = [1, 2, 3, 4, 5]

18

Từ đầu ra của tập lệnh, chúng ta có thể thấy rằng danh sách ban đầu không bị sửa đổi

Phương thức

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

17 có tham số

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

25 tùy chọn. Tham số chỉ định một hàm được gọi trên mỗi phần tử danh sách trước khi thực hiện so sánh

nums = [1, 2, 3, 4, 5]

19

Ví dụ tạo so sánh chuỗi phân biệt chữ hoa chữ thường và chữ hoa chữ thường

nums = [1, 2, 3, 4, 5]

20

Để tạo so sánh không phân biệt chữ hoa chữ thường, chúng tôi thêm hàm

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

26 vào tham số

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

25

nums = [1, 2, 3, 4, 5]

21

Chúng tôi cần thực hiện thêm công việc nếu muốn sắp xếp chuỗi Unicode

nums = [1, 2, 3, 4, 5]

22

Chúng tôi có một danh sách sáu chuỗi unicode. Chúng tôi thay đổi cài đặt ngôn ngữ để sắp xếp các chuỗi theo tùy chọn ngôn ngữ hiện tại

nums = [1, 2, 3, 4, 5]

23

Chúng tôi nhập mô-đun

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

28 và chức năng chuyển đổi

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

29

nums = [1, 2, 3, 4, 5]

24

Đây là danh sách sáu chuỗi. Các chuỗi bằng tiếng Slovak và có một số dấu phụ. Các em đóng vai sắp xếp các kí tự cho đúng

nums = [1, 2, 3, 4, 5]

25

Chúng tôi đặt cài đặt ngôn ngữ cho ngôn ngữ tiếng Slovak

nums = [1, 2, 3, 4, 5]

26

Chúng tôi sắp xếp danh sách.

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

30 so sánh hai chuỗi theo cài đặt

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

31 hiện tại. Hàm

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

29 chuyển đổi hàm so sánh

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

33 thành hàm khóa

nums = [1, 2, 3, 4, 5]

27

Chúng tôi in các từ đã sắp xếp ra bàn điều khiển

nums = [1, 2, 3, 4, 5]

28

Các yếu tố đã được sắp xếp chính xác. Các chi tiết cụ thể của bảng chữ cái tiếng Slovak đã được tính đến

Các phần tử danh sách đảo ngược Python

Chúng ta có thể đảo ngược các phần tử trong danh sách theo một số cách trong Python. Không nên nhầm lẫn các yếu tố đảo ngược với sắp xếp theo cách đảo ngược

nums = [1, 2, 3, 4, 5]

29

Trong ví dụ này, chúng ta có ba danh sách chuỗi giống hệt nhau. Chúng tôi đảo ngược các yếu tố theo ba cách khác nhau

nums = [1, 2, 3, 4, 5]

30

Cách đầu tiên là sử dụng phương thức

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

34

nums = [1, 2, 3, 4, 5]

31

Hàm

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

35 trả về một trình vòng lặp đảo ngược. Chúng tôi sử dụng trình vòng lặp trong vòng lặp for và tạo một danh sách đảo ngược mới

nums = [1, 2, 3, 4, 5]

32

Cách thứ ba là đảo ngược danh sách bằng cú pháp lát cắt, trong đó tham số bước được đặt thành -1

nums = [1, 2, 3, 4, 5]

33

Tất cả ba danh sách đã được đảo ngược OK

Hiểu danh sách Python

Hiểu danh sách là một cấu trúc cú pháp tạo danh sách dựa trên danh sách hiện có. Cú pháp bị ảnh hưởng bởi ký hiệu toán học của tập hợp. Cú pháp Python được lấy cảm hứng từ ngôn ngữ lập trình Haskell

nums = [1, 2, 3, 4, 5]

34

Mã giả ở trên cho thấy cú pháp của việc hiểu danh sách. Việc hiểu danh sách tạo ra một danh sách mới. Nó dựa trên một danh sách hiện có. Một vòng lặp for đi qua chuỗi. Đối với mỗi vòng lặp, một biểu thức được ước tính nếu điều kiện được đáp ứng. Nếu giá trị được tính toán, nó sẽ được thêm vào danh sách mới. Điều kiện là tùy chọn

Khả năng hiểu danh sách cung cấp một cách ngắn gọn hơn để tạo danh sách trong các tình huống có thể sử dụng các vòng lặp

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

36 và

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

37 và/hoặc lồng nhau

nums = [1, 2, 3, 4, 5]

35

Trong ví dụ này, chúng tôi đã xác định một danh sách các số. Với sự trợ giúp của việc hiểu danh sách, chúng tôi tạo một danh sách mới các số không thể chia hết cho 2 mà không có phần còn lại

nums = [1, 2, 3, 4, 5]

36

nums = [1, 2, 3, 4, 5]

37

Ở đây chúng ta có sự hiểu biết về danh sách. Trong vòng lặp

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

38, mỗi phần tử của danh sách được lấy. Sau đó, một điều kiện

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

39 được kiểm tra. Nếu điều kiện được đáp ứng, một biểu thức được đánh giá. Trong trường hợp của chúng tôi, biểu thức là một

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

40 thuần túy lấy phần tử như nó vốn có. Cuối cùng, phần tử được thêm vào danh sách

nums = [1, 2, 3, 4, 5]

38

các số trong danh sách không thể chia hết cho 2 mà không có số dư

Trong ví dụ thứ hai, chúng tôi so sánh khả năng hiểu danh sách với vòng lặp for truyền thống

nums = [1, 2, 3, 4, 5]

39

Trong ví dụ chúng ta có một chuỗi. Chúng tôi muốn tạo một danh sách mã số nguyên ASCII của các chữ cái trong chuỗi

nums = [1, 2, 3, 4, 5]

40

Chúng tôi tạo một danh sách như vậy với vòng lặp for

nums = [1, 2, 3, 4, 5]

41

Ở đây, điều tương tự cũng được tạo ra bằng cách sử dụng cách hiểu danh sách. Lưu ý rằng nếu điều kiện đã được bỏ qua. nó là tùy chọn

nums = [1, 2, 3, 4, 5]

42

Kiểm tra mức độ hiểu danh sách Python để biết thêm chi tiết

Hàm bản đồ và bộ lọc Python

Các hàm

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

36 và

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

37 là các hàm khối lượng hoạt động trên tất cả các mục trong danh sách. Chúng là một phần của lập trình chức năng được tích hợp trong ngôn ngữ Python

Ngày nay, nên sử dụng khả năng hiểu danh sách thay vì các chức năng này nếu có thể

nums = [1, 2, 3, 4, 5]

43

Hàm

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

36 áp dụng một hàm cụ thể cho mọi thành phần của danh sách

nums = [1, 2, 3, 4, 5]

44

Đây là định nghĩa của hàm được sử dụng bởi hàm

$ ./simple.py
1
5
[1, 2, 3, 4, 5]

37. Nó trả về

nums = [1, 2, 3, 4, 5]

53 hoặc

nums = [1, 2, 3, 4, 5]

57. Các hàm trả về một giá trị boolean được gọi là các vị từ