Hướng dẫn can you zip 4 lists python? - bạn có thể nén 4 danh sách python không?

Question

Nguồn: Bài đăng trên blog của tôi (định dạng tốt hơn)

Nội dung chính Show

Đầu vào
Đầu ra (danh sách) (list)
Trường hợp cạnh
Zip trong hành động!
Tín dụng bổ sung: Giải nén
Chú thích
Hiểu chức năng Python numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2
Sử dụng numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2 trong Python
Vượt qua student_grades = [ [ 'Morty' , 1 , "B" ], [ 'Rick' , 4 , "A" ], [ 'Jerry' , 3 , "M" ], [ 'Kramer' , 0 , "F" ], ] row_1 = student_grades[0] print row_1 # ['Morty', 1, 'B'] columns = zip(*student_grades) names = columns[0] print names # ('Morty', 'Rick', 'Jerry', 'Kramer') 2 đối số
Theo tài liệu chính thức, chức năng Python từ numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2 hoạt động như sau:
Theo tài liệu chính thức, chức năng Python từ numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2 hoạt động như sau:
Vượt qua các đối số về chiều dài không đồng đều
So sánh numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2 trong Python 3 và 2
Vòng lặp qua nhiều vòng lặp
Danh sách đi ngang song song
Đi ngang qua từ điển song song
Giải nén một chuỗi
Sắp xếp song song
Tính toán theo cặp
Xây dựng từ điển
Sự kết luận
Bạn có thể zip nhiều danh sách trong Python không?
Tôi có thể zip danh sách trong Python không?
Có bao nhiêu lập luận có thể Zip lấy Python?
Chúng ta có thể zip hai bộ dữ liệu trong Python không?

Thí dụ

numbers = [1,2,3]
letters = 'abcd'

zip(numbers, letters)
# [(1, 'a'), (2, 'b'), (3, 'c')]

Đầu vào

Không hoặc nhiều hơn lặp đi lặp

Đầu ra (danh sách) (list)

1st tuple = (Element_1 của số, Element_1 của các chữ cái)
Tuple thứ 2 = (số E_2, chữ E_2)
…
n-th tuple = (số e_n, các chữ cái e_n)

Danh sách N Bộ dữ liệu: N là độ dài của đối số ngắn nhất (đầu vào)
- Len (số) == 3
Chiều dài mỗi tuple = # của args (Tuple lấy một phần tử từ mỗi arg)
- args = (số, chữ cái); Len (args) == 2 → tuple với 2 phần tử

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

1 Tuple = (Element_I arg1, Element_I arg2, Element_i arg

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

2)

Trường hợp cạnh

1) Chuỗi trống: Len (str) = 0 = không có bộ dữ

2) Chuỗi đơn: Len (Str) == 2 Tuples với Len (args) == 1 phần tử

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

Zip trong hành động!

1. Xây dựng một từ điển [2] trong số hai danh sách

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

3 là một giải pháp thanh lịch, rõ ràng và súc tích

2. Các cột in trong bảng

"*" [3] được gọi là "Giải nén":

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

4

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

Tín dụng bổ sung: Giải nén

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

5 được gọi là “unzipping” vì nó có tác dụng nghịch đảo của

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

3

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

7: tuple_1 = e1 của mỗi bộ có khóa. Tuple_2 = E2 của mỗi

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

8

Chú thích

Một đối tượng có khả năng trả lại một thành viên của mình một lần (ví dụ: Danh sách [1,2,3], chuỗi 'Tôi thích codin', tuple (1,2,3), từ điển {'a': 1, 'b' : 2})
{key1: value1, key2: value2 ...}
"Giải nén" (*)

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

9 Mã:

# foo - function, returns sum of two arguments
def foo(x,y):
    return x + y
print foo(3,4)
# 7

numbers = [1,2]
print foo(numbers)
# TypeError: foo() takes exactly 2 arguments (1 given)

print foo(*numbers)
# 3

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

9 đã lấy

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

1 (1 arg) và đã giải nén các yếu tố của nó thành 2 args

Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Lặp lại song song với chức năng Zip () của Python This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Parallel Iteration With Python's zip() Function

Chức năng Python từ

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 tạo ra một trình lặp sẽ tổng hợp các phần tử từ hai hoặc nhiều vòng lặp. Bạn có thể sử dụng trình lặp kết quả để giải quyết nhanh chóng và nhất quán các vấn đề lập trình phổ biến, như tạo từ điển. Trong hướng dẫn này, bạn sẽ khám phá ra logic đằng sau hàm Python

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 và cách bạn có thể sử dụng nó để giải quyết các vấn đề trong thế giới thực.

