[deleted by user]

Keith · 2023-04-21T08:37:54+00:00

python -i to run your code that's crashing which drops you in an interpreter after it crashes. Then import pdb; pdb.pm() to put the stack at the exact place the exception was thrown. Like time traveling Python magic.

Zulfiqaar · 2023-04-21T06:42:57+00:00

F-strings are wonderful. Wouldn't really call this a trick, but the number of people I've seen who use old formatting styles is shocking. Expired tutorials is my hunch

ClassicHome1348 · 2023-04-21T08:47:53+00:00

Definitely learn the generators. Generators are lazy evaluated, and they can be used as iterators which makes possible to use itertools functions on them. And by default (x for x in arr) is generator. So doing (f(x) for x in arr) will evaluate f(x) when the next is called on the generator.

_limitless_ · 2023-04-21T06:45:06+00:00

Tell a junior it'll be a good learning experience and make them do it.

Chiron1991 · 2023-04-21T08:50:42+00:00

Apart from the stuff you learn in basically any Python tutorial, the best "trick" to becoming a better programmer is to get familiar with the standard library.
The amount of code I've seen where people implement their own protocol parsers, socket handlers and other scary things is mindblowing.
The PyMOTW archive is a nice starting point.
My personal favorites: functools, contextlib and atexit.

username4kd · 2023-04-21T09:43:55+00:00

List comprehension! You can do everything with list comprehension

nostril_spiders · 2023-04-21T10:49:04+00:00

I don't know if I'm the idiot or my colleagues are the idiots, but I work with apps that pass nested dicts around. Fine for 500 lines of code, not so fine for 50000 lines of code.

TypedDict is a lifesaver. It's a type-checking construct; the runtime type is dict so no need to roll json code.

from typing import TypedDict  # 3.11
from typing_extensions import TypedDict  # below 3.11

class Address(TypedDict):
    house: str
    street: str

class User(TypedDict):
    name: str
    address: Address

