__radd__ operator, which adds support for right-addition

class MyNumber:
    def __add__(self, other):
        return other + 42

    def __radd__(self, other):
        return other + 42

Now I should mention that all objects in Python can add support for all Python operators, such as +, -, +=, etc., by defining special methods inside their class, such as __add__ for +, __iadd__ for +=, and so on.

class MyNumber:
    def __add__(self, other):
        return other + 42

>>> num = MyNumber()
>>> num + 3
45

NotImplemented is used inside a class’ operator definitions, when you want to tell Python that a certain operator isn’t defined for this class.

Doing that would even catch KeyboardInterrupt, which would make you unable to close your program by pressing Ctrl+C.

every exception is a subclass of BaseException, and nearly all of them are subclasses of Exception, other than a few that aren’t supposed to be normally caught.

print(dir(__builtins__))

builtin scope in Python:It’s the scope where essentially all of Python’s top level functions are defined, such as len, range and print.When a variable is not found in the local, enclosing or global scope, Python looks for it in the builtins.

Global scope (or module scope) simply refers to the scope where all the module’s top-level variables, functions and classes are defined.

you can use the nonlocal keyword in Python to tell the interpreter that you don’t mean to define a new variable in the local scope, but you want to modify the one in the enclosing scope.

The enclosing scope (or nonlocal scope) refers to the scope of the classes or functions inside which the current function/class lives.

The local scope refers to the scope that comes with the current function or class you are in.

A builtin in Python is everything that lives in the builtins module.

in Python 3.0 (alongside 2.6), A new method was added to the str data type: str.format. Not only was it more obvious in what it was doing, it added a bunch of new features, like dynamic data types, center alignment, index-based formatting, and specifying padding characters.

TypedDict is a dictionary whose keys are always string, and values are of the specified type. At runtime, it behaves exactly like a normal dictionary.

you should only use reveal_type to debug your code, and remove it when you’re done debugging.

What this says is “function double takes an argument n which is an int, and the function returns an int.

This tells mypy that nums should be a list of integers (List[int]), and that average returns a float.

from typing import List

def average(nums: List[int]) -> float:

for starters, use mypy --strict filename.py

If no explicit epoch is given, the implicit epoch is 0.

Finding how to check if a list is empty in Python is not so a tricky task as you think. There are few effective methods available to make your functionalities easy. And of course, list play a paramount role in python that come up with few tempting characteristics listed in the below for your reference.

You probably shouldn't use Alpine for Python projects, instead use the slim Docker image versions.

Before we dive into the details, here's a brief summary of the most important changes:

Python Examples

The models are developed in Python [46], using the Keras [47] and Tensorflow [48] libraries. Detailson the code and dependencies to run the experiments are listed in a Readme file available togetherwith the code in the Supplemental Material.

Export/takeout for your personal Hypothes.is data: annotations and profile information.

exporting hypothesis annotations to obsidian (markdown files)

Some problems with the feature

One thing to note is that match and case are not real keywords but “soft keywords”, meaning they only operate as keywords in a match ... case block.

Use variable names that are set if a case matches Match sequences using list or tuple syntax (like Python’s existing iterable unpacking feature) Match mappings using dict syntax Use * to match the rest of a list Use ** to match other keys in a dict Match objects and their attributes using class syntax Include “or” patterns with | Capture sub-patterns with as Include an if “guard” clause

It’s tempting to think of pattern matching as a switch statement on steroids. However, as the rationale PEP points out, it’s better thought of as a “generalized concept of iterable unpacking”.

>>> import _ctypes>>> print(_ctypes.PyObj_FromPtr(4319088080))2077

The best practice is this: #!/usr/bin/env bash #!/usr/bin/env sh #!/usr/bin/env python

As python supports virtual environments, using /usr/bin/env python will make sure that your scripts runs inside the virtual environment, if you are inside one. Whereas, /usr/bin/python will run outside the virtual environment.

The second-to-last layer is what Han settled on as a reasonable sweet-spot.

Python is a high-level programming language that is object-oriented and used to create different desktop apps, different systems, websites, and platforms. This language might not be the most popular in the techno world, but it surely is the first choice for freshers and beginners.

PyPA still advertises pipenv all over the place and only mentions poetry a couple of times, although poetry seems to be the more mature product.

The main selling point for Anaconda back then was that it provided pre-compiled binaries. This was especially useful for data-science related packages which depend on libatlas, -lapack, -openblas, etc. and need to be compiled for the target system.

