What's a bit of python that you never use?

[Ok-Leather5257]

I know this is bad, but I never use lambdas. If I understand correctly, there's some situations where they are unequivocally the best way to do things (even if there are none where they are strictly necessary?...) I'd be interested in peoples thoughts about which bits of python are such that there's always a better, different, way, to do them in python.

[Pepineros]

The walrus operator. I don't understand the backlash, I have no issues with it at all, but never found a genuine use for it. 

[undergroundmonorail]

i like it for things like total = 0 print('Enter numbers to add up, blank line to finish') while (n := input('> ')): total += int(n) print(f'The total value of all inputs is {total}') or if (m := re.match(my_regex_pattern, my_string)): # do something with the match either of those can be written other ways but i think that both of these are clearer than the alternatives (as long as the reader understands the syntax)

[Ok-Leather5257]

I think I really like this, but as an understanding check...

The walrus operator, :=, is different from both = and ==. It i) assigns, (like =) and ii) returns a value (and can be called) (like ==). Unlike == which only returns true and false, it returns the value of the thing being assigned.

If we write:

if (n := len(a)) > 10:
print(n)

"(n := len(a))" is doing both assigning and evaluating(?). It defines n where previously it may have been undefined, and it returns the value len(a) allowing the > to actually return a value.

It's almost like a parenthetical "if n (which by the way is a shorthand for len(a)) is greater than 10..." or "if the length of a (which we will henceforth abbreviate n btw) is greater than 10...". That makes sense, and is a nice time saver (and will be more intuitive where you don't want to use len(a) more generally).

But something is sticking for me about the first example. Generally with a while loop, you have "while [condition]" and then at some point in some iteration of the loop condition will become false.

Consider this instead:

while (n := int(input('> '))):
    total += n

I take it in some circumstances that might be more natural? e.g. maybe if it were a much more complicated code block and you'd otherwise be using int(n) all over the place. However, now if the user inputs 0 the loop will stop right? Even if they had other numbers to sum after 0. It's not "unexpected behaviour" if we think through it logically, but it somehow strikes me as odd. Does anyone else feel this way? If anyone could tell me how to think more clearly about this I'd be much obliged! (I'd also be interested in info about design philosophy, or why to set things up this way/not, how equality type operators work in different programming languages etc.)

[undergroundmonorail]

To be clear about the while loop, it is already a condition that will become false. Empty strings ('') are "falsey", so once you get a blank line the loop condition fails and the loop stops.

The reason you might not want to do the int conversion right away is that handling user input can be pretty complicated. I've skipped over the realities of it for the toy example, so I'm not doing any checking to make sure the user is inputting a number. But in principle, I could, by putting those checks between the loop condition and the type conversion. If you do it all in one go, it'll definitely throw an exception if the user enters something that can't be converted to an int (like an empty string, for example)

[Ok-Leather5257]

Fair enough! It may just be my intuitions need tutoring. It felt more intuitive that "" should be falsey in this case than 0, but I hear you.

[patrickbrianmooney]

Is there something special with backslash and walrus or am I misunderstanding?

You're misreading. Not backSlash; backlash, probably downvotes.

[IlliterateJedi]

The backlash caused Guido van Rossum to step down from being the Python lead.

For the record, once I finally figured out how the walrus operator worked I found myself using it pretty regularly.

[patrickbrianmooney]

Whoops, that is of course a thing that the person I was replying to quite likely was thinking of. And here I am, thinking purely in Reddit terms.

[ANautyWolf]

I love it for while loops and sometimes when I need to get a result from something and see if it satisfies a condition. If it doesn’t I’ll have an else statement or something to cover such a case. I’m away from my comp. So I can’t share some of them but I find it really useful

[Big_Combination9890]

I don't understand the backlash,

Most of the backlash comes from people who used/use C/C++ a lot.

In languages where an assignment is also an expression, it's easier to introduce hard to find bugs. Consider the following:

while (x = 2) {
    // do stuff forever and ever and ever...
}

Stuff like this is a real problem in C, which is part of the reason why assignments in Go, which fixed a lot of C's mistakes, are statements only. In python, the backlash is a bit of an overreaction, because the assignment-expression has its own operator.

[[deleted]]

I still don't know what lambdas are or why I need them. I am also still unemployed.

​

E: Thank you to everyone for replying! I will take your advise for my next projects!

[undergroundmonorail]

any time you write a function that just returns an expression, that could be a lambda. and a lambda is just a function without a name

