Skip to main content

Published by Sams Publishing (December 10, 2015) © 2016

Richard Blum | Christine Bresnahan
    VitalSource eTextbook (Lifetime access)
    €14,99
    ISBN-13: 9780134389578

    Python Programming for Raspberry Pi, Sams Teach Yourself in 24 Hours ,2nd edition

    Access details

    • Instant access once purchased
    • Fulfilled by VitalSource

    Features

    • Add notes and highlights
    • Search by keyword or page

    Language: English

    Product Information

     

    Python Programming for Raspberry Pi®

     

    In just 24 sessions of one hour or less, Sams Teach Yourself Python Programming for Raspberry Pi in 24 Hours teaches you Python programming on Raspberry Pi, so you can start creating awesome projects for home automation, home theater, gaming, and more. Using this book’s straight-forward, step-by-step approach, you’ll move from the absolute basics all the way through network and web connections, multimedia, and even connecting with electronic circuits for sensing and robotics. Every lesson and case study application builds on what you’ve already learned, giving you a rock-solid foundation for real-world success!


    • Step-by-step instructions carefully walk you through the most common Raspberry Pi Python programming tasks.
    • Quizzes at the end of each chapter help you test your knowledge.
    • By the Way notes present interesting information related to the discussion.
    • Did You Know? tips offer advice or show you easier ways to perform tasks.
    • Watch Out! cautions alert you to possible problems and give you advice on how to avoid them.

    Richard Blum has administered systems and networks for more than 25 years. He has published numerous Linux and open source books, and is an online instructor for web programming and Linux courses used by colleges across the United States. His books include Ubuntu Linux Secrets; Linux for Dummies, Ninth Edition; PostgreSQL 8 for Windows; and Professional Linux Programming.

    Christine Bresnahan began working as a systems administrator more than 25 years ago. Now an Adjunct Professor at Ivy Tech Community College, she teaches Python programming, Linux administration and computer security. She is coauthor of The Linux Bible, Eighth Edition. With Blum, she also coauthored Linux Command Line & Shell Scripting Bible, Second Edition.

     

    • Get your Raspberry Pi and choose the right low-cost peripherals
    • Set up Raspian Linux and the Python programming environment
    • Learn Python basics, including arithmetic and structured commands
    • Master Python 3 lists, tuples, diction-aries, sets, strings, files, and modules
    • Reuse the same Python code in multiple locations with functions
    • Manipulate string data efficiently with regular expressions
    • Practice simple object-oriented programming techniques
    • Use exception handling to make your code more reliable
    • Program modern graphical user interfaces with Raspberry Pi and OpenGL
    • Create Raspberry Pi games with the PyGame library
    • Learn network, web, and database techniques you can also use in business software
    • Write Python scripts that send email
    • Interact with other devices through Raspberry Pi’s GPIO interface
    • Walk through example Raspberry Pi projects that inspire you to do even more

     

    On the Web:

    Register your book at informit.com/title/9780672337642 for access to all code examples from the book, as well as update and corrections as they become available.

    Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
        Programming with Python . . . . . . . . . . . . . . . . . . . .  . . . . . . . . 1
        Who Should Read This Book? . . . . . . . . . . .  . . . . . . . . . . . 3
        Conventions Used in This Book . . . . . . . . . . . . . . . . . . . . . . . . 3

    Part I: Python Programming on the Raspberry Pi

    HOUR 1: Setting Up the Raspberry Pi . . . . . . . . . . . . . . . . . . . . . . 5
    Obtaining a Raspberry Pi . . . . . . . . . . . . . . . . . . . . . . . 5
    Acquiring a Raspberry Pi . . . . . . . . . . . . .  . . . . . . . . . . . . . . . . . . . . . 8
    Determining the Necessary Peripherals . . . . . . . . . . . . . . . . . . . . . . . 10
    Nice Additional Peripherals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
    Deciding How to Purchase Peripherals . . . . . . . . . . . . . . .  . . 18
    Getting Your Raspberry Pi Working . . . . . . . . . . . . . . . . . . . 18
    Troubleshooting Your Raspberry Pi . . . . . . . . . . . . . . . . . . . . . . . 24
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
    Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

    HOUR 2: Understanding the Raspbian Linux Distribution . . . . . . . . . . . . . . . . . 29
    Learning About Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
    Interacting with the Raspbian Command Line . . . . . . . . . . . .. . . . 30
    Interacting with the Raspbian GUI . . . . . . . . . . . . . . . .. . . . . . . . . 35
    The LXDE Graphical Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
    Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

    HOUR 3: Setting Up a Programming Environment
    . . . . . . . . . . . . . . . . . . . 47
    Exploring Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
    Checking Your Python Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
    Installing Python and Tools . . . . . . . . . . . . . . . .  . . . . . . . . . . . . . . 50
    Learning About the Python Interpreter . . . . . . . . . . . . . . . . . . . . . . . . . 52
    Learning About the Python Interactive Shell . . . . . . . . . .. . . . . . . . . . . . . 53
    Learning About the Python Development Environment . . . . . . . . . . . . . 57
    Creating and Running Python Scripts . . . . . . . . . . . . . .. . . . . . . . . . . 63
    Knowing Which Tool to Use and When . . . . . . . . . .. . . . . . . . . 68
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
    Workshop . . . . . . . . . . . . . . .  . . . . . . . . . . . . . . . . . . . . . . 70

    Part II: Python Fundamentals

    HOUR 4: Understanding Python Basics . . . . . . . . . . .. . . . . . . . . . . . . . 73
    Producing Python Script Output . . . . . . .  . . . . . . . . . . . . . . . . . . . 73
    Formatting Scripts for Readability . . . . . . . . .  . . . . . . . . . . . . 80
    Understanding Python Variables . . . . . . . . . . . . . . . . . . . . . . . . 83
    Assigning Value to Python Variables . . . . . . . . . . .  . . . . . . . . . . 85
    Learning About Python Data Types . . . . . . . . . . . . . . . . . . . . . . 89
    Allowing Python Script Input . . . . . . . . . . . . . . . . . . . . . . . . 90
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . .  . . . . . . . . . . . . . . . . . . . . . 97
    Workshop . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . 97

    HOUR 5: Using Arithmetic in Your Programs . . . . . . . . . . .. . . . . . . . . 99
    Working with Math Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
    Calculating with Fractions . . . . . . . . . . . . . . . . . .  . . . . . . . . . . . . 105
    Using Complex Number Math . . . . . . . . . . . . .  . . . . . . . . . . . . . . . . . 107
    Getting Fancy with the math Module . . . . . . . . . .  . . . . . . . . . . . . . . . . 108
    Using the NumPy Math Libraries . . . . . . . . . . . .  . . . . . . . . . . . . . . . . . . 112
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . 114
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
    Workshop . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . 115

    HOUR 6: Controlling Your Program
    . . . . . . . . . . . .  . . . . . . . . . . . . . . 117
    Working with the if Statement . . . . . . . . . . . . . . . . . . . . . . . . . 117
    Grouping Multiple Statements . . . . . . . . . . . . . . . . . . . . . . .. . . . . 119
    Adding Other Options with the else Statement . . . . . . . . . . . . . .. . . 121
    Adding More Options Using the elif Statement . . . . . . . . . . .. . . . 123
    Comparing Values in Python . . . . . . . . . . . . . . . . . . . . . . . . 126
    Checking Complex Conditions . . . . . . . . . . . . . . . . . . . . . . . . . 130
    Negating a Condition Check . . . . . . . . . . . . . . . . . . . . . . . . . 131
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
    Workshop . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . 133

    HOUR 7: Learning About Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
    Performing Repetitive Tasks . . . . . . . . . . . . . .  . . . . . . . . . . . . . . . 137
    Using the for Loop for Iteration . . . . . . . . . . . . . . . .  . . . . . . . 137
    Using the while Loop for Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . 148
    Creating Nested Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
    Workshop . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . 157

    Part III: Advanced Python

    HOUR 8: Using Lists and Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . 159
    Introducing Tuples . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . 159
    Introducing Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
    Using Multidimensional Lists to Store Data . . . . . . . . . . . .  . . . 171
    Working with Lists and Tuples in Your Scripts . . . . . . . . . .  . . 172
    Creating Lists by Using List Comprehensions . . . . . .. . . . . . 173
    Working with Ranges . . . . . . . . . . . . . . . . . . . . . . . . . 174
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . 175
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
    Workshop . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . 176

    HOUR 9: Dictionaries and Sets . . . . . . . . . . . . .. . . . . . . . . . 179
    Understanding Python Dictionary Terms . . . . . . . . . . . .. . . 179
    Exploring Dictionary Basics . . . . . . . . . . . . . . . . . . . . . . 180
    Programming with Dictionaries . . . . . . . . . . . .. . . . . . . 186
    Understanding Python Sets . . . . . . . . . . . . .  . . . . . . . . . . 192
    Exploring Set Basics . . . . . . . . . . . . . . . . . .  . . . . . . . . . . . . . . . . 193
    Obtaining Information from a Set . . . . . . . . . . .. . . . . . . . 194
    Modifying a Set . . . . . . . . . . . . . . . . . .  . . . . . . . 197
    Programming with Sets . . . . . . . . . . . . . . . . . . . . . 199
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
    Workshop . . . . . . . . . . . . . . . . . . .  . . . . . . . . . . . . 203

    HOUR 10: Working with Strings
    . . . . . . . . . . . . . . . . . .  . . . . . . 207
    The Basics of Using Strings . . . . . . . . . . . . .  . . . . . . . . . . . . 207
    Using Functions to Manipulate Strings . . . . . . . . . . . . . . . 210
    Formatting Strings for Output . . . . . . .  . . . 217
    Summary . . . . . . . . . . . . . . . . . . . . . .  . . . . . . . . 223
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
    Workshop . . . . . . . . . . . . . . . . . . .  . . . . . . 223

    HOUR 11: Using Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
    Understanding Linux File Structures . . . . . . . . . . . . .. . . . 225
    Managing Files and Directories via Python . . . . . . .  . . . 227
    Opening a File . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
    Reading a File . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . 233
    Closing a File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
    Writing to a File . . . . . . . . . . . . . . . . . .. . . . . . . . . . . 240
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
    Workshop . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . 247

    HOUR 12: Creating Functions . . . . . . . . . . . . . . .. . . . . 249
    Utilizing Python Functions in Your Programs . . . . . . . . . . . . 249
    Returning a Value . . . . . . . . . . . . . . . . . . . .  . . . . . . . . . . . . 253
    Passing Values to Functions . . . . . . . . . . .  . . . . . . . . 254
    Handling Variables in a Function . . . . . . . .  . . . . . . . . 260
    Using Lists with Functions . . . . . . . . . . . . . . . . . . . . . . . . . . 263
    Using Recursion with Functions . . . . . . . . . . . . . . . . 264
    Summary . . . . . . . . . . . . . . . . . . . . . . .  . . . . . . . . . . . . . . 265
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . 265
    Workshop . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . 266

    HOUR 13: Working with Modules . . . . . . . . . . . . . . . . . 269
    Introducing Module Concepts . . . . .. . . . . . . . . . . . . . . . 269
    Exploring Standard Modules . . . . . . . . .. . . . . . . . . . . . . 271
    Learning About Python Modules . . . .  . . . . . . . . . . . . . . . . . . . 273
    Creating Custom Modules . . . . . . . . . . . . . . . . . . . . . . . . . 277
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . 288
    Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288

    HOUR 14: Exploring the World of Object-Oriented Programming
    . . . . . . . . 291
    Understanding the Basics of Object-Oriented Programming . . . . . .  . . . 291
    Defining Class Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
    Sharing Your Code with Class Modules . . . . . . . . . . . . 302
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
    Q&A . . . . . . . . . . . . . . . .  . . . . . . . . . . . . . . . . . . . 305
    Workshop . . . . . . . . . . . . . . . .. . . . . . . . . . 305

    HOUR 15: Employing Inheritance . . . . . . . . . . . . .  . . . . . 307
    Learning About the Class Problem. . . . . . . . . . . . . . . .. . . . . 307
    Understanding Subclasses and Inheritance . . . . . . . . . . . . . 308
    Using Inheritance in Python . . . . . . . . . . . . . . . . . . . . . . . .. . 310
    Using Inheritance in Python Scripts . . . . . .  . . . . . . . . . . 316
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
    Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328

    HOUR 16: Regular Expressions . . . . . . . . .. . . . . . . . . . . . . . . . 331
    What Are Regular Expressions? . . . . . . . . . . . . . .. . . . . . . . . . . . . 331
    Working with Regular Expressions in Python. . . . . . . . . . . .. . . . . . 333
    The match() Function . . . . . . . . . . . . . . . . . .. . . . . . . . . . . 333
    The search() Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
    The findall() and finditer() Functions . . . . . . . . . . . . . . . . . . . . . 334
    Defining Basic Patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . 335
    Using Advanced Regular Expressions Features . . . . . . . . . . . . . . 343
    Working with Regular Expressions in Your Python Scripts . . . . . . . . 346
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  . . . 348
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . 348
    Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349

    HOUR 17: Exception Handling . . . . . . . . . . . . . . . .  . . . . . . 351
    Understanding Exceptions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
    Handling Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
    Handling Multiple Exceptions . . . . . . . . . . . . .  . . . . . . . . . . . . 358
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . 370
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  . . . . . . . . . . . . . . . . 371
    Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371

    Part IV: Graphical Programming

    HOUR 18: GUI Programming . . . . . . . . . . . . . . . . . . . . . . . . 373
    Programming for a GUI Environment . . . . . . . . . . . .. . . . . . . . 373
    Examining Python GUI Packages . . . . . . . . . . . . . . . . . . . 375
    Using the tkinter Package . . . . . . . . . . . . . . . . . . . . . . . . . 376
    Exploring the tkinter Widgets . . . . . . . . . . . . . . . . . . .. . . . . . . . 384
    Summary . . . . . . . . . . . . . . . . . . . . . . .  . . . . . . . . . . . . . . . . . . . . . 395
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
    Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395

    HOUR 19: Game Programming . . . . . . . . . . . . . . . . . 397
    Understanding Game Programming . . . . . . . . .. . .. . . 397
    Learning About Game Tools . . . . . . . . . . . . . . . . . . . . . . 398
    Setting Up the PyGame Library . . . . . . . . . . . . . . . . . . . . 399
    Using PyGame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
    Learning More About PyGame . . . . . . . . . . . . .. . . 409
    Dealing with PyGame Action . . . . . . . . . . . . . . . . . . . . 414
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  . . . . 423
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
    Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . 424

    Part V: Business Programming

    HOUR 20: Using the Network . . . . . . . . . . . . . . . . . . . . . 427
    Finding the Python Network Modules . . . . . . . . .. . . . . . . 427
    Working with Email Servers . . . . . . . . . . . . . . . . . . . . . . . 428
    Working with Web Servers . . . . . . . . . . . . . . . . .  . . . . .. . 436
    Linking Programs Using Socket Programming . . . . . . . . . . . . 442
    Summary . . . . . . . . . . . . . . . . . . . . . . . . .  . . . . . . . . . . . . . . . . .. . 449
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . 449
    Workshop . . . . . . . . . . . . . . . . . . . . .  . . . . . . . . . . . . . . . . . . . . 450

    HOUR 21: Using Databases in Your Programming
    . . . . . . . . . . . . 453
    Working with the MySQL Database . . . . . . . . . . . . . . . 453
    Using the PostgreSQL Database . . . . . . . . . . . .. . . . . . 464
    Summary . . . . . . . . . . . . . . . . . . . . . . . .  . . . . . . . . . . . . . . . . . 472
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . .  . . . . . . . . . . . . . . . . . . . . . . 472
    Workshop . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . 473

    HOUR 22: Web Programming . . . . . . . . . . . . . . . . . . . . . . . .  . . . . . . 475
    Running a Web Server on the Pi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
    Programming with the Common Gateway Interface . . . . . . .  . . . . . 478
    Expanding Your Python Webpages . . . . . . . . . . . . . . . .. . . . . . 481
    Processing Forms . . . . . . . . . . . . . . . . . . . . . . . . . . .  . . . . . . 488
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
    Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494

    Part VI: Raspberry Pi Python Projects

    HOUR 23: Creating Basic Pi/Python Projects . . . . . . . . . . . . . .  . . . . . . 497
    Thinking About Basic Pi/Python Projects . . . . . . . . . . . . . . . . 497
    Displaying HD Images via Python . . . . . . . . . . . .  . . . . . . . 497
    Playing Music . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . 517
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . 530
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  . . . 530
    Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . 530

    HOUR 24: Working with Advanced Pi/Python Projects . . . . .  . . . . . . . 533
    Exploring the GPIO Interface . . . . . . . . . . . . . . . . . . . . . 533
    Using the RPi.GPIO Module . . . . . . . . . .. . . . . 539
    Controlling GPIO Output . . . . . . . . . . .  . . . . . . . . . 541
    Detecting GPIO Input . . . . . . . . . . . . . . . . . .. . . . . . . . 546
    Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
    Q&A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
    Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554

    Appendixes

    APPENDIX A: Loading the Raspbian Operating System onto an SD Card . . . . . . . . . 557
    Downloading NOOBS . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . 558
    Verifying NOOBS Checksum . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
    Unpacking the NOOBS Zip File . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . 561
    Formatting the MicroSD Card . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . 562
    Copying NOOBS to a MicroSD Card . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566

    APPENDIX B: Raspberry Pi Models Synopsis . . . . . . . . . . . . . . . . . . . . . . . 567
    Raspberry Pi 2 Model B . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
    Raspberry Pi 1 Model B+ . . . . . . . . . . . . . . . . . . . . . . . . . . . .  . . . . . . . . 568
    Raspberry Pi 1 Model A+ . . . . . . . . . . . . . . . . . . . . . . . .  . . . . . . . . . . 569
    Older Raspberry Pi Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570

    Index .............................................................................................. 573 
    Top