programming python

Bắt đầu kết thúc Python

Ký hiệu cắt lát [bắt đầu. stop] có nghĩa là mảng được cắt từ chỉ mục bắt đầu và dừng tại điểm dừng – 1. Vì vậy, điểm dừng chỉ định giá trị đầu tiên không nằm trong phạm vi đã chọn

Bạn cũng có thể bỏ qua các thông số này

  • Để trống bắt đầu có nghĩa là lát cắt bắt đầu ở phần tử đầu tiên
  • Để trống phần cuối có nghĩa là lát kết thúc đến phần tử cuối cùng
a[start:stop]  # elements from start to stop-1
a[start:]      # elements start to the end
a[:stop]       # elements from the beginning to stop-1
a[:]           # elements from first element to last [copies the iterable].

ví dụ

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]

Giá trị bắt đầu và dừng cũng có thể âm

  • Nếu bắt đầu là số âm, việc đếm bắt đầu từ cuối
  • Nếu dừng là âm, việc đếm sẽ dừng lại đối với kết thúc
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]

[bắt đầu. dừng lại. cỡ bước chân]

Một cách khác để cắt các lần lặp trong Python là chỉ định đối số thứ ba, kích thước bước, cho cú pháp cắt

[start:stop:stepsize]

Mặt khác, điều này hoạt động giống như [bắt đầu. dừng] cú pháp. Sự khác biệt duy nhất là kích thước bước hiện chỉ định số lượng phần tử sẽ nhảy qua khi cắt

ví dụ

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

# Every third element from index 1 to 8.
arr[1:8:3]   # ["B", E", H"]

# Every second element through out the list
arr[::2]     # ["A", "C", "E", "G", "I"]

Ngoài ra, kích thước bước có thể âm

Trong trường hợp này, hướng cắt bị đảo ngược

ví dụ

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2::-1]   # ["C", "B", "A"]
arr[:-4:-1]  # ["J", "I", "H"]
arr[-4::-1]  # ["G", "F", "E", "D", "C", "B", "A"]
arr[::-1]    # ["J", "I", "H", G", "F", "E", "D", "C", "B", "A"]

Đối tượng Slice là gì?

Toán tử cắt lát [] có liên quan đến đối tượng lát cắt trong Python

Dưới đây là một minh họa về cách sử dụng [] và các đối tượng lát liên quan đến nhau trong các tình huống khác nhau

Hàm 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 trong Python tạo chuỗi số bất biến bắt đầu từ số nguyên bắt đầu đã cho đến số nguyên dừng. 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 là một hàm tích hợp trả về một đối tượng phạm vi bao gồm một chuỗi các số nguyên, mà chúng ta có thể lặp lại bằng cách sử dụng vòng lặp 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
4

Trong Python, Sử dụng vòng lặp for với 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2, chúng ta có thể lặp lại một hành động với số lần cụ thể. Ví dụ: hãy xem cách sử dụng hàm 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 của Python 3 để tạo sáu số đầu tiên

Ví dụ

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
1

đầu ra

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
2

Hàm phạm vi Python []

Ghi chú. Như bạn có thể thấy ở đầu ra, Chúng tôi có sáu số nguyên bắt đầu từ 0 đến 5. Nếu bạn để ý, 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 không bao gồm 6 trong kết quả của nó bởi vì nó tạo ra các số cho đến số dừng nhưng không bao giờ bao gồm số dừng trong kết quả của nó

Giải quyết

  • Phạm vi Python[] và bài tập vòng lặp for
  • Trắc nghiệm vòng lặp Python
  • Tóm tắt các hoạt động phạm vi []

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 hoạt động khác nhau giữa Python 3 và Python 2

Xem phạm vi [] trong Python 2

  • Trong Python 2, chúng ta có các hàm 
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    2 và 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    60 để tạo ra một dãy số
  • Trong Python 3 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    60 được đổi tên thành 
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    2 và hàm 
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    2 ban đầu đã bị xóa. Chúng tôi sẽ thảo luận về nó trong phần sau của bài viết