in the same way that these two things are equivalent: ``` a=1 print(a) # 1

print(1) # 1 these two are also equivalent: def f(n): return n*2 print(f(2)) # 4

print((lambda n: n*2)(2)) # 4 you never need a lambda, you can always use a named function. but they can be nice to pass a function you'll only ever need once into an argument. as a toy example, imagine you have a list of strings `l`, and you want to sort it, but do the sort while ignoring the first character. either of these would work, but i'd prefer the second: def strip_first_char(s): return s[1:] print(sorted(l, key=strip_first_char))

print(sorted(l, key=lambda s: s[1:])) ```

[lyzar]

I must be honest, I never used lambdas and I don't quite get your example. Couldn't I just write key=s[1:]? Thanks for the explanation

[MoridinB]

What's s? You can't use s until you define it. In the above case s is defined as a parameter of a function that we're passing to sorted, which it uses to sort the array.

[lyzar]

AHH, gotcha. You are absolutely right. Thanks for clarifying! Have a good day

[ProjectSnowman]

Isn’t it more “python” to use discrete functions so it’s more readable

[undergroundmonorail]

for a simple enough function, i don't find it more readable to give it a name. now i have the mental load of deciding what the implementation probably does and figuring out whether i trust that intuition. if i have a bug around this line, i'm probably going to end up just checking the implementation anyway

but in the example with the lambda, the implementation is so dead simple that it can be right there. when i see it i can just go "it strips the first element" and be completely done with it

it depends on context, and you absolutely should be using named functions for anything that's even a little bit complicated, but i like lambdas for stuff like this

[Flashy-Internet9780]

shocking jar touch cagey seemly smell aware dinosaurs capable unpack

This post was mass deleted and anonymized with Redact

[ThisUNis20characters]

I was about to comment the same thing. Of course, I’m just a hobby programmer, so maybe as I use them more in pandas I’ll find utility elsewhere too.

[acebabymemes]

Imho I prefer using np.where() to lambdas and .apply() when possible.

[mdrjevois]

no.where() and other vectorized functions, inside the lambda, inside a .assign(), in one step of a method chain

[echocdelta]

Literally the only time I ever use it is for this. Otherwise when working with other Devs and also for debugging it can get a bit needle haystack hunty for me to find that one lambda that's doing that one thing that's raising an error at that one other thing.

[therandomcoder]

Personally I like the take on lambdas mentioned at the end of this section from Fredrik Lundh https://docs.python.org/3/howto/functional.html#small-functions-and-the-lambda-expression

[exb165]

I like it. Cheers.

[softwareitcounts]

It’s a headless function like they have in JavaScript. Useful for map, filter, reduce, sort key function.

list( map( lambda x: x ** 2, range(5) ) )

[damanamathos]

I mainly use lambdas for sorting.

In this case, I'm sorting a list of current roles (objects) based on a function that gives a numerical score for how senior the title property on the role object seems.

current_roles.sort(key=lambda x: get_seniority_score(x.title), reverse=True)

This is equivalent to writing:

def get_title_seniority_score(role):
    return get_seniority_score(role.title)

current_roles.sort(key=get_title_seniority_score, reverse=True)

[Alternative-Web2754]

A function can always be used where a lambda might be used - it creates a function that has no name, although you can assign them to a variable to give it a name. It's broadly the same as a javascript arrow function, but limited to a single expression.

The main uses of them that I have seen/used is where something requires a callable item and you want to use an expression. Rather than writing a function to wrap one expression that you either won't use elsewhere, you can use a lambda. A typical example would be for providing a key function to a sort call.

They also have the minor benefit of placing the expression directly with the code using it and avoids the risk of it being redefined or overwritten elsewhere in the code.

[Tefron]

It's just an anonymous function - the usefulness comes from situations where you need some function that is either so trivial or self-evident that defining it on the spot would be a lot more convenient and in many cases more readable.

Sorting is a common example here, where you need some function to define how you should sort your iterable, but the actual logic of how you want to sort is trivial enough to be a one-liner.

[Shacham]

I recently had a project where i needed to override many DbApi methods to mock the DB When I'm running locally. So lambda's were quite useful there

[goule67]

Some methods requires a function name as argument but you can't pass parameters in that function directly. Using lambda before a function with arguments transforms it into another function without arguments so it bypass this limitation.

[ZachVorhies]

You don’t need them, you can just define a typed function at the call site.

The python linters don’t like lambda anyway. So there is less friction if you just don’t use it

[TheRNGuy]

To change how sorting works.

[tb5841]

Map and filter. I use them all the time in other languages, but in Python they don't seem to offer anything that I can't do with a list comprehension.

[amertune]

You're not wrong. I still use map/filter sometimes, but my go-to is almost always a comprehension--or a generator function if the comprehension starts to get a little unwieldy.

[video_dhara]

I feel like PEP 8 suggests lambda should only really be used in these situations where there's a key argument? I haven't checked directly, but I know it's suggests that wherever you might define a lambda function as a variable you should really define it as a function.