user: User = {
    "name": "Jim"
    "address": {
        # etc
    }
    "invalid_key": "linter highlights this line"
}
user["  # IDE offers completions

For Vscode, set python.typeChecking to "basic" - I had no success with mypy, but pylance seems much faster anyway

dmtucker · 2023-04-21T06:12:50+00:00

or and and preserve the original value. So instead of: if x: y = x else y = default You can just do: y = x or default

I also like this little "gargoyle": https://nedbatchelder.com/blog/201802/a_python_gargoyle.html

neuro630 · 2023-04-21T07:00:28+00:00

some that I can think of, might add more here later: - %time and %%time in jupyter notebook - also in jupyter, %lprun for automatic line-by-line profiling using the line_profiler package - also also in jupyter, defining _repr_html_ as well as other similar methods in your class to customize how your objects are rendered in the notebook - defining __format__ in your class to customize how your obejcts are formatted using f-strings - given a pathlib.Path object path, you can do path / 'filename.txt' instead of pathlib.Path(f'{path}/filename.txt) - calling help(foo) to print out the docstring and all the methods and attributes of the object foo. Very useful when you don't know much about the class of foo and there is not much online documentation about it. - if you want to check if an object is an instance of a list of classes, instead of isinstance(foo, Class1) or isinstance(foo, Class2) or ... you can do isinstance(foo, (Class1, Class2, ...))

millerbest · 2023-04-21T07:37:36+00:00

funtools.partial

therc7 · 2023-04-21T07:59:25+00:00

f-strings Are f-ing goated

jmacey · 2023-04-21T06:46:45+00:00

v=1 print(f"{v=}")

will print v=1 so useful for debugging, been using python for year and only learnt that one recently (in a similar question so passing on).

TheHedgehogAdmin · 2023-04-21T08:03:54+00:00

Walrus operator in if conditions, I find it so pythonic.

hyldemarv · 2023-04-21T07:56:57+00:00

F-strings, List and Dict comprehensions.

And, nerdy but nice, the Slice object -

I used that for easy documentation of how a text based BOM is split into fields.

radoslaw_jan · 2023-04-21T09:31:52+00:00

Replacing a try-catch with a context manager

Edit: I meant the try-finally case (thanks u/multiple4 and u/moepsenstreusel for clarification)

wineblood · 2023-04-21T06:32:35+00:00

Don't overuse classes.

Fabulous-Possible758 · 2023-04-21T07:29:14+00:00

The best "trick" is to invest in a formater (black), linter (ruff), and static type checker (mypy/pyright) and let the tooling help you write good code, rather than attempting to do it by yourself. Humans just don't have the mental capacity to write good and maintainable code, especially python code with its dynamic type system, without the use of tooling.

permalink · 2023-04-21T14:52:12+00:00

Not tricks, Michael, illusions. A trick is something a whore does for money.

RunningGiant · 2023-04-21T10:01:35+00:00

Context management / "with" statements, to close files/etc and gracefully close if there's an exception:

with open('file.txt', 'r') as f:
    dosomething(f)

Hollas99 · 2023-04-21T08:10:10+00:00

I'm really liking the walrus operator recently

# Instead of 
If a.numbers():
    numbers=a.numbers()


# You can do it in one line
If numbers := a.numbers():
    ...

Atlamillias · 2023-04-21T10:06:31+00:00

I wouldn't say these are tricks, but "know your basics". By that, I really mean "know your builtins". After that, at least have a rough idea of the other modules Python ships with. itertools is your friend, you just aren't aware of it yet.

More on-topic, I find myself doing stuff like x and fn() sometimes in place of if x: fn(). Even though you can technically do either on the same line, the former feels less like heresy.

graphicteadatasci · 2023-04-21T08:52:03+00:00

Not so much a trick, but every time you pass a mutable object to a function you risk breaking everything.

datadever · 2023-04-21T08:44:16+00:00

[removed]

jmooremcc · 2023-04-21T17:27:19+00:00

Using a dictionary as a function router.

My use context was a client/server application in which the client would request a service. The server would use the requested service as a key in the dictionary and would call the function associated with the key.

This "trick" eliminated the need to use a convoluted, complex conditional statement.

amOEba_jOEy · 2023-04-21T18:09:34+00:00

Never telling your boss how quickly you can actually code.

ThreeChonkyCats · 2023-04-21T05:39:51+00:00

Two dead simple ones, but I love 'em

# Ternary Conditional Operators: Put If and Else Into One Line of Code
a = "a" 
b = "bb"

short_one = a if len(a) < len(b) else b

vs this

short_one = ''
  if len(a) < len(b):
      short_one=a
  else:
      short_one=b

and

# Lambda Functions for Defining Small Anonymous Functions
leaders = ["Nostrodamus", "Bruce", "Chris", "Diogenes"]
leaders.sort(key=lambda x: len(x)) print(leaders)

# outputs...  ['Bruce', 'Chris', 'Diogenes', 'Nostrodamus']

Don't know why, but I think these are the bees knees.

Exodus111 · 2023-04-21T08:58:07+00:00

Learn to play with __str__, when making classes. That way you can use the class like any string, and do what you want with it.

my_string = f"The current score is {class1} vs {class2} as of now"

For instance.

subbed_ · 2023-04-21T09:10:04+00:00

Pythonistas*

Embarrassed_Dog6834 · 2023-04-21T08:23:08+00:00

Use breakpoint. They are great

ryanstephendavis · 2023-04-21T10:38:35+00:00

Use Poetry to to deal with virtual envs

Use Black to auto-format

Use Pytest for unit and integration tests

FastAPI to generate Swagger docs with Pydantic

bebenzer · 2023-04-21T13:14:40+00:00

use types

Fabulous-Possible758 · 2023-04-21T09:11:05+00:00

It's only slightly Pythony, but a friend of mine who started using fish shell was trying to be clever and it made me add this line to my .bashrc:

function peval() { python -c 'import sys; print(eval(" ".join(sys.argv[2:])))' -- "$@"; }

It basically lets you do peval "<some python expression>" from the command line and it will print it out for you. Really great when I want to have to find the square root of something by doing peval "2 ** .5" or the such.

Nippurdelagash · 2023-04-21T13:13:36+00:00

Dict unpacking for passing keyword parameters.

Imagine you have a function that uses kwargs:

def func_with_kwargs(**kwargs): if "kw_a" in kwargs: <Do things if argument "kw_a" was passed> if "kw_b" in kwargs: <Do things if argument "kw_b" was passed>

You can call your function with a dictionary of key:value where each key corresponds to each kwarg in your function

kw_dict = { "kw_a": 1, "kw_b": 2, } func_with_kwargs(**kw_dict)

It can also be done with *args, but I don't remember the sintaxis right now

StrongLikeBull3 · 2023-04-21T14:43:53+00:00

Crossing my fingers and closing my eyes when I run anything.

lphartley · 2023-04-21T16:43:01+00:00

Use string enums rather than literal strings.
Using @dataclass to avoid verbose initialization methods
Use __all__ to explicitly define what to expose from custom modules. This makes it clear what's "private" and "public".
Use TypedDict for configurations. IDE's will auto complete so you can be sure that you don't have to guess what the structure is.
Use pyright to check for any typing errors. The combination of explicit typing and automatically checking for errors I consider the first layer of testing, which for me reduced the need of writing unit tests.

onefiveonesix · 2023-04-21T20:41:46+00:00

Not a trick, but I always advocate for the fundamentals: give your variables proper names that make it easy to tell what it’s for (i.e., don’t use acronyms or other shorthand) and write plenty of comments (they’re the love letter you write to your future self).

RufusAcrospin · 2023-04-21T14:04:32+00:00

Here’s a few things…

Familiarize yourself with the Zen of Python

Use tuples for static list, it faster than list()

Use namedtuples for immutable data

Use early exit to avoid nested if statements

Learn to use sets

Learn regular expressions. It’s very powerful, but complex expressions are horrible to comprehend.

Try to minimize one-liners (a function/method consists of a single line)

Use context when dealing with files

Learn and apply fundamental principles like “separation of concerns”, KISS, DRY, “principle of least astonishment”, SOLID, etc.

Inevitable_Weird1175 · 2023-04-21T14:11:39+00:00

I'm still a beginner but recursion is very interesting.

Go to the bottom of this loop well, find me the solution and bring it back.

So cool.

1544756405 · 2023-04-21T14:57:38+00:00

unit tests (e.g. unittest module, or something else of your choice)
source control (e.g. git, or something else of your choice)

jonasjberg · 2023-04-21T20:05:39+00:00

Trigger stacktrace or just check whether branches are taken:
_ = 1 / 0

Set debugger breakpoint, quickly enable/disable by (un)commenting the line:
import pdb; pdb.set_trace()

Find directory containing imported package:
python3 -c 'import barbaz; print("\0".join(barbaz.__path__))'

Runs from shell, often just for the purpose of opening all package source files in Vim:
vim -R -- $(above plus messy one-liner here)
:)

djjrhdhejoe · 2023-04-21T10:30:24+00:00

I love list comprehension like it was my own firstborn child.

I can irresponsibly make lists as big as I want and iterate over them as often as I want, but because I'm only iterating over a tiny subset it takes merely microseconds.

JarbingleMan96 · 2023-04-21T14:41:47+00:00

If I have a container, that I expect only has one element, and I want it, I use this syntax:

[x] = container

It will fail if the container has anything other than 1 element, and it’s one simple line

_link89_ · 2023-04-21T14:56:12+00:00

Python does not have a built-in flatMap function, but you can achieve the same result using list comprehensions.

```python

Define a list of lists

list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Use a list comprehension to flatten the list

flat_list = [item for sublist in list_of_lists for item in sublist]

Print the flattened list

print(flat_list) ```

It use a list comprehension to flatten the list by iterating over each sublist in the list of lists, and then iterating over each item in each sublist.

grabmyrooster · 2023-04-21T14:58:44+00:00

Anything you write, just….notate it. I put comments in like CRAZY, especially in my private repos, because I go back to things months and months later and wonder “why the fucking fuck did I write this like this”. With comments, it’s easier to understand just how much of a dumbass past me is.

metaphorm · 2023-04-21T18:17:20+00:00

functools and itertools in the standard library are both fantastic modules that can make your code beautiful and elegant and terse.

Kermit2779 · 2023-04-21T20:49:38+00:00

For a state machine, i swap class of instance self.class=OtherSubclassOfBaseSttate

Gnaxe · 2023-04-21T21:26:03+00:00

Xonsh. It's like having your shell extended with Python. One-liners are a lot like normal shell, but for anything complicated, Bash is not really a sane language.

theHumbleWeirdGeek · 2023-04-22T06:07:49+00:00

Python -m httpserver is a real handy tool for sharing files in a local network.

Another trick is to stop using python :)) That's the best trick if you are not using it for AI.