Mục lục

  • Cách sử dụng hàm range[] trong Python
    • cú pháp
    • Thông số
    • Giá trị trả về
    • Các bước sử dụng hàm range[]
  • phạm vi [] Ví dụ
    • phạm vi [dừng]
    • phạm vi [bắt đầu, dừng]
    • phạm vi [bắt đầu, dừng, bước]
    • Những điểm cần nhớ về hàm range[]
  • cho vòng lặp với phạm vi[]
    • Lặp lại danh sách bằng cách sử dụng phạm vi [] và vòng lặp for
    • Vấn đề thực hành
  • Phạm vi đảo ngược
    • Sử dụng bước âm
    • Sử dụng chức năng đảo ngược []
    • Sử dụng phạm vi [] để đảo ngược danh sách
  • Bước phạm vi Python
    • Phạm vi giảm [] sử dụng bước
  • Phạm vi phủ định [] trong Python
  • Chuyển đổi phạm vi [] thành danh sách
  • phạm vi bao gồm
  • phạm vi [] so với. xrange[] trong Python 2
  • Nối kết quả của hai phạm vi []
  • phạm vi [] lập chỉ mục và cắt
  • phạm vi [] trên ký tự hoặc bảng chữ cái
  • Tóm lược
  • Câu hỏi thường gặp

Cách sử dụng hàm range[] trong Python

cú pháp

Dưới đây là cú pháp của hàm range[]

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
0

Phải mất ba đối số. Trong số ba, hai là tùy chọn. 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
64 và 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
65 là đối số tùy chọn và 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
66 là đối số bắt buộc

Thông số

  • arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    64. [Giới hạn dưới] Đó là vị trí bắt đầu của chuỗi. Giá trị mặc định là 0 nếu không được chỉ định. Ví dụ, 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    68. Đây, 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    69 và 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
    70
  • arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    66. [Giới hạn trên] tạo số đến số này, tôi. e. , Một số nguyên xác định vị trí dừng [giới hạn trên]. 
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    2 không bao giờ bao gồm số dừng trong kết quả của nó
  • arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    65. Chỉ định giá trị gia tăng. Mỗi số tiếp theo trong chuỗi được tạo bằng cách thêm giá trị bước vào một số trước đó. Giá trị mặc định là 1 nếu không được chỉ định. Nó chẳng là gì ngoài sự khác biệt giữa mỗi con số trong kết quả. Ví dụ, 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
    74. Đây, 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
    75

Giá trị trả về

Nó trả về đối tượng của lớp 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
76

[start:stop:stepsize]
4

Các bước sử dụng hàm range[]

Hàm 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 tạo ra một chuỗi các số nguyên theo đối số được truyền. Các bước dưới đây cho thấy cách sử dụng hàm range[] trong Python

  1. Truyền các giá trị bắt đầu và dừng cho phạm vi []

    Ví dụ, 

    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
    78. Đây, 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    69 và 
    [start:stop:stepsize]
    80. Nó sẽ tạo ra các số nguyên bắt đầu từ số 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    64 đến số 
    [start:stop:stepsize]
    82. tôi. e. , 
    [start:stop:stepsize]
    83

  2. Truyền giá trị bước cho phạm vi []

    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    65 Chỉ định số gia. Ví dụ, 
    [start:stop:stepsize]
    85. Đây, 
    [start:stop:stepsize]
    86. Kết quả là 
    [start:stop:stepsize]
    87

  3. Sử dụng vòng lặp để truy cập từng số

    Sử dụng vòng lặp for để lặp lại và truy cập một dãy số được trả về bởi một 

    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    2

Các bước để sử dụng phạm vi[]

phạm vi [] Ví dụ

Bây giờ, hãy xem tất cả các tình huống có thể xảy ra. Dưới đây là ba biến thể của 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

# Every third element from index 1 to 8.
arr[1:8:3]   # ["B", E", H"]

# Every second element through out the list
arr[::2]     # ["A", "C", "E", "G", "I"]
80

Khi bạn chỉ truyền một đối số cho 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2, nó sẽ tạo ra một chuỗi các số nguyên bắt đầu từ 0 đến 
[start:stop:stepsize]
82

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9

Ghi chú

  • Ở đây, 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

# Every third element from index 1 to 8.
arr[1:8:3]   # ["B", E", H"]

