Learn More Python the Hard Way

This course will take you from a low confidence beginner who can "sort of" code to a higher confidence Junior developer who can definitely code. It contains many courses and basic concepts that gives you a lot of practice in Python, but also translate to many other programming languages.

Course Contents

This course contains the following modules and lessons. Every course offers free samples of the first 10 lessons so you can decide if you want to take the course, and excerpts from all lessons after that.

• Part I: Initial Knowledge
  
  The very first thing you need to learn is everything.
• Introduction
  
  Process, Creativity, and Quality.
• Exercise 0: The Setup
  
  You are going to need to set up and configure some tools to do this book.
• Exercise 1: On Process
  
  There's two type of processes in the world of software development.
• Exercise 2: On Creativity
  
  Creativity is nothing special.
• Exercise 3: On Quality
  
  I'm going to propose a scientific theory about cognition I cannot prove: ```...

• Part II: Quick Hacks
  
  You've got the best idea ever.
• Exercise 4: Dealing with Command Line Arguments
  
  Before you can work on this first part of the book you need to do some quick hacking that teaches you about command line arguments in Python.
• Exercise 5: cat
  
  With Exercise 4 you began the work of finding out what blocks you.
• Exercise 6: find
  
  Hopefully you are discovering the various ways you sabotage yourself even before you begin to work.
• Exercise 7: grep
  
  The find command should have been possible but a good challenge for 45 minutes.
• Exercise 8: cut
  
  Hopefully you're learning more Python but even more about yourself and how you work.
• Exercise 9: sed
  
  Using these tiny projects to study yourself is useful, but let's pan out and look at the main topics you've focused on: - Startup process for beginning work, such as your text editor, how well you can type, and other things that happen inside the computer.
• Exercise 10: sort
  
  You are slowly building up what I call a Personal Process Practice (3P), which isn't a new idea at all.
• Exercise 11: uniq
  
  There isn't much more to say in the beginning of these last two exercises.
• Exercise 12: Review
  
  The first stage of my methodic madness is complete for me but not for you.

• Part III: Data Structures
  
  You're well on your way to building a personal process that gets you started quickly and with limited friction.
• Exercise 13: Single Linked Lists
  
  The first data structure you will implement is the Single Linked List.
• Exercise 14: Double Linked Lists
  
  The previous exercise may have taken you quite a while to complete since you have to figure out how to make a single linked list work.
• Exercise 15: Stacks and Queues
  
  When working with data structures you'll oftentimes encounter a structure that is similar to another.
• Exercise 16: Bubble, Quick, and Merge Sort
  
  You are now going to attempt to implement sorting algorithms for your DoubleLinkedList data structure.
• Exercise 17: Dictionary
  
  You should be familiar with Python's dict class already.
• Exercise 18: Measuring Performance
  
  In this exercise you're going to learn to use several tools to analyze the performance of the data structures and algorithms you've created.
• Exercise 19: Improving Performance
  
  This is a mostly video exercise where I will demonstrate improving the performance of the code you've written so far, but first you should attempt it.
• Exercise 20: Binary Search Trees
  
  In this exercise I'm going to teach you to translate an English description of a data structure into working code.
• Exercise 21: Binary Search
  
  The Binary Search algorithm is a simple way to find an item in an already sorted list of items.
• Exercise 22: Suffix Arrays
  
  I'd like to tell you a story about suffix arrays.
• Exercise 23: Ternary Search Trees
  
  The final data structure we'll investigate is called a Ternary Search Tree (TSTree), and it's useful for quickly finding a string in a set of strings.
• Exercise 24: Fast URL Search
  
  We will end the section on data structures and algorithms with a performance measurement challenge that applies your data structures to an actual problem.

• Part IV: Intermediate Projects
  
  In Part III(part2.
• Exercise 25: xargs
  
  We are returning to challenge mode exercises and to warm you up you'll be implementing xargs.
• Exercise 26: hexdump
  
  You've done a warmup with xargs and are now working in the cycle of code then audit.
• Exercise 27: tr
  
  This exercise is continuing the study of doing TDD (aka Test First) style development.
• Exercise 28: sh
  
  You are now going to continue your TDD style process, but you'll add a small hack session to start.
• Exercise 29: diff and patch
  
  To finish Part IV(part3.

• Part V: Parsing Text
  
  This part of the book will teach you about text processing and, specifically, the beginning of parsing text formally.
• Exercise 30: Finite State Machines
  
  Whenever you read a book on parsing there's this scary chapter on Finite State Machines (FSM).
• Exercise 31: Regular Expressions
  
  A regular expression (regex) is a succinct way to encode how a sequence of characters should be matched in a string.
• Exercise 32: Scanners
  
  My first book very casually covered scanners in Learn Python The Hard Way, Exercise 48(https://learnpythonthehardway.
• Exercise 33: Parsers
  
  Imagine you're given a huge list of numbers and you have to enter them into a spreadsheet.
• Exercise 34: Analyzers
  
  You now have a parser that should be producing a tree of grammar production objects.
• Exercise 35: Interpreters
  
  This final exercise in parsing should be both challenging and fun.
• Exercise 36: Simple Calculator
  
  This challenge is to create a simple algebraic calculator using everything you've learned about parsing.
• Exercise 37: Little BASIC
  
  You are now going to take a trip back in time to my childhood and implement a BASIC interpreter.

• Part VI: SQL and Object Relational Mapping
  
  In this part of the book we're going to cover something that doesn't quite fit into the rest of the book's structure, but is a very necessary topic for junior developers to understand.
• Exercise 38: Introduction To SQL
  
  The best way to learn how to model and design solid data is to start with the very basic building blocks.
• Exercise 39: Creating with SQL
  
  When we talk about the acronym "CRUD" the 'C' stands for "Create" and it doesn't just mean creating tables.
• Exercise 40: Reading with SQL
  
  Out of the CRUD matrix you only know "Create".
• Exercise 41: Updating with SQL
  
  You now know the CR parts of CRUD, which leaves the Update and Delete operations.
• Exercise 42: Deleting with SQL
  
  This is the simplest exercise, but I want you to think for a second before typing the code in.
• Exercise 43: SQL Administration
  
  The word "administration" is overloaded in databases.
• Exercise 44: Using Python's Database API
  
  Python has a standardized database API that enables you to use the same code to access multiple databases.
• Exercise 45: Creating an ORM
  
  The final exercise in the SQL part of the book is a big jump.

• Part VII: Final Projects
  
  The final part of the book is where you step up to more advanced projects and try to nail down your personal process.
• Exercise 46: blog
  
  You should have your process theme written up as described in the beginning of this section, and you should have your process listed out and ready to go.
• Exercise 47: bc
  
  You should be warmed up and ready to work on this new project.
• Exercise 48: ed
  
  If your process is working then you should be able to focus on one long project for a few weeks at a time.
• Exercise 49: sed
  
  You implemented a "baby version" of sed in exercise 9 when you were learning how to make quick and dirty hacks.
• Exercise 50: vi
  
  I am going to prison for this exercise.
• Exercise 51: lessweb
  
  We are nearing the end of the book, so I'm going to give you one project in the final two exercises.
• Exercise 52: moreweb
  
  Now that you've created a web server using the Python `http.