Đến cuối hướng dẫn này, bạn sẽ học:

Cách

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 hoạt động trong cả Python 3 và Python 2
numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')]
2 works in both Python 3 and Python 2

Cách sử dụng hàm Python

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 để lặp song songparallel iteration

Cách tạo từ điển khi đang bằng cách sử dụng

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2create dictionaries on the fly using

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2

Hiểu chức năng Python numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 có sẵn trong không gian tên tích hợp. Nếu bạn sử dụng

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

9 để kiểm tra

# foo - function, returns sum of two arguments
def foo(x,y):
    return x + y
print foo(3,4)
# 7

numbers = [1,2]
print foo(numbers)
# TypeError: foo() takes exactly 2 arguments (1 given)

print foo(*numbers)
# 3

0, thì bạn sẽ thấy

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 ở cuối danh sách:

>>>

>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', ..., 'zip']

Bạn có thể thấy rằng

# foo - function, returns sum of two arguments
def foo(x,y):
    return x + y
print foo(3,4)
# 7

numbers = [1,2]
print foo(numbers)
# TypeError: foo() takes exactly 2 arguments (1 given)

print foo(*numbers)
# 3

2 là mục cuối cùng trong danh sách các đối tượng có sẵn.

Theo tài liệu chính thức, chức năng Python từ

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 hoạt động như sau:

Trả về một trình lặp của các bộ dữ liệu, trong đó bộ thứ ba chứa phần tử thứ i từ mỗi chuỗi đối số hoặc các vòng lặp. Trình lặp dừng khi có thể cạn kiệt đầu vào ngắn nhất. Với một đối số có thể lặp lại duy nhất, nó trả về một trình lặp gồm 1 bộ. Không có đối số, nó trả về một trình lặp trống. (Nguồn)

Bạn sẽ giải nén định nghĩa này trong suốt phần còn lại của hướng dẫn. Khi bạn làm việc thông qua các ví dụ mã, bạn sẽ thấy rằng các hoạt động của Python Zip hoạt động giống như dây kéo vật lý trên túi hoặc đôi quần jean. Các cặp răng xen kẽ ở cả hai mặt của dây kéo được kéo lại với nhau để đóng một lỗ mở. Trên thực tế, sự tương tự trực quan này là hoàn hảo để hiểu

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2, vì hàm được đặt tên theo khóa kéo vật lý!

Sử dụng numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2 trong Python

Hàm Python từ

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 được định nghĩa là

# foo - function, returns sum of two arguments
def foo(x,y):
    return x + y
print foo(3,4)
# 7

numbers = [1,2]
print foo(numbers)
# TypeError: foo() takes exactly 2 arguments (1 given)

print foo(*numbers)
# 3

7. Chức năng lấy Iterables làm đối số và trả về trình lặp. Iterator này tạo ra một loạt các bộ dữ liệu chứa các yếu tố từ mỗi phần có thể.

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 có thể chấp nhận bất kỳ loại có thể lặp lại nào, chẳng hạn như tệp, danh sách, bộ dữ liệu, từ điển, bộ, v.v.iterator. This iterator generates a series of tuples containing elements from each iterable.

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 can accept any type of iterable, such as files, lists, tuples, dictionaries, sets, and so on.

Vượt qua student_grades = [ [ 'Morty' , 1 , "B" ], [ 'Rick' , 4 , "A" ], [ 'Jerry' , 3 , "M" ], [ 'Kramer' , 0 , "F" ], ] row_1 = student_grades[0] print row_1 # ['Morty', 1, 'B'] columns = zip(*student_grades) names = columns[0] print names # ('Morty', 'Rick', 'Jerry', 'Kramer') 2 đối số

Nếu bạn sử dụng

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 với các đối số

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

2, thì hàm sẽ trả về một trình lặp tạo ra các bộ dữ liệu có độ dài

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

2. Để xem điều này trong hành động, hãy xem khối mã sau:

>>>

>>> numbers = [1, 2, 3]
>>> letters = ['a', 'b', 'c']
>>> zipped = zip(numbers, letters)
>>> zipped  # Holds an iterator object

>>> type(zipped)

>>> list(zipped)
[(1, 'a'), (2, 'b'), (3, 'c')]