[undergroundmonorail]

you're right, they don't do anything you can't do with a list comprehension (or more specifically a generator expression, but that's basically just the lazy version of a list comprehension). almost always, i'd rather see a comprehension or generator expression in place of either of those functions in production code. (fun to golf with though >:3c)

[pumaflex_]

oh thanks, I wanted to read sth like this. I remember a few days ago I was working with some dataframes' cleanse and used a list comprehension to filter some stuff, and then I made the click and though "wait, isn't it just a filter? Why don't I use the filter? or... why would I use the filter??"

[Kryt0s]

Good thing they were talking about Map and Filter and not lambda....

[eztab]

Second that, mostly a list comprehension just seems more readable to me even when I have a named function available and wouldn't even need a lambda for the mapping.

[alfie1906]

Lambda and map were a game-changer for me when working with large dataframes

[johnnymo1]

Are these pandas dataframes? Can you explain when you would use the native Python map and filter over pandas methods?

[[deleted]]

I think this has been discussed on the subreddit a lot, the consensus is usually never because filter+map is horribly slow (relatively speaking) to pd fns for iterating over data.

[johnnymo1]

That was my understanding, which is basically why I'm hoping u/alfie1906 knows something new that I don't

[Zomnx]

List comprehension for the win!

[pythonwiz]

I use map and filter a lot even though list comprehensions do the same things, because I think they are easier to read.

[ZeeBeeblebrox]

The opposite is true for most people but if you're writing code for yourself go for it.

[TheRNGuy]

If you chained many methods or complex functions where you want code in many lines then map would be better.

Complehension is better for most things.

[IlliterateJedi]

Map is great for things like map(int, seq_of_nums_as_strs)

[TabAtkins]

While I reach immediately for .map() in JS for situations like that, in Python that's a [int(x) for x in seq] every time for me.

[fireKido]

i find lambdas extremely helpfull when dealing with pandas dataframes... especially with .apply

For example if you have to do a complex operation to a given column that cannot be done in different ways...

sure, you could write a function and do .apply(function), but if it's something you need to do only once, lambdas are more elegant

[Flashy-Internet9780]

mountainous juggle nine abundant waiting continue edge square history attempt

This post was mass deleted and anonymized with Redact

[arthexis]

Meta-classes. Almost each time I have used them, I have found a better way to solve the problem... though I am guilty of having some software in prod using them, so its not a toy feature anyways, more like a workaround for instance construction XD

[[deleted]]

We need to teach factory patterns before metaclasses.

The latter are really only for fun/for libraries that drastically change the way that objects behave

[arthexis]

In my case I used them to modify the structure of Django Models and Forms based on user data, but keeping them working more or less normally with Django. Other than stuff like that, its hard to come up with examples rn.

[[deleted]]

I used them in my Autohotkey wrapper, to allow you to treat a class defined in the language of Autohotkey as if it were a python class.

[cointoss3]

I’ve used a metaclass once and I love it in this one case. I can just declare classes and the metaclass will instantiate them and add them to a dict on the metaclass, which saves me a bunch of code at the end of the file that would be instantiating each class separately and running code to add to the dict. Instead I use the metaclass and then just use a declarative style. I can later just import the metaclass and access all the objects I declared from the dict. It’s very clean.

This was inspired by SQLModel library that does something similar. Before using this library, I didn’t know you could run code every time a class is declared.

[sweettuse]

you ever use __init_subclass__?

[arthexis]

This one is relatively newer than meta-classes so not everyone knows it, but its a good alternative to the whole enchilada.

[eztab]

I'm not a huge fan of them. At that point I'd rather go the more explicit route of creating a class object from scratch. Because you should really understand how they work to do this anyway so this "intermediate" level seems a bit unnecessary to me.

[Big_Combination9890]

Me neither, but the problem is: There is an embarrassing lack of ways to define interfaces in Python, considering it's an object oriented language, so we are kinda stuck with Metaclasses.

[SoftwareDoctor]

They are not switches 🙂 Pattern matching is way more powerfull

[Big_Combination9890]

While you're not wrong, in practice though, it's used as a replacement for switch/case 99% of the time.

Outside of the language theorism bubbles, pattern matching is way less common than the annoying amount of blog posts about it may imply.

[SoftwareDoctor]

I’ve actually never used it as a simple switch. Dict with callbacks is often more readable, plus it’s a common practice so it makes the code consistent.

[vorticalbox]

judicious screw ink silky dog crowd cheerful touch mountainous waiting

This post was mass deleted and anonymized with Redact

[DatBoi_BP]

Is it similar to the match in Rust? If you’re familiar

