Head First Python. A Brain-Friendly Guide. 2nd Edition

Kup polskie wydanie:

Spis treści ebooka

• Head First Python
• Dedication
• Praise for the first edition
  • Praise for other Head First books
•  
• Author Of Head First Python, 2nd Edition
• How to use this Book: Intro
  • Who Is This Book For?
    • Who should probably back away from this book?
  • We Know What Youre Thinking
    • We know what your brain is thinking
  • Metacognition: Thinking About Thinking
  • Heres What WE Did:
  • Heres what YOU can do to bend your brain into submission
  • Read Me, 1 of 2
  • Read Me, 2 of 2
  • The Technical Review Team
• Acknowledgments And Thanks
• Safari Books Online
• 1. The Basics: Getting Started Quickly
  • Breaking with Tradition
    • Starting with a meatier example
  • Jump Right In
    • Pythons IDLE is all you need to get going
  • Understanding IDLEs Windows
  • What Happens Next...
  • Press F5 to Run Your Code
  • Code Runs Immediately
  • Executing Code, One Statement at a Time
    • Lets be the Python interpreter
  • Functions + Modules = The Standard Library
  • Batteries Included
  • Data Structures Come Built-in
    • Python variables are dynamically assigned
  • Invoking Methods Obtains Results
    • Invoking built-in module functionality
  • Deciding When to Run Blocks of Code
  • What Happened to My Curly Braces?
    • A colon introduces an indented suite of code
  • What else Can You Have with if?
  • Suites Can Contain Embedded Suites
  • What We Already Know
  • Extending Our Program to Do More
    • What We Need to do:
  • Whats the Best Approach to Solving This Problem?
    • Both approaches work with Python
  • Returning to the Python Shell
  • Experimenting at the Shell
  • Iterating Over a Sequence of Objects
  • Iterating a Specific Number of Times
  • Applying the Outcome of Task #1 to Our Code
  • Indent Suites with Format...Indent Region
  • Arranging to Pause Execution
  • Importation Confusion
  • Generating Random Integers with Python
  • Asking the Interpreter for Help
  • Reviewing Our Experiments
  • Updating What We Already Know
  • A Few Lines of Code Do a Lot
  • Coding a Serious Business Application
    • Dealing with all that beer...
  • Python Code Is Easy to Read
  • Is Indentation Driving You Crazy?
    • Getting back to the beer song code
  • Asking the Interpreter for Help on a Function
    • Starting, stopping, and stepping
  • Experimenting with Ranges
  • Dont Forget to Try the Beer Song Code
    • Wrapping up what you already know
    • With all the beer gone, whats next?
  • Chapter 1s Programs
• 2. List Data: Working With Ordered Data
  • Numbers, Strings... and Objects
    • Numbers
    • Strings
    • Objects
  • Everything is an Object
    • But... what Does all this Actually Mean?
  • Meet the Four Built-in Data Structures
  • Ordered Collections are Mutable/Immutable
  • An Unordered Data Structure: Dictionary
  • A Data Structure Which Avoids Duplicates: Set
    • The 80/20 Data Structure Rule-of-Thumb
  • A List is an Ordered Collection of Objects
    • How to Spot a List in Code
  • Creating Lists Literally
  • Putting Lists to Work
    • Working with Lists
    • Is One Object Inside Another? Check with in
  • Use Your Editor When Working on More Than a Few Lines of Code
    • Dont Forget: Press F5 to Run Your Program
  • Growing A List At Run-Time
  • Checking For Membership with in
    • Is the Object in or not in?
  • Its Time to Update Our Code
  • Removing Objects From a List
  • Popping Objects Off a List
  • Extending a List with Objects
  • Inserting an Object Into a List
  • What About Using Square Brackets?
  • What Happened to plist?
  • What Happened to plist, Continued?
  • Lists: What We Know
  • What Looks Like A Copy, Isnt
  • How To Copy A Data Structure
  • Square Brackets Are Everywhere
    • Lists: Updating What We Already Know
  • Lists Extend The Square Bracket Notation
  • Lists Understand Start, Stop, And Step
    • You can put start, stop, and step inside square brackets
  • List Slices In Action
  • Starting, And Stopping With Lists
  • Stepping With Lists
    • Slices are everywhere
  • Putting Slices To Work On Lists
    • Converting Dont panic! to on tap
  • Putting Slices To Work On Lists, Continued
  • Which is better? It depends...
  • Slicing A List Is Non-destructive
    • So... which is better?
  • Pythons for Loop Understands Lists
    • Understanding marvin.pys code
  • Pythons for Loop Understands Slices
  • Marvins Slices In Detail
  • Lists: Updating What We Know
  • Whats Wrong With Lists?
  • When Not To Use Lists
  • Chapter 2s Programs
  • Chapter 2s Programs, Continued
