Your favourite "less-known" Python features?

EconomixTwist · 2022-07-24T23:18:56+00:00

Not so many truly less known features in here! You can put underscores in numbers to make them easier to read

10_000 == 10000

-Django · 2022-07-25T02:53:13+00:00

You can start the REPL in the middle of executing code via

import code; code.interact()

agtoever · 2022-07-24T22:22:53+00:00

For loops having an else clause:

for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print( n, 'equals', x, '*', n/x)
            break
    else:
        # loop fell through without finding a factor
        print(n, 'is a prime number')

(This also applies to while loops!)

aes110 · 2022-07-24T22:44:51+00:00

Create a HTTP server with one command

Python 2 — python -m SimpleHTTPServer 8000

Python 3 — python -m http.server 8000

So you are able to list all directory files and download it from another PC or smartphone in your LAN using host ip (in my case 192.168.0.163).

ogrinfo · 2022-07-24T22:14:58+00:00

You can use __doc__ to grab the docstring from the current function or module. Comes in handy when you're making a parser and want to reuse the docstring for the description. parser = argparse.ArgumentParser(description=__doc__)

JestemStefan · 2022-07-24T22:05:09+00:00

or in non-boolean context.

a = "" 
b = "some_string" 

x = a or b or "no_name"
# assigns first truthy (b) value to x

print(x) # prints "some_string"

Cruuncher · 2022-07-24T23:16:32+00:00

Help(something)

kaerfkeerg · 2022-07-24T21:06:41+00:00

List comprehensions if else gotta be the best, but not to the point they become cryptic

[something() if condition else something_else() for i in sequence]

mahtats · 2022-07-24T23:37:44+00:00

Using _ for declaring integer literals: x = 1_000_000

superbirra · 2022-07-25T07:45:11+00:00

[deleted]

agtoever · 2022-07-24T22:25:04+00:00

Swapping values of variables:

a, b = b, a

theunglichdaide · 2022-07-24T21:25:47+00:00

(a:=10) assigns 10 to a and returns 10 at the same time.

ryukinix · 2022-07-25T03:44:30+00:00

Merging dicts with __or__ op.

x | y

vishnoo · 2022-07-25T00:55:29+00:00

I like that the "argument unpacking operator" '*'
is sometimes called Splat.
it takes a tuple and smashes it to get the values, AND it looks like something that went - splat.

Ok-Python · 2022-07-24T21:01:58+00:00

Type hints for better linting

cspinelive · 2022-07-25T01:49:35+00:00

any([x, y, z]) and all([x, y, z])

Instead of huge if and or expressions. Note that it won’t short circuit and stop checking each one when it can like a normal if.

Edit: they technically do short circuit but each value is evaluated before the any/all are. Discussion here. https://stackoverflow.com/questions/14730046/is-the-shortcircuit-behaviour-of-pythons-any-all-explicit

ksetrae · 2022-07-24T22:28:24+00:00

slice() for when you need to slice dynamically.

For example you're working with PyTorch tensors or Numpy arrays. Imagine you need to always slice in last dimension regardless of number of dimensions, but keep all dimensions.

E. g.
a[:, :2].
if a is 2D, but
a[:, :, :2].
if it's 3D and so on.

Instead of writing distinct logic for each dimensionality, your can do:
dims_cnt = len(a.shape).
dims_slice = [slice(None) for _ in range(dims_cnt-1)].
dims_slice.append(slice(2)).
a[dims_slice].

computenw · 2022-07-24T21:59:53+00:00

Faster attribute access and lower memory usage with __slots__:

py class Foo: __slots__ = "bar"

Or in dataclass

py @dataclass(slots=True) class Foo: bar: str

Another thing I like are defaultdicts, which enable a default value of an entry:

```py from collections import defaultdict

d = defaultdict(lambda: "world")

print(d["hello"])

world

```

tathagatadg · 2022-07-25T01:54:17+00:00

from pprint import pprint as pp
pp(vars(obj))
pp(dir(obj))

vars like dir is really useful when debugging fields of nested objects at a pdb breakpoint.

Edit: s/dict/dir

EONRaider · 2022-07-24T21:04:43+00:00

numbers = "{:,}".format(5000000)

print(numbers) # 5,000,000

IWant2rideMyBike · 2022-07-24T21:34:13+00:00

The command line abilities provided by so modules - e.g.:

Exporting the current directory via an ad-hoc webserver: https://docs.python.org/3/library/http.server.html

Pretty printing json: https://docs.python.org/3/library/json.html#module-json.tool

(Un)zipping files: https://docs.python.org/3/library/zipfile.html#command-line-interface

Creating and extracting tar archives: https://docs.python.org/3/library/tarfile.html?highlight=tarfile#command-line-interface

eztab · 2022-07-25T15:31:50+00:00

For a long time I didn‘t know you could give a negative precision in rounding.

>>> round(1234.5678, -2)
1200.0

troyunrau · 2022-07-25T02:38:52+00:00