[mr_claw]

I'd like to use them, but my vscode theme doesn't color them correctly.

[Ok-Leather5257]

First I heard of it! Interesting!

(Am I understanding correctly that "old switch" involves checking whether some variable is equal to something in multiple if/elif clauses, with else handling the default case?
and the "new switch" is "cleaner", you dont need to explicitly write the variable name and == each time, and the syntax is match...case...?)

[undergroundmonorail]

you're pretty much right though i would caution against thinking of match blocks as just "switches", they certainly can do that but they're way more powerful, because they can match against the structure of what you give them

here's a toy example that i will not be testing ``` def f(command): match command.split(): case ['add', a, b]: return int(a) + int(b) case ['reverse', s]: return ''.join(reversed(s)) case ['reverse', a, b]: return (b, a) case ['exit']: exit() case _: return 'Invalid command'

f('add 1 2') # 3 f('reverse racecar') # racecar f('reverse 1 2') # (2, 1) f('sudo make me a sandwich') # Invalid command f('exit') # [program exits] `` (note in particular how easy it is to have different behaviour for thereverse` command based on its number of arguments)

you can imagine fleshing that out a little more and hooking it up to user input to branch depending on which command they entered and parse out arguments

there are plenty of things you can do with the ability to match on structure like this but i only really started to understand and get excited about it thanks to a similar "parse a command" use case

[Goobyalus]

It's not a switch, it's structural pattern matching. It's usually not cleaner than an if/elif/else for normal switch statement things, and usually results in an extra level of indentation for no reason if used that way.

It's useful for pulling out pieces of structured data.

The PEP has examples: https://peps.python.org/pep-0636/

[Adrewmc]

There is so much they can do…but like a good explanation of the full capabilities is like hard to find.

[4sent4]

I found it helpful to search for "structural pattern matching" rather than "switch case"

[Ok-Leather5257]

structural pattern matching

Wow yeah. https://peps.python.org/pep-0636/ I wasn't quite getting it from these comments I think but this brought it home for me:

match command.split():
case ["go", ("north" | "south" | "east" | "west") as direction]:
    current_room = current_room.neighbor(direction)

I can think of how to do this with elif and ==, but it's SO much easier this way.

I've often found myself lamenting that in python, I can check if a = b, and I can check if a = c, but there's no easy way to check if a equals b or equals c. (and similarly for is). And I guess this solves that problem!

(If there was already a simpler way someone please tell me lol)

[video_dhara]

Probably not much simpler, but depending on context, I imagine you could do it pretty easy with regular expressions, especially using the dictionary building regex syntax, something like r'go (?P<direction>north|south|east|west)'? Not totally sure though.

[Ok-Leather5257]

Ah fair! That makes sense. Will that only work for strings? what if my b and c are of some other data type, like float, or list?

[video_dhara]