• 3. Structured Data: Working With Structured Data
  • A Dictionary Stores Key/Value Pairs
  • Make Dictionaries Easy to Read
  • How to Spot a Dictionary in Code
    • What happened to the insertion order?
  • Insertion Order is NOT Maintained
    • Dictionaries understand square brackets
  • Value Lookup With Square Brackets
    • Dictionary lookup is fast!
  • Working With Dictionaries At Run-Time
  • Recap: Displaying Found Vowels (Lists)
  • How Can A Dictionary Help Here?
  • Selecting A Frequency Count Data Structure
  • Updating A Frequency Counter
  • Updating A Frequency Counter, v2.0
  • Iterating Over A Dictionary
  • Iterating Over Keys And Values
  • Dictionaries: What We Already Know
    • Specifying the ordering of a dictionary on output
  • Iterating Over A Dictionary With items
  • Just How Dynamic Are Dictionaries?
    • Dictionary keys must be initialized
  • Avoiding KeyErrors At Run-Time
  • Checking For Membership With in
  • Ensuring Initialization Before Use
  • Substituting not in For in
  • Putting The setdefault Method To Work
    • Dictionaries: updating what we already know
  • Arent Dictionaries (And Lists) Enough?
  • Sets Dont Allow Duplicates
    • Spotting sets in your code
  • Creating Sets Efficiently
    • Creating sets from sequences
  • Taking Advantage Of Set Methods
  • Union Works By Combining Sets
    • What happened to the loop code?
  • Difference Tells You Whats Not Shared
  • Intersection Reports On Commonality
  • Sets: What You Already Know
  • Making The Case For Tuples
    • How to spot a tuple in code
  • Tuples Are Immutable
  • Watch Out For Single-Object Tuples
  • Combining The Built-in Data Structures
  • Storing A Table Of Data
  • A Dictionary Containing a Dictionary
  • A Dictionary of Dictionaries (a.k.a. A Table)
  • Pretty Printing Complex Data Structures
  • Visualizing Complex Data Structures
  • Accessing A Complex Data Structures Data
  • Data Is As Complex As You Make It
  • Chapter 3s Programs (1 of 2)
  • Chapter 3s Programs (2 of 2)
• 4. Code Reuse: Functions & Modules
  • Reusing Code With Functions
  • Introducing Functions
  • What About Type Information?
  • Naming A Chunk Of Code With def
  • Invoking Your Function
    • Edit your function in an editor, not at the prompt
  • Use IDLEs Editor To Make Changes
  • Whats The Deal With All Those Strings?
    • Understanding the string quote characters
  • Follow Best Practice As Per The PEPs
  • Functions Can Accept Arguments
  • Functions Return A Result
  • Returning One Value
  • Returning More Than One Value
    • Whats the deal with set()?
  • Recalling The Built-in Data Structures
  • Use Annotations To Improve Your Docs
  • Why Use Function Annotations?
  • Functions: What We Know Already
  • Making A Generically Useful Function
  • Creating Another Function, 1 of 3
  • Creating Another Function, 2 of 3
  • Creating Another Function, 3 of 3
  • Specifying Default Values For Arguments
  • Positional vs. Keyword Assignment
  • Updating What We Know About Functions
  • Functions Beget Modules
    • Creating modules couldnt be easier, however...
  • How Are Modules Found?
  • Running Python From The Command-Line
  • Not Found Modules Produce ImportErrors
  • ImportErrors Occur No Matter The Platform
  • Getting A Module Into Site-packages
    • Using setuptools to install into site-packages
  • Creating The Required Setup Files
  • Creating The Distribution File
    • Creating a distribution file on Windows
  • Distribution Files On UNIX-like OSes
  • Installing Packages With pip
    • Step 3 on Windows
    • Step 3 on UNIX-like OSes
  • Modules: What We Know Already
    • Giving your code away (a.k.a. sharing)
  • Demonstrating Call-By-Value Semantics
  • Demonstrating Call-By-Reference Semantics
  • Can I Test For PEP 8 Compliance?
  • Getting Ready To Check PEP 8 Compliance
    • Recalling our code
    • Installing pytest and the pep8 plug-in
  • Install The Testing Developer Tools
  • How PEP 8 Compliant Is Our Code?
  • Understanding The Failure Messages
  • Confirming PEP 8 Compliance
    • Conformance to PEP 8 is a good thing
  • Chapter 4s Programs