Bạn có thể thấy rằng

# foo - function, returns sum of two arguments
def foo(x,y):
    return x + y
print foo(3,4)
# 7

numbers = [1,2]
print foo(numbers)
# TypeError: foo() takes exactly 2 arguments (1 given)

print foo(*numbers)
# 3

2 là mục cuối cùng trong danh sách các đối tượng có sẵn.

Theo tài liệu chính thức, chức năng Python từ

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 hoạt động như sau:

>>>

>>> s1 = {2, 3, 1}
>>> s2 = {'b', 'a', 'c'}
>>> list(zip(s1, s2))
[(1, 'a'), (2, 'c'), (3, 'b')]

Bạn có thể thấy rằng

# foo - function, returns sum of two arguments
def foo(x,y):
    return x + y
print foo(3,4)
# 7

numbers = [1,2]
print foo(numbers)
# TypeError: foo() takes exactly 2 arguments (1 given)

print foo(*numbers)
# 3

2 là mục cuối cùng trong danh sách các đối tượng có sẵn.

Theo tài liệu chính thức, chức năng Python từ numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2 hoạt động như sau:

Trả về một trình lặp của các bộ dữ liệu, trong đó bộ thứ ba chứa phần tử thứ i từ mỗi chuỗi đối số hoặc các vòng lặp. Trình lặp dừng khi có thể cạn kiệt đầu vào ngắn nhất. Với một đối số có thể lặp lại duy nhất, nó trả về một trình lặp gồm 1 bộ. Không có đối số, nó trả về một trình lặp trống. (Nguồn)

>>>

>>> zipped = zip()
>>> zipped

>>> list(zipped)
[]

Bạn có thể thấy rằng

# foo - function, returns sum of two arguments
def foo(x,y):
    return x + y
print foo(3,4)
# 7

numbers = [1,2]
print foo(numbers)
# TypeError: foo() takes exactly 2 arguments (1 given)

print foo(*numbers)
# 3

2 là mục cuối cùng trong danh sách các đối tượng có sẵn.

Theo tài liệu chính thức, chức năng Python từ

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 hoạt động như sau:

>>>

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

0

Bạn có thể thấy rằng

# foo - function, returns sum of two arguments
def foo(x,y):
    return x + y
print foo(3,4)
# 7

numbers = [1,2]
print foo(numbers)
# TypeError: foo() takes exactly 2 arguments (1 given)

print foo(*numbers)
# 3

2 là mục cuối cùng trong danh sách các đối tượng có sẵn.

Theo tài liệu chính thức, chức năng Python từ numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2 hoạt động như sau:

Trả về một trình lặp của các bộ dữ liệu, trong đó bộ thứ ba chứa phần tử thứ i từ mỗi chuỗi đối số hoặc các vòng lặp. Trình lặp dừng khi có thể cạn kiệt đầu vào ngắn nhất. Với một đối số có thể lặp lại duy nhất, nó trả về một trình lặp gồm 1 bộ. Không có đối số, nó trả về một trình lặp trống. (Nguồn)

>>>

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

1

Điều này có thể không hữu ích, nhưng nó vẫn hoạt động. Có lẽ bạn có thể tìm thấy một số trường hợp sử dụng cho hành vi này của

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2!

Như bạn có thể thấy, bạn có thể gọi chức năng Python

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 với nhiều lần lặp lại mà bạn cần. Độ dài của các bộ dữ liệu kết quả sẽ luôn bằng số lần lặp bạn vượt qua dưới dạng đối số. Ở đây, một ví dụ với ba lần lặp:

>>>

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

2

Ở đây, bạn gọi hàm Python

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 với ba lần lặp, do đó các bộ dữ liệu kết quả có ba phần tử.

Vượt qua các đối số về chiều dài không đồng đều

Khi bạn làm việc với chức năng Python

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2, điều quan trọng là phải chú ý đến độ dài của vòng lặp của bạn. Nó có thể là các vòng lặp mà bạn truyền đi khi các đối số không có cùng chiều dài.

Trong những trường hợp này, số lượng các yếu tố mà

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 đưa ra sẽ bằng với độ dài của số ít nhất có thể. Các yếu tố còn lại trong bất kỳ lần lặp lại nào nữa sẽ bị bỏ qua hoàn toàn bởi

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2, như bạn có thể thấy ở đây:

>>>

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

3

Vì