# Every second element through out the list
arr[::2]     # ["A", "C", "E", "G", "I"]
    83 và 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
    75 là giá trị mặc định
  • Nếu bạn đặt 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    66 là 0 hoặc một số giá trị âm, thì phạm vi sẽ trả về một chuỗi trống
  • Nếu bạn muốn bắt đầu phạm vi ở mức 1, hãy sử dụng 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

# Every third element from index 1 to 8.
arr[1:8:3]   # ["B", E", H"]

# Every second element through out the list
arr[::2]     # ["A", "C", "E", "G", "I"]
    86

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

# Every third element from index 1 to 8.
arr[1:8:3]   # ["B", E", H"]

# Every second element through out the list
arr[::2]     # ["A", "C", "E", "G", "I"]
87

Khi bạn chuyển hai đối số cho 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2, nó sẽ tạo ra các số nguyên bắt đầu từ số 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
64 đến số 
[start:stop:stepsize]
82

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
6

Ghi chú

  • Ở đây, 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
    75 là giá trị mặc định
  • Phạm vi sẽ trả về một chuỗi trống nếu bạn đặt giá trị 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    66 nhỏ hơn giá trị 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    64

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
44

Khi bạn chuyển cả ba đối số cho phạm vi [], nó sẽ trả về một dãy số, bắt đầu từ số bắt đầu, tăng dần theo số bước và dừng trước số dừng

Tại đây, bạn có thể chỉ định một mức tăng khác bằng cách thêm tham số 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
65

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
7

Ghi chú

  • Ở đây, 
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    46 là giá trị mặc định
  • Python sẽ đưa ra một ngoại lệ 
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    47 nếu bạn đặt 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    65 thành 0

Những điểm cần nhớ về hàm range[]

  • Hàm 
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    2 chỉ hoạt động với các số nguyên, vì vậy tất cả các đối số phải là số nguyên. Bạn không thể sử dụng số float hoặc bất kỳ loại dữ liệu nào khác làm giá trị bắt đầu, dừng và bước. Vui lòng tham khảo cách tạo dãy số float trong Python
  • Cả ba đối số có thể là tích cực hoặc tiêu cực
  • Giá trị 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    65 không được bằng 0. Nếu là 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    201, Python sẽ đưa ra một ngoại lệ 
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    47

Vấn đề thực hành. –

Sử dụng 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 để tạo một dãy số bắt đầu từ 9 đến 100 chia hết cho 3

Hiển thị giải pháp

[start:stop:stepsize]
8

Nhìn thấy. Bài tập Python cho vòng lặp và phạm vi []

cho vòng lặp với phạm vi[]

Vòng lặp for Python thực thi lặp đi lặp lại một khối mã hoặc câu lệnh trong một số lần cố định. Chúng ta có thể lặp qua một dãy số được tạo bởi hàm range[] bằng cách sử dụng vòng lặp for

Hãy xem cách sử dụng vòng lặp 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
4 với hàm 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 để in các số lẻ từ 1 đến 10. Sử dụng ví dụ này, chúng ta có thể hiểu cách biến iterator 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
206 nhận giá trị khi chúng ta sử dụng phạm vi [] với vòng lặp for

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

# Every third element from index 1 to 8.
arr[1:8:3]   # ["B", E", H"]

# Every second element through out the list
arr[::2]     # ["A", "C", "E", "G", "I"]
8

đầu ra

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
4

Để hiểu ý nghĩa của 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
207 trong Python, trước tiên chúng ta cần hiểu hoạt động của hàm 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2

Hàm 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 sử dụng trình tạo để tạo số. Nó không tạo ra tất cả các số cùng một lúc

Như bạn đã biết range[] trả về đối tượng 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
76. Một đối tượng phạm vi sử dụng cùng một lượng bộ nhớ [nhỏ], bất kể kích thước của phạm vi mà nó đại diện. Nó chỉ lưu trữ các giá trị bắt đầu, dừng và bước và tính toán các mục riêng lẻ và các dải phụ khi cần

I. e. , Nó chỉ tạo ra giá trị tiếp theo khi vòng lặp for được yêu cầu. Trong mỗi lần lặp vòng lặp, Nó tạo ra giá trị tiếp theo và gán nó cho biến lặp i

  • Như bạn có thể thấy ở đầu ra, biến 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    206 không nhận đồng thời các giá trị 1, 3, 5, 7 và 9
  • Trong lần lặp đầu tiên của giá trị vòng lặp của 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    206 là số bắt đầu của một phạm vi
  • Tiếp theo, trong mỗi lần lặp tiếp theo của vòng lặp for, giá trị của 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    206 được tăng theo giá trị bước. Giá trị của 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    206 được xác định theo công thức 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    215

