Job Ready Python

Cover
Title Page
Copyright Page
About the Authors
About the Technical Writer
About the Technical Editor
Acknowledgments
Contents
Introduction
	What Does This Book Cover?
	Reader Support for This Book
Part 1 Getting Started with Python
	Lesson 1 Setting Up a Python Programming Environment
		Python Overview
		Using Replit Online
			Creating a Replit Account
			Creating a Python Program in Replit
			Running a Python Program in Replit
			Other Replit Tasks
				Renaming Your Code File
				Saving Your Coding File Locally
				Creating a New File for Your Python Project
				Adding Files to Your Python Project
				Returning to Replit
				Getting More Help for Replit
		Getting Started with Jupyter Notebook
			Installing Anaconda Jupyter Notebook
			Creating a New Jupyter Notebook File
			Renaming a Jupyter Notebook Project File
			Saving a Python File Locally
			Opening an Existing Jupyter Notebook File
		A Quick Look at Visual Studio Code
			Obtaining Visual Studio Code
			Adding the Python Extension to Visual Studio Code
		Using Python from the Command Line
		Summary
		Exercises
			Exercise 1: Say Hello
			Exercise 2: What’s It Do?
			Exercise 3: Counting
			Exercise 4: Fruity Code
	Lesson 2 Understanding Programming Basics
		The Future of Computer Programming
			What Is Programming?
			What Is a Program?
			Computational Thinking
		Programming Languages
			Common Components
				Statements
				Syntax
				Reserved Words
				Operators
			Hello, World!
		Data Types and Variables
			Data Types
				Text
				Numbers
				True/False
				Date/Time
				Data Collections
			Variables
				Reserving Memory
				Variables and Data Types
			Constants
				Example 1: Area of a Circle
				Example 2: Tax Rate
				Example 3: Output Messages
		Summary
		Exercises
			Exercise 1: Daily Tasks
			Exercise 2: Python Programming
	Lesson 3 Exploring Basic Python Syntax
		Using with Single-Line Commands
		Using Semicolons
		Continuing with Backslash
		Working with Case Structure
		Adding Comments
		Using the Input Function
		Storing Input
		Understanding Variable Types
		Displaying Variable Values
		Naming Variables
		Summary
		Exercises
			Exercise 1: Displaying Text
			Exercise 2: Follow the Comments
			Exercise 3: Fixing the Code
			Exercise 4: Broken Variables
			Exercise 5: Broken Names
			Exercise 6: Where Are You?
	Lesson 4 Working with Basic Python Data Types
		Review of Data Types
		Number Data Types
		Identifying Data Types
		Mathematical Operations
		PEMDAS
		Common Math Functions
		Math Library Functions
		Using Numbers with User Input
		Boolean Types and Boolean Operations
			Convert to Boolean
		Logic Operations
		Comparative Operators
		Summary
		Exercises
			Exercise 1: Prompting the User
			Exercise 2: Manipulated Math
			Exercise 3: Integers Only
			Exercise 4: Current Value
			Exercise 5: Simple Interest
			Exercise 6: True or False
			Exercise 7: Playing with Numbers
			Exercise 8: Do the Math
			Exercise 9: Street Addresses
	Lesson 5 Using Python Control Statements
		Control Structures Review
		Understanding Sequence Control Structure
		Understanding Selection Statements
		Understanding Conditional Statements
		If-Else Statements
		Working with Nested Conditions
		Embedding Conditions
		Summary
		Exercises
			Exercise 1: Are You Rich?
			Exercise 2: Cats or Dogs
			Exercise 3: True or False Quiz
			Exercise 4: For Every Season…
			Exercise 5: Company Picnic
	Lesson 6 Pulling It All Together: Income Tax Calculator
		Getting Started
		Step 1: Gather Requirements
			Values in Use
			User Interface
			Other Standards
		Step 2: Design the Program
		Step 3: Create the Inputs
		Step 4: Calculate the Taxable Income
		Step 5: Calculate the Tax Rate
			Add a Conditional Statement
			Create Nested Conditionals
		Step 6: Update the Application
			What About Negative Taxable Incomes?
			Does Code Compare to Standards?
		Step 7: Address the UI
		On Your Own
		Summary