>>> zipped = zip()
>>> zipped

>>> list(zipped)
[]

3 là độ dài của đối tượng đầu tiên (và ngắn nhất)

>>> zipped = zip()
>>> zipped

>>> list(zipped)
[]

4,

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 đưa ra danh sách năm bộ dữ liệu. Vẫn còn 95 phần tử chưa từng có từ đối tượng

>>> zipped = zip()
>>> zipped

>>> list(zipped)
[]

4 thứ hai. Tất cả đều bị bỏ qua bởi

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 vì không có thêm các phần tử nào từ đối tượng

>>> zipped = zip()
>>> zipped

>>> list(zipped)
[]

4 đầu tiên để hoàn thành các cặp.

Nếu các giá trị kéo dài hoặc chưa từng có là quan trọng đối với bạn, thì bạn có thể sử dụng

>>> zipped = zip()
>>> zipped

>>> list(zipped)
[]

9 thay vì

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2. Với hàm này, các giá trị bị thiếu sẽ được thay thế bằng bất cứ điều gì bạn chuyển sang đối số

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

01 (mặc định là

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

02). Việc lặp lại sẽ tiếp tục cho đến khi có thể cạn kiệt lâu nhất:

>>>

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

4

Ở đây, bạn sử dụng

>>> zipped = zip()
>>> zipped

>>> list(zipped)
[]

9 để mang lại năm bộ dữ liệu với các phần tử từ

>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', ..., 'zip']

8,

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

1 và

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

06. Việc lặp lại chỉ dừng lại khi

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

06 cạn kiệt. Các yếu tố bị thiếu từ

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

1 và

>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', ..., 'zip']

8 chứa đầy dấu hỏi

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

10, đó là những gì bạn đã chỉ định với

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

01.

Kể từ Python 3.10,

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 có một đối số từ khóa tùy chọn mới gọi là

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

13, được giới thiệu thông qua PEP 618, ADD-ADD kiểm tra độ dài để kiểm tra để zip. Mục tiêu chính của đối số này là cung cấp một cách an toàn để xử lý các vòng lặp có độ dài không đồng đều.safe way to handle iterables of unequal length.

Giá trị mặc định của

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

13 là

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

15, đảm bảo rằng

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 vẫn tương thích ngược và có hành vi mặc định phù hợp với hành vi của nó trong các phiên bản Python 3 cũ hơn:

>>>

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

5

Trong Python> = 3.10, gọi

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 mà không thay đổi giá trị mặc định thành

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

13 vẫn cung cấp cho bạn một danh sách năm bộ dữ liệu, với các phần tử chưa từng có từ đối tượng

>>> zipped = zip()
>>> zipped

>>> list(zipped)
[]

4 thứ hai bị bỏ qua.

Ngoài ra, nếu bạn đặt

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

13 thành

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

21, thì

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 kiểm tra xem các lần lặp đầu vào mà bạn cung cấp dưới dạng đối số có cùng độ dài, tăng

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

23 nếu chúng don lồng:

>>>

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

6

Tính năng mới này của

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 rất hữu ích khi bạn cần đảm bảo rằng chức năng chỉ chấp nhận các vòng lặp có độ dài bằng nhau. Cài đặt

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

13 thành

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

21 Làm cho mã mong đợi các vòng lặp có độ dài bằng nhau an toàn hơn, đảm bảo rằng các thay đổi bị lỗi đối với mã người gọi don lồng dẫn đến việc âm thầm mất dữ liệu.

So sánh numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2 trong Python 3 và 2

Chức năng Python từ

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 hoạt động khác nhau trong cả hai phiên bản của ngôn ngữ. Trong Python 2,

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 trả về

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

30 của các bộ dữ liệu. Kết quả

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

30 bị cắt theo chiều dài của đầu vào ngắn nhất có thể. Nếu bạn gọi

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 không có đối số, thì bạn sẽ nhận được một

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

30 trống:

>>>

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

7

Trong trường hợp này, cuộc gọi của bạn đến hàm Python

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 trả về một danh sách các bộ dữ liệu bị cắt cụt ở giá trị

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

35. Khi bạn gọi

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 không có đối số, bạn sẽ nhận được một

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

30 trống.

Tuy nhiên, trong Python 3,

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 trả về một trình lặp. Đối tượng này mang lại bộ dữ liệu theo yêu cầu và chỉ có thể đi qua một lần. Việc lặp lại kết thúc với một ngoại lệ