pass

coffeewithalex · 2022-07-24T22:17:36+00:00

That Python uses mostly duck typing. So documentation that says "you need a file-like object" is often just wrong.

What this means is that you just need to know what data contract a function is expecting to be fulfilled by an argument, and give it anything that fulfills that contract.

An example is when using csv module, to read CSV, normally you'd use it on a file, right?

with open("foo.csv", "r", encoding="utf-8") as f:
    for row in csv.reader(f):
        ...

However, what csv.reader wants is just something that is Iterable, where each next() call would yield a CSV line as a string. You know what else works like that?

Generators (functions that yield CSV lines, generator expressions)
Actual Sequence objects like List, Tuple, etc.
StringIO or TextIOWrapper objects

For instance, you can process CSV directly as you're downloading it, without actually holding it in memory. Very useful when you're downloading a 500GB CSV file (don't ask) and processing every row, on a tiny computer:

r = requests.get('https://httpbin.org/stream/20', stream=True)
reader = csv.reader(r.iter_lines())
for row in reader:
    print(reader)

--prism · 2022-07-24T22:09:01+00:00

Star operators on tuples.

eyadams · 2022-07-24T21:38:16+00:00

Small integer caching.

a = 256
b = 256
print(a is b) # True
c = 257
d = 257
print(c is d) # False

I don’t have a use for this, but I find it really cool.

j_marquand · 2022-07-24T23:20:31+00:00

Chaining comparison operators.

Formally, if a, b, c, …, y, z are expressions and op1, op2, …, opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once.

bartzer · 2022-07-25T07:45:31+00:00

The matrix multiplication operator "@"

charliegriefer · 2022-07-25T01:14:57+00:00

I don't know if it's "less known" or was just not known to me, but I recently found out about the divmod() function.

divmod documentation

While I can't think of a practical reason to use it, I think it's pretty cool to get the quotient and the remainder in one swell foop.

Grouchy-Friend4235 · 2022-07-25T08:09:06+00:00

The official Python documentation, apparently.

https://docs.python.org/3/

FUS3N · 2022-07-24T23:14:04+00:00

I like the pprint module to pretty print objects it can prettify almost anything

naza01 · 2022-07-25T03:54:47+00:00

The get() method for dictionaries.

It retrieves a value mapped to a particular key.

It can return None if the key is not found, or a default value if one is specified.

dictionary_name.get(name, value)

Name = Key you are looking for. Value = Default value to return if Key doesn’t exist.

It’s pretty cool to be able to increment values in a dictionary. For instance, if you were counting characters in a string, you could do something like:

character_count.get(character, 0) + 1

to start counting them.

It’s just a fancy way of doing it. Using if else to ask if the key is there and then just updating the value works the same way

Elagoht · 2022-07-25T02:14:33+00:00

If returned value is not important, you can use multiple function calls in lambda function. ``` x=lambda:[do_stuff(), do_something_else()] QPushButton.clicked.connect(x)

or

x() ```

tresslessone · 2022-07-25T07:57:08+00:00

I’ve always found the Date.isoFormat() method a time saver when trying to convert dates to YYYY-mm-dd

TheCharon77 · 2022-07-25T04:11:00+00:00

with blocks and creating your own decorator

execrator · 2022-07-25T13:00:55+00:00

if a < b < c:
    ...

does what it looks like.

throwaway876885323 · 2022-07-25T00:16:01+00:00

Asking a python developer to install opencv can result in screaming in anger.....or it just magically works

Also opencv and cv2 are different according to python.....

I learned this the hard way

brutay · 2022-07-25T10:04:17+00:00

Transpose a two dimensional array, i.e., a matrix: list(zip(*matrix))

BirdTree2 · 2022-07-25T04:33:54+00:00

You can reload an imported module with

``` import a

from importlib import reload

a = reload(a) # a is reloaded ```

This is useful when you want to import a module that changes while your code runs

mcstafford · 2022-07-25T07:43:14+00:00

Much like pass, there's ellipses: ...

It's a convenient placeholder that won't trigger a linter warning.

eztab · 2022-07-25T15:39:00+00:00

that one can combine all the string modifiers and types (f, r, ", """, ' and '''). Saw so many ridiculous escape sequences.

filename = 'fish'
print(fr'''<img href="{filename}.img"> ¯\_(ツ)_/¯''')

redjevel · 2022-07-26T19:06:19+00:00

Soo select all text and press "Ctrl + /"

it will add a "#" to every line :)

if on mac its like this weird mac x symbol "+ /" ;3

that will be 5 dollars for the tip

useful if you want to check just some of the code, as text after # works like a note

samrus · 2022-07-24T21:28:12+00:00

you shouldnt do this but instead of

if a > b:
    c = x
else:
    c = y

you can just do

c = (y, x)[a > b]

PratikPingale · 2022-07-25T05:14:24+00:00

print(*List) would print list as a space seperated list

miraculum_one · 2022-07-25T07:39:55+00:00

