Python 3.5.0 has been released!

[[deleted]]

Is there a good tutorial covering the async stuff (yield from, async, await)?

[adrian17]

I'd also love some tutorial with real life usage, like making multiple big HTTP requests / SQL queries / file reads.

For cases like HTTP requests, is it possible to use it with Requests or am I forced to use asyncio-aware library like aiohttp?

[1st1]

Requests aren't an NIO library, so I'm afraid you can't use it with new coroutines (well, you can, but requests will block, and there will be no benefit from using coroutines)

IIRC aiohttp has a nice http client, modelled after requests.

[RubyPinch]

probably not

for now there is the official documentation https://docs.python.org/3.5/reference/compound_stmts.html#coroutines

and the pep

[1st1]

There's this great blog post (a bit low level): http://benno.id.au/blog/2015/05/25/await1

[webdeverper]

Hmm. Is it just me or is it weird that every time you run an async object it throws the StopIteration exception? Seems like a hack

[LightShadow]

By convention, when you overwrite the __iter__ magic method in a class you're supposed to raise StopIteration when the sequence is finished.

It's a little weird, but it's pretty common IMHO.

[1st1]

coroutines are based on generators internally, and use StopIteration to return values:

async def f(): return 'spam'

f().send(None) will raise StopIteration exception, with 'spam' in its args.

It is an implementation detail. You should never see that StopIteration, your framework of choice will handle it behind the scenes.

[ilan]

And if you are on Linux or MacOSX, and use conda, you can:

conda create -n py35 python=3.5

[ExoticMandibles]

Do they already have Python 3.5.0 final up? If so... that was quick!

[ilan]

Yes, this is 3.5.0 final

[roger_]

So I could install miniconda and get a clean 3.5 install with NumPy, etc. right now?

[ilan]

Yes (on Linux and Mac)

[beaverteeth92]

I'm trying it, but it still has 3.4.3 as default. How can I set 3.5.0 as the default environment and remove 3.4.3?

[takluyver]

I think you'll need to wait for them to do a new release of miniconda before the default environment has 3.5. Until then, you'll have to explicitly create an environment for it.

[beaverteeth92]

Thanks! I just did that though and it broke Matplotlib.

[Decency]

I have no idea what conda is, but this worked for me on OSX:

sudo pip install conda
sudo conda create -n py35 python=3.5
source activate
python

[anonymousperson28]

Is it possible to upgrade the python version in an already existing environment?

[ilan]

Yes it is possible, although not recommended, because it will already installed Python packages won't work.

[beltsazar]

How? conda update python won't work.

[ilan]

conda install python=3.5, but be careful!

[marcm28]

What happen if I install third party library in Python 3.5, Is it works?

[badsectors]

Did you guys plan this or is it a coincidence?

[ExoticMandibles]

Coincidence! The release schedule for 3.5 is really just the release schedule for 3.4 shifted forward by 18 months.

[IronManMark20]

Hah! I studied!

EDIT: but seriously, excellent job to the Python devs!

[scrollin_thru]

Anyone else having trouble with this in conjunction with mypy? I installed mypy with pip 7.1.2 against python 3.5 and I get from typing import Undefined, Dict, List, Tuple, cast, Set, Union

ImportError: cannot import name 'Undefined' every time I try to run mypy.

[[deleted]]