Many of Python’s standard tools allow already for configuration in pyproject.toml so it seems this file will slowly replace the setup.cfg and probably setup.py and requirements.txt as well. But we’re not there yet.

Any import statement compiles to a series of bytecode instructions, one of which, called IMPORT_NAME, imports the module by calling the built-in __import__() function.

databases is an async SQL query builder that works on top of the SQLAlchemy Core expression language.

The fact that FastAPI does not come with a development server is both a positive and a negative in my opinion. On the one hand, it does take a bit more to serve up the app in development mode. On the other, this helps to conceptually separate the web framework from the web server, which is often a source of confusion for beginners when one moves from development to production with a web framework that does have a built-in development server (like Django or Flask).

FastAPI makes it easy to deliver routes asynchronously. As long as you don't have any blocking I/O calls in the handler, you can simply declare the handler as asynchronous by adding the async keyword like so:

Fixtures are created when first requested by a test, and are destroyed based on their scope: function: the default scope, the fixture is destroyed at the end of the test.

When pytest goes to run a test, it looks at the parameters in that test function’s signature, and then searches for fixtures that have the same names as those parameters. Once pytest finds them, it runs those fixtures, captures what they returned (if anything), and passes those objects into the test function as arguments.

“Fixtures”, in the literal sense, are each of the arrange steps and data. They’re everything that test needs to do its thing.

Here is how you can create a fully configured new project in a just a couple of minutes (assuming you have pyenv and poetry installed already).

After reading through PEP8, you may wonder if there is a way to automatically check and enforce these guidelines? Flake8 does exactly this, and a bit more. It works out of the box, and can be configured in case you want to change some specific settings.

Pylint is a very strict and nit-picky linter. Google uses it for their Python projects internally according to their guidelines. Because of it’s nature, you’ll probably spend a lot of time fighting or configuring it. Which is maybe not bad, by the way. Outcome of such strictness can be a safer code, however, as a consequence - longer development time.

The goal of this tutorial is to describe Python development ecosystem.

For Windows, there is pyenv for Windows - https://github.com/pyenv-win/pyenv-win. But you’d probably better off with Windows Subsystem for Linux (WSL), then installing it the Linux way.

There are often multiple versions of python interpreters and pip versions present. Using python -m pip install <library-name> instead of pip install <library-name> will ensure that the library gets installed into the default python interpreter.

In addition to SQLAlchemy core queries, you can also perform raw SQL queries

query = notes.insert()
values = [
    {"text": "example2", "completed": False},
    {"text": "example3", "completed": True},
]
await database.execute_many(query=query, values=values)

query = "INSERT INTO notes(text, completed) VALUES (:text, :completed)"
values = [
    {"text": "example2", "completed": False},
    {"text": "example3", "completed": True},
]
await database.execute_many(query=query, values=values)

query = notes.select()
rows = await database.fetch_all(query=query)

query = "SELECT * FROM notes WHERE completed = :completed"
rows = await database.fetch_all(query=query, values={"completed": True})

If you're serious about neural networks, I have one recommendation. Try to rebuild this network from memory.

Some options (you will have to use your own judgment, based on your use case)

Create an account or session

Uber and Booking.com’s ecosystem was originally JVM-based but they expanded to support Python models/scripts. Spotify made heavy use of Scala in the first iteration of their platform until they received feedback like:some ML engineers would never consider adding Scala to their Python-based workflow.

Integrated access to the pdb debugger and the Python profiler.

Python’s Significant Whitespace Problems

TensorFlow.js provides theLayers API,which mirrors the Keras API as closely as possible, in-cluding the serialization format.

Uses Pydantic which enforces type hints at runtime.

if a module's name has no dots, it is not considered to be part of a package. It doesn't matter where the file actually is on disk.

if you imported moduleX (note: imported, not directly executed), its name would be package.subpackage1.moduleX. If you imported moduleA, its name would be package.moduleA. However, if you directly run moduleX from the command line, its name will instead be __main__, and if you directly run moduleA from the command line, its name will be __main__. When a module is run as the top-level script, it loses its normal name and its name is instead __main__.

A file is loaded as the top-level script if you execute it directly, for instance by typing python myfile.py on the command line. It is loaded as a module if you do python -m myfile, or if it is loaded when an import statement is encountered inside some other file.