Part 2 Loops and Data Structures
	Lesson 7 Controlling Program Flow with Loops
		Iterations Overview
		The Anatomy of a Loop
		The for Loop
		The while Loop
			Unexecutable while Loop
		for vs. while Loops
		Strings and String Operations
			Determining the Length of a String
			Splitting a String
			Storing Characters
			Comparison Operators in Strings
			Concatenating Strings
			Slicing Strings
			Searching Strings
		Iterating through Strings
		Summary
		Exercises
			Exercise 1: Separating Your Fruits
			Exercise 2: Keeping It Short
			Exercise 3: Fruit Finder
			Exercise 4: It’s Divisible
			Exercise 5: Identify the Numbers
			Exercise 6: And the Total Is…
			Exercise 7: Multiplication Tables
			Exercise 8: Sum of Prime Numbers
			Exercise 9: One Letter at a Time
			Exercise 10: Length without len()
			Exercise 11: Count the Numbers
			Exercise 12: Fizz Buzz
	Lesson 8 Understanding Basic Data Structures: Lists
		Data Structure Overview—Part 1
		Creating Lists
		Determining List Length
		Working with List Indexes
		Negative Indexing in Lists
		Slicing Lists
			Using the Slice Object
		Adding Items to a List
		Inserting List Items
		Removing List Items
			Deleting versus Removing Items
			Popping Instead of Removing
		Concatenating Lists
		List Comprehension
		Sorting Lists
		Copying Lists
		Summary
		Exercises
			Exercise 1: All About You
			Exercise 2: Shopping List
			Exercise 3: List Deletion
			Exercise 4: List Modification
			Exercise 5: A Complete List Program
	Lesson 9 Understanding Basic Data Structures: Tuples
		Tuples and Tuple Operations
			Syntax of Tuples vs. Syntax of Lists
			Tuple Length
		Tuple Index Values
		Negative Indexing in Tuples
		Slicing Tuples
		Immutability
		Concatenating Tuples
		Searching Tuples
		Summary
		Exercises
			Exercise 1: Creating Tuples
			Exercise 2: Modifying Tuples
			Exercise 3: Where’s Waldo?
			Exercise 4: A Complete Tuple Program
	Lesson 10 Diving Deeper into Data Structures: Dictionaries
		Data Structure Overview—Part 2
		Getting Started with Dictionaries
		Generating a Dictionary
		Retrieving Items from a Dictionary
		Using the keys() Method
		Using the items() Method
		Reviewing the keys(), values(), and items() Methods
		Using the get() Method
		Using the pop() Method
		Working with the in Operator
		Updating a Dictionary
		Duplicating a Dictionary
		Clearing a Dictionary
		Summary
		Exercises
			Exercise 1: Working with Text
			Exercise 2: Separating the High from the Low
			Exercise 3: High and Low All in One
			Exercise 4: Self-Assessment
	Lesson 11 Diving Deeper into Data Structures: Sets
		Sets
		Retrieving Items from a Set
		Adding Items to a Set
		Creating an Empty Set
		Understanding Set Uniqueness
		Searching Items in a Set
		Calculating the Length of a Set
		Deleting Items from a Set
		Clearing a Set
		Popping Items in a Set
		Deleting a Set
		Determining the Difference Between Sets
		Intersecting Sets
		Combining Sets
		Summary
		Exercises
			Exercise 1: Line by Line
			Exercise 2: Adding New Names
			Exercise 3: Popping Accounts
			Exercise 4: Everywhere That Mary Went…
			Exercise 5: Self-Assessment
	Lesson 12 Pulling It All Together: Prompting for an Address
		Step 1: Getting Started
		Step 2: Accept User Input
		Step 3: Display the Input Value
		Step 4: Modify the Output
		Step 5: Split a Text Value
		Step 6: Display Only the House Number
		Step 7: Display the Street Name
		Step 8: Add the Period
		Summary
	Lesson 13 Organizing with Functions
		Functions Overview
		Defining Functions in Python
		Function Syntax
		Default Input Values
		Parameter Syntax
		Arbitrary Arguments
		Keyword Arguments
		Arbitrary Keyword Arguments
		Summary
		Exercises
			Exercise 1: Lower Numbers
			Exercise 2: This Will Be
			Exercise 3: Finding the Largest
			Exercise 4: Simple Calculator
			Exercise 5: Which Is Greater?