>>> s1 = {2, 3, 1}
>>> s2 = {'b', 'a', 'c'}
>>> list(zip(s1, s2))
[(1, 'a'), (2, 'c'), (3, 'b')]

1 một khi đầu vào ngắn nhất có thể cạn kiệt. Nếu bạn không cung cấp đối số cho

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2, thì hàm sẽ trả về một trình lặp trống:iterator. This object yields tuples on demand and can be traversed only once. The iteration ends with a

>>> s1 = {2, 3, 1}
>>> s2 = {'b', 'a', 'c'}
>>> list(zip(s1, s2))
[(1, 'a'), (2, 'c'), (3, 'b')]

1 exception once the shortest input iterable is exhausted. If you supply no arguments to

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2, then the function returns an empty iterator:

>>>

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

8

Tại đây, cuộc gọi của bạn đến

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 trả về một trình lặp lại. Lần lặp đầu tiên được cắt ngắn tại

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

35 và lần thứ hai dẫn đến ngoại lệ

>>> s1 = {2, 3, 1}
>>> s2 = {'b', 'a', 'c'}
>>> list(zip(s1, s2))
[(1, 'a'), (2, 'c'), (3, 'b')]

1. Trong Python 3, bạn cũng có thể mô phỏng hành vi Python 2 của

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 bằng cách gói trình lặp lại được trả về trong một cuộc gọi đến

>>> numbers = [1, 2, 3]
>>> letters = ['a', 'b', 'c']
>>> zipped = zip(numbers, letters)
>>> zipped  # Holds an iterator object

>>> type(zipped)

>>> list(zipped)
[(1, 'a'), (2, 'b'), (3, 'c')]

0. Điều này sẽ chạy qua trình lặp và trả lại một danh sách các bộ dữ liệu.

Nếu bạn thường xuyên sử dụng Python 2, thì lưu ý rằng sử dụng

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 với các vòng lặp đầu vào dài có thể vô tình tiêu thụ nhiều bộ nhớ. Trong những tình huống này, hãy xem xét sử dụng

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

47 thay thế. Hàm này tạo ra một trình lặp tập hợp các phần tử từ mỗi lần lặp. Nó tạo ra hiệu ứng tương tự như

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 trong Python 3:

>>>

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

9

Trong ví dụ này, bạn gọi

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

49 để tạo trình lặp. Khi bạn tiêu thụ trình lặp lại được trả về với

>>> numbers = [1, 2, 3]
>>> letters = ['a', 'b', 'c']
>>> zipped = zip(numbers, letters)
>>> zipped  # Holds an iterator object

>>> type(zipped)

>>> list(zipped)
[(1, 'a'), (2, 'b'), (3, 'c')]

0, bạn sẽ nhận được một danh sách các bộ dữ liệu, giống như khi bạn đang sử dụng

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 trong Python 3. Lặp lại dừng khi có thể rút được đầu vào ngắn nhất.

Nếu bạn thực sự cần viết mã hành xử theo cùng một cách trong cả Python 2 và Python 3, thì bạn có thể sử dụng một mẹo như sau:

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

0

Ở đây, nếu

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

52 có sẵn trong

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

53, thì bạn sẽ biết rằng bạn sẽ ở Python 2 và

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

52 sẽ được nhập bằng bí danh

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

3. Nếu không, chương trình của bạn sẽ tăng

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

56 và bạn sẽ biết rằng bạn đã ở Python 3. (Tuyên bố

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

57 ở đây chỉ là một trình giữ chỗ.)

Với thủ thuật này, bạn có thể sử dụng chức năng Python

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 một cách an toàn trong suốt mã của mình. Khi chạy, chương trình của bạn sẽ tự động chọn và sử dụng phiên bản chính xác.

Cho đến nay, bạn đã đề cập đến cách chức năng Python từ ____42 hoạt động và tìm hiểu về một số tính năng quan trọng nhất của nó. Bây giờ, thời gian để cuộn tay áo lên và bắt đầu mã hóa các ví dụ trong thế giới thực!

Vòng lặp qua nhiều vòng lặp

Vòng lặp qua nhiều lần lặp là một trong những trường hợp sử dụng phổ biến nhất cho chức năng Python từ

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2. Nếu bạn cần lặp lại thông qua nhiều danh sách, bộ dữ liệu hoặc bất kỳ chuỗi nào khác, thì nó có khả năng là bạn sẽ quay trở lại trên

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2. Phần này sẽ chỉ cho bạn cách sử dụng

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 để lặp qua nhiều lần lặp cùng một lúc.

