I've been tasked with converting some python code over to Java. I came across some notation I'm not familiar with and can't seem to find any information on. I'm guessing this is a lack of keywords on my part.
I've sanitized the code and hard coded some basic values for simplicity.
index_type = c_int * 1000 #size of int, basically 1000 integers?
indexes = index_type() # not entirely sure what this does
indexes[:] = range(2000, 3000)[:] # no idea
# c_int equals 4
The logic doesn't really matter to me, I'm just trying to figure out what's going on in terms of datatypes and converting to Java.
This is called "slicing". See the tutorial sections on Strings and Lists for a good description of how it works. (In your example, it's actually a ctypes array that's being sliced, not a list, but they work the same way. So, for simplicity, let's talk about lists.)
The notation indexes[:] is a slice of the entire list. So, you can do this:
a = [1, 2, 3]
b = a[:]
… to get a copy of the whole list, and this:
a[:] = [4, 5, 6]
… to replace the contents of the whole list.
You may wonder how this is different from just using a itself. The difference is that in the first case, b = a doesn't copy the list, it just makes another reference to the same list, and in the second case, a = [4, 5, 6] doesn't mutate the list, it rebinds a to refer to a new list. Here's an example that shows the difference:
>>> a = [1, 2, 3]
>>> b = a # b is now the same list as a
>>> a[0] = 10 # so changing that list is visible to b
>>> b
[10, 2, 3]
>>> a = [1, 2, 3]
>>> b = a[:] # b is now a new list, with a copy of a
>>> a[0] = 10 # so changing the original list doesn't affect b
>>> b
[1, 2, 3]
>>> a = [1, 2, 3]
>>> b = a # b is now the same list as a
>>> a = [4, 5] # but now a is a different list
>>> a[0] = 10
>>> b
[1, 2, 3]
>>> a = [1, 2, 3]
>>> b = a # b is now the same list as a
>>> a[:] = [4, 5] # and we've replaced the contents
>>> b
[4, 5]
You may wonder why anyone would use range(2000, 3000)[:] on the right side of the assignment.
Well, I wonder the same thing.
If this is Python 2.x, range(2000, 3000) is a brand-new list. You replace the contents of indexes with the contents of that range list, then give up your only reference to the range list. There is no way anyone could possibly end up sharing it, so there is no good reason to make an extra copy of it, unless you're worried that your computer has too much CPU and too much RAM and might be getting bored.
If this is Python 3.x, range(2000, 3000) is a smart range object. And range(2000, 3000)[:] is a new and equal range object. The copying this time is a lot cheaper, but it's exactly as unnecessary.
The other answers are talking about what x[:] means as an expression. But when this notation is used as the target of an assignment (i.e., on the left side of the =), it means something different. It is still a slice of the object, but it doesn't create a copy; rather, it assigns the given value (the right hand side) to the specified "part" of the object. If you use [:], the slice is the whole object, so its contents will be replaced by what you pass.
An example:
>>> x = [1, 2, 3]
>>> x[:] = [8, 8]
>>> x
[8, 8]
Notice that you can replace the contents by new contents of different length.
If you use a partial slice, only part of the contents will be replaced:
>>> x = [1, 2, 3, 4]
>>> x[1:3] = [8, 8, 88]
>>> x
[1, 8, 8, 88, 4]
The notation:
[a:b]
Is a range that starts at a and ends at b. When you leave one of them blank, it counts as "beginning" and "end", respectively.
Basically, your indexes is a list of values, each one has a number to associate with it that shows its order inside indexes. It starts at 0 and progresses until the end. The line of code:
indexes[:]
Simply means
"first value of indexes to last value of indexes"
I hope this helps,
happy coding!
It means getting a COPY of the original list, since lists are mutable in python, for example
>>a = [1,2,3]
>>b = a
>>a[0] = 3
>>a
[3, 2, 3]
>>b
[3, 2, 3]
>>b = a[:]
>>a[0] = 0
>>a
[0, 2, 3]
>>b
[3, 2, 3]
[:] is an example of slice notation, Python's way to specify any number of items in a sequence. [:] specifies the entire sequence. The notation is succinct and powerful in what it can express. Some other possible forms are:
sequence[n] #an index to one item (not a slice)
sequence[n:] #the nth item to the end of the sequence
sequence[:n] #all items until the nth item (exclusive)
sequence[m:n] #the mth item until the nth item (exclusive)
sequence[:] #all items
sequence[::2] #every other item
sequence[::-1] #all items in reverse order
When slicing is used to modify items in a sequence, the item(s) are modified:
>>> a = [1, 2, 3]
>>> a[0:1] = [4] #same as a[0] = 4
>>> a
[4, 2, 3]
>>> a[:] = [1, 2, 3, 4] #the sequence can be made larger
>>> a
[1, 2, 3, 4]
>>> a[:] = [] #or smaller
>>> a
[]
When slicing is used to read items in a sequence, a shallow copy of the item(s) are returned instead of a reference to the item. The term shallow copy means that if a copied item is itself a sequence, the item will refer to the original sequence, not a copy of it:
For instance:
>>> a = [1, 2, 3]
>>> b = a[0]
>>> b #b has the same value as, but does not reference the same object as a[0]
1 #this is a copy of a[0]
>>> a = [1, 2, 3]
>>> b = a[:]
>>> b #b has the same values as, but does not reference the same object as a
[1, 2, 3] #this is a copy of list a
>>> a = [1, 2, 3]
>>> b = [a, 2, 3]
>>> c = b[:] #c is a hallow copy of b
>>> c
[[1, 2, 3], 2, 3]
>>> b[:] = [] # modifying b does not affect c
>>> c
[[1, 2, 3], 2, 3]
>>> a[0] = 4 # modifying a will affect a in c
>>> c
[[4, 2, 3], 2, 3]
Related
This question already has answers here:
What is the difference between slice assignment that slices the whole list and direct assignment?
(4 answers)
Understanding slicing
(38 answers)
Closed last year.
If we have a list a = [1,2,3,4]
and list b = [5,6,7]
why is a[1] interpreted differently than a[1:1] and what exactly is the difference?
If I want to add all of list b to list a at index 1, so that the list a becomes [1,5,6,7,2,3,4] why do I have to run a[1:1] = b instead of a[1] = b?
how exactly is a[1:1] interpreted?
a[1:1] means an empty slice spanning from before index 1, and until before index 1. It does not include 1, as that would be a[1:2].
When you replace that empty slice, you basically insert the new list in that position.
If you do a[1] you replace the item at position 1 with the list.
Some examples:
>>> a = [1,2,3]
>>> b = [4,4,4,4]
>>> a[1] = b
>>> a
[1, [4, 4, 4, 4], 3] # [4, 4, 4, 4] is a sublist
>>> a[1]
[4, 4, 4, 4]
>>> len(a)
3 # List contains only 3 items - `1`, the sublist, and `3`.
>>> a = [1,2,3] # Reset back
>>> a[1:1] = b
>>> a
[1, 4, 4, 4, 4, 2, 3]
>>> len(a)
7 # List contains 7 integers
a[1] is for get single value from list by index in square brackets (0 is first value)
and a[1:1] is for get subset of list, not only one value. ([start:end]), but in this case get empty list, because start and end it's same
I leave python for a while and now I'm preparing for interviews. When I was reviewing some basics I found this:
>>> a = [1,2]
>>> b = a
>>> b.append(3)
>>> a
[1, 2, 3]
>>> a = [1,2]
>>> a[:] = [1,2,3]
>>> a
[1, 2, 3]
>>> a = [1,2]
>>> b = a[:]
>>> b.append(3) # /a[:].append(3)
>>> a
[1, 2]
As I understand it, in the second case a[:] acts as a shallow copy while in the third it is a deep copy. Can anyone help me with this basic concept, thanks beforehand.
No, in the second case, the expression a[:] on the left-hand side of the assignment does not make any copy (shallow or deep) of a
It just says that you want to replace the complete slice of a, with the values from [1, 2, 3]
Only in the 3rd part of your code snippet, a[:] results in a copy of a. And it will be a shallow copy -- not a deep one. But to demonstrate that a[:] makes only a shallow copy, you'll have to fill your list a with some mutable objects. Currently, you've only filled them with int values. For example, you could fill your list a with inner lists:
a = [ ['a', 'b'], 2] # First element of a is a list, which is a mutable object.
b = a[:] # b will now have a shallow copy of a, which means that
# the first element of a and the first element of b, both refer to
# the same object, which is the inner list ['a', 'b']
b[0].append('c') # Mutate the first element of b.
a # You'll find that the change is visible thru list a also.
Output:
[['a', 'b', 'c'], 2]
It is a shallow copy. But I think you misunderstand what "shallow" means. Your 3rd example does only illustrate that a and b are different objects. However, the items they contain are not different objects. You can't see it in this case, since you have numbers, which are immutable anyway.
However, if the items in a were mutable objects (eg, other lists), modifying them in a would also modify them in b
a = [[]]
b = a[:]
b.append(3) # this does not change a
a[0].append(1) # this changes b
print(b)
a=[1,2]
b=a #in this case whatever changes we apply to a or b
is reflected in both.
a.append(3)
b
[1, 2, 3]
a
[1, 2, 3]
b.append(4)
a
[1, 2, 3, 4]
b
[1, 2, 3, 4]
a=[[]]
b=a[:] #in this case whatever changes we apply to
b is reflected only in b and whatever changes are
applied in a is only reflected in a.
b.append(3)
a[0].append(1)
print(b)
[[1], 3]
a
[[1]]
a=[1,2]
b=a[:]
b.append(3)
b
[1, 2, 3] #change only in b.
a
[1, 2] #no change in a
a.append(4)
a
[1, 2, 4] #change only in a.
b
[1, 2, 3] #no change in b.
I want to return the number 5 from this:
list_1 = [[1, 2, 3], [4, 5, 6]]
I thought this would work but it is not:
print(list_1[1:1])
It returns an empty list. It is Index 1 (second list) and position 1 (second number in the list).
Shouldn't that work?
You need two separate operations:
sub_list = list_1[1]
item = sub_list[1]
# or shortly list_1[1][1]
What you did was calling the slice interface which has an interface of [from:to:step]. So it meant: "give me all the items from index 1 to index 1" (read about slicing for more information).
list_1 = [[1, 2, 3], [4, 5, 6]]
then
list_1[0] == [1,2,3]
list_1[1] == [4,5,6]
then
list_1[1][1:1] == [] #slice starting from position '1', and around to the position before '1', effectively returning an empty list
list_1[1][1] == 5
edit corrections as from comments
list_1[1][1]
The first [1] gives you [4, 5, 6]. The next [1] gives you 5
Let's say we have a list:
list_1 = [[1, 2, 3], [4, 5, 6]]
You're question asks, why does
list_1[1:1]
Return []?
Because you're asking for the objects from index 1 to index 1, which is nothing.
Take a simple list:
>>> x = [1, 2, 3]
>>> x[1:1]
[]
This is also empty because you're asking for all objects from index 1 to index 1.
All the 2nd number does is say the maximum reach non-inclusive. So...
>>> x = [1, 2, 3]
>>> x[1:10000]
[2, 3]
>>> x[1:-1023]
[]
>>> x[1:2]
[2]
If the 1st number is equal to or greater than the 2nd number, you'll always end up with an empty list unless you change the step of the slice (if it's equal, it'll always be empty)
Of a 2-dimensional array, if you wanted the 2nd object of the 2nd list in the list:
>>> list_1[1]
[4, 5, 6]
>>> list_1[1][1]
5
I have a list called ones that changes value after a block of code that shouldn't affect it. Why?
s = 3
ones = []
terms = []
for i in range (0, s):
ones.append(1)
terms.append(ones)
print(terms)
twos = []
if len(ones) > 1:
twos.append(ones)
twos[-1].pop()
twos[-1][-1] = 2
print(twos)
print(terms)
Output:
[[1, 1, 1]] # terms
[[1, 1, 2]] # twos
[1, 1, 2] # terms
For context, I'm trying to use this to begin to solve the problem on page 5 of this British Informatics Olympiad past exam: http://www.olympiad.org.uk/papers/2009/bio/bio09-exam.pdf.
Here:
twos.append(ones)
You are appending a reference to ones, not its values. See the difference:
In [1]: l1 = [1, 2, 3]
In [2]: l2 = []
In [3]: l2.append(l1)
In [4]: l2, l1
Out[4]: ([[1, 2, 3]], [1, 2, 3])
In [5]: l2[0][1] = 'test'
In [6]: l2, l1
Out[6]: ([[1, 'test', 3]], [1, 'test', 3])
In order to avoid this you can give a copy by using [:] operator:
In [7]: l1 = [1, 2, 3]
In [8]: l2 = []
In [9]: l2.append(l1[:])
In [10]: l2, l1
Out[10]: ([[1, 2, 3]], [1, 2, 3])
In [11]: l2[0][1] = 'test'
In [12]: l2, l1
Out[12]: ([[1, 'test', 3]], [1, 2, 3])
twos.append(ones) does not copy ones.
There is only ever one list ones in memory, which also goes by the following references:
terms[0]
twos[0]
and also terms[-1] and twos[-1] because terms and twos only have one element each, so the first is the last.
Now, when you mutate ones/terms[0]/terms[-1]/twos[0]/twos[-1] you are mutating the same list in memory.
I highly recommend watching Facts and Myths about Python names and values.
When you do twos.append(ones), you're passing the reference to the ones list, not the value itself. Therefore, when you do twos[-1][-1] = 2, it'll modify the value in the ones list itself, not a copy in the twos list.
To pass the value instead of the reference to the ones list, you can do:
twos.append(ones[:])
I have two lists, a and b.
I want to reassign the content of a into b and the content of b into a.
or in other words, after running a few operations with two lists, I want to switch the names of the lists. so that the list that was named a would now be named b, and the list that was named b would now be named a.
this way is obviously wrong:
a=b
b=a
(because they are both b now)
so, is there a right way to do this?
python lets you do that as follows:
a, b = b, a
Example
a = [1,2,3]
b = [4,5,6]
a, b = b, a
>>> print a
[4,5,6]
>>> print b
[1,2,3]
This is because the expression on the right hand side is evaluated first and then assigned to variables on the left.
This might be not necessary for you, but good to remember that:
a = [1, 2, 3]
b = [3, 4, 5]
c = a # now 'c' points to the same list as 'a'
a[0] = 0 # let's change the first element
print a
# [0, 2, 3]
print c
# now let's use multiple assigment:
a, b = b, a
print a
# [3, 4, 5]
print c
# [0, 2, 3]
# list didn't change, but 'a' now point do different list
# but 'c' still point to the same, unchanged list, the one
# that is now referenced by 'b'
Above solution is fast and usually the best. But if you have the same list (or other mutable data structure) referenced by other names, you may swap contents of list instead:
a = [1, 2, 3]
b = [3, 4, 5]
c = a
a[0] = 0
a[:], b[:] = b[:], a[:] # now we actually swap contents
# 'a' and 'c' still point to the same list,
# but values are from 'b' list
print a
# [3, 4, 5]
print b
# [0, 2, 3]
print c
# [3, 4, 5]