Part 3 Object-Oriented Programming in Python
	Lesson 14 Incorporating Object-Oriented Programming
		Object-Oriented Programming Overview
		Defining Classes
			Attributes
			Methods
		Creating Objects
		Working with Methods
		Class Attributes
			Working with Static Methods
			Working with Class Methods
		Summary
		Exercises
			Exercise 1: Create Your Own Class
			Exercise 2: Classy Vehicles
			Exercise 3: Streamlined Banking
			Exercise 4: Using a Calculator in Class
	Lesson 15 Including Inheritance
		Understanding Inheritance
		Creating a Parent Class
		Creating a Child Class
		Inheriting at Multiple Levels
		Overriding Methods
		Summary
		Exercises
			Exercise 1: Basic Inheritance
			Exercise 2: Adding Attributes
			Exercise 3: Creating More Children
			Exercise 4: Dogs and Cats
			Exercise 5: Hourly Employees
			Exercise 6: File System
	Lesson 16 Pulling It All Together: Building a Burger Shop
		Requirements for Our Application
		Plan the Code
		Create the Classes
		Create the Food Item Class
			Create a Burger Class
			Create a Drink Class
			Create a Side Class
			Create a Combo
			Create the Order Class
		Create the Main File
			Create order_once
			Order a Burger
			Add a Drink
			Add Sides
			Order a Combo
		Display the Output
		Tie the Code Files Together
		Summary
Part 4 Data Processing with Python
	Lesson 17 Working with Dates and Times
		Getting Started with Dates and Times
			Creating a Variable for a Date
			Creating a Variable for Time
			Creating a Variable for Both Date and Time
		Getting the Current Date and Time
		Splitting a Date String
		Using datetime Attributes
		Creating Custom datetime Objects
		Compare datetime Values
		Working with UTC Format
		Applying Timestamps
		Arithmetic and Dates
		Calculating the Difference in Days
		Using Date without Time
		Using Time without Date
		Summary
		Exercises
			Exercise 1: Displaying Dates
			Exercise 2: Leap Years
			Exercise 3: The Past
			Exercise 4: Unix Dates
			Exercise 5: Yesterday, Today, and Tomorrow
			Exercise 6: Setting Future Days
			Exercise 7: Five Seconds in the Future
			Exercise 8: Date Calculators
	Lesson 18 Processing Text Files
		File Processing Overview
		Introduction to File Input/Output
			The input() Function
			The open() Function
			The read() Method
			The write() Method
			The close() Method
			The print() Function
		Processing Text Files
		Opening a File
		Reading Text from a File
			Use the read() Method to Limit the Content
			Reading Lines
			Iterating through a File
		Add Content to a File
		Overwriting the Contents of a File
		Creating a New File
		Using the os Module
		Deleting a File
		Summary
		Exercises
			Exercise 1: Reading Lines
			Exercise 2: Combination of the Two
			Exercise 3: Combination of Them All
			Exercise 4: Listing Lines
			Exercise 5: Longest Word
			Exercise 6: Listing Text
			Exercise 7: Text in Reverse
	Lesson 19 Processing CSV Files
		Reading CSV Files
		Using the DictReader Class
		Creating a Dataset List
		Using writerow()
		Appending Data
		Writing Rows as Lists
		Writing Rows from Dictionaries
		Summary
		Exercises
			Exercise 1: Reading Lines
			Exercise 2: Company Stocks
			Exercise 3: Rearranging Files
			Exercise 4: Pop Music Evolution
			Exercise 5: All About Cars
	Lesson 20 Processing JSON Files
		Processing JSON Files
		Creating a JSON File with dump()
		Converting to JSON with dumps()
		Formatting JSON Data
		Using json.loads()
		Iterating through JSON Data
		Reading and Writing JSON Data
		Summary
		Exercises
			Exercise 1: Company Bank Account
			Exercise 2: Formatted Account Information
			Exercise 3: Nobel Prizes
			Exercise 4: New York Restaurants
			Exercise 5: Movies