• 5. Building a Webapp: Getting Real
  • Python: What You Already Know
  • Lets Build Something
  • What Do We Want Our Webapp To Do?
  • What Happens On The Web Server?
    • What do we need to get going?
  • Lets Install Flask
    • Install Flask from the command-line with pip
  • How Does Flask Work?
    • Check that Flask is installed and working
    • Run Flask from your OS command-line
  • Running Your Flask Webapp For The First Time
  • Heres What Happened (Line-By-Line)
  • Creating A Flask Webapp Object
  • Decorating A Function With A URL
  • Running Your Webapps Behavior(s)
  • Exposing Functionality To The Web
  • Recall What Were Trying To Build
    • Heres the plan
  • Building The HTML Form
    • But... what if youre new to all this HTML stuff?
    • Create the HTML, then send it to the browser
  • Templates Relate To Web Pages
  • Rendering Templates From Flask
  • Displaying The Webapps HTML Form
  • Preparing To Run The Template Code
  • Were Ready For A Test-Run
  • Understanding HTTP Status Codes
  • Handling Posted Data
  • Refining The Edit/Stop/Start/Test Cycle
  • Accessing HTML Form Data With Flask
  • Using Request Data In Your Webapp
    • Automatic Reloads
  • Producing The Results As HTML
  • Calculating The Data We Need
  • Adding A Finishing Touch
  • Redirect To Avoid Unwanted Errors
  • Functions Can Have Multiple URLs
  • Updating What We Know
    • Is that all there is to this chapter?
  • Preparing Your Webapp For The Cloud
  • Exploiting Dunder Name Dunder Main
    • Deploying to PythonAnywhere (well... almost)
  • Chapter 5s Programs
• 6. Storing & Manipulating Data: Where To Put Your Data
  • Doing Something With Your Webapps Data
  • Python Supports Open, Process, Close
  • Reading Data From An Existing File
  • A Better Open, Process, Close: with
    • The with statement manages context
    • Invoking the logging function
  • A Quick Review
    • Take your webapp for a spin...
    • Data is logged (behind the scenes)
  • View The Log Through Your Webapp
    • Where to start when things go wrong with your output
  • Examine The Raw Data With View Source
  • Its Time To Escape (Your Data)
  • Viewing The Entire Log In Your Webapp
  • Learning More About The Request-object
    • Whats all this, then?
  • Logging Specific Web Request Attributes
  • Log A Single Line Of Delimited Data
  • One Final Change To Our Logging Code
  • From Raw Data To Readable Output
  • Does This Remind You Of Anything?
  • Use A Dict Of Dicts... Or Something Else?
    • Take a closer look at the logged data
  • Whats Joined Together Can Be Split Apart
    • Getting to a list of lists from a list of strings
  • When Should The Conversion Occur?
  • Processing Data: What We Already Know
    • Take a closer look at the output
  • Generate Readable Output With HTML
  • Embed Display Logic In Your Template
  • Producing Readable Output With Jinja2
  • The Current State Of Our Webapp Code
  • Asking Questions Of Your Data
  • Chapter 6s Code
