Python's BUG?

[ZZZ1]

>>> h=[[0,0]]*2    ## replace this line with h=[[0,0],[0,0]] and result will be ok.
>>> h
[[0, 0], [0, 0]]
>>> for i in xrange(10):
	h[0][1]+=i
    
>>> h
[[0, 45], [0, 45]]
>>>

[TFK1]

Just in case anyone else takes an interest in this,

This is not a bug per se, but rather a quirk in the design. Apparently, the * operator, when applied to lists, uses shallow-copy (which just copies references, and not the objects themselves). Since [0,0] is a proper list object, it's reference just gets copied, so you actually get a list of two references to the same object. (Think of it like a=[0,0]; h = [a]*2; a[0]=1; => h will be equal [[1,0],[1,0]] now)

Even if I'm totally wrong about the mechanics, one thing is certian:

h[0] is h[1]

resutls in True, i.e., h[0] and h[1] are the same object. (But if h=[[0,0],[0,0]] then h[0] is h[1] evaluates in False.)

This is not a problem with immutable objects, methinks.

[ZZZ1]

Very interesting! and de facto you are right!

But I always thought that [...]*N form was invented just for

our convenience, just for to ease typing.

[TFK1]

Indeed. I just found out what the official docs have to say about it (I never did pay attention to the small print...):

python.org/doc/2.3.4/lib/typesseq.html

s * n , n * s: n shallow copies of s concatenated (2)

(2)
Values of n less than 0 are treated as 0 (which yields an empty sequence of the same type as s). Note also that the copies are shallow; nested structures are not copied. This often haunts new Python programmers; consider:

>>> lists = [[]] * 3
>>> lists
[[], [], []]
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]

What has happened is that lists is a list containing three copies of the list [[]] (a one-element list containing an empty list), but the contained list is shared by each copy. You can create a list of different lists this way:
>>> lists = [[] for i in range(3)]
>>> lists[0].append(3)
>>> lists[1].append(5)
>>> lists[2].append(7)
>>> lists
[[3], [5], [7]]

Let it serve as a warning to beginning Pythoneers! List comprehensions win yet again... Also, note that list1 += list2 is not the same as list1 = list1 + list2: the first is actually list1.append(list2) and the other is just normal list concatenation. Weird? You bet.

I still love Python, though

[BlackJack_sof]

Also, note that list1 += list2 is not the same as list1 = list1 + list2: the first is actually list1.append(list2) and the other is just normal list concatenation. Weird? You bet.

That would be weird if true. list1 += list2 is list1.extend(list2) and the other is concatenation. In the first case you modify list1, in the second you get a new list. But both results contain the same elements.

[zzz]

Yes!

>>> ================= RESTART ======
>>> s=[1,2,3]
>>> ss=s
>>> s=s+[4,5]
>>> ss
[1, 2, 3]
>>> s
[1, 2, 3, 4, 5]
>>> ================= RESTART ======
>>> s=[1,2,3]
>>> ss=s
>>> s+=[4,5]
>>> ss
[1, 2, 3, 4, 5]
>>> s
[1, 2, 3, 4, 5]
>>>

[m_sasinowski1]

Przecież aby wczytać dane nie potrzebujesz wiedzieć ile ich będzie np.

Powiedzmy, że na wejściu dostajemy n liczb (lecz nie znamy n), które mamy zsumować:

while(scanf("%d", &x) != -1)
  suma+= x;

PS. Temat poruszany był przynajmniej z 4-5 razy na forum, także proponuję poszukać

[mjs_sof]

dziękuje, ale jak w ten sposób wprowadzić całe linijki?
np w tym zadaniu:

W celu zaoszczędzenia ilości znaków w krótkich wiadomościach tekstowych (SMS) nie pisze się spacji, a każdy wyraz rozpoczyna się z dużej litery. Twoim zadaniem jest otrzymany tekst przerobić zgodnie z powyższym trendem.
Input

Na wejściu znajduje się dowolny tekst bez polskich znaków.

bo tak:

while(cin.getline(slowka, sizeof(slowka))!=-1){
}

sie nie da...

[m_sasinowski1]

cppreference.com/cppstring/getline.html

to powinno pomóc