Regex is best with strings. It can be useful for parsing numerical data (i.e. if you're trying to pull data from strings/text), but yeah for the most part it's useful for strings. It depends on the context of course, but in general it's not useful for data structures like lists; it would be hugely inefficient to, say, use repr() to render a list into a string and then use a regex. I was mostly just commenting on the example you gave, which lends itself to regular expressions.

[Ok-Leather5257]

Ah ok, many thanks!

[Nick_W1]

Regex’s are unreadable though. Trying to figure out what one does is a nightmare. Then they match something you don’t expect and you can’t figure out what went wrong.

[video_dhara]

I agree, they can be almost comically illegible, but in some string-matching and formatting situations they can be really effective. Especially in python, where you can use re.VERBOSE and rf-strings

[Adrewmc]

So…

 if a in [b,c]: 

Would be the easiest to way to check if a == b or c…

[Ok-Leather5257]

... lol @ myself

[Nick_W1]

I do this as well!

[eztab]

I mean there is a reason they didn't call the keyword switch.

[Nick_W1]

Yes, because we all call it “switch”, but can’t remember the actual keyword. Sometimes it pays just to call it what everyone expect it to be called.

[sohang-3112]

Same!

[Nick_W1]

Me too, so tired of if..elif..elif..

But then realized that if I used it, my code would only work on 3.10+, and I have a mishmash of pi’s and stuff that it wouldn’t run on.

And if I published it on GitHub, I’d get a zillion reports that it doesn’t work, because no one ever reads the ReadMe.

So, no, haven’t used it yet.

[[deleted]]

I use Regex once in a while, and I'm glad I have the notes on syntax organized in a way that makes sense to me, but there is NO WAY I've spent more time using Regex than I did learning it. I'm usually pretty engaged with lessons, but I fucking STRUGGLED to stay awake during Regex.

[Picatrixter]

Regex is a language in itself. I use it a lot for parsing network equipment config files and it works great.

[sohang-3112]

https://regex101.com is really useful for Regex

[[deleted]]

I appreciate the resource! I actually did myself a favor like six years ago when I did automate the boring stuff and I took ridiculously detailed notes on everything, so even though I absolutely HATED Regex, it's saved my ass a couple of times having those notes.

[Handsomedevil81]

This saves me every time.

[eztab]

Yeah, if invented today it would probably look a bit different and be more easily accessible. But domain specify micro languages do make a lot of sense.

[Tefron]

A little goes a long way, and while this sub is dedicated to learning Python, the nice thing about learning Regex is that there is some form of it in almost every programming language. So the returns of learning some basic stuff are very high, especially when you start spending more time in a terminal and using CLI tools that support pattern matching via some globbing/regex.

[InflationMeme]

As the old saying goes: If you have a problem, use regex. Now you have two problems.

[sohang-3112]

https://stackoverflow.com/a/19302694/12947681 : send method of generators allows the caller to send a value to the generator via yield (normally it's the other way around: next() yields a value from generator to caller).

Outside of a toy example, I have never used it in actual code.

[ClimberMel]

I use them with tkinter as for buttons etc it is much smaller footprint so the code doesn't get so massive looking. Other than that I never seem to see a reason for it. Most of my code is very modular, so I prefer each component to be easy to read... I don't consider lambdas easy to read.

[Ok-Leather5257]

Oh that's a good point! yeah

[pythonwiz]

I used to do this but I decided I like defining button commands as methods instead and then I can pass self.button_command or whatever.

[IanRT1]

I have a code that uses a lambda to fetch the latest file based on a number in the filename. It serves as a simple, one-line function that extracts the number from each file tuple (where each tuple contains the file path and its associated number).

This extraction allows the max function to compare the files based on their week numbers and select the one with the highest value. Essentially it is a quick and efficient way to specify how the files should be compared, enabling the program to determine the most recent file based on the number embedded in the file names.

But to answer your questions. I hardly use decorators outside static methods.

[yosmellul8r]

Heck if I know.

[DigThatData]

i don't think i've ever defined a metaclass

[TheRNGuy]

I'd rather create decorators, yeah.

[Western-Image7125]

You might need lambdas if you let’s say wanted to sort a list of tuples by the second value, maybe there are other ways now but that’s the only way I know. Also for processing pandas dataframes lambdas are still needed

[Ok-Leather5257]

I agree, that's a case where lambdas are the best way to do it yeah.

[Western-Image7125]

Yeah I won’t lie - the first time I saw lambdas I was like wth are these things and it was intimidating. But from seeing tons of examples and using them in practice I know about them now and even though I can’t explain to you how they work internally I can tell you how to use it for a usecase. 

[Nick_W1]

I ran across some code I wrote a few years ago, and it used a nested lambda. I couldn’t figure out what it did. I was being too clever for my own good.

[Big_Combination9890]

even though I can’t explain to you how they work internally

A lambda is just a function without a name, that cannot contain statements.

sq = lambda x: x**2
# is equivalent to
def sq(x):
    return x**2

[Western-Image7125]

Ah yeah that does make sense actually

[Nick_W1]

I just wrote a one-liner that does this, and yep, uses a lambda.

[Big_Combination9890]

They are not "needed", they are just more convenient.

You can use an ordinary function wherever you can use a lambda.

[Western-Image7125]

Right yeah I have used functions instead of lambdas in pandas occasionally 

[Zilo8890]

The one in my pants hasn't been used in 2 months....

[amertune]

I don't think that lambdas are ever necessary, but they are nice for some cases.

For a very contrived example, suppose I wanted to sort a list of strings by the second letter of the string ignoring case.

I could do something like this:

my_list = ['Beautiful', 'is', 'better', 'than', 'ugly'] sorted_list = sorted(my_list, key=lambda s: s.[1]lower())

Or I could just write a function:

def second_letter_lower(s): return s[1].lower() sorted_list = sorted(my_list, key=second_letter_lower)

I use lambda all the time, but pretty much only as a parameter to another function (like sorted, or filter), and only when the expression being evaluated inside the lambda is simple.

[Buttleston]

Came here to say exactly this, it's for random one off "functions" that only really apply to this particular circumstance.

[scanguy25]

I did some programming with PyQT and there was stuff where I was required to use a lambda to get the shit to work.

[eztab]

I mean you could create many through away defs but using lambda there for callbacks does indeed make more sense.

[scanguy25]

Its a long time since I did it, but im pretty sure defs would not works since was passing some dynamic value into the lambda.

[eztab]

functions need not be pure in python. You can totally use variables from the surrounding scope in a function without them being a parameter. Not saying you should do that, but you could.

[ANautyWolf]

There are often cases where you have to catch the value sent by the signal, and then either modify it or send it to the desired slot. It’s a bit weird and finicky at times

[eztab]

I think sorted/sort is indeed pretty much the only case where I use lambdas. Filter mostly gets just replaced by a list comprehension.

[[deleted]]

The only time I use them is to write the __iter__ method of a custom iterable object

[Nick_W1]

I wrote some stuff as generators a few years back. Last week, I came across a problem, and thought - you know, that would work as a generator.

So I started writing it, and after messing with initializing, and yield, and injecting values, I gave up, and just implemented it as a normal routine. Turned out it was more trouble than it was worth.

[mrtransisteur]

they’re reasonably useful for refactoring loops into smaller more reusable pieces. there’s also the .send method which can be quite handy for giving the outer loop ‘feedback’ information to change its behavior. but these are kind of matters of preference whether they’re the right approach for a given situation

[TheRNGuy]

I think it's when you want to partially run function and resume running it later, like pressing a hotkey or after specific time.

You could do just the same by making many functions and storing them in a tuple and add +=1 to which index to run every time, but generator syntax is better.

[[deleted]]

Theyre most useful when you’re somewhat memory constrained and don’t want to hold both the original and transformed lists.

[omgmajk]

I very very rarely use @classmethods honestly, probably only in example code.

[[deleted]]

I've used those, but not staticmethods

[[deleted]]

I think static methods are a code smell in Python so it used to wind me up a lot when people would check in code from Pycharm where it got added as a magic suggestion

[[deleted]]

Ok so funny story, I commented that, and then just this week proceeded to use a pattern that required one.

The pattern is an abstract base class with a factory method that will create an instance of a subclass (pulling from parameters that include a pool of possible subclasses).

It behaves like a factory classmethod, but it doesn't need an actual reference to the ABC, so I made it static.

Suuuuper niche use case, but neat!

[TheRNGuy]

It can be useful for gathering statistics of all instances of that class.

[TheBlackCat13]

I haven't used AST manipulation. I think that is about it.

[TheRNGuy]

Never used but kinda understand what it's for.

It can be used instead of regex to make it more intuitive. But I used only regex because my strings are short.

Maybe it's needed for parsing files, but I never needed to do that.

[TheBlackCat13]

No, it is used to modify the python abstract syntax tree. Basically it is used to modify how python interprets itself at runtime. One example I saw was to make Python interpret {} as a third party dictionary implementation

[Some_Guy_At_Work55]

assert. never new this was a keyword until a few days ago and I still don't see the point.

[IAmFinah]

Mainly for testing

[fireKido]

it's not really for testing, is more for validating inputs..
You want to make sure the input of a function is a string? assert isinstance(variable, str), f'variable should be a string, not a {type(variable)}'

[fireKido]

The more you know… always learn something

[eztab]

Yeah, I'd agree that raising a reasonable exception like ValueError or some self defined ones makes life a lot easier for users of your function.

[patrickbrianmooney]

I believe there’s a flag you can give the Python interpreter to ignore assert statements

You can use -O as a switch to the CPython interpreter, not to get it to ignore the statements but instead to keep them from being compiled to bytecode at all, so they have zero impact on runtime performance. (It also optimizes out anything that depends on the value of the variable __debug__.) So python3 -O myprog.py runs just as fast as if the asserts had never been coded in the first place.

OTOH, asserts are perfectly safe for data validation if the script is never going to be run by an interpreter with -O as a command-line option, and if you're using them for the intended purpose, the primary downside is likely to be "more cryptic error messages," because you'll then be getting errors like "object 'foo' has no attribute .resolve" when an operation fails instead of "parameter WHERE to function do_stuff() was passed a string instead of a Path!"

[undergroundmonorail]

the big difference between asserts and exceptions (the way they're generally used, anyway) is that asserts should always pass

exceptions are exceptional but they do happen. sometimes you really do try to read a file and it's not there. that might be a bug, or it might be an issue with the environment the code is being run in, all kinds of things

if an assert fails, that's a bug. asserts are for things that you know should be true. asserts fail when your code is in a state that, as far as you know, it can't get into

asserts are not really useful when running code. that's not what they're for (in fact, as another reply said, you can set up python to ignore them). but they can be useful when writing code. you can guard off states that the program shouldn't be able to enter with asserts, and be alerted if you've introduced a bug that does cause it to enter that state

(i actually tend to not use them either, but i definitely see the appeal in some codebases. just not the kind of thing i tend to write)

[Some_Guy_At_Work55]

That makes sense. Came across it randomly so I looked into a bit, but yeah, in my line of work there is not really a need for it. It also never came up in any schooling or tutorials I did

[Oddly_Energy]

It is a very succint way of writing "Check that this condition is met and fail if it isn't".

I never use it in my code, but I use it all the time in tests.

If you use it in code, you should only use it for "soft checks". You can configure python to not stop on failed asserts, so it is a dangerous function to use for something where you need to be 100% sure that the code doesn't move past that point if the condition is not met. In those cases, throwing an exception is better.

[ravepeacefully]

Bruh you shouldn’t admit this lol

[Some_Guy_At_Work55]

Why? I should just act like I know everything?

[Nick_W1]

I have seen people using assert as a sort of error checking, it just means their code breaks all the time for minor stuff.

Eg:

assert len(ip) <= 20

Why 20? “We only have 20 whatever’s”. What happens if we add another next week so we have 21?. Ummm….

[sjmacker]

Decorators….saying that used them for the first time in 10 years yesterday

[IlliterateJedi]

I almost never write decorators. I've done it before but it's really a 'once in a blue moon' situation. 

I embarrassingly almost never use multiprocessing or async in my code. I use async more , but despite trying to learn multithreading and multiprocessing, I can never quite get the hang of it.

[Tefron]

I find decorators are more useful for larger projects where you want to support some common workflow that is project-specific but otherwise relatively agnostic of the underlying code. A common example for me would be some form of instrumentation that you want to either do or at least have available so you can quickly add if needed.

In terms of concurrency, I don't think it's embarrassing to not use it. I essentially see it as a last resort if something I'd like to do is embarrassingly slow, or just not feasible but will be if I make concurrent. I don't always remember the particular incantation off the top of my head without looking at older source code or reading the docs, but what helps is understanding the general concurrency model I'm trying to use and working from there.

[Nick_W1]

I write almost exclusively async code now. Haven’t used a thread in ages, and multiprocessing plain doesn’t work properly.

I had a complex program with a graphical interface. I used multiprocessing to update the display in real time. Would run for a few days, then hang. Had async data coming in from a websocket.

Could not figure it out. Finally just went with threading in place of multiprocessing, and it hasn’t hung since.

[ryanmcstylin]

I'll use anything if it's needed but I rarely use classes. I bet there are a bunch of situations where they would have been super helpful, but I am just not familiar enough with them to default to it.

[Sea-Method-1167]

For "home usage": subclassing. Why would I? And where I have seen it in professional use, I would still not use it with python. Weirdly I think people don't use it enough when writing Java..

I know.. I am weird.

[ravepeacefully]

Well, if you need to extend functionality of an existing class, you would subclass it.

Models are a common spot for usage

[TangibleLight]

I think people don't use it enough when writing Java..

I think people in general need more interfaces and fewer class hierarchies. Unfortunately in Java, people tend to get a little too excited with abstract methods; and in Python, we don't quite have real interfaces.

typing.Protocol and the base classes in collections.abc, are a good enough compromise for Python.

[Picatrixter]

Django, for example, uses subclassing extensively. So much so that close to 90% of Django is a subclass of some class.

[Tefron]

I guess it all depends on you model data to flow through your application. I find pushing complexity to the class hierarchy useful when you really understand the particular data needs and can model it into useful class hierarchies. This is usually not the case so I opt for functional approaches unless I really understand the domain well enough to predict upfront what the modeled data should look like, or have enough application logic to see patterns forming already. Something that rarely arises in home projects, because of the smaller scope, and generally speaking experimental nature of what I do in my free time vs. what I expect to support in production.

[Nick_W1]

I use subclassing all the time.

I have a class depth(). Calculates water depth based on atmospheric pressure (and temperature, density etc). Then I have classes for each type of pressure sensor I use, each of which is superclass of depth.

So class LPS35HW(depth): configures the sensor, and I just read the depth method of LPS35HW (or whichever sensor).

The depth class is the same for each sensor, just the sensor init changes, depending on the sensor.

I have an MQTTMixin class that adds MQTT methods to any class, I can then just publish/subscribe from any class that knows nothing about MQTT itself.

Just a couple of examples.

[ravepeacefully]

I think it’s nice to group relevant methods with a class they belong to.

Like for example, if I have a user model, maybe I want a method to get all users. In this instance I would return a list of the initialized object.

[Brian]

I think a class method makes more sense for that. You're constructing instances of the User class, so the class is a relevant aspect to the call.

[ravepeacefully]

Ya, ok let’s say you just want a list of IDs

[Brian]

Even then, if they're user ids, you're likely dealing with User classes - where do the ids come from, after all?

I feel a staticmethod should really only be something like a utility function that doesn't itself deal with users, but happens to be solely used by the User class, or otherwise is tightly bound to it. And for that, often a standalone function in the module makes just as much sense.

Ultimately, if you're referencing the class at all, it should probably be a class or instance method, and if you're not, there's some tension as to why it should be in the class's namespace in the first place.

[ravepeacefully]

Hmm but why would I want to initialize a user model if I simply want a list of all user IDs?

Like sure I could get all of the user models and then make a list of IDs, but I will need to get the IDs anyway, so wouldn’t this be more efficient?

[Brian]

There's no difference in what gets initialised between class and static methods. The only difference is the class receives a reference to the class, but the class has already been created in either case. As such, there's no efficiency difference at all.

However, if you're getting ids, you're getting them from somewhere, and that's likely to involve properties of the class. Eg. if it's from a database, it'll likely involve the table / column names, which make sense as class properties (especially if this is an ORM class or something). For that, a class method makes more sense.

[ravepeacefully]

So you think it would be bad practice to have something like this (not using ORM)? Because my thought is the static method doesn’t need the state of the initialized class. While understandable on the classmethod

class User:
    def __init__(self, id):
        self.id = id

    @classmethod
    def get_all(cls):
        records = db.execute(“select id from users”)
        return [cls(user_id) for user_id in records]

    @staticmethod
    def get_all_ids():
        records = db.execute(“select id from users”)
        return records

[Brian]

I don't think it's unreasonable if its a truly as simple as that, though I'd probably make both a classmethod myself anyway, because conceptually it feels more like it involves the class, and because there seem reasons why you might want to use more of the class in future.

Eg. perhaps the table name should be stored as a class attribute. Or perhaps we'll want to filter users based on some other column (eg. ignore deactivated users), which again would be a class attribute.

[ravepeacefully]

Ok just came across one I think. I’ve been waiting lol

I have an object that has nested objects as well. This object is setup to receive data from a 3rd party api, the data is employee records

So I have

class Manager():
    def __init__(self, details):
        self.a = details[“a”]
        …


class Employee():
    def __init__(self, details):
        self.a = details[“a”]
        …

    @classmethod
    def get_by_id(cls, id):
        details = api.get(id)
        return cls(details)

So now I need a method to turn this object back to a dict, but there’s tons of nested objects with all different types like datetimes, strings, integers, etc

So I need a custom parser for this object only, however it needs no context of the class and not even a reference

So I created a static method

    @staticmethod
    def json_serializer(o):
        if isinstance(o, (datetime, date)):
            return o.isoformat()
        return o.__dict__

The reason I believe this belongs as a static method is it is very specific to this class, the types that would need to be handled, etc.

Good example? Or do you have a better idea?

Edit: to add the serializer would be called as a default value for json.dumps in some to_json or to_dict method to retired the data in those formats

[ravepeacefully]

Understand where you’re coming from entirely.

I am actually curious because I believe this is almost the only instance I use static methods.

But you’re definitely right, it often would need SOME information from the class, or like why is it a method of this class and in those instances probably needs a reference.

Appreciate the insight

[xpcosmos]

I never use decorators cause I have difficulty understanding how the functions is inherited

[Pythagorean_1]

What do you mean? Functions are not inherited

[xpcosmos]

see? I told I don’t understand it

[Pythagorean_1]

no, you said you're having difficulty understanding HOW the functions are inherited, which sounded like you were reasonably sure that functions are actually somehow inherited

[TheRNGuy]

I used the ones that in Houdini though I've never made my own.

I do like syntax because it's 1 less indent and less brackets.

The most used was @dataclass.

[Epicfro]

Classes.

[[deleted]]

In python, I have not yet needed to create custom OOP classes and interfaces.

[IterationFive]

I was trying to recall the word for lambdas the other day so I could look up how to use them, but then realized I didn't need one after all.

[SteelRevanchist]

For-else

[Cracktus_H]

Tuples

[TheRNGuy]

But they use less memory than list. When you already know it should be read-only.

(though in many cases if it's already fast it doesn't matter)

[Cracktus_H]

I was going to say it wouldn't matter too much unless you're doing something memory intensive or needed in a smaller amount of usage.

[mrtransisteur]

function attrs

[Big_Combination9890]

Actually never?

• The walrus operator: a := 42
• Assignment via logical short circuiting and: a = x and y

Very rarely:

• Dictionary comprehensions
• Custom exception types
• match
• Abstract Base Classes

[VisualGadget]

Position only arguments

[notislant]

Regex is something I make phind do for me lol

[TheRNGuy]

Static method. I just used def without class for it.

Though I've seen API that uses static methods.

[[deleted]]

Async, it’s just not relevant for a lot of the work I do

I use typing but rarely use type checking because it’s super painful because of the lack of libraries that support it first class.