• 7. Using a Database: Putting Pythons DB-API To Use
  • Database-Enabling Your Webapp
  • Task 1: Install The MySQL Server
  • Introducing Pythons DB-API
  • Task 2: Install A MySQL Database Driver For Python
  • Install MySQL-Connector/Python
  • Task 3: Create Our Webapps Database & Tables
  • Decide On A Structure For Your Log Data
  • Confirm Your Table Is Ready For Data
  • Task 4: Create Code To Work With Our Webapps Database And Tables
  • Storing Data Is Only Half The Battle
    • This new function is a big change
  • How Best To Reuse Your Database Code?
  • Consider What Youre Trying To Reuse
  • What About That Import?
    • Be careful when positioning your import statements
  • Consider What Youre Trying To Do
  • Youve Seen This Pattern Before
  • The Bad News Isnt Really All That Bad
  • Chapter 7s Code
• 8. A Little Bit of Class: Abstracting Behavior and State
  • Hooking Into The with Statement
  • An Object-Oriented Primer
    • A class bundles behavior and state
    • Classes have methods and attributes
  • Creating Objects From Classes
  • Objects Share Behavior But Not State
    • Defining what we want CountFromBy to do
  • Doing More With CountFromBy
  • Its Worth Repeating Ourselves: Objects Share Behavior But Not State
  • Invoking A Method: Understand The Details
  • Method Invocation: What Actually Happens
  • Adding A Method To A Class
  • Are You Serious About self?
  • The Importance Of self
  • Coping With Scoping
  • Prefix Your Attribute Names With self
  • Initialise (Attribute) Values Before Use
  • Dunder Init Initializes Attributes
  • Initializing Attributes With Dunder Init
    • Pass any amount of argument data to dunder init
    • What have we learned from this Test Drive?
  • Understanding CountFromBys Representation
  • Defining CountFromBys Representation
  • Providing Sensible Defaults For CountFromBy
  • Classes: What We Know
  • Chapter 8s Code
• 9. The Context Management Protocol: Hooking Into Pythons With Statement
  • Whats The Best Way To Share Our Webapps Database Code?
  • Consider What Youre Trying To Do, Revisited
    • How best to create a context manager?
  • Managing Context With Methods
    • Dunder enter performs set-up
    • Dunder exit does tear-down
    • (As you know) dunder init initializes
  • Youve Already Seen A Context Manager In Action
    • Whats required from you
  • Create A New Context Manager Class
  • Initialise The Class With The Database Config
    • Your context manager begins to take shape
  • Perform Set-up With Dunder Enter
    • Dont forget to prefix all attributes with self
  • Perform Tear-down With Dunder Exit
    • Your context manager is ready for testing
    • Theres not much code here, is there?
  • Reconsidering Your Webapp Code, 1 of 2
  • Reconsidering Your Webapp Code, 2 of 2
  • Recalling The log_request Function
  • Amending The log_request Function
  • Recalling The view_the_log Function
  • Its Not Just The Code That Changes
  • Amending The view_the_log Function
    • Heres the SQL query youll need
    • Its nearly time for one last Test Drive
  • All That Remains...
  • Answering The Data Questions
    • How many requests have been responded to?
    • Whats the most common list of letters?
    • Which IP addresses are the requests coming from?
    • Which browser is being used the most?
  • Chapter 9s Code, 1 of 2
  • Chapter 9s Code, 2 of 2
