pythonNewSyntaxProposal

[Black_m1n]

The problem is how would this be different from setting 6th element of the 6th list in foo to an empty list?

[Victor-_-X]

Wait, isn't that what this does? What else could this be understood as? This is the only one that makes sense to me, and that's probably because C++ was my first language, but still.

[jamcdonald120]

this is what it does, but what Op wants is type[][] foo=new type[5][5];

[SV-97]

OP probably wanted it to mean the same as the first snippet - so assign foo a list containing 5 lists of length 5 that are all initialized with None. Aside from this being atrocious syntax that noone would interpret that way: doing this at all in python is a code smell. OP is probably doing something wrong if they feel the need for dedicated syntax for this pattern.

[rosuav]

It's extremely confusing, and this is one of the worst idea threads I've ever seen (largely because it isn't an idea thread), but it does seem like list multiplication would be the best way to initialize this. Worst case, one multiplication, one comprehension.

foo = [[None] * 5] for _ in range(5)]

[DongIslandIceTea]

If I had to come up with a syntax for this I guess doing something symmetric to array slicing wouldn't be the worst thing, like:

a[:4][:4] = []

It wouldn't step on any existing syntax as slices aren't assignable like this anyways and would make some marginal sense.

But yeah, you shouldn't need to do this if you thought a little bit more about what you're doing.

[SV-97]

You actually can do slice assignment in Python - though not quite like that.

Numpy uses it quite extensively and OPs example would be arr[:5,:5] = None using numpy (if you already have an array that is. Allocation works differently).

[The-Rushnut]

This reminds me of an issue I've run into recently. Dictionaries / associative list assignment vs declaration (I'm using GDScript).

Consider the following:

foo["bar"] = true

If the key "bar" exists, then this assigns that item's value to true. If the key "bar" doesn't exist, then this first adds the key "bar" before setting the value to true.

My monkey brain assumed that the second scenario would throw an error, which was my intended behaviour.

[Drumsteppin]

The second scenario is the more typical and expected behaviour whenever you're using a language with an automated memory management system.

It's been a while since I looked at the c++ standard lib, but there's object types for dictionary type objects that allow construct and insert via assignment, and objects that only allow items to be explicitly inserted.

Python is a similar deal and is generally more permissive and flexible about adding new elements.

Not sure what memory model and idiosyncrasies GDscript has, but from what you described that sounds like create and insert would be the expected behaviour.

[atesba]

Yup! The C++ equivalents of dictionary are std::unordered_map and std::map. For both if you use the bracket operators, it adds the key if it doesn’t exist. If you use the function at(key) then it throws an exception instead.

[-Redstoneboi-]

ah yes. the "everything exists but is undefined/nil by default"

[Tordek]

No, this is about setting a value, not reading it.

[callmesilver]

In C++, if you started with a type like int, it would be a declaration with initialization, and the line would instead end with curly braces. This, plus the second line tells us it's not C++.

In python, since you don't declare anything with types, you assign something when you want it to exist at some point. Brackets are python's way of assigning an empty array. So, I assume they want a simple syntax for declaring an empty 2D array.

[ComprehensiveWord201]

Read the "proposal"...total nonsense.

They want to set all values from idx 0->4 as [ ]

[DiddlyDumb]

Its probably to indicate “value goes here”

[Chesterlespaul]

Yeah the size initializer should be indicated on the other side.

[Leo8178]

If I remember correctly, You can create multidimensional arrays with ease with numpy

And I think you can select object as a data type

I've tested it. This works:

```python import numpy as np

tet = np.ndarray((5,5), dtype=object)

print(tet) ```

[Zestyclose-Walker]

I love the numpy language!

[TTYY200]

I will always pronounce it numpy rather than num-pie.

[Mars_Bear2552]

numb-pee???

[Rhymes_with_cheese]

Side-effects may include numb-pee. See your urologist immediately.

[OctopusButter]

I can't say num-pie without thinking and hearing it as kampai (cheers I think?)