The majority of Python packaging tools also act as virtualenv managers to gain the ability to isolate project environments. But things get tricky when it comes to nested venvs: One installs the virtualenv manager using a venv encapsulated Python, and create more venvs using the tool which is based on an encapsulated Python. One day a minor release of Python is released and one has to check all those venvs and upgrade them if required. PEP 582, on the other hand, introduces a way to decouple the Python interpreter from project environments. It is a relative new proposal and there are not many tools supporting it (one that does is pyflow), but it is written with Rust and thus can't get much help from the big Python community. For the same reason it can't act as a PEP 517 backend.

However, the place where pip places that package might not be in your $PATH (thus requiring you to manually update your $PATH afterwards), and on windows the pip install might not take care of python-specific issues for you (see "Notes for Windows Users", above). As such, installation via package managers is recommended instead.

If your python3 executable is named "python" instead of "python3" (this particularly appears to affect a number of Windows users), then you'll also need to modify the first line of git-filter-repo to replace "python3" with "python".

you want to pass a function as an argument to higher-order functions

Lambda functions are used when you need a function for a short period of time.

Cookiecutter takes a source directory tree and copies it into your new project. It replaces all the names that it finds surrounded by templating tags {{ and }} with names that it finds in the file cookiecutter.json. That’s basically it. [1]