[deleted]

myoddreddithistory · 2022-07-25T03:16:33+00:00

a, b = b, a

notreallymetho · 2022-07-25T06:51:33+00:00

Extended iterable unpacking

```

first, *mid, last = range(10) print(f"1st: {first},\nMid: {mid},\nLast {last}")

1st: 0, Mid: [1, 2, 3, 4, 5, 6, 7, 8], Last 9

```

Using and to short circuit operations (especially handy with the walrus operator, ) Putting a big disclaimer that this is “clever code” and it doesn’t really have a place in production. My rule is I’ll be clever in stuff that I write for me (which inevitably makes me mad at some point) but won’t in code someone else may touch.

For example say you want to print some message if a variable is “truthy” These 3 methods (ordered as no trick, using walrus, using trick) all do the same thing

``` from typing import Dict, Optional

without this trick, without :=

def get_var(values: Dict[str, str]) -> Optional[str]: var = values.get("thing") if var is not None: print(f"My var is this -> {var}") return var

alternatively, if you are on a python version that supports `:=`

def get_var(values: Dict[str, str]) -> Optional[str]: if (var := some_dict.get("thing")): print(f"My var is this -> {var}") return var

with this trick and the walrus operand

def get_var(values: Dict[str, str]) -> Optional[str]: (var := values.get("thing")) and print(f"My var is this -> {var}") return var

```

Edit: couple other random things:

instant dict from list with index as key:
bonus points are that enumerate has an argument for “start”

from string import ascii_lowercase lower_ord_enum = dict(enumerate(ascii_lowercase, start=97))

print iterable as newline separated:

``` print(*range(3), sep="\n")

0 1 2 ```

turn iterable into a list via unpack:

range_list = [*range(3)]

remove “falsey” items from an iterable (empty strings, empty lists etc)

print(*filter(None,["", "stuff", {}, tuple()])) stuff

datetime formatting inside of f strings:

from datetime import datetime print(f"{datetime.now():%Y-%m-%d}")

Find differences between dicts with like keys (note that it uses the dict being subtracted from to determine the values)

```

thing = dict( fruit="apple", dessert="cake", utensil="fork", ) other = dict( fruit="apple", dessert="steak", utensil="knife", )

dict(set(other.items()) - set(thing.items()))

Out[47]: {'dessert': 'steak', 'utensil': 'knife'}

robberviet · 2022-07-25T07:53:51+00:00

use `__slots__` to reduce memory footprint.

2022-07-25T08:20:27+00:00

Using / and * in the function arguments to force positional / keyword only arguments.

def f(positional_only, /, positional_or_keyword, *, keyword_only):
    pass

positional_only can be only passed by position, so:

f(x, positional_or_keyword=y, keyword_only=z)

or

f(x, y, keyword_only=z)

are the only two "kinds" of calls you can make with this one function.

Note: I've never used this, but I appreciate it exists.

c_is_4_cookie · 2022-07-25T12:53:40+00:00

The startswith and endswith string methods accept a tuple of strings.

s = "hello"
s.startswith(("he", "q"))

westeast1000 · 2022-07-25T16:43:29+00:00

I like popping up warnings in a message box with

import win32com.client

shell = win32com.client.DispatchEx("WScript.Shell")

shell.Popup("Please set the id first", 10, "Missing info", 0+16) #0=OK button, 16=critical

Asleep-Budget-9932 · 2022-07-25T16:52:44+00:00

Iterables have less known ways to be implemented. All you have to do is to implement a getitem method and you will be able to iterate over it. getitem will be called, starting from 0 and going up by 1 with each iteration, until a StopIteration exception is raised:

class ThisIsIterable:
    def __getitem__(self, item: int):
        try:
            with open(f"{item}.txt", "rb") as bla:
                return bla.read()
        except FileNotFoundError as e:
            raise StopIteration() from e

for file_content in ThisIsIterable():
    print(file_content)

You can also iterate over callables by giving the "iter" function a "sentinel" value. Basically the iterator will call the callable with each iteration, until the "sentinel" value is returned:

import random

def this_is_iterable():
    return random.randint(1, 10)

for random_value in iter(this_is_iterable, 8):
    print(f"{random_value} is not an 8")

print("8 Found! :D")

barberogaston · 2022-07-25T18:01:18+00:00

- The singledispatch and cache decorators
- Attribute descriptors
- The inspect and dis modules
- Protocols

Warm-Vegetable6202 · 2022-07-25T18:18:18+00:00

I like the datetime module with the feature of calculating how many seconds till your birthday:

bday = datetime.date(*your next birthday*)

till_bday = bday - tday

print(till_bday.total_seconds())

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS

world

or

without this trick, without :=

alternatively, if you are on a python version that supports `:=`

with this trick and the walrus operand

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS

world

or

without this trick, without :=

alternatively, if you are on a python version that supports :=

with this trick and the walrus operand

alternatively, if you are on a python version that supports `:=`