Vì vậy, nó có nghĩa là phạm vi [] tạo ra từng số một khi vòng lặp chuyển sang lần lặp tiếp theo. Nó tiết kiệm rất nhiều bộ nhớ, giúp cho phạm vi [] nhanh hơn và hiệu quả hơn

Hoạt động của hàm phạm vi Python với vòng lặp for

Lặp lại danh sách bằng cách sử dụng vòng lặp 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 và 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
4

Bạn có thể lặp lại các loại trình tự Python như danh sách và chuỗi bằng cách sử dụng vòng lặp 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 và vòng lặp for

Khi bạn chỉ lặp lại danh sách bằng một vòng lặp, bạn chỉ có thể truy cập các mục. Khi bạn lặp lại danh sách chỉ bằng một vòng lặp, bạn chỉ có thể truy cập các mục của nó, nhưng khi bạn sử dụng phạm vi [] cùng với vòng lặp, bạn có thể truy cập số chỉ mục của từng mục

Ưu điểm của việc sử dụng 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 để lặp lại danh sách là nó cho phép chúng tôi truy cập số chỉ mục của từng mục. Sử dụng số chỉ mục, chúng tôi có thể truy cập cũng như sửa đổi các mục danh sách nếu cần

Ví dụ

Truyền tổng số mục trong danh sách cho 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 bằng cách sử dụng hàm 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
221. 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 sẽ sử dụng nó như một đối số 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
66

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
20

đầu ra

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
21

Vấn đề thực hành

In mẫu số sau bằng Python 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 và một vòng lặp

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
22

Hiển thị giải pháp

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
23

Đọc thêm

  • Bài tập Python cho vòng lặp và phạm vi []

Phạm vi đảo ngược

Bạn có thể hiển thị dãy số được tạo bởi hàm 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 theo thứ tự giảm dần hoặc thứ tự đảo ngược

Bạn có thể sử dụng hai cách sau để lấy dãy số đảo ngược trong Python

  • Sử dụng giá trị âm 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    65
  • Sử dụng hàm 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    227

Sử dụng bước âm

Sử dụng giá trị bước âm trong hàm 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 để tạo chuỗi số theo thứ tự ngược lại. Ví dụ: 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
229 sẽ tạo ra các số như 5, 4, 3, 2 và 1

I. e. , bạn có thể đảo ngược một vòng lặp bằng cách đặt đối số bước của 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 thành -1. Nó sẽ khiến vòng lặp 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
4 lặp lại theo thứ tự ngược lại

Hãy xem cách lặp theo kiểu lặp ngược hoặc lặp ngược để hiển thị dãy số từ 5 đến 0

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
24

đầu ra

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
25

Sử dụng chức năng đảo ngược []

Sử dụng hàm 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
227 tích hợp sẵn của Python, bạn có thể đảo ngược bất kỳ chuỗi nào, chẳng hạn như danh sách hoặc phạm vi

  • Truyền 
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    2 làm đầu vào cho hàm Reverse[], Nó trả về một 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    234 truy cập chuỗi số do 
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    2 cung cấp theo thứ tự ngược lại
  • Tiếp theo, lặp lại kết quả do hàm 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    227 cung cấp bằng vòng lặp for

ví dụ 2. phạm vi đảo ngược bắt đầu từ 20 đến 10

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
26

ví dụ 3. phạm vi đảo ngược bắt đầu từ 20 đến 10 với bước 2

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
27

Ghi chú. 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
237 trả về một 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
234 truy cập chuỗi số được cung cấp bởi 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 theo thứ tự ngược lại

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
28

Ngoài ra, nếu bạn cần danh sách từ nó, bạn cần chuyển đổi đầu ra của hàm 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
227 thành danh sách. Vì vậy, bạn có thể lấy danh sách đảo ngược của phạm vi

Sử dụng phạm vi [] để đảo ngược danh sách

Sử dụng 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 để đảo ngược danh sách bằng cách chuyển số lượng mục trong danh sách dưới dạng đối số 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
64 và 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
65 dưới dạng -1

