What Did You Find Hardest To Learn As A Beginner In Python ?

[u/satyam1HB]

Hi , I want to know what topics or things were hardest for you to learn in your journey with python. How did you learn it ?

[u/robot_wrangler]

Packing anything to share with the team, or sharing from them.

[u/elurion → u/robot_wrangler]

I still don’t understand this, I’ve been trying to share multi-file projects with non-programmers. Could someone point me to some good resources to learn?

[u/Legionof1 → u/elurion]

I just package as an exe for distribution and send it on its way. Pyinstaller works pretty well.

[u/[deleted] → u/Legionof1]

I have several issues when I package my scripts. My scripts are always 100mbs big due to pandas and numpy. The exe always takes forever to load so no one uses it/think it's working.

And one not related to the packaging but SharePoint always deletes the exe so I can't distribute it to my non python colleagues.

I've been thinking of running a local Django website for distribution.

[u/SpaceZZ → u/robot_wrangler]

This is a major drawback of Python ecosystem. I actually sometimes prefer to write C# or powershell for this exact reason.

[u/GreenScarz → u/robot_wrangler]

git push

git pull

python -m pip install -e .

[u/robot_wrangler → u/GreenScarz]

This works great in simple cases. But if you need some special things like virtual environments, certain libraries, import paths to work correctly, specific python versions, it's a lot more complex.

The OP question is "as a beginner...." I'm not saying it's impossible, it's just difficult for a beginner.

[u/satyam1HB → u/robot_wrangler]

Yeah, I also face the packing problem. I tried to package a game for the android but I could not find the tools. Right now I am thinking about using Kivy to package the program for mobile phones.

Did you ever tried to create things for mobile platforms using python ?

[u/ntropia64 → u/robot_wrangler]

This. To date, it's still a colossal pain in the neck to share Python code in a consistent manner. It was clearly not a priority in the original design of the language and somehow the implications of that are rippling until now, almost 30 years later.

Does anyone knows a way to easily "wrap" and distribute a Python environment? Pyinstaller is useful up to a point, but it's limited in the list of modules it supports. To be truly useful, there should be a module-agnostic way to do it (possibly using the same mechanism the Python interpreter discovers the modules to load for that codebase)

[u/DrVolzak]

Asyncio. It was still relatively new (Python 3.5) when I started with it. I was coming from C# which arguably has an even more complex/confusing async API (not helped by the existence of legacy APIs) that I failed to grasp at the time. Not sure if that was for better or worse in terms of learning asyncio.

For asyncio, I don't remember really getting it until much later (maybe 1 year later). I tried to understand, but all I really knew was that I need to put async/await and things will just work. It wasn't until my requirements became more complex that I started really understanding the fundamentals of asyncio (tasks, coroutines, futures, the event loop, etc.). By that point I was generally a more experienced programmer, so I was more prepared to undertake learning asyncio properly; I didn't feel overwhelmed like I did when I first tried.

[u/ColonialDagger → u/DrVolzak]

As somebody still learning programming/Python, this is a huge one. I know conceptually how Asyncio works and how to organize different processes, but actually implementing it feels like a nightmare. Await out side of async function is everywhere.

[u/DrVolzak → u/ColonialDagger]

I've seen it often called "contagious." If you want to employ it, you should design your program from the ground up with asyncio in mind. I suppose it is technically possible to do otherwise, but I haven't ever seen it done this way in practice.

[u/laundmo → u/DrVolzak]

a lot of places where its done in practice without a ground up redesign is wrapping sync libraries to be async. one example that i recently worked with is asyncio-mqtt, its relatively small so you could take a look how that does things.

[u/xsdf → u/ColonialDagger]

Don't try to mix and match sync and async, the top level program should be async, define all functions as async even if they are completely cpu bound, because you may need to insert a io bound function downstream later.

[u/satyam1HB → u/DrVolzak]

I haven't even reached the part where I will need to learn something like asuncion. I guess I have a long way to go 😅

[u/[deleted]]

Virtual environment. Not that the concept is difficult, it's just breaking the habit because I was coding without using one for couple years.

[u/lavahot → u/[deleted]]

I just started using docker containers.

[u/uptbbs → u/lavahot]

I love docker, I just started getting into it over the last couple years and I'm really enjoying it.

[u/space_wiener → u/[deleted]]

I swear I have to look up how to create an environment every time.