Danh sách đi ngang song song

Chức năng Python từ

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 cho phép bạn lặp lại song song hơn hai hoặc nhiều lần lặp. Vì

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 tạo ra các bộ dữ liệu, bạn có thể giải nén chúng trong tiêu đề của vòng lặp

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

65:

>>>

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

1

Ở đây, bạn lặp lại thông qua loạt các bộ dữ liệu được trả về bởi

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 và giải nén các yếu tố thành

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

67 và

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

2. Khi bạn kết hợp các vòng lặp

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2,

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

65 và giải nén, bạn có thể nhận được một thành ngữ hữu ích và pythonic để đi qua hai hoặc nhiều lần lặp cùng một lúc.

Bạn cũng có thể lặp qua nhiều hơn hai lần lặp trong một vòng

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

65. Xem xét ví dụ sau, có ba lần lặp đầu vào:

>>>

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

2

Trong ví dụ này, bạn sử dụng

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 với ba lần lặp để tạo và trả về một trình lặp tạo ra các bộ dữ liệu 3 mục. Điều này cho phép bạn lặp lại thông qua cả ba lần lặp trong một lần. Không có hạn chế nào về số lượng lặp mà bạn có thể sử dụng với chức năng Python từ

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2.

Đi ngang qua từ điển song song

Trong Python 3.6 và hơn thế nữa, từ điển được đặt hàng các bộ sưu tập, có nghĩa là chúng giữ các yếu tố của chúng theo cùng một thứ tự mà chúng được giới thiệu. Nếu bạn tận dụng tính năng này, thì bạn có thể sử dụng chức năng Python

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 để lặp qua nhiều từ điển theo cách an toàn và mạch lạc:

>>>

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

3

Ở đây, bạn lặp lại thông qua

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

75 và

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

76 song song. Trong trường hợp này,

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 tạo ra các bộ dữ liệu với các mục từ cả hai từ điển. Sau đó, bạn có thể giải nén từng tuple và có quyền truy cập vào các mục của cả hai từ điển cùng một lúc.

Lưu ý rằng, trong ví dụ trên, thứ tự đánh giá từ trái sang phải được đảm bảo. Bạn cũng có thể sử dụng hàm Python từ

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 để lặp lại thông qua các bộ song song. Tuy nhiên, bạn sẽ cần phải xem xét điều đó, không giống như từ điển trong Python 3.6, các bộ don don giữ các yếu tố của chúng theo thứ tự. Nếu bạn quên chi tiết này, kết quả cuối cùng của chương trình của bạn có thể không hoàn toàn như bạn muốn hoặc mong đợi.

Giải nén một chuỗi

Có một câu hỏi xuất hiện thường xuyên trong các diễn đàn cho Pythonistas mới: Nếu có chức năng

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2, vậy tại sao không có chức năng

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

80 mà ngược lại?

Lý do tại sao không có chức năng

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

80 trong Python là do đối nghịch với

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 là rất tốt,

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2. Bạn có nhớ rằng chức năng Python

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 hoạt động giống như một dây kéo thực sự không? Các ví dụ cho đến nay đã cho bạn thấy Python mọi thứ đã đóng lại như thế nào. Vì vậy, làm thế nào để bạn giải nén các đối tượng Python?

Giả sử bạn có một danh sách các bộ dữ liệu và muốn phân tách các yếu tố của mỗi tuple thành các chuỗi độc lập. Để làm điều này, bạn có thể sử dụng

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 cùng với toán tử giải nén

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

9, như vậy:

>>>

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

4

Ở đây, bạn có một

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

30 các bộ dữ liệu chứa một số loại dữ liệu hỗn hợp. Sau đó, bạn sử dụng toán tử giải nén

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

9 để giải nén dữ liệu, tạo hai danh sách khác nhau (

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

1 và

>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', ..., 'zip']

8).

Sắp xếp song song

Sắp xếp là một hoạt động phổ biến trong lập trình. Giả sử bạn muốn kết hợp hai danh sách và sắp xếp chúng cùng một lúc. Để làm điều này, bạn có thể sử dụng

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 cùng với

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

92 như sau:

>>>

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

5

Trong ví dụ này, trước tiên bạn kết hợp hai danh sách với

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 và sắp xếp chúng. Lưu ý cách

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