Hãy xem các cách khác nhau để đảo ngược danh sách các số bằng cách sử dụng 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
29

Bước phạm vi Python

Một bước là một đối số tùy chọn của một phạm vi[]. Nó là một số nguyên xác định số gia giữa mỗi số trong dãy. tôi. e. , Nó chỉ định mức tăng

Bạn cũng có thể định nghĩa nó là sự khác biệt giữa mỗi số trước và số tiếp theo trong chuỗi kết quả. Ví dụ: Nếu bước là 2, thì sự khác biệt giữa mỗi số trước và sau là 2

Giá trị mặc định của bước là 1 nếu không được chỉ định rõ ràng

Ví dụ. Tăng sử dụng bước

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
00

Bạn cũng có thể thực hiện nhiều thao tác bằng cách sử dụng các đối số bước chẳng hạn như đảo ngược một chuỗi chẳng hạn như danh sách và chuỗi

Phạm vi giảm [] sử dụng bước

Bạn có thể giảm phạm vi [] bằng cách sử dụng giá trị âm 165

Khi chúng ta đặt giá trị âm cho bước, trong mỗi lần lặp lại, số sẽ giảm dần cho đến khi đạt đến số dừng

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
01

Ghi chú. Để giảm 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 thì 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
64 phải lớn hơn 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
66. Một phạm vi [] trả về chuỗi trống nếu 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
249

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
02

Ngoài ra, bạn có thể sử dụng 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
65 để tạo dãy số nhân n

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
03

Ngoài ra, bạn sẽ nhận được một 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
251 nếu bạn đặt 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
46

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
04

Ngoài ra, bạn không thể sử dụng giá trị 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
65 thập phân. Nếu bạn muốn sử dụng bước float/thập phân trong 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2, vui lòng tham khảo cách tạo một dải số float

Phạm vi phủ định [] trong Python

Bạn có thể sử dụng số nguyên âm trong phạm vi[]

Hầu hết thời gian, chúng tôi sử dụng giá trị bước âm để đảo ngược một phạm vi. Nhưng ngoài bước, chúng ta có thể sử dụng các giá trị âm trong hai đối số khác [bắt đầu và dừng] của hàm phạm vi []

Ví dụ. Dải âm từ -1 đến -10

Cùng xem ví dụ in dãy số từ âm sang dương

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
05

Hãy hiểu chương trình trên, chúng tôi đặt -

  • arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    255 [vì chúng tôi muốn bắt đầu sản xuất số từ -1]
  • arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    256 [Chúng tôi muốn ngừng tạo số khi đạt -11]
  • arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    257

Chấp hành

  • Trong lần lặp đầu tiên của vòng lặp, 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    206 là -1
  • Trong lần lặp thứ 2 của vòng lặp for, 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    206 là -2 vì 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    260 và nó sẽ lặp lại quá trình này cho đến số dừng

Ví dụ. Phạm vi đảo ngược âm từ -10 đến -1

Bạn cũng có thể in đảo ngược giá trị âm của 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 bằng cách sử dụng số nguyên dương 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
65

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
06

Sự kết hợp của số âm và số dương

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
07

Chuyển đổi phạm vi [] thành danh sách

Hàm 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 của Python không trả về loại 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
264. Nó trả về một chuỗi số nguyên bất biến

Chúng ta có thể chuyển đổi 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 thành danh sách bằng hàm tạo 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
266

  • Truyền hàm 
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    2 làm đầu vào cho hàm tạo danh sách
  • Hàm tạo 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    266 tự động tạo danh sách bằng cách đặt các số nguyên được trả về bởi the
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    2 bên trong dấu ngoặc vuông
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
08

Truy cập và sửa đổi mục danh sách bằng cách sử dụng 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2

Ngoài ra, bạn có thể sử dụng 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 để truy cập và sửa đổi các mục của 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
264

  • Sử dụng hàm 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    221, bạn có thể nhận được số lượng mục danh sách
  • Tiếp theo, sử dụng số đếm này làm số dừng trong 
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    2 và lặp lại cho vòng lặp 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    275 lần
  • Trong mỗi lần lặp lại, bạn sẽ nhận được số chỉ mục của một mục danh sách hiện tại
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
09