you can take the opportunity of using Python as a corresponding module pexpect is written for it (http://pexpect.sourceforge.net). It's clear that Python language should be installed on the system beforehand

Holy xxx, it takes 3.37s to calculate merely 1,000,000 reciprocal numbers. The same logic in C takes just a blink: 9ms; C# takes 19ms; Nodejs takes 26ms; Java takes 5ms! and Python takes self-doubting 3.37 SECONDS.

As to why both is_a? and kind_of? exist: I suppose it's part of Ruby's design philosophy. Python would say there should only be one way to do something; Ruby often has synonymous methods so you can use the one that sounds better. It's a matter of preference.

I don't like notebooks.- Joel Grus (Allen Institute for Artificial Intelligence)

session.query(Book.author, Chapter.title).select_from(Book).join(Book.chapters) or session.query(Book).options(load_only("author"), joinedload("chapters").load_only("title"))

PyPy uses a technique known as meta-tracing, which transforms an interpreter into a tracing just-in-time compiler.

Default: 0

You can use container values, that wraps actual success or error value into a thin wrapper with utility methods to work with this value. That’s exactly why we have created @dry-python/returns project. So you can make your functions return something meaningful, typed, and safe.

I'm not a fan of listing exceptions functions can throw, especially here in Python, where it's easier to ask forgiveness than permission.

Here is a quick recap table of every technology we discussed in this blog post.

We recommend the Alpine image as it is tightly controlled and small in size (currently under 5 MB), while still being a full Linux distribution. This is fine advice for Go, but bad advice for Python, leading to slower builds, larger images, and obscure bugs.

Did you know that everything you can do in VBA can also be done in Python? The Excel Object Model is what you use when writing VBA, but the same API is available in Python as well.See Python as a VBA Replacement from the PyXLL documentation for details of how this is possible.

You can write Excel worksheet functions in your Jupyter notebook too. This is a really great way of trying out ideas without leaving Excel to go to a Python IDE.

Use the magic function “%xl_get” to get the current Excel selection in Python. Have a table of data in Excel? Select the top left corner (or the whole range) and type “%xl_get” in your Jupyter notebook and voila! the Excel table is now a pandas DataFrame.

to run Python code in Excel you need the PyXLL add-in. The PyXLL add-in is what lets us integrate Python into Excel and use Python instead of VBA

Turning my Jupyter-compatible Python code into Flask-compatible Python code took dozens of hours. I ran into small bugs and errors

Comparison between pytest and unittes test frameworks

The behaviour of the argument function is extended by the decorator without actually modifying it.

As of Python 3.6, f-strings are a great new way to format strings.

A location into which the result is stored.

Text Sequence Type

和 Python 里的字符串和列表切片不同，你不能在 start, stop 或者 step 这些参数中使用负数。:

line.strip()

# A recursive generator that generates Tree leaves in in-order.

Any function containing a yield keyword is a generator function;

Generators

if expression is creating a tuple, it must be surrounded with parentheses.

list comprehensions

An object is called iterable if you can get an iterator for it.

An iterator is an object representing a stream of data;

key 形参用来指定在进行比较前要在每个列表元素上调用的函数

Sprawdźmy który rodzaj modelu daje najlepszą skuteczność: Python sns.boxplot(data=models_df, x='score', y='model') 1 sns.boxplot(data=models_df, x='score', y='model')

Przy tych danych wygląda, że właściwie nie ma większej różnicy (nie bijemy się tutaj o 0.01 punktu procentowego poprawy accuracy modelu). Może więc czas treningu jest istotny? Python sns.boxplot(data=models_df, x='time_elapsed', y='model') 1 sns.boxplot(data=models_df, x='time_elapsed', y='model')

Teraz w zagnieżdżonych pętlach możemy sprawdzić każdy z każdym podmieniając klasyfikatory i transformatory (cała pętla trochę się kręci):

hyperscript is more concise because it's just a function call and doesn't require a closing tag. Using it will greatly simplify your tooling chain.

Used by convention to avoid naming conflicts with Python keywords.

meant as a hint to the programmer only.

The second is a “throwaway” variable that we don’t need just yet, denoted with an underscore.

If <key> is not found, it returns None

The len() function returns the number of key-value pairs in a dictionary

the in and not in operators

key values are simple strings

Restrictions on Dictionary Values

it is not quite correct to say an object must be immutable to be used as a dictionary key.

Restrictions on Dictionary Keys#

a dictionary key must be of a type that is immutable.

the values contained in the dictionary don’t need to be the same type.

Python does guarantee that the order of items in a dictionary is preserved.

they have nothing to do with the order of the items in the dictionary.

If you refer to a key that is not in the dictionary, Python raises an exception:

Dictionary elements are not accessed by numerical index

A list of tuples works well for this:

dd = dict([('a',1),('b',2)])

Dictionaries and lists share the following characteristics:

Dictionaries differ from lists primarily in how elements are accessed:

the instance behaves like a standard dictionary.

The first argument to the Python defaultdict type must be a callable that takes no arguments and returns a value.

Using the Python defaultdict Type for Handling Missing Keys

not to call it using the parentheses at initialization time.

the dictionary assigns it the default value that results from calling list().

if you call .setdefault() on an existing key, then the call won’t have any effect on the dictionary.

four available ways to handle missing keys

if you try to access or modify a missing key, then defaultdict will automatically create the key and generate a default value for it.

Decide when and why to use a Python defaultdict rather than a standard dict

augmented assignment operator

Sets are collections of unique objects,

for large datasets, it can also be a lot faster and more efficient.

Diving Deeper Into defaultdict

When and why to use a Python defaultdict rather than a regular dict

Note that __missing__() is not called for any operations besides __getitem__().

use code to parameterize calls:

python -c "
from mymodule import set_dragon_feeding_schedule, Creatures, Date
set_dragon_feeding_schedule(
    feeding_times=['10:00', '14:00', '18:00'],
    dishes={Creatures.Tiger: 2, Creatures.Human: 1},
    start_day=Date('1020-03-01'),
)
"

python -m mymodule \
    set_dragon_feeding_schedule \
    --feeding-times ['10:00','14:00','18:00'] # hopefully this way it gets recognized \
    # how will you define parsing a dict with enum to integer mapping? 
    --dishes=Creatures.Tiger:2 \
    --dishes=Creatures.Human:1 \
    --start-day=1020-03-21 # BTW bash allows no comments in multiline calls

That’s it. Types are parsed, checked and converted. Defaults and description are picked from function itself. Even provides bash completions you can install. You wrote no code for that!

import typer
from pathlib import Path

app = typer.Typer()

@app.command()
def find_dragon(name: str, path: Path, min_age_years: int = 200):
    <implementation goes here>

@app.command()
def feed_dragon(dragon_name: str, n_humans: int = 3):
    <implementation goes here>

if __name__ == "__main__":
    app()

python example.py find_dragon 'Drake' --path /on/my/planet

Merge (|) and update (|=) operators have been added to the built-in dict class. Those complement the existing dict.update and {**d1, **d2} methods of merging dictionaries.

Use Streamlit if you want to get going as quickly possible and don’t have strong opinions or many custom requirements.Use Dash if you need something more flexible and mature, and you don’t mind spending the extra engineering time.

Here’s a table showing the tradeoffs:

The Census FTP page contains the microdata and dictionaries identifying each variable name, location, value range, and whether it applies to a restricted sample. To follow this example, download the April 2017 compressed data file that matches your operating system and unpack it in the same location as the python code. Next download the January 2017 data dictionary text file and save it in the same location.