94 được sắp xếp bởi

>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', ..., 'zip']

8 và

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

96 được sắp xếp bởi

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

1.

Bạn cũng có thể sử dụng

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

98 và

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 cùng nhau để đạt được kết quả tương tự:

>>>

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

6

Trong trường hợp này,

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

98 chạy qua trình lặp được tạo bởi

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 và sắp xếp các mục theo

>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', ..., 'zip']

8, tất cả trong một lần. Cách tiếp cận này có thể nhanh hơn một chút vì bạn chỉ cần hai cuộc gọi chức năng:

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 và

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

98.

Với

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

98, bạn cũng viết một đoạn mã tổng quát hơn. Điều này sẽ cho phép bạn sắp xếp bất kỳ loại trình tự, không chỉ danh sách.

Tính toán theo cặp

Bạn có thể sử dụng chức năng Python

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 để thực hiện một số tính toán nhanh. Giả sử bạn có dữ liệu sau trong bảng tính:

Element/Month	tháng Giêng	tháng 2	Bước đều
Tổng doanh số	52,000.00	51,000.00	48,000.00
Chi phí sản xuất	46,800.00	45,900.00	43,200.00

Bạn sẽ sử dụng dữ liệu này để tính toán lợi nhuận hàng tháng của bạn.

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 có thể cung cấp cho bạn một cách nhanh chóng để thực hiện các tính toán:

>>>

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

7

Ở đây, bạn tính toán lợi nhuận cho mỗi tháng bằng cách trừ

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

08 từ

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

09. Hàm Python từ

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 kết hợp các cặp dữ liệu phù hợp để thực hiện các tính toán. Bạn có thể khái quát logic này để thực hiện bất kỳ loại tính toán phức tạp nào với các cặp được trả về bởi

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2.

Xây dựng từ điển

Từ điển Python sườn là một cấu trúc dữ liệu rất hữu ích. Đôi khi, bạn có thể cần xây dựng một từ điển từ hai chuỗi khác nhau nhưng liên quan chặt chẽ. Một cách thuận tiện để đạt được điều này là sử dụng

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

12 và

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 cùng nhau. Ví dụ: giả sử bạn lấy dữ liệu của một người từ biểu mẫu hoặc cơ sở dữ liệu. Bây giờ bạn có các danh sách dữ liệu sau:

>>>

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

8

Với dữ liệu này, bạn cần tạo một từ điển để xử lý thêm. Trong trường hợp này, bạn có thể sử dụng

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

12 cùng với

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 như sau:

>>>

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

9

Ở đây, bạn tạo một từ điển kết hợp hai danh sách.

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

16 Trả về một trình lặp tạo ra các bộ dữ liệu 2 mục. Nếu bạn gọi

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

12 trên trình lặp đó, thì bạn sẽ xây dựng từ điển bạn cần. Các yếu tố của

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

18 trở thành các khóa từ điển và các yếu tố của

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

19 đại diện cho các giá trị trong từ điển.

Bạn cũng có thể cập nhật một từ điển hiện có bằng cách kết hợp

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 với

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

21. Giả sử rằng John thay đổi công việc của mình và bạn cần cập nhật từ điển. Bạn có thể làm một cái gì đó như sau:

>>>

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

0

Ở đây,

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

21 cập nhật từ điển với bộ xử lý giá trị khóa mà bạn đã tạo bằng hàm Python tựa

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2. Với kỹ thuật này, bạn có thể dễ dàng ghi đè lên giá trị của

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

24.

Sự kết luận

Trong hướng dẫn này, bạn đã học được cách sử dụng chức năng Python từ ____42.

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2 có thể nhận nhiều lần lặp làm đầu vào. Nó trả về một trình lặp có thể tạo các bộ dữ liệu với các phần tử được ghép nối từ mỗi đối số. Trình lặp kết quả có thể khá hữu ích khi bạn cần xử lý nhiều lần lặp trong một vòng lặp và thực hiện một số hành động trên các mục của chúng cùng một lúc.

Bây giờ bạn có thể:

Sử dụng hàm
numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')]
2 trong cả Python 3 và Python 2 in both Python 3 and Python 2

Vòng lặp qua nhiều lần lặp và thực hiện các hành động khác nhau trên các mục của chúng song song and perform different actions on their items in parallel
Tạo và cập nhật từ điển một cách nhanh chóng bằng cách kết hợp hai lần lặp lại đầu vào với nhau on the fly by zipping two input iterables together