phạm vi bao gồm

Trong phần này, chúng ta sẽ tìm hiểu cách tạo một phạm vi bao gồm trong Python. Theo mặc định, 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
276 là độc quyền, vì vậy nó không bao gồm số cuối cùng trong kết quả. Nó tạo ra dãy số từ 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
64 đến 
[start:stop:stepsize]
82

Ví dụ: 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
279 sẽ tạo ra 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
280. Kết quả chứa các số từ 0 đến tối đa 5 nhưng không phải năm

Nếu bạn để ý thì kết quả có 5 phần tử bằng với 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
281. Lưu ý, chỉ số luôn bắt đầu từ 0, không phải 1

Nếu bạn muốn bao gồm số cuối trong kết quả, tôi. e. , Nếu bạn muốn tạo một phạm vi bao gồm, hãy đặt giá trị đối số dừng là 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
282

Ví dụ

[start:stop:stepsize]
40

ví dụ 2. Phạm vi bao gồm chẵn[]

[start:stop:stepsize]
41

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 so với. 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
60 bằng Python 2

So sánh giữa 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 và 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
60 chỉ phù hợp nếu bạn đang sử dụng Python 2 và Python 3. Nếu bạn không sử dụng Python 2, bạn có thể bỏ qua phần so sánh này

Hàm range[] hoạt động khác nhau giữa Python 3 và Python 2. Nếu ứng dụng của bạn chạy trên cả Python 2 và Python 3, bạn phải sử dụng 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 thay vì 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
60 để tương thích mã tốt hơn

Trong Python 2, chúng ta có các hàm 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 và 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
60 để tạo ra một dãy số

Trong Python 3, 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
60 được đổi tên thành 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 và hàm 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 ban đầu đã bị xóa

Vì vậy, nói một cách đơn giản, 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
60 bị xóa khỏi Python 3 và chúng ta chỉ có thể sử dụng hàm 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 để tạo các số trong một phạm vi nhất định

Sử dụng 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 và 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
60

  • Trong Python 2, 
    # Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
    2 trả về đối tượng 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    264, tôi. e. , Nó tạo ra tất cả các số cùng một lúc. 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
    000 sẽ tạo danh sách Python gồm 499 số nguyên trong bộ nhớ. Vì vậy, nó tiêu thụ bộ nhớ cao và tăng thời gian thực hiện
  • arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
    60. Hàm 
    arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
    002 không tạo ra tất cả các số cùng một lúc. Nó tạo ra từng số một khi vòng lặp chuyển sang số tiếp theo. Vì vậy, nó tiêu thụ ít bộ nhớ và tài nguyên hơn

Ví dụ

[start:stop:stepsize]
42

đầu ra

[start:stop:stepsize]
43

Nối kết quả của hai phạm vi []

Giả sử bạn muốn thêm 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
003. Và bạn muốn dãy được nối như 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
004

Ví dụ bạn muốn cộng kết quả của 2 hàm 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 để ra một dãy số khác. Bạn có thể thêm/hợp nhất kết quả của nhiều hàm 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 bằng cách sử dụng 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
007

[start:stop:stepsize]
44

phạm vi [] lập chỉ mục và cắt

Hàm tích hợp 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 là hàm tạo trả về đối tượng 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
76, đối tượng phạm vi này cũng có thể được truy cập bằng số chỉ mục của nó bằng cách sử dụng lập chỉ mục và cắt

Phạm vi truy cập[] thuộc tính

Điều cần thiết là phải biết các thuộc tính 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 khi bạn nhận nó làm đầu vào cho hàm của mình và bạn muốn xem giá trị của đối số 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
64, 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
66 và 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
65

[start:stop:stepsize]
45

lập chỉ mục

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 hỗ trợ cả chỉ số tích cực và tiêu cực. Ví dụ dưới đây chứng minh điều tương tự

Trong trường hợp của ____62, Giá trị chỉ số bắt đầu từ 0 đến [dừng]. Ví dụ muốn truy cập số thứ 3 thì chúng ta cần sử dụng 2 làm số chỉ mục

[start:stop:stepsize]
46

lập chỉ mục tiêu cực

Các số có thể được truy cập từ phải sang trái bằng cách sử dụng lập chỉ mục phủ định

[start:stop:stepsize]
47

