I think the only reason I read your posts is for comedy, seeing if this
is yet another "Xah Lee just threw a tantrum" post. I don't know why
I'm wasting my time responding, though... It's against my better
judgment and my previous advice to the group.
Xah Lee wrote:
>in coding Python yesterday, i was quite stung by the fact that lists
>appened to another list goes by as some so-called "reference". e.g.
>
>
What would you have it do? A list is just a collection of objects. If
I want to append my object to some list, I don't want a copy of it
appended. If I did, I'd pass in a copy of it. Otherwise, a reference
gets appended.
>t=range(5)
>n=range(3)
>n[0]='m'
>t.append(n)
>n[0]='h'
>t.append(n)
>print t
>
>
>in the following code, after some 1 hour,finally i found the solution
>of h[:]. (and that's cheating thru a google search)
>
>def parti(l,j):
> '''parti(l,j) returns l partitioned with j elements per group. If j
>is not a factor of length of l, then the reminder elements are dropped.
> Example: parti([1,2,3,4,5,6],2) returns [[1,2],[3,4],[5,6]]
> Example: parti([1,2,3,4,5,6,7],3) returns [[1,2,3],[4,5,6]]'''
> n=len(l)/j
> r=[] # result list
> h=range(j) # temp holder for sublist
> for n1 in range(n):
> for j1 in range(j):
> h[j1]=l[n1*j+j1]
> r.append( h[:] )
> return r
>
>interesting that a dictionary has copy method, but not list. (the pain
>is coupled with the uselessness of the Python doc)
>
>
You keep blasting the Python documentation. You have *yet* to produce
anything of 1/10th the quality of any piece of the Python
documentation. Until you are able to do so, I recommend shutting your
proverbial trap. You have no grounds for raising the first criticism of
the Python documentation since you have obviously not spent a
significant amount of time reading them. In another thread from
yesterday (entitled "functions with unlimited variable arguments..."),
you asked where one could find a certain feature in the documentation
(functionality which is, in my opinion, pretty basic). You appear to
have found a reference in the tutorial by yourself and one person kindly
pointed to a reference in the Python reference doc.
>------
>
>
You really don't do a good job making a good point in this section.
Maybe it's the poor English, although I can typically extract good
thought from poor English. Maybe it really is just poor thought.
>Btw, behavior such as this one, common in imperative languages and info
>tech industry, is a criminality
>
Nice. If you don't like something, just call it "a criminality". Let
me try: the criminality of Xah Lee's postings caused all occupants of
at least 4 continents to roll their eyes. You know - even though I
think my assertion had some validity, I think even there it's ridiculous
to make such a forceful assertion without a foundation for it.
> arose out of hacks C, Unix, and from
>there all associated imperative langs. (C++, csh, perl, Java... but
>each generation improves slightly)
>
>The gist of the matter is that these behaviors being the way they are
>really is because they are the easiest, most brainless implementation,
>as oppose to being a design decision.
>
>
Again, prove it. Why is passing references (or appending references -
you're not totally clear on what your beef is) brainless? What better
implementation do you have to offer the world, oh great one?
>In hindsight analysis, such language behavior forces the programer to
>fuse mathematical or algorithmic ideas with implementation details. A
>easy way to see this, is to ask yourself: how come in mathematics
>there's no such thing as "addresses/pointers/references".
>
>
Maybe because in pure mathematics there isn't the need for a computer.
Although, if we updated Descartes, Pascal, Fermat, Newton, and Leibnitz
with some of Rambaldi's works, you might see the concept of
addresses/pointers/references in pure mathematics.
>---------
>
>PS is there any difference between
>t=t+[li]
>t.append(li)
>
>
In [1]: def summit(lst, item):
...: lst = lst + item
...: print lst
...:
In [2]: def appender(lst, item):
...: lst.append(item)
...: print lst
...:
In [3]: def plus_equals(lst, item):
...: lst += item
...: print lst
...:
In [5]: import dis
In [6]: dis.dis(summit)
2 0 LOAD_FAST 0 (lst)
3 LOAD_FAST 1 (item)
6 BINARY_ADD
7 STORE_FAST 0 (lst)
3 10 LOAD_FAST 0 (lst)
13 PRINT_ITEM
14 PRINT_NEWLINE
15 LOAD_CONST 0 (None)
18 RETURN_VALUE
In [7]: dis.dis(appender)
2 0 LOAD_FAST 0 (lst)
3 LOAD_ATTR 1 (append)
6 LOAD_FAST 1 (item)
9 CALL_FUNCTION 1
12 POP_TOP
3 13 LOAD_FAST 0 (lst)
16 PRINT_ITEM
17 PRINT_NEWLINE
18 LOAD_CONST 0 (None)
21 RETURN_VALUE
In [8]: dis.dis(plus_equals)
2 0 LOAD_FAST 0 (lst)
3 LOAD_FAST 1 (item)
6 INPLACE_ADD
7 STORE_FAST 0 (lst)
3 10 LOAD_FAST 0 (lst)
13 PRINT_ITEM
14 PRINT_NEWLINE
15 LOAD_CONST 0 (None)
18 RETURN_VALUE
Figure it out.
>---------
>References:
>
>for a analysis of the same situation in Java, see
>http://xahlee.org/java-a-day/assign_array_to_list.html
>
>How to write a tutorial
>http://xahlee.org/Periodic_dosage_dir/t2/xlali_skami_cukta.html
>
> Xah
> [EMAIL PROTECTED]
>∑ http://xahlee.org/
>
>
>
It's really bad enough that you waste the time of the folks on
comp.lang.python. Why cross post like you are? I really fail to see
the point.
Jeremy Jones
--
http://mail.python.org/mailman/listinfo/python-list