Bạn cũng đã mã hóa một vài ví dụ mà bạn có thể sử dụng làm điểm bắt đầu để thực hiện các giải pháp của riêng bạn bằng cách sử dụng hàm Python tựa

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2. Hãy thoải mái sửa đổi các ví dụ này khi bạn khám phá độ sâu

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

2!

Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Lặp lại song song với chức năng Zip () của Python This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Parallel Iteration With Python's zip() Function

Bạn có thể zip nhiều danh sách trong Python không?

Zip () trong Python: Nhận các yếu tố từ nhiều danh sách.Trong Python, chức năng tích hợp zip () tổng hợp nhiều đối tượng có thể lặp lại (danh sách, bộ dữ liệu, v.v.).Bạn có thể lặp lại nhiều danh sách trong vòng lặp với zip ().You can iterate multiple lists in the for loop with zip() .

Tôi có thể zip danh sách trong Python không?

Hàm zip () của Python được định nghĩa là zip (*tererables).Chức năng lấy Iterables làm đối số và trả về trình lặp.Iterator này tạo ra một loạt các bộ dữ liệu chứa các yếu tố từ mỗi phần có thể.ZIP () có thể chấp nhận bất kỳ loại có thể lặp lại, chẳng hạn như tệp, danh sách, bộ dữ liệu, từ điển, bộ, v.v.zip() can accept any type of iterable, such as files, lists, tuples, dictionaries, sets, and so on.

Có bao nhiêu lập luận có thể Zip lấy Python?

Nó có thể lấy không hoặc nhiều đối số và nó đưa chúng ta một trình lặp lại cho Tuple.zero or more arguments and it returns us an iterator to the tuple.

Chúng ta có thể zip hai bộ dữ liệu trong Python không?

12.5 Danh sách và Tuples ZIP là một hàm tích hợp có hai hoặc nhiều chuỗi và các zips, chúng vào một danh sách các bộ dữ liệu trong đó mỗi bộ chứa một phần tử từ mỗi chuỗi.Trong Python 3, ZIP trả về một bộ lặp của các bộ dữ liệu, nhưng đối với hầu hết các mục đích, một trình lặp lại hoạt động như một danh sách.zip is a built-in function that takes two or more sequences and “zips” them into a list of tuples where each tuple contains one element from each sequence. In Python 3, zip returns an iterator of tuples, but for most purposes, an iterator behaves like a list.

programming python Unzip Python NumPy zip For zip Python Unzip list Python zip() trong python

Hướng dẫn can you zip 4 lists python? - bạn có thể nén 4 danh sách python không?

Đầu vào

Đầu ra (danh sách) (list)

Trường hợp cạnh

Zip trong hành động!

Tín dụng bổ sung: Giải nén

Chú thích

Hiểu chức năng Python numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2

Sử dụng numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2 trong Python

Vượt qua student_grades = [ [ 'Morty' , 1 , "B" ], [ 'Rick' , 4 , "A" ], [ 'Jerry' , 3 , "M" ], [ 'Kramer' , 0 , "F" ], ] row_1 = student_grades[0] print row_1 # ['Morty', 1, 'B'] columns = zip(*student_grades) names = columns[0] print names # ('Morty', 'Rick', 'Jerry', 'Kramer') 2 đối số

Theo tài liệu chính thức, chức năng Python từ numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2 hoạt động như sau:

Theo tài liệu chính thức, chức năng Python từ numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2 hoạt động như sau:

Vượt qua các đối số về chiều dài không đồng đều

So sánh numbers = (1,2,3) letters = ('a','b','c') zipped = zip(numbers, letters) print zipped # [(1, 'a'), (2, 'b'), (3, 'c')] unzipped = zip(*zipped) print unzipped # [(1, 2, 3), ('a', 'b', 'c')] 2 trong Python 3 và 2

Vòng lặp qua nhiều vòng lặp

Danh sách đi ngang song song

Đi ngang qua từ điển song song

Giải nén một chuỗi

Sắp xếp song song

Tính toán theo cặp

Xây dựng từ điển

Sự kết luận

Bạn có thể zip nhiều danh sách trong Python không?

Tôi có thể zip danh sách trong Python không?

Có bao nhiêu lập luận có thể Zip lấy Python?

Chúng ta có thể zip hai bộ dữ liệu trong Python không?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội