Just started as in, I’m about an hour into a 4 hour intro video. Seeing two basic ways of manipulating things and don’t understand the difference.
If I want to know the length of a string and I just guess at how to do it I would try one of these two things,
- Len(string)
- string.len()
What is the difference between these types of statements? How do I think about this to know which one I should expect to work?
Follow up question. Are there any other ways I would find the length? Or are methods and functions the only options?
You could get creative and find several inferior, silly, and utterly insane ways of achieving the same result, for example by treating a string as an interable (read: “list” or “array”) of its constituent characters, and count the number of characters. This feels very “example (but not exemplary) code on the first pages of a crappy C++ textbook”, but hey, it’s a way:
length = 0 string = "foobar" for char in string: length = length + 1 print(length)Mind you, this is not programming. This is toying around, and perfectly valid in that way, but no-one in a halfway sane state of mind would dare suggest doing it this way with Python if you actually care about the result. :)
Clearly you meant:
string = "foobar" length = 0 _ = [length += 1 for _ in string] print(length)Much more readable!
Edit: Damn, doesn’t work, was hoping to make something cursed but you can’t make an assignment during comprehension. Oh well, maybe Python 3.14!
Definitely don’t want the extra complexity. Guess my question is if there is a third type of statement (function, method, ____) or maybe even more. From other replies it doesn’t sound like it.
I would not differentiate needlessly between the terms function and [“dunder”, “instance”, “module”, “class”] method, this isn’t practical at the current point in time, and arguably not pythonic. They are all
callablesand behave very similar for all practical purposes, all quacking like a duck.If you want to deep-dive into the intricacies, there’s technically a bunch of alternative “method types” with slightly differing calling and argument passing conventions. There are class methods, static methods, class properties, and module-scope functions off the top of my head, all very similar, but particularly suitable under specific circumstances.
If I wanted a
Stringutility class, for example, I could have that:class String: @staticmethod def len(string: str) -> int: if not isinstance(string, str): raise TypeError("Cannot determine length of non-string object") return len(string) s = "foobar" assert String.len(s) == 6In Python I generally find static methods hardly as relevant as in other languages, and tend to create utility modules instead, with plain functions and maybe dataclasses for complex arguments or return values, which can then be imported and called pretty much the same way as a static method, but without the extra organisational class layer. I’d argue that’s very much a matter of taste, and how much of a purebred OOP jockey you are, for better or worse.
Class properties are cool, however, you might want to look into that. It’s getters/setters on crack, masquerading as their respective property, so that something like this “just works”:
s = MyString("foobar") assert s.len == 6There are definitely ways, IIRC str.len() is a function, but the double underscores basically mean “please don’t call this directly”. There might be other “hidden” variables tracking it, and if you wanted you could add a .length method to the string class at runtime
The beauty of python is it’s pretty consistent in giving you one correct way to do things with the language, it will let you shoot yourself in the foot if you want to though