• 10. Function Decorators: Wrapping Functions
  • Your Webapp is Working well, but...
    • Only Authenticated Users gain Access
  • The Web is Stateless
    • HTTP is to blame...
  • Your Web Server (Not Your Computer) Runs Your Code
  • Its Time for a Bit of a Session
  • Flasks Session Technology Adds State
  • Dictionary Lookup Retrieves State
    • Time for a Test Drive?
  • Managing Logins with Sessions
  • Lets do Login
    • Amend the Webapps code to Handle Logins
  • Lets do Logout & Status Checking
    • Amend the webapps code once more
  • Why not Check for False?
  • Can we now Restrict Access to URLs?
  • Copy-and-Paste is Rarely a good Idea
    • Put Shared Code into its Own Function
  • Creating a function helps, but...
  • Youve been Using Decorators all Along
  • Pass a Function to a Function
    • Functions can take a Function as an Argument
  • Invoking a Passed Function
  • Functions can be Nested inside Functions
    • When would you ever use this?
  • Return a Function from a Function
  • Accepting a list of Arguments
    • Use * to accept an arbitrary list of arguments
  • Processing a list of Arguments
    • * Works on the way in, Too
  • Accepting a dictionary of Arguments
    • Use ** to accept arbitrary keyword arguments
  • Processing a dictionary of Arguments
    • ** Works on the way in, too
  • Accepting any Number and type of Function Arguments
  • A Recipe for Creating a Function Decorator
  • Recap: We need to Restrict Access to Certain URLs
  • Creating a Function Decorator
    • Thats almost too easy, isnt it?
    • Can you see why the nested function is called wrapper?
  • The Final Step: Handling Arguments
    • Were done... or are we?
  • Your decorator in all its Glory
  • Putting your decorator to Work
  • The Beauty of Decorators
  • Creating more Decorators
  • Back to Restricting Access to /viewlog
  • Whats Next?
  • Chapter 10s Code, 1 of 2
  • Chapter 10s Code, 2 of 2
• 11. Exception Handling: What to Do When Things Go Wrong
  • Databases Arent Always Available
  • Web Attacks Are A Real Pain
  • Input-Output Is (Sometimes) Slow
  • Your Function Calls Can Fail
  • Considering The Identified Problems
    • 1. Your database connection fails
    • 2. Your application is subjected to an attack
    • 3. Your code takes a long time to execute
    • 4. Your function call fails
  • Always Try To Execute Error-prone Code
  • Catching An Error Is Not Enough
    • There can be more than one exception raised...
  • Try Once, But Except Many Times
  • A Lot Of Things Can Go Wrong
  • The Catch-All Exception-Handler
  • Havent We Just Lost Something?
  • Learning About Exceptions From sys
  • The Catch-All Exception-Handler, Revisited
  • Getting Back To Our Webapp Code
  • Silently Handling Exceptions
  • Handling Other Database Errors
  • Does More Errors Mean More Excepts?
  • Avoid Tightly Coupled Code
  • The DBcm Module, Revisited
  • Creating Custom Exceptions
    • The Empty Class Isnt Quite Empty...
  • What Else Can Go Wrong With DBcm?
  • Creating More Custom Exceptions
  • Are Your Database Credentials Correct?
  • Handling SQLError Is Different
  • Be Careful With Code Positioning
  • Raising SQLError
  • A Quick Recap: Adding Robustness
    • What happens if something takes a long time?
  • How To Deal With Wait? It Depends...
  • Chapter 11s Code, 1 of 3
  • Chapter 11s Code, 2 of 3
  • Chapter 11s Code, 3 of 3
• 12. 11 A Little Bit of Threading: Dealing With Waiting
  • Waiting: What To Do?
  • How Are You Querying Your Database?
  • Database Inserts And Selects Are Different
  • Doing More Than One Thing At Once
    • Concurrent code: you have options
  • Dont Get Bummed Out: Use Threads
  • First Things First: Dont Panic
  • Dont Get Bummed Out: Flask Can Help
  • Is Your Webapp Robust Now?
  • Chapter 11s Code, 1 of 2
  • Chapter 11s Code, 2 of 2
