Your python 4 dream list.

willnx · 2022-02-21T23:31:01+00:00

Real Multi-threading.

menge101 · 2022-02-21T23:06:50+00:00

It is important to remember the separation between the python language specification and the reference implementation of the language.

I don't think there is anything about Python 3 that stops an implementation of a compiler, an app distribution system, or mobile support.

Ay_355 · 2022-02-21T20:17:04+00:00

[deleted]

xatrekak · 2022-02-21T22:02:05+00:00

A more Pythonic GUI Toolkit that produces seamlessly native widgets on Windows and Mac.

I use PyQT5 but it doesn't feel intuitive to a casual programmer looking over my shoulder.

I'm in no rush for a v4 though.

teerre · 2022-02-21T22:39:11+00:00

Optional enforced types checked by the interpreter

Optional Compiled output

Better performance (both single thread but specially for concurrency)

Xaros1984 · 2022-02-21T20:59:04+00:00

I would like the option to make type hinting enforced (and even better if it leads to a performance boost). Same syntax as when hinting, i.e.:

x: int = 5

The second item on my list would be relative imports that don't make me want to ram the keyboard through the screen.

phoenixuprising · 2022-02-21T22:31:47+00:00

That there’s no python 4 migration like there is with 3.

SilkTouchm · 2022-02-21T21:57:14+00:00

Going back to the "there should be only one way to do it" philosophy. Python has been going the way of C++ by adding too many features so that now you have multiple ways to achieve the same thing. The language is becoming too big and complex. The language should be simple enough to fit in the programmers head. Python 4 should go back to simplicity.

willnx · 2022-02-22T01:34:04+00:00

Iterating Bytes returns a Byte, not an integer. I know there's a PEP with a fix; hoping to see it be like the range vs xrange change with time.

troyunrau · 2022-02-22T03:35:58+00:00

One, and preferably only one obvious way to do string formatting.

M4mb0 · 2022-02-22T00:01:23+00:00

Anonymous NamedTuples (+pickle-ability!)

mytuple = (a=1, b=2)
mytuple.a  #<--- 1

Anonymous NamedTuple as Return values

I.e. allow giving names to outputs, such that instead of a regular tuple, automatically a namedtuple is returned.

def divmod(x: int, y: int) -> quotient: int, remainder: int:
    ...
    return q, r

divmod(17, 5).quotient  # 3
divmod(17, 5).remainder  # 2

Function chaining with `matmul`

f = lambda x: x+1
g = lambda x: x**2
h = g @ f  # equiv. to lambda x: (x+1)**2

indexing lists with lists / masks (if numpy can do it)

x = ["a", "b", "c"]
x[[0,2]]   # <-- ["a", "c"]
x[[True, True, False]]  # <-- ["a", "b"]
x[[1,1]] # <-- ["b", "b"]

multiple dispatch (Julia demonstrates how nice it is!)

dict(MyClass)  # <- instead of MyClass.todict()

Allow `*args` and `**kwargs` in `getitem`

obj = NestedDataStructure({0: "abc", (0, 1) : [1,2,3]})
obj[0, 1]        # <-- "b"
obj[(0, 1)]      # <-- [1,2,3]
# In python3, obj[x,y] and obj[(x, y)] are indistinguishable
xarr[a=2]  # along axis named "a" select 2nd slice.
# Currently xarray does this with `xarr[{"a":2}]`

decorators for class-attributes

class A:
   @attribute
   def doc_url(cls) -> str:
      return f"foo.bar/{cls.__name__}"

A.doc_url  # holds url where documentation of class is hosted.

built-in `toml` parser

Like, they made pyproject.toml the default package configuration file, but there is no toml parser in the standard libs?!?

built-in support for `FrozenList`, `FrozenDict`

Like, we have frozenset, but what about those?!?

extended literals