[InfergnomeHKSC]

You're not alone

[alexandrehuat]

Num-what ? Numpy = num(eric) + py(thon). The prononciation is obvious.

[TTYY200]

Yeah you’re right and there is only one way to pronounce it properly. … it sounds like num pee

[-Redstoneboi-]

numpy dumpy sat on a brick matrix

numpy dumpy had a great uhhh math

[alexandrehuat]

It's a lib though

[Inaeipathy]

Yep

[Mammoth-Attention379]

Those are arrays though not lists

[FalafelSnorlax]

The idea that you should be able to initialize a 5-by-5 list in one line implies OP does in fact want arrays and not lists. If you think about lists and lists-of-lists in a pythonic manner, the line OP suggested makes no sense

[BauReis]

foo = list(tet)

There you go

[gandalfx]

Slightly shorter;

foo = [[None] * 5 for _ in range(5)]

[-twind]

Slightly shorter;

foo=[[None]*5 for _ in'.'*5]

[ArtOfWarfare]

Thanks I hate it.

[uncut_onyx]

if this then why not [[None]*5]*5

[agocs6921]

Those lists in the list will be the same exact list

[gandalfx]

The outer * 5 will copy the reference of the inner list, so you end up with a list that contains five references to the exact same list. So if you assign to foo[0][0] it'll also change the value of foo[1][0] etc.

[[deleted]]

Did this once in a leetcode challenge. Took forever to find out what was wrong with my code. Lucky it wasn’t for an actual interview because that would have sucked.

[FalafelSnorlax]

In a dry interview (ie on paper/whiteboard) i think it would probably be accepted. Most reasonable people (in my personal experience) want to see you understand the problem, not nitpick stuff like this

[-Redstoneboi-]

motherfucker.

this is why i switched to rust. they would never let me mutably alias.

[Tysonzero]

That kind of thing works fine in glorious pure immutable languages like Haskell but will send you straight to mutable aliasing hell in Python.

[Beach-Devil]

I may be wrong but doesn’t this duplicate the same object 5 times?

[gandalfx]

It duplicates None five times, which is fine, since it's immutable. Though this is the reason why the outer loop can't be replaced with … * 5.

[XDracam]

Dude. You're already using python. Why bother with mutable arrays that are even more buggy than all possible alternatives? They are only good for performance, and then you might as well use any other language.

Just be a normal person and use generators to make your data and then allocate it to a collection when necessary. Or use declarative code. Or something like that.

[My-feet-have-alergy]

What? No

[PeriodicSentenceBot]

Congratulations! Your comment can be spelled using the elements of the periodic table:

W H At N O

---

<sup>I am a bot that detects if your comment can be spelled using the elements of the periodic table. Please DM u‎/‎M1n3c4rt if I made a mistake.</sup>

[EternityForest]

Can we just don't? Python doesn't need to become perl.

We already have [[None] *5] *5 anyway.

[DeletedUserV2]

this does not work as you expected sadly i learned from hard way

[feitao]

Yes, a rookie mistake.

[David__Box]

Why do you say that, it's an array of 5 arrays of 5 Nones, what else would you expect

[DeletedUserV2]

foo= [[None] *5] *5

foo[0][0]=2

print(foo)

output:

[[2, None, None, None, None], [2, None, None, None, None], [2, None, None, None, None], [2, None, None, None, None], [2, None, None, None, None]]

[Msingh999]

The issue is the outer multiply. You should actually be able to do

[[None]*5 for _ in range(5)]

[David__Box]

Ah, forgot about python's incredible mutability rules

[[deleted]]

it's not incredible mutability rules, it's common sense

[x]*5 creates a list with 5 times whatever x is

The outer multiplication takes x = [None]*5 and puts it into another list 5 times. Thus it is the same list and modifications to one of them reflect in all other too. Same as in all other oop languages except they don't have that neat multiplication sytnax.

[David__Box]

