Head First Learn To Code A Learner's Guide Coding And Computational Thinking
Head%20First%20Learn%20to%20Code%20-%20A%20Learner's%20Guide%20to%20Coding%20and%20Computational%20Thinking
Head%20First%20Learn%20to%20Code%20-%20A%20Learner's%20Guide%20to%20Coding%20and%20Computational%20Thinking
Head%20First%20Learn%20to%20Code%20-%20A%20Learner's%20Guide%20to%20Coding%20and%20Computational%20Thinking
Head%20First%20Learn%20to%20Code%20-%20A%20Learner's%20Guide%20to%20Coding%20and%20Computational%20Thinking
Head%20First%20Learn%20to%20Code%20-%20A%20Learner's%20Guide%20to%20Coding%20and%20Computational%20Thinking
User Manual: Pdf
Open the PDF directly: View PDF
Page Count: 641 [warning: Documents this large are best viewed by clicking the View PDF Link!]
- Praise
- Copyright
- Table of Contents
- Intro: How to use this book
- Chapter 1: Getting Started: Thinking computationally
- Breaking it down
- How coding works
- Are we even speaking the same language?
- The world of programming languages
- How you'll write and run code with Python
- A very brief history of Python
- Putting Python through its paces
- Saving your work
- Congrats on coding your first Python program!
- Phrase-O-Matic
- Getting the code in the machine
- Chapter 2: Know Your Value: Simple values, variables, and types
- Chapter 3: Decisive Code: Booleans, decisions, and loops
- Would you like to play a game?
- First, a high-level design
- The computer's choice
- How to use the random number
- True? Or False?
- Introducing the Boolean type
- Making decisions
- Decisions and more decisions
- Back to Rock, Paper, Scissors
- Getting the user's choice
- Taking a look at the user's choice
- Adding the code to detect a tie
- Who won?
- How to implement the game logic
- More about Boolean operators
- Display the winner
- Got documentation?
- How to add comments to your code
- We need to finish that game!
- How do we know if the user's choice is invalid?
- Checking out and cleaning up the expression
- How to continually prompt the user
- Doing things more than once
- How the while loop works
- How to use while to prompt the user until you get a valid choice
- Congratulations on coding your first game!
- Beware of the Dreaded Infinite Loop
- Chapter 4: Providing Some Structure: Lists and iteration
- Can you help Bubbles-R-Us?
- How to represent multiple values in Python
- How lists work
- How to access a list item
- How big is that list, anyway?
- Accessing the last item in the list
- Python makes this even easier
- Using Python's negative indices
- Meanwhile, back at Bubbles-R-Us...
- How to iterate over a list
- Fixing the output glitch
- Really fixing the output glitch
- The for loop, the preferred way to iterate over a list
- How the for loop works
- How the for loop works on a range of numbers
- Doing more with ranges
- Putting it all together
- Test drive the bubble report
- Building your own list, from scratch
- Doing even more with lists
- Test drive the final report
- Testing the most cost-effective solution
- Chapter 5: Getting Functional: Functions and abstraction
- What's wrong with the code, anyway?
- Turning a block of code into a FUNCTION
- We created a function, so how do we use it?
- But how does all this actually work?
- Functions can RETURN things too
- How to call a function that has a return value
- Getting a little refactoring under our belts
- Running the code
- How to abstract the avatar code
- Writing the get_attribute function body
- Calling get_attribute
- Let's talk about variables a little more...
- Understanding variable scope
- When variables get passed to functions
- Making the drink_me function call
- What about using global variables in functions?
- Going further with parameters: default values and keywords
- Always list your required parameters first!
- Using arguments with keywords
- How to think about all these options
- Chapter 4, part 2: Putting Some Order in Your Data: Sorting and nested iteration
- Chapter 6: Putting It All Together: Text, strings, and heuristics
- Welcome to the data sciences
- How do you compute something like readability?
- The game plan
- Writing some pseudocode
- We need some text to analyze
- Setting up the function
- First up: we need the total number of words in our text
- Computing the total number of sentences
- Writing the count_sentences function
- Computing the number of syllables, or, learning to love heuristics
- Setting up the heuristic
- Writing the heuristic
- How to count vowels
- Ignoring consecutive vowels
- Writing the code to ignore consecutive vowels
- Removing final e's, y's, and punctuation
- Putting slicing (substrings) to work
- Finishing off the heuristic
- Implementing the reading ease formula
- Taking it even further
- Chapter 7: Getting Modular: Modules, methods, classes, and objects
- A quick module review
- The __name__ global review
- Using analyze.py as a module
- Adding docstrings to analyze.py
- Exploring other Python modules
- Wait, did someone say "turtles"?!
- Creating your very own turtle
- Turtle lab
- Adding a second turtle
- What are turtles, anyway?
- What are objects?
- Okay, what's a class then?
- A class tells us what an object knows and what an object can do
- How to use objects and classes
- What about those methods and attributes?
- Seeing classes and objects everywhere
- Get ready for some turtle races
- Planning the game
- Let's start coding
- Setting up the game
- Writing the setup code
- Not so fast!
- Starting the race
- Chapter 8: Beyond Iteration and Indices: Recursion and dictionaries
- A different way to compute
- And now the different way...
- Now let's write some code for our two cases
- Let's get some more practice
- Using recursion to detect palindromes
- Writing a recursive palindrome detector
- The Anti-Social Network
- Introducing the dictionary
- What about iterating through a dictionary?
- Leveraging dictionaries at the Anti-Social Network
- But how do we add more attributes?
- Remember the Anti-Social Network's killer feature?
- Finding the most anti-social user
- Now, it's all you!
- Can we just remember function call results?
- We might as well use the $5 words: Memoization
- Some more brain building
- A closer look at the koch function
- Truly exploring the koch fractal
- Chapter 9: Persistence: Saving and retrieving files
- Ready for some Crazy Libs?
- How Crazy Libs is going to work
- Step 1: Read the text of the story from a file
- To read a file in Python, you first have to open it
- How to use file paths
- Relative paths
- Absolute paths
- Oh, and don't forget to clean up when you're done!
- Reading a file into your Python code
- Using the file object to read a file
- Oh, give it a break already...
- Hey, we've got a Crazy Lib game to finish!
- Using the readline method of the file object
- How do we know when we've read the last line?
- Reading in a Crazy Lib template
- Processing the template text
- Now let's process the text
- Using a new string method to fix the bug
- Actually fixing the bug
- Some code has real problems
- Handling exceptions
- Explicitly handling exceptions
- Updating Crazy Libs to handle exceptions
- Our last step: storing the Crazy Lib
- Updating the rest of the code
- Chapter 10: You Really Should Get Out More: Using web APIs
- Extending your reach with Web APIs
- How Web APIs work
- All Web APIs have a web address
- Time for a quick upgrade
- Doing the upgrade
- All we need now is a good Web API...
- A closer look at the API
- Web APIs provide data using JSON
- Now let's look at that request module again
- Putting it all together: making a request to Open Notify
- How to use JSON in Python
- Using the JSON module on our ISS data
- Meet the screen object
- Let's add a turtle to represent the ISS
- Turtles can look like space stations too
- Forget the ISS—where are we?
- Finishing off the ISS code
- Chapter 11: Getting Interactive: Widgets, events, and emergent behavior
- A closer look at the Game of Life
- What we're going to build
- Do we have the right design?
- How we're going to build the simulator
- Building the data model
- Computing a generation of the Game of Life
- Completing the model code
- Where are we?
- Building the view
- Creating your first widget
- Adding the rest of the widgets
- Correcting the layout
- Placing the widgets into a grid layout
- Translating the grid layout to code
- Moving on to the controller
- Ready for another new style of computation?
- Let's add a click handler
- How the start/pause button is going to work
- Implementing the start/pause button
- Another kind of event
- We have the technology: the after method
- Are we there yet?
- How to enter and edit cells directly
- Writing the grid_view handler
- Now it's time to add some patterns
- Writing a handler for the OptionMenu
- How to define your patterns
- Writing the pattern loader
- Chapter 12: A Trip to Objectville: Object-oriented programming
- Breaking it down, a different way
- What's the point of object-oriented programming, anyway?
- Designing your first class
- Writing your first class
- Writing the bark method
- How methods work
- Adding some inheritance
- Implementing the ServiceDog class
- A closer look at subclassing
- A ServiceDog IS-A Dog
- Testing IS-A in code
- How would you describe yourself?
- Overriding and extending behavior
- Welcome to Jargon City
- Object can HAS-Another object
- Designing a Doggie Hotel
- Implementing the Doggie Hotel
- Renovating the Doggie Hotel
- Adding some hotel activities
- I can do anything you can, or Polymorphism
- It's about time we teach the other dogs to walk
- The power and responsibility of inheritance
- Creating a Doggie Hotel walking service
- How are we going to hire a person to walk our dogs if we don't even have people objects?
- Have you considered a career in coding?
- Appendix: The Top Ten Topics (We Didn't Cover): Leftovers
- Index