https://pypi.org/ More on reddit.com

That depends on a few things. First you have to define dependencies. Are you talking about direct dependencies (the ones you actively define and import) or indirect dependencies (ie the whole dependency tree)? Then it also really does depend on the project. You could come up with an average number but it wouldn’t have to much value because the number of dependencies varies a lot, and doesn’t always have something to do with how big the actual project is. A few examples to illustrate the differences: SQLAlchemy: ~300,000 loc, 3 dependencies (which are all sub project related to building SQLAlchemy) Django: ~100,000 loc, 3 dependencies Celery: ~60,000 loc, 8 dependencies Sphinx: ~60,000 loc, 24 dependencies Tensorflow: ~800,000 loc, 36 dependencies Random commercial project I’ve worked on: ~80,000 loc, 67 dependencies (loc here only refers to Python code) As you can see, there is a trend, but it doesn’t have something to do with the size of the project. It’s more about the scope. Usually the more generalised a project becomes, ie the more problems it tries to solve, the more different dependencies it needs. Frameworks like Django and SQLAlchemy usually don’t have that many dependencies because they’re quite focused on a single topic. To answer your question directly: Yes it is very normal for professional applications to have dependencies. Usually the more business oriented the application becomes, the more dependencies it has. More on reddit.com

1 ) Yes. You will get nowhere when you try to understand every module/library/package/dependency. I'm a Java developer and there are probably thousands of different libraries in Maven Repository. The similar thing goes also for Python libraries. Python is a multipurpose language. You can make GUIs with it. You can use it in data engineering. You can use it in IoT. You can use it cyber security. You can use it in cryptography. You can use it in statistics. And the list goes on and on. Each separate field has its own libraries. You will never ever understand every each library and its whole extent of source code. Yes, you do can dig in the source code. Sometimes it is even necessary when debugging some weird behaviour/bug or trying to implement something in an unorthodox way. I have done so with Java libraries. But you will not go then deeper than necessary. You find out the internal function/class/flow, study it, and then move on. You will not try to understand the library fully. It is an endless rabbit hole, otherwise. 2 ) Most likely yes. Because libraries are also Python code. Somebody just implemented whatever you are trying to do by using the regular Python (and sometimes also using some other libraries). The deeper you dig into a library the more you will see a regular Python. Although some libraries do are written in a different language. But they use wrapper methods and such. But do not concentrate on that. It is more an exception that a rule. Most libraries you'll be using are in the same language as the programming language that makes use of these libraries. 3 ) No. Junior Python developers will be also using existing libraries. Why should you reinvent a wheel? Your client is not waiting after you when you are doing something in a regular Python and spending perhaps a week on something that another developer does in an hour by using an existing library. I'm not telling that you should not understand the source code. Understanding it comes handy. Also when you start writing your own libraries you have to build the stuff from scratch. So knowing the basics and how to work without libraries is a valuable knowledge. Also not always you can use a library. There can be some custom use cases where you have to implement the feature all by yourself, with little ways to use existing libraries. More on reddit.com

It really does depend on what you want to do, but I'll give you a list of some of my personal favorites as well as the ones that I use a lot. (Includes standard library modules and stuff from PyPI) os/shutil - The os and shutil modules are both built in, and they are super useful. The os module basically provides a bunch of interfaces to your operating system; you can get the name, environment variables, work with paths, and do stuff with files and directories. The shutil module is a bit smaller, as it just contains a bunch of high-level file operations, like recursive copying/removing, an implementation of the Unix which command, and an implementation of chown. re - I might be a little bit insane, but I really like regular expressions. The re module allows you to work with regular expressions, and it can be super powerful. Regular expressions can be super confusing, but like everything, you learn over time. Useful tip: you can comment regular expressions in Python, which is really nice. flask - This is the first module from PyPI. Flask is a backend web framework written in Python. If you are good at Python and want to do backend, Flask is super powerful and really good for beginners. Another thing, if you're working with bigger projects with big databases, you could also look at django, just its really just preference. configparser - Going back to stuff in the standard library, we have configparser. ConfigParser allows you to read/write to .ini files, allowing you to easily save user preferences for your program. It's super easy to use so I like it a lot. decimal - This one can be super helpful. Have you ever tried to do math in Python and it is almost correct but slightly off, causing hours of debugging with no avail? That's because of something called "Floating Point Precision Errors," and it's in most programming languages. Because of the way that computers add numbers with binary, when you do arithmetic on floats, things tend to break. For example, open up the Python interpreter and try running 1.1 * 3. You should get something like 3.3000000000000003. The decimal module can allow you to fix this. After importing Decimal from the decimal module, try running Decimal("1.1") * Decimal("3") and see what happens, it should be the correct answer now. requests - requests is a module from PyPI, and it is incredibly helpful. requests allows you to, well, send HTTP requests for one thing. You could do this with the builtin urllib module, but requests has more features and is so much easier to use. argparse - This one is built in, and it allows you to easily create command-line utilities. argparse will let you create different types of arguments, which can then be fed into your program to produce a result. PyQt5 - Interested in making GUIs but Tk isn't your favorite? Me too. I don't really create GUIs too often, but when I do, I like to use PyQt5. PyQt5 allows you to create Qt applications, and it is probably one of the most powerful GUI modules in Python. It comes with a ton of different widgets, and it's super easy to do stuff like multithreading with it. I personally like to use Qt Designer to create the GUIs, and then I use pyuic5 to convert the .ui files to PyQt5 code. colorama - colorama allows you to easily add color to your command-line programs. Thats basically it. json - The json module allows you to parse json into a Python dictionary, and then write a Python dictionary into JSON. Useful when paired with requests for getting API data, and just a useful module to know about in general. rich - Rich allows you to create really nice looking console output, you can make errors look nice, render markdown, progress bars, and a ton of other stuff. It has support for 4-bit color, 8-bit color, Truecolor, and Dumb Terminals. I would really recommend checking it out. numpy - NumPy is really good if you need to handle large amounts of data. NumPy also provides high-level mathematical functions to operate on these large, multi-dimensional arrays and matrices. Since a lot of it is written in C, it is super fast, and the only downside really is that the arrays are stored completely in memory, so it's pretty easy to run out. By popular demand: itertools - Itertools it's definitely an extremely useful module. It is used for creating iterators in a really easy way. For example, you can get all possible combinations of length x of two lists, get all the possible permutations of an iterable, and other really useful things. I should probably look more into this module myself. In conclusion, there are a lot of different modules, and these are definitely not all of the useful ones, or even all of the ones that I use, but I figured that those are some nice modules to at least give you inspiration. You could also check out my GitHub for inspiration, if you wanted, and I have a few Python modules myself. I'll link my GitHub and some projects of note below, as well as all of the projects I mentioned in this comment. My GitHub randfacts Module ti842py Module ImaginaryInfinity Calculator os - https://docs.python.org/3/library/os.html shutil - https://docs.python.org/3/library/shutil.html re - https://docs.python.org/3/library/re.html flask - https://flask.palletsprojects.com/en/2.0.x/quickstart/ configparser - https://docs.python.org/3/library/configparser.html decimal - https://docs.python.org/3/library/decimal.html requests - https://docs.python-requests.org/en/master/ argparse - https://docs.python.org/3/library/argparse.html PyQt5 - https://pypi.org/project/PyQt5/ colorama - https://pypi.org/project/colorama/ json - https://docs.python.org/3/library/json.html rich - https://pypi.org/project/rich/ numpy - https://numpy.org/doc/1.20/ itertools - https://docs.python.org/3/library/itertools.html More on reddit.com