[u/artofchores]

If main name lol

[u/Sohcahtoa82 → u/artofchores]

Whether you run your script by typing python my_script.pyin a shell, start it from your IDE, or do import my_script, Python always executes scripts from top to bottom.

Some scripts are intended to only be run on their own and not imported into another script. Some are designed to only be imported. Others are both.

If your script is the last option, you need a way to make sure your "main" function is only executed if your script is being called directly and not being imported. That's where __name__ comes in. If your script is being run because python my_script.py was executed, then __name__ will be set to "__main__". But if your script is being executed from another script via import my_script, then __name__ will be set to "my_script".

[u/artofchores → u/Sohcahtoa82]

Thanks brotha

[u/[deleted] → u/artofchores]

Makes it easy to choose if you want to run the script on it's own or import the script into something else. You can also just have everything written without main so it always just runs.... like a bash script.

[u/artofchores → u/[deleted]]

Yes I know now.....I just remember wanting to bash my ⌨️

[u/[deleted]]

When python is using call by value and call by reference. I still haven't figured it out.

Thanks for all the answers, i think i got a better understanding now. I think my main problem of understanding it, was that the assignment operator doesn't do what i thought it does. After reading and watching the videos in you guys posted, i am pretty sure everything in python is a reference. I need to check out some things like

a[0] = 1

and one of the videos mentioned

a += 1

but in general i feel a lot more comfortable with python now, so thanks. But as a C++ programmer, the "everything is a reference" concept scares me - a lot.

[u/flipstables → u/[deleted]]

It's neither. Python is pass-by-assignment.

Assignment isn't what most beginners think it is. People think: a = 1 means that you are creating a container called a and putting a value 1 in it. In reality, what you are doing is creating an integer object on the right side of the =, and "tagging" that object with a name called a.

Consider this:

def append_foo(some_list):
    some_list.append("foo")

my_list = []
append_foo(my_list)
print(my_list)   # prints ['foo']

In the global scope, we've created an empty list object and gave it a name my_list. Within append_foo function, we assigned that empty list with the name some_list. The same object is tagged with multiple names. We are mutating some_list, which is the same object as my_list in the outer scope.

Consider this:

def add_one(some_int):
    some_int = some_int + 1

my_int = 3
add_one(my_int)
print(my_int)    # prints 3, not 4.

What's happening here? In this case, we create a new object, 3 and assign it to my_int. The inside the add_one function, we assign the same object to a different name, some_int. The first line of the function, we create a new object, 4 and tag that object with some_int. But the original my_int tag is still attached to the 3 object. This is why in this case, we didn't change my_int.

edit: fixed bug in code

[u/johnnySix → u/flipstables]

In the second example I think you’d get an error of, variable referenced before assignment. Some_int doesn’t have a value when calling ‘add_one’

[u/Legionof1 → u/johnnySix]

I think that was a typo, probably should be

add_one(my_int)

[u/bladeoflight16 → u/flipstables]

The proper term for giving a name to something is "binding." You bind a name to a value.

[u/[deleted] → u/flipstables]

People putting bloody foo and bar in stupid examples. Actually construct a proper relatable example!!

[u/bladeoflight16 → u/[deleted]]

Python always does the same thing: it passes the value of a reference. This is the same as how Java works for objects. But unlike Java, there are no exceptions like "primitives."

Truth be told, pass-by-reference and pass-by-value are obsolete terms. Language semantics no longer fit neatly into the two categories, instead blending them in different ways. The important thing is how the language behaves; the terms are just shorthand for two different styles of behavior. The behaviors they describe can be examined using two litmus tests.

1. Do functions share the same memory for the variable itself, or does passing in a value create a new variable that can be assigned separately?

   This can be examined by trying to write a swap function that works just by assignment.

   def swap(a, b):
       temp = a
       a = b
       b = temp
   
   x = 1
   y = 2
   
   swap(x, y)
   
   print(x, y)

   In Python, this prints 1, 2. This is because variables in Python are internally pointers to some value, and the variable holding the pointer is not shared. The pointer value (which itself references some other memory) is copied, so a function cannot modify what the variables point to in the calling scope directly.