Part 5 Data Analysis and Exception Handling
	Lesson 21 Using Lambdas
		Creating a Lambda Function
		Working with Multiple Inputs
		Placing Lambda Functions Inside a Function
		Using the map() Function
		Combining Map and Lambda Functions
		Using the filter() Function
		Combining a Filter and a Lambda
		Using the reduce() Function
			Specify an Initial Value
			Using reduce() with Comparison Operations
		Summary
		Exercises
			Exercise 1: Computing the Square Root
			Exercise 2: Converting a Text File to Uppercase
			Exercise 3: Determining Prime
			Exercise 4: Identifying Absolute Value
			Exercise 5: Highest Number
			Exercise 6: Lowest Number
			Exercise 7: Last Key
			Exercise 8: Highest Value
			Exercise 9: Sum of Even
			Exercise 10: Sum of Positive Numbers
			Exercise 11: Highest Stock Market Volume
			Exercise 12: Bad Stock Market Day
			Exercise 13: Highest Opening Price
			Exercise 14: Highest Price at Closing
			Exercise 15: Self-Assessment
	Lesson 22 Handling Exceptions
		Built-In Exceptions
		Working with try and except
		Working with Multiple Excepts
		Combining Exception Types
		Using Multiple Operations in a try
		Using the raise Keyword
		Exploring the General Exception Classes
		Adding finally
		Summary
		Exercises
			Exercise 1: Typing Numbers
			Exercise 2: Current Value
			Exercise 3: Reading Lines
			Exercise 4: Concatenating Files
			Exercise 5: Creating a List from a File
			Exercise 6: Self-Assessment
	Lesson 23 Pulling It All Together: Word Analysis in Python
		Examine the Data
		Read the Data
		Tokenize the Dataset
			Tokenize an Input String
			Tokenize an Input Review
			Tokenize the Entire Dataset
			Using the Tokenize Functions
		Count the Words in Each Review
			Word Count for an Input List of Words
			Word Count an Input Review
			Word Count for the Dataset
		Summary
	Lesson 24 Extracting, Transforming, and Loading with ETL Scripting
		ETL Scripting in Python
		Design and Implement Custom ETL Scripts
		The extract Class
			Adding the extract.fromCSV Method
			Creating the extract.fromJSON Method
			Creating the extract.fromMySQL Method
			Creating the extract.fromMongoDB Method
			Verify the extract.py Module
			Using Our Script as an External Module
		The transform Class
			Defining the transform Class
			Creating the head and tail Methods
			Renaming a Column
			Removing a Column from the Data Source
			Renaming Multiple Columns
			Removing Multiple Columns
			Transforming the Data
		The load Class
			Creating the load.toCSV Method
			Creating the load.toJSON Method
			Creating the load.toMYSQL Method
			Creating the Load.toMONGODB Method
		Summary
		Exercises
			Exercise 1: Transforming CSV to CSV
			Exercise 2: Transforming CSV to JSON
			Exercise 3: Transforming JSON to CSV
			Exercise 4: Transforming JSON to JSON
			Exercise 5: Removing an Attribute
			Exercise 6: Renaming an Attribute
			Exercise 7: Confirming an Attribute
	Lesson 25 Improving ETL Scripting
		Converting to Static Methods for the extract Class
		Converting to Static Methods for the transform Class
			Converting to Static Methods for the load Class
			Adding Exception Handling in the extract Class
			Creating a Custom Extractor for the extract Class
		Summary
		Exercises
			Exercise 1: Revisiting Lessons Learned
			Exercise 2: Day of Week
			Exercise 3: Date Validity
			Exercise 4: Listing Duplicates
			Exercise 5: Removing Duplicates
			Exercise 6: Transforming Names
Part 6 Appendices
	Appendix A: Flowcharts
		Flowchart Basics
			Sequences
			Branches
			Loops
		Common Flowcharting Shapes
			Flowcharting Example
			Additional Flowchart Elements
	Appendix B: Creating Pseudocode
		What Is Pseudocode?
	Appendix C: Installing MySQL
		MySQL Installation
			Download and Install MySQL
			Configure MySQL
		Verify the Installation
		The MySQL Notifier
	Appendix D: Installing Vinyl DB
		Database Structure
		Create the Database
	Appendix E: Installing MongoDB
		Installing MongoDB Community Server
		Running MongoDB
	Appendix F: Importing to MongoDB
Index
EULA