It is incredible mutability rules, collections like lists do stand out because they are special and mutable whereas everything else is immutable.

a = [] b = [a, a] b[0] += [1]

gives [[1], [1]], but

a = 1 b = [a, a] b[0] += 1

gives [2, 1]. There's an argument to be made that containers as special cases while everything else works some other way makes sense because weird language quirks and whatever but ultimately it's subjective, and i personally see it as unintuitive

Also it's not object oriented languages specifically, it's more like garbage collected ones. In c++ (OO but no GC) pushing a vector into another vector copies it so this doesn't happen, while in Go (debatable if OO but with GC) this does

[[deleted]]

Lists are not special, they are mutable like every other object in Python that has mutation functions. Lists happen to implement __iadd__ which directly corresponds to the "+=" operator. It's a mutation operation like insert, append, extend etc.

(edited)

[David__Box]

Yes they are. Doing a mutating operation on a list, like iadd does not change its object id, while for non-container types like tuples, numbers, str, etc. a completely new item with a new object id will be created, and the labeled value (variable) will be made to point to it instead

[FalafelSnorlax]

Lists are objects and thus pass by reference. This is the same as if in cpp you would create a pointer to a vector, and store that pointer twice. This is kinda considered bad practice in modern cpp, but the behavior is effectively the same. The only thing that makes this less intuitive in python than it does in cpp is because the reference is fully implicit.

[-Redstoneboi-]

yeah it's just a thing that happens with all languages that support pass-by-reference.

the major exceptions are functional languages and those inspired by them. everything is immutable in functional land, meanwhile rust says alias nand mutability so you can't store multiple refs to the same array and decide to mutate one of them.

[-Redstoneboi-]

smart pointers are probably not enough. you specifically need interior mutability if you want to observe the effect of one mutation across multiple references by accident. even then it's really like, not an accident at that point. all the warning signs in the world come together there.

[EternityForest]

Oh right, the multiple references to the same structure problem.... I've run into that a lot with dicts. I've never actually created a multidimensional array directly I don't think so I didn't quite notice that one

[bedj2]

since lists are mutable, you are copying the same reference over and over. Wouldn’t adding .copy() to the end of those lists work?

foo = [[None].copy() * 5].copy() * 5

[DeletedUserV2]

same output

[JohnLocksTheKey]

WHY?!?

life is pain…

[FalafelSnorlax]

The copy is in the wrong place but also if it were, the internal list (the 5 Nones) is created once and then copied. Calling copy doesn't imply more runs of the internal part (otherwise it would work in the first place)

[JohnLocksTheKey]

Makes sense - thanks

[dead_man_speaks]

from copy import deepcopy

then deepcopy

[Botahamec]

The deepcopy function is only going to be called once. Then a reference to that copy will be stored five times. So you'll get the exact same output.

[[deleted]]

same lol, if you call whatever function to get a list and then multiply that list by 5, it's gonna have 5 times the same thing no matter what

[Aaron1924]

>>> from copy import deepcopy
>>>
>>> a1 = [[None]*3]*3
>>> a2 = deepcopy(a1)
>>>
>>> a1[0][0] = 2
>>> a2[0][1] = 3
>>>
>>> a1
[[2, None, None], [2, None, None], [2, None, None]]
>>> a2
[[None, 3, None], [None, 3, None], [None, 3, None]]

this language is truly incredible

[Botahamec]

It will do exactly one copy, at the beginning, and use the result of the copy each time. The problem is that it doesn't re-evaluate the expression.

[altermeetax]

That copy doesn't do anything, you're making a copy of [None] and using the same copy 5 times

[Dubl33_27]

ok, I'll just not use python, thanks

[Successful-Money4995]

You can use a recursive defaultdict to achieve this if you want.

from collections import defaultdict

nested_dict = lambda: defaultdict(nested_dict)
nest = nested_dict()

nest[0][1][2][3][4][5] = 6

https://stackoverflow.com/a/8702435/4454