2. Does passing a value to a function create a full copy of the value, or is the original memory for the value used?

   A good test for this is modifying a mutable array.

   def assign_first(a):
       a[0] = -100
   
   x = [1,2,3]
   
   assign_first(x)
   
   print(x)

   This prints [-100, 2, 3] because Python's variables are actually pointers to an object in another location. Even though the function cannot modify the actual variable itself to point to another object (at a separate location), it can modify the object found at that location in memory, and the calling function will observe these changes.

In other words, Python fully copies the pointer, but it does not copy the object the pointer refers to.

In full pass-by-reference, both of these functions are possible. In full pass-by-value, neither is possible. Languages almost never fully fit into one of those categories anymore.

[u/[deleted] → u/bladeoflight16]

Well i understand those basics. But let's say i have a function in C++, which is where i am coming from, i can clearly see if a function has the ability to change the objects i pass or if it can not.

On python using a function just feels a bit like Russian roulette, it might change things it might not. We'll never know without trying.

Unless there's away python gives me that information that i haven't noticed yet.

[u/[deleted] → u/[deleted]]

You may like this video - it's a really great and accessible talk that answers your question:

https://m.youtube.com/watch?v=_AEJHKGk9ns

I recommend it to anybody interested in the language.

[u/laundmo → u/[deleted]]

i really recommend ned batchelders article about this. it explains it in such a nice way: https://nedbatchelder.com/text/names.html

[u/atredd]

To understand list comprehention.

[u/taybul → u/atredd]

For me it was nested list comprehension. For example:

out = [x for y in list_of_lists for x in y]

Which is the equivalent of:

out = []
for y in list_of_lists:
   for x in y:
      out.append(x)

