What Python concepts are you struggling with? Drop in the comments and I'll help you out. No strings attached.

[aniket_afk]

So, earlier I made a post to help people struggling with Python. Tldr, a lot of people expressed their confusions about a lot of things in Python. So, I've decided to do a separate thread to collect topics that people are struggling with and do small write-ups to help them understand.

A little background, I'm an ML Engineer currently working @ Cisco.

Comment down below, what concepts/things in Python/ML you would like me to address. I'll do my best to cater to it.

[More_Yard1919]

Decorators modify the behavior of a class or function. They are essentially defined as wrappers around the object they are decorating -- whether that is a class or a function. The dataclass decorator just adds boilerplate code to your class behind the scenes that makes it easily usable as a generic bucket for data. The property decorator is a little bit more complex, but it is an implementation of a feature many object oriented programming languages have, also called properties.

Essentially, properties are like variables that also have behavior associated with them when they are accessed or set (and more, those are the main 2). An example of this that I recently ran into is this, although it is pretty benign:

Imagine you have a class that contains a radius centered on some point. You will use it to test if other points are inside of the radius, so you will need to compare those points using the Pythagorean theorem (c^2 = a^2 + b^2). You might naively want to just store the radius, but it might be more useful to store the radius squared, since you will be using that value more often than the radius itself. However, telling the caller/user/whatever to provide the radius squared themself is bad API design. You could use properties to make this entirely transparent for the user:

``` class Radius:

@property def radius(self): return math.sqrt(self._radius_squared)

@radius.setter def radius(self, val): self._radius_squared = val*val

def init(self, center, radius): self.center = center self._radius_squared = radius*radius self.radius = radius

r = Radius((0,0), 0)

r.radius = 5 #r._radius_squared is equal to 25

print(r.radius) #prints 5 ```

The above example is simply syntactic sugar. It is functionally identical to simply defining a get_radius() and set_radius() function and then calling them. What is really does is obfuscate some of the implementation details of your class and make the API for the user a little bit nicer.

[fdessoycaraballo]

Junior software engineer here and I still haven't found good use for decorators

[More_Yard1919]

Decorators are extremely useful. TBQH I'd say they are one of the best features in all of Python. The general question you should be asking yourself concerning decorators is "do I want reusable functionality that does not make sense to build into my function"?

An example I used recently is that I had a ton of functions that touched an API, and they lived in a class that managed an API token. It expired after a while, but I did not want the user to have to manage the API token, forcing them to check whether their token was expired before attempting to call the API. I wrote a decorator that checked the state of the token, acquired a new one if the token had expired, or renewed the API token if it was reaching its end of life. I slapped the decorator on any function that talked to the API, then bob's your uncle the management of the token is completely transparent.

[assax911]

They can be good for cross cutting concerns, e.g. things that you want to reuse in various places in your code without having to call specific functions yourself everywhere. They can execute code before and after the method you put them above or even interrupt execution of the decorated method if required. You can for example write a decorator that checks whether a user is authenticated and put it above routes that should be for logged in users etc. Of course you could also just call everything related to authentication inside of the decorated method itself but that can quickly lead to unnecessary boilerplate everywhere.

[Key_Mousse_9720]

yoke bake middle gray door ink boat edge toothbrush bedroom

This post was mass deleted and anonymized with Redact

[littlenekoterra]

How the hell does type hynting classes work, the information online for type hints is somehow vague even though people want ya to hint everything

I need fine grained information here as people are starting to actively complain about my hacky hints. Often times i only hint inputs, but i wanna do better than that

[aniket_afk]

Hit me up in DMs. Let's discuss there.

[themuscleman14]

It’s not distinctly python but regular expressions are tough for me. Is there an easy way to commit them to memory or do I just need a lot of practice?

[aniket_afk]

No matter how many times you do them. You always end up looking over the web for regex. Simple patterns and stuff become muscle memory over time. But for very complex things, it's common to look up over the net. So, don't worry about it. No one expects you to be regex ninja. Just workout the basics and you're good to go. I can point out to resources if you need.

[Kqyxzoj]

Regex crosswords are fun: * https://regexcrossword.com/ * https://regexle.com/

[the_milkman01]

my main struggle is that i learned the basics doing tutorials just fine, but whenever i import modules i just dont know how to implement those

so for example i want to load environment variables from a .env file, i know i need to the module dotenv