cắt lát

Cắt một ngụ ý truy cập một phần từ 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2

[start:stop:stepsize]
48

phạm vi [] trên ký tự hoặc bảng chữ cái

Có cách nào để in một loạt ký tự hoặc bảng chữ cái không? 

[start:stop:stepsize]
49

Có cách nào để in một loạt ký tự hoặc bảng chữ cái không? . Có thể tạo một loạt các ký tự bằng cách sử dụng trình tạo tùy chỉnh. Hãy xem cách tạo bảng chữ cái 'a' thành 'z' bằng cách sử dụng hàm 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 tùy chỉnh

Ghi chú. Chúng ta cần sử dụng giá trị ASCII và sau đó chuyển đổi giá trị ASCII thành một chữ cái bằng hàm 

arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
018

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
0

đầu ra

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
1

Tóm lược

Tôi muốn nghe từ bạn. Bạn nghĩ gì về hướng dẫn này trên Python range[]?

Ngoài ra, hãy thử giải Bài tập vòng lặp Python và Câu đố về vòng lặp

Dưới đây là tóm tắt tất cả các thao tác mà chúng ta đã học trong bài học này

Hoạt động Mô tả
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

# Every third element from index 1 to 8.
arr[1:8:3]   # ["B", E", H"]

# Every second element through out the list
arr[::2]     # ["A", "C", "E", "G", "I"]
80Tạo một chuỗi các số nguyên từ 0 đến dừng-1
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

# Every third element from index 1 to 8.
arr[1:8:3]   # ["B", E", H"]

# Every second element through out the list
arr[::2]     # ["A", "C", "E", "G", "I"]
87Tạo một chuỗi các số nguyên từ đầu đến dừng-1
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
44Tạo một chuỗi các số nguyên bắt đầu từ số bắt đầu, tăng dần từng bước và dừng trước một số dừng. Tôi. e. , Mỗi số tiếp theo được tạo bằng cách thêm giá trị bước vào một số trước đó. 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
022Phạm vi đảo ngược
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
023Phạm vi đảo ngược sử dụng hàm 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
227
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
025Phạm vi âm từ -1 đến -10
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
026Chuyển đổi phạm vi[] thành danh sách
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
027Tạo phạm vi bao hàm
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
028Truy cập trực tiếp số thứ năm của một 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
030Cắt một phạm vi để truy cập các số từ chỉ mục 3 đến 8
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
031Nhận giá trị bắt đầu của một 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
036giá trị 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
036Nhận giá trị dừng

Câu hỏi thường gặp

Phạm vi[] trong Python có bắt đầu từ 0 không?

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 theo mặc định bắt đầu từ 0, không phải 1, nếu đối số bắt đầu không được chỉ định. Ví dụ: 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[2:5]  # ["C", "D", "E"]
arr[5:]   # ["F", "G", "H", "I", "J"]
arr[:5]   # ["A", "B", "C", "D", "E"]
279 sẽ trả về 0, 1, 2, 3, 4

Phạm vi [] trả về trong Python là gì?

Hàm 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 trả về một đối tượng thuộc lớp 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
76, không gì khác ngoài một chuỗi số nguyên

Phạm vi có phải là một danh sách trong Python không?

Không. 

# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 không phải là danh sách, cũng không trả về kiểu danh sách. Một đối tượng 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 trả về 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
76. Bạn có thể xác minh kiểu dữ liệu của 
# Print first 10 numbers

# stop = 10
for i in range[10]:
    print[i, end=' ']

# Output 0 1 2 3 4 5 6 7 8 9
2 bằng hàm 
arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

arr[-3:]     # ["H", "I", "J"]
arr[:-3]     # ["A", "B", "C", "D", "E", "F", "G"]
045

Bắt đầu dừng trong Python là gì?

Ký hiệu cơ bản là. [bắt đầu. dừng lại. step] Mặc định để bắt đầu là không có hoặc 0. Điểm dừng mặc định là phần cuối của cấu trúc dữ liệu . Sử dụng tham chiếu số dương từ phần tử đầu tiên, tham chiếu số âm từ phần tử cuối cùng trong cấu trúc của bạn.

Bước trong việc cắt lát Python là gì?