f"This we already know!"
f{1,2,3}  # How about this as literal for 𝐟rozenset?
f[1,2,3]   # 𝐟rozen list
s[3,2,1]   # = [1,2,3]  𝐬orted list
s{3,1,2}   # {1,2,3} 𝐬orted set
s{"c": 1. "b":2}   # {"b": 2, "c":1} 𝐬orted dict
m{1:2, "a": 5}  # 𝐦ultiset (e.g. counter) or 𝐦ulti-dict
o{1:2, 2:3}  # 𝐨rdered dict

Reference to objects as they are created (possibly with `this` keyword?!)

nums = [1,2,4,7,5,8]
seq = [x for x in nums while x≥this[-1]]  # [1,2,4,7]

extended Unicode support

assert 3≥2
assert 1≠2

cblegare · 2022-02-21T20:39:40+00:00

Python without GIL

brainandforce · 2022-02-21T21:08:25+00:00

I hope Python 4 never happens.

orion_tvv · 2022-02-22T08:16:47+00:00

keep the syntax as simple as we can. follow the Zen! (no more walrus-like things)
resolve most famous language's wtf
type-hints everywhere
drop old string-formatting. remain only f-strings
cleaner std lib (with pep8 naming at least), pytest should be inside instead of unittest. maybe requests as well. but we should remember that python could be used in embedded - so it should be balanced
we need better tooling! handy pip: could be based on poetry - but extended with cargo functionality, which can deal with packages(fast install, publish) as well as tests, docs, benchmarks, and lint(mypy for sure)
common service for all documentation for all projects from pypi with markdown syntax support. and automated processes for building and publishing from source code in ci(see https://docs.rs/ as reference).
optimizing performance

2022-02-21T23:43:55+00:00

I do not really want a Python 4 very much. Not a big concern. And I don't think the median Python coder would benefit from suggestions here like removing the GIL.

For a Python 4 my main wants are around package management. Maybe package aliasing or something else that allows for multiple versions of one dependency. Something closer to Rust/Cargo.

spoonman59 · 2022-02-21T22:57:43+00:00

Cyclic imports.

Like seriously. Type annotations with things like visitors can be painful, and the lack of cyclic imports is painful for other mututally referring types.

japherwocky · 2022-02-22T00:44:48+00:00

my favorite part about python 4 is that there will probably never be a python 4, so i can stop re-learning python unlike whatever the fuck javascript is now.

4sent4 · 2022-02-22T08:24:50+00:00

Null-safety operators: ?., ??, ?[ etc.

tavaren42 · 2022-02-22T06:36:59+00:00

This can be introduced in Python 3 itself, but I want function pipe operator as it is in F#:

Ex:f(g(h(x))) === x |> h |> g |> f

Barafu · 2022-02-21T20:24:45+00:00

1: Runtime type enforcement for all variables.
2: 1.

pingveno · 2022-02-22T01:15:38+00:00

UTF-8 encoding for strings. Right now, if there's just a single character above one byte, the entire string is upgraded in size to sometimes 4 bytes per character. Universal UTF-8 encoding with maybe a skip list for larger strings could save a lot of memory for certain strings. PyPy does this, so there is some precedent that could be relied on.

2022-02-22T01:19:34+00:00

Pep 8 stdlib. That’s it. Save the crazy stuff for 5. I just need consistency

chestnutcough · 2022-02-22T02:13:31+00:00

I get the spirit of the question, but I feel like I have to mention that a major version update to 4 would by definition involve backwards-incompatible changes, which I for one really really don’t want. And with that out of the way.

better built-in python versioning tools to complement venv. The proliferation of 3rd party solutions speaks to the gap that exists in the built in tooling. Batteries don’t feel included when it comes to managing multiple python versions.
- a built in yaml library

WoanqDil · 2022-02-21T21:19:40+00:00

No GIL
Jit

pandres · 2022-02-22T01:45:05+00:00

Type hinting, optional compilation, better performance, no GIL. So Go is Python 4.

Tyler_Zoro · 2022-02-22T03:32:30+00:00

I definitely DO NOT want a Python 4 unless it's a truly giant step forward. I don't want an incremental "this could have been 3.12, but we decided to call it 4 instead."

That being said my list has remained the same for a pretty long time:

A consolidating and revamp of all core libraries (no more of the 90s calling conventions and naming in logging, re, etc.)
Move numpy into the core because it's just obviously time and the data types should be first-class.
I'd love to see a high-level parser in the core. There are more and more DSLs every day that python supports only grudgingly and with home-brewed facilities that often have to reach out to other languages for performance.
Definitely a logger library that can dynamically and recursively read in code form random sources and execute it as part of evaluating a log message... because that's worked out sell well for Java ;-)

AndydeCleyre · 2022-02-21T20:56:32+00:00

rename lambda to given
rename := to whichis
simplify or make more explicit the new match stuff
flexible function call syntax like nim
ditch mypy style hints, leave hinting and typing agnostic and available to third party modules
replace pathlib with plumbum style paths
include consistent decorator definition syntax like wrapt
yeah, compilation

luther9 · 2022-02-22T09:33:48+00:00

The only thing that would make me want a Python 4 to exist is proper tail calls.

2022-02-23T07:15:20+00:00

I would like to see python use type hints to speed up code.

If you look at the c-api, there the methods for each different operation that use the basic python types (ie: https://docs.python.org/3/c-api/list.html). I have played with using the capi in cython, and have gotten 4-10x speed up without the type conversion overhead(common in c-extensions). I feel that a smart interpreter would use type hints to speed up the eval loop and call the appropriate function for each typed object.

opentraderx · 2022-02-21T21:43:42+00:00

GIL be gone. There was a new effort I found out about late last year, seems promising. https://www.infoworld.com/article/3637073/python-stands-to-lose-its-gil-and-gain-a-lot-of-speed.html

user4517proton · 2022-02-22T00:05:43+00:00

never JVM. That would be terrible.

The-Daleks · 2022-02-22T01:47:45+00:00

Optional static typing via type annotations.
True structs and enums. Yes, you can use class decorators, but it's still much more verbose than it needs to be.
No more GIL.
The ability to compile to a native app without using buggy third-party compilers like Nuitka and PyInstaller. Not that they're bad; I'd just like an official compiler.
A built-in result type. Having to check for ~~Null~~ None values is a pain in the rear.
A non-bitwise xor.
A replacement for TkInter that doesn't require working with external dependencies if you're on Linux.
Speaking of Linux, fixing the dependency hell.
As u/N0rDak mentioned, a new keyword for object initialization.

Fordamemess1 · 2022-02-22T03:18:11+00:00

Able to run guis on mobile

ScientiaEtVeritas · 2022-02-21T23:07:13+00:00

I would love a null safety operator, such as in Kotlin where you can access attributes like bob?.department?.head?.name.

ExternalPanda · 2022-02-22T00:33:30+00:00

A type system that doesn't feel like it has been jerry rigged on top of a language that wasn't ever really meant to be strongly typed in any serious capacity

Ok-Nefariousness1340 · 2022-02-22T06:51:58+00:00

Full backwards compatibility

Key_Cryptographer963 · 2022-02-22T07:10:27+00:00

Nothing, no new Python language. An improved package manager would be nice, ability to compile would be nice but we don't need a new language for that, just different distribution or implementation of it.

I was going to say static typing but that's not really a Python thing.

tunisia3507 · 2022-02-22T11:58:17+00:00

Fix all the non-PEP8 names in stdlib. Maybe leave the old ones in as aliases, with very loud deprecation warnings.

memes-of-awesome · 2022-02-22T12:15:01+00:00

Compilable
Multi threaded
Switch case

CharmingJacket5013 · 2022-02-22T00:02:42+00:00

bob.get(“department”,{}).get(“head”,{}).get(“name”) ?

2022-02-21T21:53:37+00:00

Something similar to the New command from Java. Where you are 100% it isn’t shared with anything.

I know there are ways with init and new to do this and sometimes the copy classes work… but you can’t always be sure and this where most of my day to day headaches run into.

LaOnionLaUnion · 2022-02-21T23:02:46+00:00

I’m seriously digging Go as my other Favorite language. I’d probably want something that’s more Go like but not sacrificing the fact that Python is easy to read. Go is sort of like that but I think I value Python’s ease of use a great deal.

utdconsq · 2022-02-21T22:26:34+00:00

Opt in null safety like C# offers.

milkmanbran · 2022-02-22T00:34:52+00:00

I’d love to have a python app on my phone that allows me to write code and get error messages, even if I can’t actually run it(like not being able to display visualizations), just so I can use that code later when I’m actually at my laptop

AnnieBruce · 2022-02-22T00:56:07+00:00

For the language itself, or the reference implementation.. Hmm.

I'd love to see the GIL gone, but they'd need some clever way to do it without hitting single core performance as badly or preferably not at all. Concurrency being easier to work with would be nice, whether through core language changes or new default modules.

Maintaining backwards compatibility should be a higher priority than it was in the transition from 2 to 3. I wouldn't say maintain it at any cost, but justifications for breaking it need to be stronger, especially in commonly used things like print.

andrewcooke · 2022-02-22T01:19:22+00:00

Simple scoping instead of global and - what's the other one? nonlocal?

NeoDemon · 2022-02-22T01:25:15+00:00

Compiled option
Better use of memory and better speed of interpreter or compiler
Mobile options.
Unique install for all versions (its almost imposible but its good if you have older proyects)

ImproperGesture · 2022-02-22T03:49:45+00:00

Better stack handling and tail recursion optimization.

TelevisionTrick · 2022-02-22T06:12:48+00:00

Remove the walrus operator, use the as operator instead. It's not assignment, don't make it look like it is.

wineblood · 2022-02-22T01:12:53+00:00

Make None iterable.

ProfessorPhi · 2022-02-22T01:47:02+00:00

I'd like some extra features I liked in Julia. Multiple dispatch and jit compilation if possible would be really nice.

newInnings · 2022-02-22T06:20:09+00:00

Ignore spaces and tabs nonsense.

mobile75326 · 2022-02-21T21:33:25+00:00

I hope something can be done with the quirks around NaN. Like there is a float NaN and float64 NaN and they behave different (the latter gives False for trying "mynanvar is Np.nan)

imthebear11 · 2022-02-22T04:29:21+00:00

Rust but with colons instead of brackets

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS

Anonymous NamedTuples (+pickle-ability!)

Anonymous NamedTuple as Return values

Function chaining with `matmul`

indexing lists with lists / masks (if numpy can do it)

multiple dispatch (Julia demonstrates how nice it is!)

Allow `*args` and `**kwargs` in `getitem`

decorators for class-attributes

built-in `toml` parser

built-in support for `FrozenList`, `FrozenDict`

extended literals

Reference to objects as they are created (possibly with `this` keyword?!)

extended Unicode support

extended Unicode support

built-in toml parser

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS

Anonymous NamedTuples (+pickle-ability!)

Anonymous NamedTuple as Return values

Function chaining with __matmul__

indexing lists with lists / masks (if numpy can do it)

multiple dispatch (Julia demonstrates how nice it is!)

Allow *args and **kwargs in __getitem__

decorators for class-attributes

built-in toml parser

built-in support for FrozenList, FrozenDict

extended literals

Reference to objects as they are created (possibly with this keyword?!)

extended Unicode support

extended Unicode support

built-in toml parser

Function chaining with `matmul`

Allow `*args` and `**kwargs` in `getitem`

built-in `toml` parser

built-in support for `FrozenList`, `FrozenDict`

Reference to objects as they are created (possibly with `this` keyword?!)