• 13. Advanced Iteration: Looping Like Crazy
  • Bahamas Buzzers Have Places To Go
  • Reading CSV Data As Lists
  • Reading CSV Data As Dictionaries
  • Lets Back Up A Little Bit
  • Stripping, Then Splitting, Your Raw Data
  • Be Careful When Chaining Method Calls
  • Transforming Data Into The Format You Need
  • Transforming Into A Dictionary Of Lists
    • Think about the data wrangling thats needed here...
  • Lets Do The Basic Conversions
  • Did You Spot The Pattern In Your Code?
  • Spotting The Pattern With Lists
  • Converting Patterns Into Comprehensions
  • Take A Closer Look At The Comprehension
  • Whats The Big Deal?
    • Comprehensions arent just for lists
  • Specifying A Dictionary Comprehension
  • Extend Comprehensions With Filters
  • Recall What You Set Out To Do
  • Deal With Complexity The Python Way
  • Extract A Single Destinations Flight Times
  • Extract Flight Times For All Destinations
  • That Feeling You Get...
  • The Set Comprehension In Action
  • How To Spot A Comprehension
  • What About Tuple Comprehensions?
  • Parentheses Around Code == Generator
    • Generators produce data items one-at-a-time...
  • Using A Listcomp To Process URLs
  • Using A Generator To Process URLs
  • Using A Generator: What Just Happened?
  • Define What Your Function Needs To Do
  • Yield To The Power Of Generator Functions
  • Tracing Your Generator Function, 1 of 2
  • Tracing Your Generator Function, 2 of 2
  • Concluding Remarks
  • One Final Question
  • Chapter 12s Code
  • Its Time To Go...
    • Youre on your way!
• A. Installation: Installing Python
  • Install Python 3 on Windows
    • Download, then install
  • Check Python 3 on Windows
    • Its Python 3 on Windows, sort of...
  • Add to Python 3 on Windows
  • Install Python 3 on Mac OS X (macOS)
    • Using a package manager
  • Check & Configure Python 3 on Mac OS X
    • The Python 3 folder on Mac OS X
    • Youre ready to run on Mac OS X
  • Install Python 3 on Linux
• B. Pythonanywhere: Deploying Your Webapp
  • Step 0: A Little Prep
  • Step 1: Sign-up For PythonAnywhere
  • Step 2: Upload Your Files To The Cloud
  • Step 3: Extract And Install Your Code
  • Step 4: Create A Starter Webapp, 1 of 2
  • Step 4: Create A Starter Webapp, 2 of 2
  • Step 5: Configure Your Webapp
  • Step 5: Take Your Cloud-based Webapp For A Spin!
• C. Top Ten Things We Didnt Cover: Theres Always More To Learn
  • 1. What About Python 2?
  • 2. Virtual Programming Environments
  • 3. More On Object Orientation
  • 4. Formats For Strings And The Like
  • 5. Getting Things Sorted
  • 6. More From The Standard Library
    • Collections
    • Itertools
    • Functools
  • 7. Running Your Code Concurrently
    • New keywords: async and await
  • 8. GUIs With Tkinter (And Fun With Turtles)
  • 9. Its Not Over Til Its Tested
  • 10. Debug, Debug, Debug
• D. Top Ten Projects Not Covered: Even More Tools, Libraries, And Modules
  • 1. Alternatives To >>>
  • 2. Alternatives To IDLE
    • What does Paul use?
  • 3. Jupyter Notebook: The Web-Based IDE
  • 4. Doing Data Science
  • 5. Web Development Technologies
    • But, wait, theres more
  • 6. Working With Web Data
    • Scrape that web data!
  • 7. More Data Sources
    • Theres more to querying data than SQL
  • 8. Programming Tools
    • More help with testing, too
  • 9. Kivy: Our Pick For Coolest Project Ever
  • 10. Alternative Implementations
• E. Getting Involved: The Python Community
  • BDFL: Benevolent Dictator For Life
    • PSF: The Python Software Foundation
    • PyCon: The Python Conference
  • A Tolerant Community: Respect For Diversity
    • Come for the language, stay for the community
  • The Python Podcasts
    • Python Newsletters
  • The Zen Of Python
  • Which Book Should I Read Next?
  • Our Favorite Python Books
• F. Back Cover Content: TOC images
  • What will you learn from this book?
  • Why does this book look so different?
  • Chapter 1 TOC Image
  • Chapter 2 TOC Image
  • Chapter 3 TOC Image
  • Chapter 4 TOC Image
  • Chapter 5 TOC Image
  • Chapter 6 TOC Image
  • Chapter 7 TOC Image
  • Chapter 8 TOC Image
  • Chapter 9 TOC Image
  • Chapter 10 TOC Image
  • Chapter 11 TOC Image
  • Chapter 11 TOC Image
  • Chapter 12 TOC Image
• About the Author
• Copyright

pokaż cały spis treści

ukryj recenzje