Định nghĩa và cách sử dụng . Bạn có thể chỉ định nơi bắt đầu cắt lát và nơi kết thúc. Bạn cũng có thể chỉ định bước cho phép bạn. g. chỉ cắt mọi mục khác .

Khi cắt trong Python 2 trong [. 2 chỉ rõ 1 điểm?

chuỗi[. 2] đọc “ chỉ mục bắt đầu mặc định, chỉ mục dừng mặc định, kích thước bước là hai—lấy mọi phần tử thứ hai ”.

Khi cắt trong Python 2 trong 2 chỉ định điều gì?

Các mục ở khoảng 2 bắt đầu từ chỉ mục cuối cùng được cắt lát. Nếu bạn muốn các mục từ vị trí này sang vị trí khác, bạn có thể đề cập đến chúng từ đầu đến cuối. Các mục từ chỉ số 1 đến 4 được cắt với khoảng cách là 2.

Bài Viết Liên Quan

Chuyển đổi powershell sang python trực tuyến
Nhị phân sang char python
Nam Carolina sẽ có tuyết vào năm 2023?
Làm cách nào để kiểm tra xem một giá trị là số lẻ hay số chẵn trong python?
Tôi có thể sử dụng các thư viện Python trong lập trình cạnh tranh không?
Làm thế nào để bạn in một số float mà không có số thập phân trong python?
Tạo json lồng nhau trong python
Safari có cho phép javascript không?
Ẩn video css
Chuyển đổi biểu tượng cảm xúc sang unicode php
1:15 phút bằng bao nhiêu phút lớp 3
Xác thực Laravel cho phép các ký tự đặc biệt
Sự kiện ngày 6 tháng 5 năm 2023
Class of 2023 College age
Cài đặt tiện ích mở rộng GD PHP Windows
Coursera Python miễn phí cho mọi người
Đường dẫn lưu trữ Laravel ở đâu?
2 người T23 Singapore
Làm thế nào để bạn chèn dữ liệu vào một bảng?
Các ứng dụng HTML5 là gì?

Toplist mới

#1
Top 9 tập bản đồ lớp 8 bài 31 2023
6 tháng trước
#2
Top 6 kết quả thi hsg đà nẵng 2022 2023
6 tháng trước
#3
Top 9 tủ nhựa đài loan 4 cánh 3d 2023
6 tháng trước
#4
Top 9 chất khí có thể làm mất màu dung dịch nước brom là: a. so2. b. co2. c. o2. d. hcl. 2023
6 tháng trước
#5
Top 8 tìm việc làm tiện, phay bảo q7 2023
6 tháng trước
#6
Top 3 tôi xuyên thành tiểu kiều the của lão đại phản 2 2023
6 tháng trước
#7
Top 9 đổi mới phong cách, thái độ phục vụ của cán bộ y tế hướng tới sự hài lòng của người bệnh 2023
6 tháng trước
#8
Top 2 bài the dục phát triển chung lớp 6 2022 2023
6 tháng trước
#9
Top 3 bài giảng vũ điệu sắc màu (lớp 4) 2023
6 tháng trước

Bài mới nhất

Bệnh viêm mô tế bào là gì năm 2024
Tỷ số khả năng thanh toán ngắn hạn năm 2024
Vợ chồng sinh năm 1988 nên sinh con năm nào năm 2024
Bất tử khác với bất diệt ở chỗ nào năm 2024
Nên treo gương bát quái vào ngày nào năm 2024
Giải bài 12 sbt toán 9 tập 1 trang 62 năm 2024
Đề thi toán lớp 2 học kỳ i năm 2024
Chổi lau nhà tiếng trung là gì năm 2024
Bài tập đệ quy quay lui trong c năm 2024
Kem chống rạn da cho bà bầu loại nào tốt năm 2024

Chủ Đề

programming Hỏi Đáp Toplist Là gì Mẹo Hay Địa Điểm Hay Học Tốt mẹo hay Công Nghệ Nghĩa của từ Bao nhiêu Khỏe Đẹp đánh giá Top List bao nhieu bao nhiêu hướng dẫn Xây Đựng So Sánh Bài tập Tiếng anh So sánh Sản phẩm tốt Ngôn ngữ Bài Tập javascript Ở đâu Thế nào Hướng dẫn Dịch Máy tính Tại sao Đại học Món Ngon Khoa Học