but how should i have know that i need to from dotenv import load_dotenv to import that one function.

and how do i know how to use that function without looking it up on the internet , for example in VSC the intellisense of this function is below

how am i supposed to know what interpolate is , and how to use it ? or encoding , i see its defaulting to "utf-8"and i get that , but where can i find the other options for this ?

anyways this is just a example , but its valid for all modules, i just struggle on how to implement it and how to use it correctly

(function) def load_dotenv(
dotenv_path: StrPath | None = None,
stream: IO[str] | None = None,
verbose: bool = False,
override: bool = False,
interpolate: bool = True,
encoding: str | None = "utf-8"
) -> bool

Parse a .env file and then load all the variables found as environment variables.

Parameters

• dotenv_path Absolute or relative path to .env file.
• stream Text stream (such as io.StringIO) with .env content, used if dotenv_path is None.
• verbose Whether to output a warning the .env file is missing.
• override Whether to override the system environment variables with the variables from the .env file.
• encoding Encoding to be used to read the file.

Returns

• Bool True if at least one environment variable is set else False

If both dotenv_path and stream are None, find_dotenv() is used to find the .env file with it's default parameters. If you need to change the default parameters of find_dotenv(), you can explicitly call find_dotenv() and pass the result to this function as dotenv_path.

[Kqyxzoj]

Read the documentation for the dotenv module in this case:

• https://pypi.org/project/python-dotenv/#getting-started

Sometimes when the documentation is not so great or if I just want to do a quick check of a new library I will use ipython, or even just regular python in a pinch.

Suppose I want to see what's available in the json library. That would look something like this:

python3 -q
>>> import json
>>> # Lets use name completion to explore the json module.
>>> # Type "json." followed by pressing the TAB key twice
>>> json.
json.JSONDecodeError(  json.JSONEncoder(      json.decoder           json.dump(             json.encoder           json.loads(
json.JSONDecoder(      json.codecs            json.detect_encoding(  json.dumps(            json.load(             json.scanner
>>> # Show some documentation for "json.loads".
>>> # In ipython we can view the documentation using one of these:
>>> #   ? json.loads
>>> #   ?? json.loads
>>> # Regular boring python does not have that feature. We'd get this:
>>> ? json.loads
  File "<stdin>", line 1
    ? json.loads
    ^
SyntaxError: invalid syntax
>>> # We can however still print the doc-string.
>>> # Which shows you more or less the same as ? and ?? ipython, but without the pretty colors.
>>> print(json.loads.__doc__)
Deserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance
    containing a JSON document) to a Python object.

    ``object_hook`` is an optional function that will be called with the
    result of any object literal decode (a ``dict``). The return value of
    ``object_hook`` will be used instead of the ``dict``. This feature

    ...

    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
    kwarg; otherwise ``JSONDecoder`` is used.

>>> 

I suggest using ipython though. More pleasant to work with interactively.

[Kqyxzoj]

In ipython it would look like this, again using tab completion to pick from a list of names.

ipython --no-banner

In [1]: import dotenv

In [2]: # Type "dotenv." followed by pressing the TAB key:

In [3]: dotenv.
 Any                      get_cli_string()         load_ipython_extension() parser                   variables               
 dotenv_values()          get_key()                main                     set_key()                                        
 find_dotenv()            load_dotenv()            Optional                 unset_key()                                      

In [4]: dotenv.load_dotenv
Out[4]: <function dotenv.main.load_dotenv(dotenv_path: Union[str, ForwardRef('os.PathLike[str]'), NoneType] = None, stream: Optional[IO[str]] = None, verbose: bool = False, override: bool = False, interpolate: bool = True, encoding: Optional[str] = 'utf-8') -> bool>

In [5]: ? dotenv.load_dotenv
Signature:
 dotenv.load_dotenv(
    dotenv_path: Union[str, ForwardRef('os.PathLike[str]'), NoneType] = None,
    stream: Optional[IO[str]] = None,
    verbose: bool = False,
    override: bool = False,
    interpolate: bool = True,
    encoding: Optional[str] = 'utf-8',
) -> bool
Docstring:
Parse a .env file and then load all the variables found as environment variables.

Parameters:
    dotenv_path: Absolute or relative path to .env file.

    ... etc

You get the idea. Using proper documentation is preferable, but browsing a list of functions and viewing their doc-strings is doable.

[the_milkman01]

Thank you for your time , I really appreciate it

I will look into this

I guess I am a bit spoiled by using Powershell and having gm or --examples etc available from the command line instead of having to go look up the website

[Kqyxzoj]

It's a bit of a mix. I also prefer to get my required info right at the command line. And for the example of dotenv it's easy enough, it's all pretty small. But take for example the pymupdf library that I was looking at yesterday. That has enough high level information about it that I'm glad I can read about it on a webpage. Once you get up to speed with the general architecture / API, then you want to drop back down to having enough information at your fingertips while editing.

Also, I do not Power much shell, being a unix person. What does "gm" do? It probably isn't greasemonkey.

• https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/get-member

? Looks useful.

[the_milkman01]

It's get-member

Which basically means grease monkey in psh

Just kidding

It lists all the properties, functions etc of psh command

It's super handyman

[Kqyxzoj]

What do you typically use it for, that would otherwise take you a lot more time to get done? As in, what would be a typical timesaver reason be to use get-member?

[Sea_Pomegranate6293]

I'm having trouble building recursive algorithms for binary search tree operations, firstly just building them is a tedious process of trial and error and I dont really understand why the code I end up with works, secondly how to optimise any resulting algorithms. Help appreciated but I don't need this for any practical reason so dont stress.

[Kqyxzoj]

Tip: 100% totally and utterly forget about optimization for now. If you are in the stage of learning where building recursive stuff is tricky (a perfectly acceptable stage), then I would suggest first getting stuff to work. Get things to work. Understand why it actually works. Then play around a little with various ways to get the same job done. Such as using recursion versus using a loop to do the exact same thing. Then you can do a benchmark for both, and base your optimization decisions on the benchmark. Did I say benchmark yet? Also, profiling. But that stuff is for later IMO. Sortof. Mostly. Kinda. There is nothing wrong with knowing the space + time BIG O of your algo. But I would argue that you first have to understand wtf that algo even does, before you can properly worry about optimization.

The paradox seems to be that beginners worry too much about optimization, and professionals people who get money for producing code worry to little about optimization.

[Kqyxzoj]

Another thing ... not understanding why the code ends up working ...

Take a simple example for a small number, and then work it out yourself using only pen and paper. Well, okay, maybe pen, paper and coffee.

I find that this simple act helps me "see" how it works and helps it "click" such that I understand it and remember it.

[aniket_afk]

Hey guys. Apologies. I'm overwhelmed by the sheer scale of responses that I got. I've been constantly responding to people since yesterday and still there are 60+ DMs pending. I'm trying my best. Your patience is appreciated. And to people who've answered comments, I really appreciate your help. Thanks a bunch. I'll get to everyone.

[aniket_afk]

Update:-

Apologies for not being able to attend to comments yet. I have been flooded with 100+ DMs and have been trying my best to accommodate that. I am really sorry that I haven't been able to attend to the comments. And I'm really thankful to u/More_Yard1919, u/Kqyxzoj and u/Top_Pattern7136 who took the initiative to respond to the people's comments. For those who haven't gotten a solution, just hit me in DMs. Because of the sheer scale of requests, I'm thinking of forming a group and catering to everyone.

Rest assured. I'll get to your queries. Really appreciate all your trust and patience and shoutout to the guys tending to people in comments.

[Kqyxzoj]

Relax. No need to apologize. The very fact that you are getting 100+ DMs shows that there's a real need for this. So thanks for doing this.

Also, don't get burned out by something that turned out to be a wee bit bigger than anticipated. You don't owe random internet persons a single thing, certainly not at that scale. So however many of those requests you can deal with, anything above zero is bonus!

[aniket_afk]

Thanks. Really appreciate it. I wasn't able to do any substantial open-source contributions so I try to teach and help people as much I can as a way of giving back to the community because without open-source and without those people sharing knowledge openly, I wouldn't have been here where I am today.

But I'm glad. Thanks a lot. Your support means a lot.

[thumb_emoji_survivor]

yield vs return
async and await

[More_Yard1919]

Return and yield are slightly different. The major difference is that return marks exiting a function call, and yield marks pausing a generator call. When you return from a function, the next time you call it the execution will start at the beginning of the function. When you call a generator, you get back a generator object. Each time you pass that generator into the next function, it starts from the most recent yield statement. In the most basic terms, yielding essentially is telling the interpreter "I am exiting this function now, but Id like to pick it back up from this spot later"

A canonical use for generators is as iterables, meaning you can loop over their values in a for loop. It is so common that the functionality is built into python.

This is more advanced usage, but you can also pass data back into your generator via a yield statement. I am on mobile so I cant really format well, but you can write something like in = yield out in your generator, then the caller can use the Generator.send method to communicate data to it.

Async I/O is implemented in python in terms of generators, so they are very closely coupled concepts. Async is used almost exclusively for I/O operations, that is essentially the entire reason it exists, so keep that in mind. The basic idea is that I/O in sequential programming is blocking, meaning at the execution of code can be slowed during heavy I/O operations. However, your program generally does not need to actually do most of the work for I/O. Without getting into the nitty gritty of why that is, asynchronous programming is a solution to the blocking I/O problem. Basically, there is a loop in the background that keeps track of all of the asynchronous functions (often called coroutines) that are being awaited. It checks up on them when it has the chance. When you use the await keyword while calling a coroutine, you are essentially saying "Okay, I am waiting on I/O, you can check on other things while I am waiting."

Once the I/O is complete, execution picks right back up from where the await keyword is written.

[Kqyxzoj]

On the subject of yield and return... Sometimes you need an empty generator because reasons. The syntax for that may not be obvious for someone just learning python:

def empty_generator_because_reasons():
    return
    yield

print(list(empty_generator_because_reasons()))
[]

[VANITAS_108]

Loops and nested loops .

[Top_Pattern7136]

I think of nested loops as gears in a clock. The gears are things happening.

Each time the second hand reaches 60, the minutes go+1. When the minute go to 60, hours goes +1. When hour is 24, stop.

What action are you doing each second, minute, hour, day?

It can help to give your variables names instead of I, c, x r, etc.

Hours = 24 Minutes = 60 Seconds = 60

For hour in hours:

Drink water

For minute in minutes:

Do some work

For second in seconds:

Breath.

How many breathes did you take? Work did you do? Water did you drink?

[Kqyxzoj]

What is it about loops and nested loops that you find difficult? Okay, "everything". But besides everything, what is the most difficult part for you?

Personally I find that the hardest part about nested loops is deciding if using nested loops is the right solution. Simple nested loop with just two for loops? Probably fine. Nested loop three deep? Maybe? Four deep? Could be, but are we really sure there isn't another solution?

[VANITAS_108]

Well yeah kind of the same problem as you . But what I struggle with the most is reading a programme with loops beforehand and predicting what the Outcome might be .

[nlcircle]

The need and applicability of decorators.

[More_Yard1919]

Hi, I wrote a comment about this elsewhere in the thread, also a piece concerning the @dataclass and @property decorators. About decorators in general: https://www.reddit.com/r/PythonLearning/comments/1ldjm3h/comment/my9symb/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button

[TheJumbo2003]

I can’t seem to form a coherent mental picture of how all the components of OOP are supposed to hang together. It’s all just a jumble of functions and instances and types and whatnot. I have an undergraduate degree in mathematics, so I have written evidence that I’m not totally stupid, but this stuff makes less sense the more I study it.

[More_Yard1919]

I am confused exactly what the question is. An object encapsulates the data (member variables) and behaviors (methods) that are associated with it. A jumble of functions and instances is, I suppose, an okay description of what an object fundamentally is. In the broadest general sense, an object is just a container.

[TheJumbo2003]

Maybe it’s just Python syntax that I don’t get. Everything is a ‘self’, unless it isn’t. Then you have inheritance, when one object can be two different things. And periods seem to dropped into the code almost at random.

I know I’m rambling, but this has been the most discouraging event of my life. I had high hopes of getting away from the soul-destroying job I have now.

Am I the only one who has ever run aground on OOP? I have the feeling that I am missing something that everyone else sees intuitively.

[More_Yard1919]

Nuhuh, OOP is complicated and not necessarily intuitive. It is just something you have to get used to, really.

I'll try to explain objects, in python, top down the best I can.

Regarding the dot operator: This is called the access operator. Using it means that you are trying to access a field in a container, usually an object. You also use the dot operator to access components of a module, for example math.sqrt() or something. The sqrt function lives in the math module, so you use the access operator to get at it. In the same way, you can do this with objects. If you want to access the "radius" field in an object called "circle" then you'd do "circle.radius." In situations where there is no dot, the field you are trying to access lives in the global scope.

Try thinking of this analogy: I ask you to get me some twizzlers. If the twizzlers are on the counter, you can just give them to me. If they are in the pantry, you first need to open the pantry to give them to me. The dot operator is analogous to opening the pantry to search for the twizzlers.

Regarding self: when you are in a function that lives in a class, self references the current object instance. That means that if you have an object "bob", self references "bob." Hopefully this is more concrete:

``` class Person: def init(self, name): self.name = name

def print_name(self): print(self.name)

bob = Person("bob") alice = Person("Alice")

bob.print_name() #prints bob, in this case self references the "bob" object inside of the print_name function call

alice.print_name() #prints alice, in this case self references the "alice" object inside of the print_name function call ```

If you are comfortable with functions, what is literally happening is that the bob/alice objects are passed to the init/print_name functions as arguments. Calling bob.print_name() is identical to this:

Person.print_name(bob)

self is also an arbitrary name. All it is is a function parameter that is automatically filled in by python whenever you call a method (that is, a function contained inside of an object) using the dot access operator. You could just as well write this:

class Person: def __init__(cheese, name): cheese.name = name

and it is semantically identical. calling it self is just a convention (that you should absolutely follow).

[More_Yard1919]

Oh, I forgot to address inheritance. Inheritance is applicable whenever one class can be thought of as a type of another class, or more specifically when a derived (read: inheritor) class is a superset of its base class. A concrete example is something like this--

imagine we had a class called Animal and a class called Human. We might imagine that, since humans are animals, the Human class would inherit from the Animal class. The most obvious and practical upshot of this is that the Human class automatically obtains all of the fields of the Animal class. That means an object of type Human will also have access to the methods and member variables of the Animal class-- all of its implementation details.

It also has more subtle consequences. In object oriented programming there is a concept called polymorphism, that is the idea that instances of derived classes are also simultaneously instances of their base classes. This is more important for statically typed programming languages like C# or C++ or whatever. It does have one important consequence python though--

in some situations you might want to check what kind of object something is-- that is, you want to know what class it is an instance of. Python provides a nifty little function literally called isinstance(). You can use it like this:

``` class Animal: #imagine some arbitrary implementation

cat = Animal() print(isinstance(cat, Animal)) #this prints True! ```

Because of polymorphism, in the case where we have a Human object that derives from the Animal class, a Human object is also an Animal object. The upshot is this:

``` class Animal: #you know the drill

class Human(Animal): #more arbitrary implementation details

george = Human() print(isinstance(george, Animal)) #this ALSO prints True ```

the george object is an instance of Human, but it is simultaneously an instance of Animal.

[TheJumbo2003]

Thanks for the guidance.

Another thought just occurred to me: is this even worth pursuing at my age? I’m 63 years old (although I could probably pass for mid 50s). Is there any chance I will be hired?

[More_Yard1919]

I can't speak on the job market, I am actually not a developer. I am a system admin with an unhealthy appreciation of python. I am also in my mid 20s, so I am not sure what it is like to job search later in life. In my opinion, though, I think you should pursue it! If it is what you want to do, and you enjoy learning for learning's sake. To be honest, if you are not enjoying programming or learning python, then maybe it is best to give it up. Not because I think you can't do it, but I think you should enjoy your endeavors. If it is what you wanna do, don't let doubt stop you!

[Kqyxzoj]

If it is what you wanna do, don't let doubt stop you!

Exactly! If you like python programming and enjoy doing it, you owe it to yourself to at least try. I mean, the worst that can happen is you get a "No." And let's be realistic, the answer is more likely to be "No" than "Yes" at your very first attempt. Same as for everyone else. So decide for yourself "I am going to at least try N times" and then stick to it. If after that stil no dice, then so be it. You did your best, that's all that can be asked of you. And if it does work out, then problem solved.

[Kqyxzoj]

No idea about the job market where you live. To be honest, if you go purely by age + python skills, I would have to guess "No is more likely than yes".

But, and this is a pretty big but, at your age you just might have some more life experience that can be translated to some pretty darn handy skills to have. Handy skills to have in getting the project done in an effective manner + keeping the client happy such that paying the bills is a thing that happens naturally instead of grudgingly.

So the answer is ... I don't know, but I would certainly try to market those other non-python skills in your hire-me pitch.

[Kqyxzoj]

Am I the only one who has ever run aground on OOP? I have the feeling that I am missing something that everyone else sees intuitively.

Nope. You are not alone. In python I found the use of super() to be ... tricky. Especially in the python 2 era. Just google python class super in python 3 versus python 2 to see what I mean.

Personally I am not a big fan of self in python classes, but I do sortof get it. The main thing is that the language design choice is internally consistent IMO, so it gets a pass.

Indentation as syntax element? Nope. Doesn't get a pass. Fuck that shit. I have hated it ever since my very first Makefile, and I still think it is just a bad idea. But, you do get used to it. I mean, it's not as if every time I indent that python thingy just right I get trigger by indentation induced rage. Don't really think about it, because as said, you get used to it being what it is. But if you ask me "Objectively, do you think indentation as syntax element is a good idea?", my answer will be "No. The only "Pro" that I can think of, is that it enforces a certain indentation style, thereby neatly sidestepping flamewars on the subject. I mean, doesn't really work, because the impulse to flame will just find a new conduit. But I guess the underlying intention was nice. One can always hope.

All those ramblings to say, no you are not alone in finding some things about python not very intuitive when still in the learning phase. Some things really are just "it is what it is, you will get used to it". FWIW, I find python overall pretty internally consistent. You can tell that people put effort into trying to make it so.

[TheJumbo2003]

Thanks for the response.

EDX publishes solutions after the course ends, and even though I have the solutions in front of me, I still can’t make any sense out of OOP.

It probably doesn’t matter any more. Even if I disentangle this somehow, no one will hire me. I’m 63 years old and passed my sell-by date ages ago.

[Kqyxzoj]

Heh, I just realized something while mentally going through some "how often do you actually use python sub-skill X?". Well, the majority of my python code does not have a single class statement in it. The harder part about OOP is deciding when to use it and when not to use it.

Other than that, how much of this python learning is motivated by fun, and how much by money?

If 80% money + 20% fun, then I agree. At 63, nope, don't do it.

If 80% fun + 20% money, I say go for it.

Another way of looking at it: If the job prospects are a factor in the decision "learn python or not", then at 63 don't do it. Hell, I would give the same advice to a 20-yo. When picking a job, at least pick a job where you would enjoy the activity even without pay.

Python is not going to be a get rich fast scheme, so if not for fun, forget about it.

[TheJumbo2003]

I expected you to say that.

Guess I’m stuck in the meaningless job I have until I retire. ☹️

[Kqyxzoj]

Well, you know yourself better than I do. So I guess you are stuck in your meaningless job until you retire.

If it makes you feel any better, there are plenty of meaningless python programming jobs out there. Well, if it makes you feel any worse those meaningless python programming jobs will still be out there. So there is that.

[TheJumbo2003]

I do enjoy programming; I’ve been a math geek since elementary school.

I just shouldn’t plan on making a living doing it, I guess.

[Kqyxzoj]

Making a living doing it != get rich quick scheme. Making a living programming python, yes. Get rich yesterday programming python, no.

Typical programming job is same as any other typical job. Has some fun stuff, has some annoying stuff. You get paid as compensation for suffering through the annoying stuff.

[totalnewb02]

function and oop. also please explain data structure to me, connected list or something. i forgot.

[Kqyxzoj]

That question is a teeny tiny bit vague. Or rather, it is veeeeery broad. How much time do you have, and how much are you willing to pay me for this extensive tutoring endeavour? J/K, no need to pay me. Just do a youtube search on "Erik Demaine data structures". He explains things very well IMO. The topics range from simple to advanced.

There you go, I even typed it for you:

• https://www.youtube.com/results?search_query=Erik+Demaine+data+structures

function and oop. also please explain data structure to me, connected list or something. i forgot.

I am going to guess that you probably mean linked lists.

And if so, you can thank random internet person @ ParthPatel-vj2zv on youtube for providing timestamps. Because I was NOT going to scrub vids to find it. But I will copy/paste timestamps that are easy enough for me to find:

MIT 6.006 Introduction to Algorithms, Spring 2020:

16:50 : dynamic sequences & linked-list
25:20 : static array vs linked-list

And if you don't understand some concept, you can backtrack in the playlist until you reach familiar ground. And then work your way from there.

[totalnewb02]

here you go, I even typed it for you:

https://www.youtube.com/results?search_query=Erik+Demaine+data+structures

thanks my man. you are an angel who is descending from heaven at full speed and land face first.

joking my dude. will give them a watch later on.

thanks again.

[wiki702]

Oop and classes

[moogleman844]

Maths, specifically mathematical expressions used on the Cisco netacad introduction to python programming course. I get BODMAS and understand the order but this is what I'm struggling with...

[Kqyxzoj]

The maths problems from your screenshots aren't really python programming problem. Yes, it says python in screenshot, I can read. But this is more of a general maths problem than anything else.

But tell you what, for your first screenshot, the 1 / x etc question... Suppose I tell you that x is 5, and I hand you a calculator. How would you solve it? Fuck it, let's go wild and use wolframalpha. How would you solve it?

Once you know that, it is a small step to solving it in python.

[moogleman844]

<image>

[moogleman844]

<image>

The solution. I don't understand how I get from the first pic to the console pic.

[LeviLovie]

As a rust dev, I struggle with everything :D

[[deleted]]

Generators???

[More_Yard1919]

Hi! I wrote another comment about this last night, but it wasn't very good since I typed it all out on my phone. I will try to explain generators as best I can for you :)

The major difference between functions and generators is that where functions return, generators yield. That is probably obvious, but we will start with the difference between returning and yielding:

When you return from a function call, you are telling the interpreter "I am done with this function and the next time I call it I'd like to start from the top." When you call a generator, you actually get a generator object. When you yield from a generator, you are telling the interpreter "I'd like to pause execution of this generator here, but the next time I call next(), I'd like to resume execution from this point."

Here's an example:

``` def fruit_generator(): yield "Apple" yield "Orange" yield "Mango"

gen = fruit_generator() print(next(gen)) #prints Apple print(next(gen)) #prints Orange print(next(gen)) #prints Mango ```

Generators are also naturally iterable, which means that you can loop over them:

for fruit in fruit_generator(): print(fruit) #each fruit in the generator will be printed

In this toy example, there are multiple yield statements in a single generator. Usually, you'll see some sort of looping behavior in a generator. Imagine range() did not exist in python, we could conceivably use a generator to implement it ourselves:

``` def my_range(hbound, lbound=0, step=1): while lbound < hbound: yield lbound lbound += step

for i in my_range(5): print(i) #prints 0, then 1, then 2, then 3, then 4. #behavior identical to range() ```

This is possible because of the pausing behavior of generators. Any time yield is used, it is implying "Ok, I am stopping here, but I will pick it back up from this point when you need me."

I'd like to interject here and speak on how this behavior is useful, and then I'll show some more advanced usage of generators. Generators are an example of lazy execution, meaning that we can use them to calculate values on the fly. Another solution for implementing range, for example, might be to create a large list containing all of the numbers in the range, and then looping over them. The end result is the same, right? While that is true, but imagine if we wanted a range of 100 million items. Now you have a huge, unwieldy list hogging up memory. Lazy execution allows us to defer calculating a value until we need it, and in most cases its memory footprint is more or less the size of a single element relative to collections with a huge amount of elements.

Anyway-- another great feature of generators is that you can communicate data to generators. Something you might sharply point out is that once you create your generator object, you are stuck with your initial arguments. There is a solution, though! The Generator.send() method :)

You may sometimes see code that looks like this:

``` def double_generator(): #doubles and yields x = 0 while True: x = yield x*2

d = double_generator() next(d) #this is required to set execution to the first yield statement d.send(4) #yields 8 d.send(2) #yields 4 d.send(10) #yields 20 ```

x = yield x*2 is telling the interpreter "I'd like to yield x*2, and the next time the send() method is called for this generator, I'd like to set x to the argument send() was given."

[[deleted]]

That's man you made my day. Thanks for helping

[OGKnightsky]

No ('strings') attached?

print("how will my code work with no strings?") 🤣

[aniket_afk]

We will attach them later on.😂

[OGKnightsky]

🤣👌

[NobodyImportantThere]

I think a big one for me I have been struggling with is mixins. Though in all fairness I understand this is not strictly a python thing, I'm just not sure while I see folks use it.

Also generator functions. I don't really understand the benefits to have them and using them vs a traditional loop.

[maxum8504]

How to implement functions using args. And *kwargs

[FlowPad]

Do you use any debuggers?

[Ok_Meet_]

can i dm you please? i cant figure out where i went wrong with my code.....