Python How-To MEAP V10 1. Copyright_2023_Manning_Publications 2. welcome 3. 1_Developing_a_pragmatic_learning_strategy 4. 2_Processing_and_formatting_strings 5. 3_Using_built-in_data_containers 6. 4_Dealing_with_sequence_data 7. 5_Iterables_and_iterations 8. 6_Defining_user-friendly_functions 9. 7_Using_functions_beyond_the_basics 10. 8_Defining_user-friendly_classes 11. 9_Using_classes_beyond_the_basics 12. 10_Fundamentals_of_objects 13. 11_Dealing_with_files 14. 12_Logging_and_exception_handling 15. 13_Debugging_and_testing 16. 14_Completing_a_real_project 17. Appendix_A._Learn_Python_with_REPL 18. Appendix_B._Managing_Python_packages_with_pip 19. Appendix_C._Using_Jupyter_Notebook_–_A_web- based_interactive_Python_editor 20. Appendix_D._Integrating_version_control_in_your_project 21. Appendix_E._Preparing_your_package_for_public_distribution 22. Appendix_F._Solutions_to_the_challenges MEAP Edition Manning Early Access Program Python How-To Version 10 Copyright 2023 Manning Publications ©Manning Publications Co. We welcome reader comments about anything in the manuscript - other than typos and other simple mistakes. These will be cleaned up during production of the book by copyeditors and proofreaders. https://livebook.manning.com/#!/book/python-how-to/discussion For more information on this and other Manning titles go to manning.com welcome Dear Readers, Thank you for purchasing the MEAP for Python How-To. As a scientist, I have been using Python for more than five years. As a self-learner, I know how important but also hard to find the right learning material, because there are just too many choices — YouTube videos, blog articles, online courses, and books. Among them, books are my favorite because compared to other media, text provides the most amount of information. After learning through several Python books and years of first-hand use experience, I put a great deal of efforts into this book, trying to consolidate all essential techniques about writing readable and maintainable Python code. I hope that this book can give you a head start in writing better Python code to fulfill your job duties. As you may realize, Python is so versatile that it has a plethora of tools for many specialty domains, such as finance, engineering, data science, and artificial intelligence. If you're entering or about to enter one of these domains, knowing Python will make your work much easier because of the access to these handy tools. However, using these tools requires you have a solid understanding of the essential Python skills, which are this book's focus — teaching you domain-independent Python knowledge. No matter how sophisticated your domain-specific Python tool is, it won't take long for you to figure it out! To get most out of this book, you may have used Python for several months and have some basic understanding of data models and functions. If you have additional background in programming, it will help too. Anyhow, even if you don't have any Python or programming experience, you can still get started with Python using this book, because each section is filled with realistic scenarios and code examples. Thus, you can simply copy and paste the code to run, without requiring you to do anything to learn! I hope you'll enjoy this book. If you have any questions, comments, or suggestions, please share them in Manning’s liveBook discussion forum for my book. —Yong Cui In this book Copyright 2023 Manning Publications welcome brief contents 1 Developing a pragmatic learning strategy 2 Processing and formatting strings 3 Using built-in data containers 4 Dealing with sequence data 5 Iterables and iterations 6 Defining user-friendly functions 7 Using functions beyond the basics 8 Defining user-friendly classes 9 Using classes beyond the basics 10 Fundamentals of objects 11 Dealing with files 12 Logging and exception handling 13 Debugging and testing 14 Completing a real project Appendix A. Learn Python with REPL Appendix B. Managing Python packages with pip Appendix C. Using Jupyter Notebook – A web-based interactive Python editor Appendix D. Integrating version control in your project Appendix E. Preparing your package for public distribution Appendix F. Solutions to the challenges 1 Developing a pragmatic learning strategy This chapter covers What being pragmatic means What Python can do When you should consider alternative languages What you can expect to learn from this book As one of the most popular languages, Python is the choice of language for many first-time coding learners. Its open-source, general-purpose, platform- independent nature has engendered probably the most active developer community, which has resulted in tens of thousands of freely available libraries for web development, machine learning (ML), data science, and many other specialties. No matter whether you just started with coding in Python or programming in general, I hope that we share the same belief: we’ve entered an era in which knowing to code in Python gives you a tremendous advantage — you’re having access to numerous tools that Python has to offer. In the Python ecosystem, we use domain-specific Python tools, such as web frameworks and ML libraries, to address specific tasks in our jobs. The effective employment of these tools is nontrivial, as it requires a considerable breadth of familiarity with essential Python skills, such as processing texts, dealing with structured data, creating control flows, and handling files. Python programmers can write different solutions to address the same tasks. Among these solutions, one of them is probably better than the remaining, because it may be more concise, more readable, or more efficient, which we term as Pythonic — an idiomatic coding style that all Python programmers strive to acquire. It is what this book is about — how to write Pythonic code to address programming tasks. We shall recognize that Python is so well-developed and there are just too many features to learn. Thus, it’s impossible or unwise if we try to learn everything about Python. Instead, I’ll take a pragmatic approach to defining what I’ll teach in this book —the essential skills that you’ll most likely use in your projects. Equally important is that I’ll frequently mention how to use them with the consideration of readability and maintainability such that you can form good coding habits, which, I bet, you and your teammates will much appreciate. Note You'll see callouts like this throughout the book. Many of them are devoted to tips regarding readability and maintainability. Don't miss them out! 1.1 Aiming at becoming a pragmatic programmer We code for purposes: building websites, training ML models, or analyzing data. Whatever the purposes are, we want to be pragmatic — we write code to solve problems. Thus, before we learn to code from the beginning or advance our coding skills in the middle of our career, we should be clear with our intentions. However, even if you're unsure about what you desire to achieve with Python at this stage, the good news is that core Python features are universal knowledge. Once you grasp the core features, it'll become much easier for you to learn any domain-specific Python tools. Aiming at becoming a pragmatic programmer means that you should focus on techniques that are most useful. Mastering these skills is just a first milestone of your journey, and the long-term game in coding is writing readable code that doesn't only work but also fosters maintainability. 1.1.1 Focusing on writing readable Python code As a developer, I’m obsessed with readability. Writing code is like speaking a real-world language. When we speak a language, don't we want others to understand us? If your answer is yes, you probably agree with me that we want others to understand our code too. Whether our code’s readers possess the necessary technical expertise to understand our code is out of our control. But what we can control is how we write the code — how readable our code is. Consider some simple questions: Are my variables properly named to indicate what they are? None can appreciate if your code is full of variables named as var0, temp_var, or x. Do my functions have proper signatures to indicate what they do? People are lost if they see functions named as do_data(data) or run_step1(). Do I organize my code consistently across different files? People expect that different files of the same type use similar layouts. For instance, do you place import statements at the top of your files? Is my project folder structured with specific files stored in the desired folders? When your project’s scope grows, you should create separate folders for related files. These are a few example questions pertaining to readability. We don’t just ask them from time to time. Instead, we continuously ask ourselves these and many other readability-related questions throughout the project. The reason is simple — (good) practice makes perfect. Trained as a neuroscientist, I know exactly how the brain works when it comes to behavioral learning. By focusing on readability through these self-checking questions, we’re training our brain's neural circuits. In the long term, our brain will be trained to know what behaviors constitute good practice of readability, making you write readable and maintainable code even without your consciousness. 1.1.2 Considering maintainability even before you write any code In rare cases, we write code just for one-time use. When we write a script, we almost always succeed in convincing ourselves that we'll never use the script again, and thus, we don’t care about giving good variable names, laying out the code properly, refactoring functions and data models, and not to mention leaving no or outdated comments. However, how many times did it turn out that we would have to use the same script the next week or even the following day? It probably has happened to most of us. The previous paragraph describes a mini-scale maintainability issue. In this case, it only affects your own productivity in a short span of time. However, if you work in a team environment, issues from individual contributors add up to large-scale maintainability issues. The team members fail to follow the same naming rules for variables, functions, and files. There are countless incidents of commented-out code. Outdated comments are everywhere. To address maintainability issues in a later stage in your own projects, you should build a good mindset when we're learning to code at this stage. The following are some questions that you may consider to develop a good "maintainability" mindset in the long run. Is your code free of outdated comments and commented-out code? If no, update or delete them! These are situations that are even worse than those without any comments because of conflicting information that they may provide. Is there any considerable duplication in the code? If yes, refactoring is probably warranted. A rule of thumb in coding is DRY – don’t repeat yourself. By removing duplicates, you’ll deal with just a single shared portion, which is less prone to bugs compared to the situation when you must track the changes of repeated parts. Do you use version control tools, like git? If no, look at the extensions or plugins of your IDEs (Integrated Development Environment; for Python, common IDEs include PyCharm and Visual Studio Code), many of which have integrated version control tools and made it much easier to manage versions. Being a pragmatic Python programmer requires these maintainability trainings. After all, almost all Python tools are open source and rapidly evolving. Thus, maintainability should be the cornerstone of any viable project. Throughout the book, where applicable, we’ll be touching base on how to implement maintainability practices in our daily Python coding. Please remember that readability is key to sustained maintainability. When you focus on writing readable code, your codebase’s maintainability improves consequentially. 1.2 What Python can do well or do equally well as