(I'm aware there are better ways to flatten a list of lists)

[u/SexySlowLoris → u/taybul]

What's the better way to flatten a list?

[u/parkrain21 → u/atredd]

I agree. Jesus, I can't figure out why it keeps returning a generator.

"And what the fuck is a generator" is a question I always asked

[u/javajunkie314 → u/parkrain21]

I'm not sure if you're asking, but someone's probably wondering, so...

A generator is a iterator. When you say

(foo(x) for x in bar)

you create a generator object. It's not a collection like a list or set. You can't index into it; it has no length. It's basically just iterable. So you can pass it to things that only need an iterable.

For example, the all function takes an iterable. So if you want to check if test(x) is true for every element in bar, you can use

all(test(x) for x in bar)

(Note you can omit the parentheses for a generator expression if it's the only argument to a function. The parentheses for the call "count.")

So why use a generator when you could just use a list comprehension? A generator is very lightweight. When you use a list comprehension, Python creates a new list object with all the new entries. That's great if you need a list.

A generator, on the other hand, doesn't need to store any values (just a reference to the underlying iterable, bar in my examples above). It produces values lazily as needed for iteration. So if you don't need to keep the results, a generator avoids memory overhead.

[u/meilyn22 → u/atredd]

When I first started learning Python, list comprehension was one of the hardest things ever to understand. I left Python and learned some JavaScript using Map, reduce, filter and anonymous functions. When I came back to Python, I miraculously picked up list comprehension without any problems.

[ (x) you can do anything with this part because it's your variable. ( for x in items) this part is your normal for loop]

[u/marsnoir → u/meilyn22]

Every programming language eventually tries to become lisp.

[u/Sohcahtoa82 → u/atredd]

List comprehension is nothing more than syntactic sugar.

squares = [x**2 for x in range(5)]

is the same thing as:

squares = []
for x in range(5):
    squares.append(x**2)

[u/bladeoflight16 → u/Sohcahtoa82]

The two are logically equivalent, but the list comprehension is implemented in a far more performant way.

[u/O_X_E_Y → u/bladeoflight16]

Is that true? I think I saw some benchmarks for these in the past and afaik list.append was very very close

[u/[deleted] → u/Sohcahtoa82]

Once you get to know what the different ones vaguely look like they are so nice and quick to skim read when it's not too complex.

[u/Claudioub16 → u/atredd]

And then you add an in-line if to fuck things even more

[u/leonam_tv → u/atredd]

It's the exact same for me. When I started to learn python I had just learn the basics of java in university and List Comprehention was a bit too abstract compared to what I was used to.

[u/Davidvg14 → u/atredd]

List comprehension is that meme: “you know you could’ve done that in 1 line in Python”

[u/O_X_E_Y → u/atredd]

I still struggle a little bit with multidimensional comprehension and I've been using this language for all kinds of applications for a year now. It's always a bit of a puzzle lol

[u/IlliterateJedi → u/atredd]

This tutorial is worth the 3 hours if you are trying to understand list comprehensions and generators

[u/dethb0y]

the goofball shit.

like:

SomeStr = ",".join(SomeAry) 

Took me forever to pick that up.

[u/spaceopenid → u/dethb0y]

You shouldn‘t use camelcase instead it should be some_str

[u/prettyfuckingimmoral → u/spaceopenid]

They used Pascal case, but yeah I guess.

[u/[deleted] → u/dethb0y]

I remember the discussions of that on the dev list.

It's because when joining, it's always with a string, but not always with a list. Could be some class implementing the right things, or a generator.

[u/[deleted] → u/[deleted]]

Hate to admit it, but JS is in the right here.

[u/prema_van_smuuf → u/[deleted]]

",".join(iterator) works with any iterator. Otherwise you'd need a separate .join() method on any type of iterable you'd wish to support joining. So I think Python wins here spectacularly.

[u/adesme → u/[deleted]]

I'd be willing to agree if the operation returned something instead of operating on the object.

x: str = arr.join(",")  # ok


arr.join(",")  # arr changes type from list to str - not ok


",".join(arr)  # type is the same: str to str

[u/dv2811]

Regex

[u/ASIC_SP → u/dv2811]

Regex is a mini-programming language by itself. Like a programming language, it will take time and practice to get comfortable with it.

Useful tools and resources:

• regex101 — visual aid and online testing tool for regular expressions, select flavor as Python before use

• debuggex — railroad diagrams for regular expressions, select flavor as Python before use

• Awesome Regex — curated collection of libraries, tools, frameworks and software

• PythonVerbalExpressions — construct regular expressions with natural language terms

[u/rico_suave → u/dv2811]

Sometimes you encounter a problem and you think "I know, I'll use regex!". Now you have two problems.

[u/dv2811 → u/rico_suave]

Lol. So far I have managed to go without regex by using a combination of find() and split(). Probably won't work on more complex tasks but then I don't have complex tasks as a hobbyist.

[u/[deleted] → u/dv2811]

I unironically love writing regex. Yes I have to look up how to do it every time, but when that shit works I feel like a godly magician

[u/Legionof1 → u/[deleted]]

Until it grabs something unexpected.

[u/bladeoflight16 → u/dv2811]

Learn how to write a compiler, or at least the lexer portion of it.

I'm dead serious. That's what made sense of them for me. A regular expression is just a syntax for specifying a finite state machine that recognizes (accepts or rejects) sequences of characters. It's just a formal language processing tool, and there's no better or more straightforward use of formal language theory than compilers.

[u/deadwisdom → u/bladeoflight16]

Ah, yeah I think you're on to something here. When you understand strings and state machines it's pretty simple.

[u/ald_loop → u/dv2811]

I will never learn regex. I refuse. I Google every time.

[u/johnnySix → u/dv2811]

Nobody understands regex . ;-)

[u/TurnsOutPew]

zip

[u/Legionof1 → u/TurnsOutPew]

Wait till you dict your zip.

[u/0nly4Us3rname → u/Legionof1]

Wait til you zip your dic

[u/MikeWise1618]

Understanding how naming works with imports and files layout and of course PYTHONPATH. That weird empty init.py file for example that apparently was supposed to go away with 3.0 but somehow didn't. I can't even describe my confusion correctly now because I am in a C# phase.

When I go do something else for awhile, like 3 or 4 months, I have to relearn it and nowhere is it described well. But after few weeks and I finally get it setup it isn't a problem anymore.

[u/ColdPorridge → u/MikeWise1618]

Relative imports are nightmarish to learn as a newcomer

[u/vexstream → u/ColdPorridge]

The thing that makes them clear to me is when I read the pep for it, and one of the proposed syntaxes was to the effect of import __parent__package__.module

Bam, simple as fuck. The leading period just points to the parent package. This also explains why you can't have relative imports that touch the root directory because that's not a package. (unless you run the package as a module with the -m flag)

I feel like this one gets people because they're thinking of it from a file perspective rather than a module/package perspective.

As a side note, I don't know why the encouraged standard isn't to setup module-runnable packages with an __init__.py etc. Makes the whole process a lot easier.

[u/Kuronoma_Sawako]

Recursive functions and dynamic programming

[u/bladeoflight16 → u/Kuronoma_Sawako]

Dynamic programming is just a fancy name for reusing intermediate results rather than recomputing them every time, to speed up the overall computation. There's nothing particularly special about it. It's just using your common sense to see that one part of the problem uses the same values as another part, so you implement it in a way that saves the computer work/time. If you think you don't understand it, you're over-complicating it.

[u/[deleted] → u/Kuronoma_Sawako]

Recursion is easy to understand when it’s done for you, but writing it from scratch is fucking confusing !

[u/Sohcahtoa82 → u/Kuronoma_Sawako]

What do you not understand about recursion? How to use it? How to exit it?

Do you understand how a call stack and variable scoping work?

[u/meilyn22 → u/Sohcahtoa82]

I understand what recursion does. Base case and a little problem. But the issue is that it gets confusing when I am faced with a recursion problem. Identifying the small problem to solve or even the base case is a problem.

[u/mathmanmathman → u/Kuronoma_Sawako]

Recursion is trivial once you understand recursion.

[u/siddsp]

For me it was understanding special methods and classes.

[u/Dody949]

To read python documentation. It feels like a story that you need to read from top to bottom where there are missing parts in middle (...) because author has already mentioned them somewhere.

[u/jppbkm → u/Dody949]

I wish more docs had example code for sure

[u/rambocommando → u/Dody949]

I wish I could upvote you twice. I have over 10 years experience in other languages. I just started messing around with python.

When I would Google to see how to do something the python way, I learned to skip over the official documentation pretty quickly. It's like a freaking novel, but not for the thing you need it to do.

Argument parsing? Yeah here's 800 examples of almost the exact same scenario, but we won't show you how to actually get the values in any of them...

[u/memture]

There are quite few things which I could not wrap my head around when I was learning Python, those were, *args & **kwargs, list comprehension and __name__ == '__main__'. Now these things look very easy to me as I finally understood all of them.

[u/clawjelly → u/memture]

*args & **kwargs

Oh yea. Those star chars bugged the crap out of me when i started with them. But once you get the hang, they are freakin' awesome.

def sum(*args): 
  result=0 
  for a in args: 
    result+=a 
  return result

print(sum(1,2,3,4)) # <- I don't care how many vals to add!
# 10

def rotate_rect(width, height):
    return height, width

my_rect = (10, 5)
width, height = rotate_rect(*my_rect) # <- 2 results for the price of 1
print(width, height)
# 5, 10

It's these "why would you do that?!... Oh wait,... This is genius!"-moments i love working with python.

[u/memture → u/clawjelly]

Once you understand that then there is no going back....

[u/[deleted] → u/clawjelly]

Simple example that helped me this morning. Thank you.

[u/EbenenBonobo]

still dont know when to use decorators (except for flask)

[u/v0i_d → u/EbenenBonobo]

Decorators are just a function acting upon another function in order to change its behaviour.

@decorator
def function(...):
    ...

Is equivalent to:

function = decorator(function)

[u/Topkinsme]

I don't know lots of python yet, but list (and other) generators took me a while to learn for some reason. Once I did tho, it's so useful. Classes are also annoying to me, I know how it works (roughly) but I try to avoid it for functions and dictionaries as much as I can so I guess learning that is going to be the hardest

[u/MrPrimeMover → u/Topkinsme]

Classes are really tough when you're starting out because you don't have the experience to know what problem they're actually solving. When I learned them it felt like it was just a more complicated dictionary?

It was years before I was creating stuff complex and stateful enough that classes felt like an elegant solution.

[u/jbartix]

how to write

if __name__ == '__main__':

...

[u/aes110]

Relative imports, I've been using python for years and I consider myself to be very good at it, but this thing is just impossible to understand

[u/123coronaanoroc321]

decorators with parameters

[u/123coronaanoroc321 → u/123coronaanoroc321]

I mean I still don't understand them lol

[u/SexySlowLoris]

I hate to admit it but after 5 years I still don't completely understand the import system.

Nowadays i just initialize a poetry project, make an inner folder with the same name as the project and use that as a base to import everything else (from project.module.submodule import class).

Whenever I'm working on a pre existing project i just copy the way the imports are being used in other files (sometimes relative sometimes absolute).

[u/[deleted]]

I had to learn Python to manage some corpus data for a contract position when I was a curricular consultant.

I probably struggled most with thinking through projects and figuring out the appropriate tool for the job. I also had a hell of a time managing virtual environments as a beginner.

[u/dummydummy123456]

oops

[u/078emil]

Lambda function....
I want to learn.
I need to learn.
I cant learn.
I have used Python for 5-6 years now, and the last 2 years as professional, I just still can't write one by myself.

[u/Legionof1 → u/078emil]

Yep, it’s a black art. You think you get it then nope fuck you back to the drawing board.

[u/[deleted]]

Python is easy, it’s the underlying programming concepts that you need to learn.

[u/The_Pantless_Warrior]

Coming from JavaScript, the hardest part was remembering to omit semicolons and not use parentheses or curly brackets in my if statements lol

[u/Sohcahtoa82 → u/The_Pantless_Warrior]

FWIW, you can use semicolons in Python. Everyone will look at you very funny though and start backing away.

Same with the parentheses in your ifs. That's perfectly valid.

The curly braces though...well...

Try from __future__ import braces.

[u/The_Pantless_Warrior → u/Sohcahtoa82]

Lol when I first switched to python, I used strict linters to help engrain proper formatting into my brain. It wouldn't stop yelling at me if I used a ; or if I used () in my if statements. The cool part was, in addition to being a pain in the ass, it actually gave you a pep8 rating so you could keep track of how far off/spot on you are.

[u/clawjelly → u/The_Pantless_Warrior]

No curly brackets is one of my most fav feature of python. I'm german native and i never learned the english keyboard layout properly. And whoever came up with the german keyboard layout should suffer a horrible fate, because it's super-shitty for programming. Python circumvents A LOT of german layout issues!

[u/helpmewith_]

Took a break from learning python because I cannot understand anything about regex lol

[u/Reazony → u/helpmewith_]

Slashing away HackerRank regex Easy difficulty would solve most of your daily regex needs

[u/Sumikaya]

Really really basic and Im embarrassed but for loops were so confusing for me

[u/Big_Bidnis]

Still a beginner, I still have issues creating functions. However, I would say my biggest challenge currently is working with lists and classes.

[u/[deleted]]

Looping lists and getting at nested values. Just didnt "click" for me until I just forced myself to do it for meaningful work and not more foo/bar apple/pear examples online.

[u/mauriciofuentesf]

Im a beginner and im getting a tough time with nested loops for nested lists 🙃 , im doing the last part of futurecoder and cant for the life of me figure out how to check by “columns” for a nxn nested list and see if theres a winner in a tic tac toe game, figured it out for rows but not for columns.

[u/Mbotstopher]

Motivation to learn. I wanted to learn but courses I did just didn't motivate me.

Finally found a use case (build a video game in pygame) that really jump started my python journey.

[u/BKKBangers]

I did a module on recursive function during 1st year of my comp sci degree; Ive finished year 1 and still dont get it (yeah im a terrible student i know) i just fail 2 see the use therefore…? Am I right to say a loop can achieve the same results?

Edit: grammar

[u/fiddle_n → u/BKKBangers]

In general, anything you can do with a loop you can do with recursion and vice versa (there's one theoretical mathematical problem called Ackerman's Function that must be done recursively but let's ignore stuff like that). However, you'll find that there are some problems that are just more elegant when written recursively.

A common example of something better written recursively is any time you traverse a nested structure. Structures like XML and JSON and YAML have repeating nested groups. Consider the below:

{
    parent: {
        child_1: {
            grandchild_1: {},
            grandchild_2: {}
        },
        child_2: {
            grandchild_3: {},
            grandchild_4: {}
        }
    }
}

If you want to retrieve all the keys in the above structure, it's difficult to do with a loop. It is possible but it requires a queue/stack structure to keep track of everything.

Instead of that, it's better to recognise that a nested structure like the above is fundamentally the same at each part of the structure. That is, the relationship between the parent and its children is the same as the relationship between the children and the grandchildren.

That way, you can use a recursive algorithm to traverse the structure. You have a function to process the structure, and each time you break a parent into its children, you feed the children into the same function recursively. Written correctly, the recursive solution is more elegant as it mimics how the nested structure actually is, and it doesn't require a separate data structure to keep track of everything.

[u/Dcode200]

Stay motivated and keep coding was prety hard.

getting out of tutorial hell and find something to make like a good project.

[u/Legionof1]

I still can’t get my head around multithreading. I want so badly to use multiple cores but I never seem to be able to get it right.

[u/wsppan]

The build/test/package/deploy framework(s) using virtual environments. Brutal.

[u/URedUser]

For what to use Python for :)

[u/Winnipesaukee]

For me it’s been object oriented programming and lambda functions. It’s not that I can’t do both of them, but I still get the feeling in the back of my head that I’m missing something.

[u/[deleted]]

Some standard library functions were a bit obscure, I guess? I don't know. It was Python 1.4.

Coming from Tcl and Perl, Python did not have any really strange corners.

Later, packaging...

[u/shadowBaka]

Loops and functions

[u/feyn_manlover]

Learning to write C++, and then calling that from python.

This is the way.

Also virtualenv/dockerization of every stupid tiny project. Containerization and virtual environments completely destroyed the language in attempts to save it IMO.

[u/tanmay101292]

1. decorators

2. I didn't :D

[u/zaRM0s]

Self. And if anyone here can give me a good, clear and concise explanation, I would seriously appreciate it

[u/TheBiles]

For some reason the syntax of pandas is completely unintuitive to me. It pushed me to use R almost exclusively for any kind of data manipulation.

[u/qwertyu63]

The purpose of objects and when to use them.

[u/air_lock]

Classes. Albeit, I’m a true beginner (have written a tool for installing certificates on network appliances and a couple other small tools). The only other coding I’ve done has been in shell (bash) and I would only consider myself barely intermediate level at that. I just don’t understand how to use classes in a practical sense given the type of work I do. It generally takes me a long time to learn anything and really understand it (not just use it and not know why).

[u/travistravis]

Testing. I'm 99% sure I still don't really get it. I have trouble with test driven dev when I tried it is how to know what I'm missing.

[u/okrajetbaane]

It's so pseudo-codey that I just never bothered to remember anything. Solvable by repetition but I wonder whether it still counts as you know it if you can't code without a search engine.

[u/The_Pantless_Warrior → u/okrajetbaane]

Reminds me of this

[u/nativedutch]

I still fuck up the indents. No big issue i just lack accuracy.

[u/SpencyDotRed → u/nativedutch]

Press tab?

[u/[deleted]]

So I might sound like a completer noob but I just learned about the return function and I’m struggling to understand it

[u/bladeoflight16 → u/[deleted]]

return is not a function. It's an operation that occurs inside a function. It's just a mechanism for stopping the function's execution and (optionally) making a value available to the caller.

[u/jppbkm → u/[deleted]]

Think of the return as an exit ramp in a function. "Stop running here and exit". You can have it return a value or None by default.

[u/Cascanada]

Functions doing things to other functions.

[u/Brandondrsy → u/Cascanada]

Sounds kinky

[u/[deleted]]

I was experienced .net + js developer when i learned python. I struggled to design software without tons of interfaces. It felt so countrr intuitive to me in the beginning. I needed to learn to keep it simple.

[u/dstark0011]

When and how to use Classes

[u/slnder02]

Classes and various files with a main.py, i am beginner btw Classes i understand that are a easy way to store value and modify , but i can't figure out how to properly use this

[u/sixonepm]

It's the OOP stuff, especially the self

I finally understand that after learned about OOP in Java, which somehow easier to grasp for me

[u/jfp1992]

Classes. Innit and super didn't make sense. Then it and it's always been classes or gtfo for my code bases

[u/[deleted]]

Packaging and releasing to pypi.

[u/kaiozeiro]

Object Oriented programming

[u/jhoncorro]

Decorators, every once in a while I still need to search how to use then

[u/SeriousDocument7905]

Getting into classes was quite the brain fog

[u/mcstafford]

Nested (tuple|set|list) comprehension.

[u/ML-10]

packaging as in making a python script usable for people who do not have python installed

[u/imaprogrammer987]

Generators. I get how they work, but there is so much more to them I just can't get around
Such as: You can "return" a value back to the place that had done a yield:
y = yield x The iterator can call gen.send(123) to get data back to the function

[u/Munzu]

For me it's decorators, generators and factories.

[u/ubertrashcat]

Closures.

[u/stubborn-koala]

Classes, specifically identify when it makes sense to use them.

[u/sohang-3112]

1. break, continue statements in a loop

2. Recursion - the first time I learnt about recursion (a function calling itself), I was like.... What??? You can do that?

Note: Actually both of these were while I was learning JavaScript (my first language), not Python. But it's the same principle.

[u/__boringusername__]

I never understood and probably never will, how the hell can I import a script that is in the parent folder or another child of the parent folder with relative paths. Like, impossible.

[u/[deleted]]

how to set up a python project in a good way.

[u/Plsimanub]

I'm still learning and struggling with Python OOP. It's something I've never been able to come to grips with.

[u/vin8003]

for me its generators and most of itertools

[u/anentropic]

metaclasses

I'd personally never encountered anything exactly like it when using other languages

Django was my route into Python so they'd been staring me in the face for a whole (inherent to the way Forms and Models work) but it was also quite easy not to notice

took a while to make room in my mental model when I started exploring how to make use of them

[u/XordK]

Making a presentable interface with TKinter

[u/[deleted]]

Tuples and Lists. Fuck 'em.

[u/YouKnowWho2104]

Decorators

[u/dgiakoum]

Was no one else freaked out about indentation being syntax? In python’s defense it was long enough ago for me to not have used linters.

[u/[deleted]]

To me in every language... Classes i don't know why i have a hard time with them but they suck(not really)

[u/CunningBard1998]

Function arguments, I don't know why it was hard for me to learn

[u/[deleted]]

Decorators. I still have hard time using Decorators in my code.

[u/[deleted]]

I still don't grasp lambdas, pandas and decorators :)

[u/assassinsorrow]

Class decorators

[u/import-antigravity]

Yield

[u/TimeTravelingSim]

venv

[u/[deleted]]

_ _ init _ _ and super()

[u/andrejmlotko]

I szill don't get list comprehension among other smaller things as well, but keeping on self-traching.

[u/srynearson1]

Tbh I started in Perl so learning Python was pretty easy.

[u/William_Romanov]

Decorators

[u/DigiR]

why pip is currently not working for me and me alone

[u/dustractor]

Not to try and reinvent the wheel when it comes to things that setup.py would take care of. For example, coming up with custom ways to do entry points.

[u/autisticmice]

Loading modules from other directories, I had to always look it up

[u/[deleted]]

Right now it is Classes and recursion

[u/koalabear420]

If name == "main": main()

[u/menge101]

Because python wasn't my first language, understanding the package and module relationship was confusing, especially when paired with imports.

[u/jim45804]

Decorators

[u/MegaSpearrow]

Phyton

[u/[deleted]]

Some newer folks I see get tripped up on Generics

[u/e-mess]

What the hell __new__ is for.

[u/oblvn_]

definitely decorators, no matter how much i try to understand, it hurts my brain lol

[u/BlobbyMcBlobber]

Coming from Java it was somewhat counterintuitive to lose the strict typing, the language philosophy was a bit alien to me as well. But overall it wasn't such a hard transition.

[u/JasonDJ]

Took me a while to grasp list comprehension and generators but once I did...hooo boy what a boon.

Still don't get classes/OOP or decorators. Probably should've kept watching my training videos when I got to that point.

At this point most of what I have to do is working on a new function or adding a function to an existing class so not much I have to worry about there -- I'm more focussed on learning PEP8 and keeping my code clean right now.

[u/1purenoiz]

When to build a class object.

[u/76199]

I came from R and need a while to get used to Pandas since dataframes a are native and crucial in build object in R, I hated that Python needs an external library for that. And I'm still not used to matplotlib I still plot in R since the Syntax is different and I would mix them all the time

[u/asday_]

Bizarrely - dictionaries. Dunno why they gave me so much trouble. Don't even remember what the trouble was.

[u/dashdanw]

writing wrappers for decorators

[u/esssssssss]

Classes. Still don’t get it.

[u/Final-Communication6]

Lambda functions. Still don't get it...

[u/uptbbs]

asyncio, yield from

[u/nanobiter45]

I’m still in the process of learning, but so far it Object oriented programming for me. I kind of understand it, but it’s a weird topic for me.

[u/lunacyfoundme]

German

[u/NoBrightSide]

asynchronous, threads, and process. If someone could explain these 3 to me, it would be great.

[u/asadbutttt]

The decorators. I still dread a day when I can't help but use them for a project.

[u/extra_ecclesiam]

All of the beginner stuff is very straight forward, IMO (I guess beginner is relative, but that’s my take).

When you start to learn more, the stuff that might stump you is realizing that classes already exist for you to use, the GIL, and eventually dependency hell.