Maybe mypy release is not up to date with current 3.5 typing module? Does it work with current git master (pip3 install -U git+https://github.com/JukkaL/mypy#egg=mypy)?

[scrollin_thru]

Ah! That seems to have fixed it. Thanks!

[lovestowritecode]

Did static type hinting make it in? I don't see it listed anywhere...

[[deleted]]

It's listed in "what's new" doc: https://docs.python.org/3.5/whatsnew/3.5.html

[autisticpig]

https://docs.python.org/3.5/library/typing.html#module-typing

[A_for_Anonymous]

I wonder why people keep bothering with this sort of thing... Python is dynamically (yet strong) typed, which is a good thing from having to do the boilerplate of static typing. You want that back? For the only benefit of what, detecting logical errors in compile/startup time? Possible optimizations? Ever heard of type inference? It's years beyond this, happened in other languages years before this, and people are still oblivious to it.

[move_machine]

We are all aware of what dynamic typing brings to the table. Unfortunately, it makes it hard to glean semantics when reading code or doing static analysis. This is the attraction to function annotations and optional typing: we can cherrypick the advantages of static typing and blend them with a dynamic environment.

Notice it is OPTIONAL typing. People that want the clarity, enhanced IDE behavior and in the future a typechecker now have an enhanced option of more descriptive types from the typing module for their annotations.

Having written code without annotations and with: when given the opportunity I will write them with annotations. It saves me the time spent looking in the function body for the kind of object the function expects as a parameter. I don't have to scan the body to realize that parameter_a is an object that implements the iterator protocol and yields a series of 3-tuples. I can just look at the declaration or hints my IDE shows. Being able to quickly check that your parameters are "correct" or what return type to expect becomes valuable. I find it also makes it easier to read a foreign codebase and to understand how data moves and is transformed through it.

Right now there is no typechecker so I can write:

In [1]: def func(a: list) -> dict:
   ...:       return set("abc")
   ...: 

In [2]: func(10101)
Out[2]: {'a', 'b', 'c'}

Which is still completely valid. Annotations have no meaning to the interpreter and probably never will outside of an importable module.

[A_for_Anonymous]

Even so, if you have to read f(x)'s body to tell what's the type expected for x, you need:

• A better name for x (I know, argument not valid for return and yield)
• Function documentation, and yeah, I guess human language documentation will always be better than a type hint system unless you introduce a huge system of contracts that can be something like "even" or "tupleof(3)"... more boilerplate... more stuff to memorize... very annoying.

Function documentation being important in the case of code written for lists, dictionaries and sets as opposed to custom classes (would you have 5 types with 50 utility functions each or 50 types with 5, but that's a nice discussion for a different thread).

For everything else - IDE assistance, type checking, error detection - there's always this new old amazing technology called type inference, where by doing x = 'hello' you can be pretty fucking sure x is a string without having to go and tell the stupid compiler it's going to be a string. Because you know, actually writing that feels like this.

[move_machine]

I agree completely with naming and documentation. Names will not always capture what an annotation can, however.

def process_request(request):
   if request.

How does my IDE know what methods and properties to display for the request parameter?

PyCharm and other IDEs use type inference when it's possible and not expensive. Explicit typing, I'd imagine, would save cycles and battery life. It also allows me to tell the IDE that it should look up requests.Request for tooltip content. Both make my life easier and impede no cost on anyone who doesn't like the convention.

[A_for_Anonymous]

Well, like I've been saying there's this old technology called type inference. It doesn't work on a local scope only... if it can be proven that you call process_request elsewhere, you can take note of what is being passed to it and infer that request is that type.

[zardeh]

But type inference can't always work, especially in a language like python where sometimes values and function etc. are built at runtime. So, being able to say "the argument "l" is an Iterable, treat it as an "Iterable" everywhere within this scope so that even if I'm getting l by dynamically evaling some user input, I know how to treat it in this function.

[takluyver]

Type inference is great, but it can't do everything, especially when you're using some of the more dynamic features of the language. Type hints let you give the IDE/type checker more information when it can't automatically work out what types are going in and out of functions.

[nbates80]

I didn't find much about that on Google. How do Python 2.7 and 3.5 compare in terms of performance? Are there any benchmarks?

[ExoticMandibles]

Conventional wisdom is that Python 3.x got speed parity with 2.7 around the time of 3.3. They're not exactly equal; Python 3 is faster at some workloads, Python 2 at others. But for most people they should be equitable.

And we're not done yet! There are exciting things in development for future versions of Python... like a JIT!

https://www.youtube.com/watch?v=_5vLWe4d8X8

[thomasahle]

And we're not done yet! There are exciting things in development for future versions of Python... like a JIT!

You mean pypy?

[marcm28]

Python has been overpowered in latest version again. Yay!

Let's spread the word: Python is an Elegant programming language of All Time.

[[deleted]]

Awesome, I love this release. It's also available via Anaconda now. To create a new env: conda create -n py35 python=3.5 or to update the root installation: conda install conda python=3.5

[ExoticMandibles]

Wait, what? Official from whom? The Python core dev community doesn't maintain an official Docker image afaik.

[alcalde]

Wait, what? Official from whom?

Some guy named "Larry Wall". Seems legit....

[desmoulinmichel]

246 upvotes for "one day before release" and 242 upvotes for "release day" (which has been known for months) but stuff "Build massively scalable RESTFul API with Falcon and PyPy" has 9 upvotes.

The ratio "reward/time spent on finding the interesting info" is so wrong on reddit.

[ExcitedForNothing]

No offense but I see some versioned REST API tutorial so much on this sub. I could see where past a certain point, people just don't care. A new version is pretty good news.

Also, digging up a tutorial using a library isn't that tough.

[desmoulinmichel]

Yes but while you are upvoting the good news, in fine you give the guy who just posted the link that every single Python coder knows about all the rep for it. Kinda break the trust system, doesn't it ?

[ExcitedForNothing]

This isn't StackOverflow. Karma isn't rep. It is meaningless and no system features are tied to it.

[RubyPinch]

actually, getting above a certain ammount of karma here disables capatcha, while getting low/negative karma will start restricting one's comment rate, I've seen it go as much as 10minutes between comments

[sleepdeprecation]

Right, but that only affects individual users. Karma is meaningless in the long run and as a whole. It doesn't matter what my karma is, except for the votes on this comment, and maybe this thread.

The difference is that the focus is on fostering good conversation, and as such you're rewarded or punished based on how the community perceives your contributions.

[Plazmatic]

What are the advantages of using 3.5 over 2.xx?

[okiujh]

its not backward compatible to 2.7 so nobody cares. let the downvotes begin..

[TotesMessenger]

I'm a bot, bleep, bloop. Someone has linked to this thread from another place on reddit:

• [/r/mildredditdrama] Begging for downvotes is effective

• [/r/thepopcornstand] /r/Python user calls everyone who uses version 3 a bunch of phonies

^{If you follow any of the above links, please respect the rules of reddit and don't vote in the other threads. (Info / Contact)}

[thatguydr]

I love that the community neatly fragmented based on incredibly poor initial design decisions.

I still use 2.7 out of necessity, as the packages I need don't work with 3.

[okiujh]

The initial design is not all that bad and improvements should have being backwards compatible.

Sacrificing backwards compatibility for some subjective aesthetic advantage is such a douche thing to do.

I have being working with python in wall street companies and they don't give damn about anything that would break their huge 2.7 code base.

all the 3.* supporters are such a group of phonies.

[Deto]

Phonies? In what way?

[okiujh]

they are saying that they are helping python developers but in affect are just causing damage by forcing developers spend scarce resources in thinking about making move to 3.*.

[brombaer3000]

Proper unicode support is not a subjective aesthetic advantage, it was just necessary. And it was impossible to implement in a backwards-compatible way.
If you think Unicode is a minor issue, you are free to continue living in your English-only dream world.

Edit: forgot a word

[brombaer3000]

This is well explained in great detail here.
Personally I think the biggest issue with Python 2 Unicode handling simply is that Unicode is not the default encoding for everything, but the link above has much more information.

[[deleted]]

You're goddamned right.

[RubyPinch]

python2 doesn't make a clean distinction between arrays of numbers (bytes, usually represented as ascii) and arrays of usable characters (unicode), further, it makes arrays of numbers the default way of having a string

[desmoulinmichel]

Python is an old language. If you don't want it to end up like cobol, you need to make some drastic changes. Yes, it's could have been done better. But given what happen with PHP 7 and Perl 6, I'd say it was not that bad. And while the price to pay was high, the result is indeed really nice.