I recently saw some Clojure or Scala (sorry I'm not familiar with them) and they did zip on a list or something like that. What is zip and where did it come from ?
Python's zip() function is defined as zip(*iterables) . The function takes in iterables as arguments and returns an iterator. This iterator generates a series of tuples containing elements from each iterable. zip() can accept any type of iterable, such as files, lists, tuples, dictionaries, sets, and so on.
If multiple iterables are passed, zip() returns an iterator of tuples with each tuple having elements from all the iterables. Suppose, two iterables are passed to zip() ; one iterable containing three and other containing five elements. Then, the returned iterator will contain three tuples.
In Haskell, we have a zip function that is used to merge the two arrays or lists or any data structure. But to merge them directly there is some condition by which they get merged. All the values which get merged with the same position element from the other array or input passed.
Basically, it passes the contents of the lists as arguments.
Zip is when you take two input sequences, and produce an output sequence in which every two elements from input sequences at the same position are combined using some function. An example in Haskell:
Input:
zipWith (+) [1, 2, 3] [4, 5, 6]
Output:
[5, 7, 9]
The above is a more generic definition; sometimes, zip
specifically refers to combining elements as tuples. E.g. in Haskell again:
Input:
zip [1, 2, 3] [4, 5, 6]
Output:
[(1, 4), (2, 5), (3, 6)]
And the more generic version is called "zip with". You may consider "zip" as a special case of "zipWith":
zip xs ys = zipWith (\x y -> (xs, ys)) xs ys
zip is a common functional programming method like map or fold. You will find these functions in early lisps all the way up to ruby and python. They are designed to perform common batch operations on lists.
In this particular case, zip takes two lists and creates a new list of tuples from those lists.
for example, lets say you had a list with (1,2,3) and another with ("one","two","three") If you zip them together, you will get List((1,"one"), (2,"two"), (3,"three"))
or from the scala command line, you would get:
scala> List(1,2,3).zip(List("one","two","three"))
res2: List[(Int, java.lang.String)] = List((1,one), (2,two), (3,three))
When I first saw it in Python, without knowing functional programming, I thought it was related to the compression format. After I learned more about functional programming, I've used it more and more.
Unfortunatley I don't have enough points to even leave a comment on the top answer, but
zip xs ys = zipWith xs ys (\x y -> (xs, ys))
is wrong, it should be:
zip xs ys = zipWith (\x y -> (x,y)) xs ys
or simply:
zip = zipWith (\x y -> (x,y))
You could use the following code in Python:
>>> a = [1,2]
>>> b = [3,4]
>>> zip(a,b)
[(1,3),(2,4)]
Pavel's answer pretty much describes it. I'll just provide an F# example:
let x = [1;2]
let y = ["hello"; "world"]
let z = Seq.zip x y
The value of z
will be a sequence containing tuples of items in the same position from the two sequences:
[(1, "hello"); (2, "world")]
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With