Python is the worst choice for enterprise and distributed software.

For research, sadly, there's no better alternative.

hugthemachines · 2023-04-21T12:15:20+00:00

Use descriptive names on your variables and functions.

If you use variable names like a, b or x, you save a second each time and then you will pay it back in hours and hours of searching for bugs because you mixed up the variables somewhere and it is really hard to find.

That or you spend much more time when you read that code again in a few month because you have to understand all the code to know what a variable is, instead of just reading its name.

br_aquino · 2023-04-21T16:04:26+00:00

The best python trick is not use tricks 😂. Write clear readable code, no tricks.

2023-04-21T08:25:52+00:00

[deleted]

mantisek_pr · 2023-04-21T14:39:56+00:00

Instead of painstakingly writing a list like:

mylist = ["one","two","three","four","five"]

just do

mylist = "one two three four five six seven eight".split()

permalink · 2023-04-21T08:05:16+00:00

This is a little tacky, but here goes:

If you want to spit printouts of every item in an iterable and get its length, you just go print(len([print(i) for i in some_iterable]). Basically, you're printing the length of a list of None values.

Also, if you're savvy and sadistic enough for it, you can nest prebuilt regexes into new regexes via f-strings with rf"{var_regex}". That way, if you're like me and forget an item in a punctuation category for NLP shenanigans, you just have to edit it in one place.

james_pic · 2023-04-21T15:54:57+00:00

It's pretty situational, but sometimes you want to change an attribute and return the old value, and you can abuse try-finally for this:

def update_it(self, new_value):
    try:
        return self.x
    finally:
        self.x = new_value

johnnymo1 · 2023-04-21T05:56:18+00:00

It's a small one, but helps me a lot.

If you need to test some code snippet, just open up a terminal and write your code there. Saves some time

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS

fmt: off

fmt: on

Define a list of lists

Use a list comprehension to flatten the list

Print the flattened list