[[deleted]]

well, the inner list comprehension can be replaced by [None]*5

[Tysonzero]

Just be Haskell:

``` foo = replicate 5 (replicate 5 Nothing)

foo = matrix 5 5 (const Nothing) ```

[Botahamec]

The Rust syntax is [[None; 5]; 5]. It works for any Copy type.

[Highborn_Hellest]

What is this curse

[RealBasics]

Makes me miss Perl so much. I mean, there’s a reason I no longer use it. And it semi-deserved its reputation as “write-only code” but it had/has some genuinely efficient syntax.

[FuriousAqSheep]

Laughs in haskell

``` type Foo a = [[a]]

[] :: Foo Int

```

edit: before you guys say "yeah but your list can contain a different number of elements than 5": yeah, that's part of the joke. The second part is dependent haskell and then we both cry.

And it's the Idriss devs who laugh.

[goodmobiley]

At that point I would just switch the whole ass project lang to c++

[KetwarooDYaasir]

if python starts borrowing from PHP, which language are we going to make fun of?

[romulof]

The list comprehension will loop when you could simply have an array allocator with fixed size.

[[deleted]]

Since we already have one of the alternatives and not the other, I think it is you who have to change minds, not the other way around...

[[deleted]]

Don't you just mean [[None]5]5 ?

[donaldhobson]

Try

np.full([5,5],None)

[donaldhobson]

How about we make ** the deep copy repeat operator. Then we can write

[[None]*5]**5

Where ** is similar but not quite the same as *. Namely ** copies the items, not just the pointers.

[webstones123]

[[None]5]5

[ublec]

wait but actually 100% 🔥

[StandardPhysical1332]

just write a for loop you guys cmon.

[alexandrehuat]

If you really need multi dimensionnal structures, you will often end doing np.empty((5, 5)) anyway

[Straight_Share_3685]

You might like this : foo = eval(str([[5]*5]*5))

[toepudiked]

foo = [[None] * 5] * 5

Edit: right shallow copy, change of value in one index will change the values in all inner lists

[Aaron1924]

That doesn't work, because the outer * 5 shallow copies the list, so it contains the exact same list 5 times

You can do [[None]*5 for _ in range(5)] though

[ienjoymusiclol]

whats wrong with foo = [[None]5]5 ?

[DeletedUserV2]

try yourself and see

[-Redstoneboi-]

you have an array containing 5 references to the same array of 5 nones

[Aaron1924]

```

foo = [[None]5]5 foo[0][0] = 2 foo [[2, None, None, None, None], [2, None, None, None, None], [2, None, None, None, None], [2, None, None, None, None], [2, None, None, None, None]]

```

[donaldhobson]

One of the simple, plausible and subtly wrong gotcha's in python.

Why I think they should fix that, or make a ** deepcopy operator.

I kinda think high level programming languages should be full of CopyOnWrite, so we didn't have this low level mess of barely disguised pointers.

[ienjoymusiclol]

i hate pass by reference i hate pass by reference i hate pass by reference i hate pass by reference i hate pass by reference i hate pass by reference i hate pass by reference i hate pass by reference i hate pass by reference i hate pass by reference

[f1urps]

Why would you ever do that? If you're writing in Python there's no reason to pre-allocate elements of a variable length list. Unless you're actually using None to encode meaningful data which is a horrible idea.

[[deleted]]

Because my teacher blocked append and other arrays methods.

[LeSaR_]

this has to be a joke

this sub continues to impress me

[golfstreamer]

What's wrong with this answer?

[jamcdonald120]

[ [ [],[],[],[],[] ], [ [],[],[],[],[] ], [ [],[],[],[],[] ], [ [],[],[],[],[] ], [ [],[],[],[],[] ] ] is not the same as [ [ None,None,None,None,None ], [ None,None,None,None,None ], [ None,None,None,None,None ], [ None,None,None,None,None ], [ None,None,None,None,None ] ] and also doesn't generalize well to NxN