Python Fundamentals

Python Fundamentals

by Paul J. Deitel
Released August 2019
Publisher(s): Pearson
ISBN: 0135917417

Watch it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Video description

45+ hours of video instruction.

Overview

The professional programmer’s Deitel® video guide to Python development with the powerful IPython and Jupyter Notebooks platforms.

Related Learning:

Live Training: Python Full Throttle and Python Data Science Full Throttle by Paul Deitel

Book: Python for Programmers by Paul Deitel and Harvey Deitel

Description

Python Fundamentals LiveLessons with Paul Deitel is a code-oriented presentation of Python—one of the world’s most popular and fastest growing languages. In the context of scores of real-world code examples ranging from individual snippets to complete scripts, Paul will demonstrate coding with the interactive IPython interpreter and Jupyter Notebooks. You’ll quickly become familiar with the Python language, its popular programming idioms, key Python Standard Library modules and several popular open-source libraries. In the Intro to Data Science videos, Paul lays the groundwork for later lessons in which he’ll introduce some of today’s most compelling, leading-edge computing technologies, including natural language processing, data mining Twitter® for sentiment analysis, cognitive computing with IBM® Watson™, supervised machine learning with classification and regression, unsupervised machine learning with clustering, computer vision through deep learning and convolutional neural networks, sentiment analysis through deep learning with recurrent neural networks, big data with Hadoop®, Spark™ streaming, NoSQL databases and the Internet of Things.

Download the code examples for this LiveLesson from https://github.com/pdeitel/PythonFundamentalsLiveLessons. This repository will be updated with the additional lessons’ examples as the lessons are completed.

About the Instructor

Paul J. Deitel, CEO and Chief Technical Officer of Deitel & Associates, Inc., is a graduate of MIT, where he studied Information Technology. He holds the Sun (now Oracle) Certified Java Programmer and Certified Java Developer certifications, and is an Oracle Java Champion. Through Deitel & Associates, Inc., he has delivered Java, C#, Visual Basic, C++, C and Internet programming courses to industry clients, including Cisco, IBM, Sun Micro systems, Dell, Siemens, Lucent Technologies, Fidelity, NASA at the Kennedy Space Center, the National Severe Storm Laboratory, White Sands Missile Range, Rogue Wave Software, Boeing, SunGard Higher Education, Stratus, Cambridge Technology Partners, One Wave, Hyperion Software, Adra Systems, Entergy, CableData Systems, Nortel Networks, Puma, iRobot, Invensys and many more. He and his co-author, Dr. Harvey M. Deitel, are the world’s best-selling programming-language textbook/professional book authors.

Skill Level

Beginner-to-Intermediate

What you Will Learn in Part I

  • Before You Begin—Configure your system for Python, obtain the code examples, Python package managers, Paul’s contact info
  • Lesson 1—Test-Drives: Using IPython and Jupyter Notebooks—Work with snippets and scripts in the context of IPython and Jupyter Notebooks
  • Lesson 2—Intro to Python Programming—Variables, types, operators, strings, I/O, decisions, objects and dynamic typing
  • Lesson 3—Control Statements—if, if…else, if…elif…else, for, while, break, continue, augmented assignments, boolean operators, intro to lists
  • Lesson 4—Functions—Custom function definitions, importing libraries, simulation with random-number generation, scope, default parameter values, keyword arguments, arbitrary argument lists, methods, intro to tuples, intro to functional-style programming

What you will learn in Part II:

  • Lesson 5—Sequences: Lists and Tuples—Create, initialize and access the elements of lists and tuples; sort and search lists, and search tuples; pass lists and tuples to functions and methods; list methods; functional-style programming (lambdas, filter, map, reduce, list comprehensions, generator expressions, 2D lists); static visualization with the Seaborn and Matplotlib visualization libraries.
  • Lesson 6—Dictionaries and Sets—Dictionaries of key—value pairs; sets of unique values; iterating through keys, values and key—value pairs; adding, removing and updating key—value pairs; dictionary and set comparison operators; set operators and methods; operators in and not in for membership testing; mutable set operations; dictionary and set comprehensions; dynamic visualization with the Seaborn and Matplotlib visualization libraries.
  • Lesson 7—Array-Oriented Programming with NumPy—numpy module’s high-performance ndarrays; how ndarrays differ from lists; comparing list vs. ndarrayperformance with the IPython %timeit magic; one-dimensional and multidimensionalndarrays; common ndarray manipulations; introduction to the pandas data manipulation library; one-dimensional Series and two-dimensional DataFrames; custom Series and DataFrame indices; basic descriptive statistics for data in aSeries and a DataFrame; customizing pandas output formatting.

What you will learn in Part III:

  • Lesson 8—Strings: A Deeper Look—String methods; string formatting; concatenating and repeating strings; stripping whitespace; string comparisons; search strings for substrings and replacing substrings; tokenizing strings; regular expressions for pattern matching, replacing substrings and validating data; manipulating data in pandas.
  • Lesson 9—Files and Exceptions—Text-file processing; serializing objects into the JSON with the json module; with statement for avoiding “resource leaks”; exception handling; try…except statement; else clause; executing code when no exceptions occur in a try suite; finally clause; raise exceptions; more details on tracebacks; stack unwinding; CSV file processing via the csv module; loading and manipulating CSV files in pandas.
  • Lesson 10—Object-Oriented Programming—Custom classes; controlling access to attributes; properties for data access; simulating “private” attributes; Python special methods for customizing string representations; inheritance, duck typing and polymorphism; class object; Python special methods for overloading operators; named tuples; Python 3.7 data classes; unit testing with doctest; namespaces and how they affect scope; Introduction to time series and simple linear regression.

What you will learn in Part IV:

  • Lesson 11—Natural Language Processing (NLP)—Install and use the TextBlob, NLTK, Textatistic and spaCy NLP libraries;, tokenize text into words and sentences; parts-of-speech tagging (noun, verb, etc.); sentiment analysis (positive, negative or neutral); detect the language of text; translate between languages; get word roots via stemming and lemmatization; spell checking and correction; word definitions, synonyms and antonyms; remove stop words from text; create word-cloud visualizations; determine text readability.
  • Lesson 12—Data Mining Twitter®—Access tweets and other information on Twitter with Tweepy—a popular Python Twitter API client; search past tweets with the Twitter Search API; sample the live tweet stream with the Twitter Streaming API; work with tweet object meta data; use NLP techniques to clean and preprocess tweets for analysis; perform sentiment analysis on tweets; spot trending topics with Twitter’s Trends API; map tweets using folium and OpenStreetMap.
  • Lesson 13—IBM Watson® and Cognitive Computing—Intro to Watson and its free Lite tier services; demos of several Watson services; registering for an IBM Cloud account; set up and get credentials for Watson services; install the Watson Developer Cloud Python SDK; build a Traveler’s companion language translator app that mashes up the Watson Speech to Text, Language Translator and Text to Speech services.

What you will learn in Part V’s case studies:

  • Lesson 14—Machine Learning: Classification, Regression and Clustering—Use scikit-learn with popular datasets to perform machine learning studies; Use Seaborn and Matplotlib to visualize and explore data; Perform supervised machine learning with k-nearest neighbors classification and linear regression; Perform multi-classification with Digits dataset; Divide a dataset into training, testing and validation sets; Tune hyperparameters with k-fold cross-validation; Measure model performance; Display a confusion matrix showing classification prediction hits and misses; Perform multiple linear regression with the California Housing dataset; Perform dimensionality reduction with PCA and t-SNE on the Iris and Digits datasets to prepare them for two-dimensional visualizations. Perform unsupervised machine learning with k-means clustering and the Iris dataset.

  • Lesson 15—Deep Learning—What a neural network is and how it enables deep learning; Create Keras neural networks;Keras layers, activation functions, loss functions and optimizers; Use a Keras convolutional neural network (CNN) trained on the MNIST dataset to build a computer vision application that recognizes handwritten digits; Use a Keras recurrent neural network (RNN) trained on the IMDb dataset to create a sentiment analysis application that performs binary classification of positive and negative movie reviews.

  • Lesson 16—Big Data: Hadoop, Spark, 17—Manipulate a SQLite relational database using SQL; Understand the four major types of NoSQL databases; Store tweets in a MongoDB NoSQL JSON document database and visualize them on a Folium map; Apache Hadoop and how it’s used in big-data batch-processing applications; Build a Hadoop MapReduce application on Microsoft’s Azure HDInsight cloud service; Apache Spark and how it’s used in high-performance, real-time big-data applications; Process mini-batches of data with Spark streaming; Internet of Things (IoT) and the publish/subscribe model; Publish messages from a simulated Internet-connected device and visualize messages in a dashboard; Subscribe to PubNub’s sample live streams and visualize the data.

LiveLessons Video Training series publishes hundreds of hands-on, expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. This professional and personal technology video series features world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, IBM Press, Pearson IT Certification, Prentice Hall, Sams, and Que. Topics include: IT Certification, Programming, Web Development, Mobile Development, Home & Office Technologies, Business & Management, and more. View All LiveLessons on InformIT: http://www.informit.com/imprint/series_detail.aspx?ser=2185116

Table of contents

  1. Part 1
    1. Introduction to Python Fundamentals: Part 1
  2. Before You Begin
    1. Lesson Overview: Before You Begin
    2. Getting the code
    3. Structure of the examples folder
    4. Installing Anaconda
    5. Updating Anaconda
    6. Package managers
    7. Installing jupyter-matplotlib
    8. Twitter developer account
    9. Getting your questions answered
  3. Lesson 01: Test-Drives: Using IPython and Jupyter Notebooks
    1. Lesson 01 Overview: Test-Drives: Using IPython and Jupyter Notebooks
    2. Using IPython Interactive Mode as a Calculator
    3. Executing a Python Program Using the IPython Interpreter
    4. Writing and Executing Code in a Jupyter Notebook
  4. Lesson 02: Intro to Python Programming
    1. Lesson 02 Overview: Intro to Python Programming
    2. Variables and Assignment Statements
    3. Self Check
    4. Arithmetic
    5. Self Check
    6. Function print and an Intro to Single- and Double-Quoted Strings
    7. Self Check
    8. Triple-Quoted Strings
    9. Self Check
    10. Getting Input from the User
    11. Self Check
    12. Decision Making: The if Statement and Comparison Operators
    13. Self Check
    14. Objects and Dynamic Typing
    15. Self Check
    16. Intro to Data Science: Basic Descriptive Statistics
    17. Self Check
  5. Lesson 03: Control Statements
    1. Lesson 03 Overview: Control Statements
    2. if Statement
    3. Self Check
    4. if...else and if...elif...else Statements
    5. Self Check
    6. while Statement
    7. Self Check
    8. for Statement; Iterables, Lists and Iterators; Built-in range Function
    9. Self Check
    10. Augmented Assignments
    11. Self Check
    12. Sequence-Controlled Iteration
    13. Self Check
    14. Sentinel-Controlled Iteration
    15. Built-In Function range: A Deeper Look
    16. Self Check
    17. Using Type Decimal for Monetary Amounts
    18. Self Check
    19. break and continue Statements
    20. Boolean Operators and, or and not
    21. Self Check
    22. Intro to Data Science: Measures of Central Tendency--Mean, Median and Mode
    23. Self Check
  6. Lesson 04: Functions
    1. Lesson 04 Overview: Functions
    2. Defining Functions
    3. Self Check
    4. Functions with Multiple Parameters
    5. Self Check
    6. Random-Number Generation
    7. Self Check
    8. Case Study: A Game of Chance
    9. Self Check
    10. math Module Functions
    11. Default Parameter Values
    12. Keyword Arguments
    13. Arbitrary Argument Lists
    14. Self Check
    15. Methods: Functions That Belong to Objects
    16. Scope Rules
    17. import: A Deeper Look
    18. Self Check
    19. Passing Arguments to Functions: A Deeper Look
    20. Self Check
    21. Functional-Style Programming
    22. Intro to Data Science: Measures of Dispersion
  7. Part 2
    1. Introduction to Python Fundamentals: Part 2
  8. Lesson 05: Sequences: Lists and Tuples
    1. Lesson 05 Overview: Sequences--Lists and Tuples
    2. Lists
    3. Self Check
    4. Tuples
    5. Self Check
    6. Unpacking Sequences
    7. Creating a primitive bar chart
    8. Self Check
    9. Sequence Slicing Part 1: Getting a Subset of a Sequence
    10. Sequence Slicing Part 2: Modifying a List
    11. Self Check
    12. del Statement
    13. Self Check
    14. Passing Lists to Functions
    15. Sorting Lists
    16. Self Check
    17. Searching Sequences
    18. Self Check
    19. Other List Methods
    20. Self Check
    21. Simulating Stacks with Lists
    22. List Comprehensions
    23. Self Check
    24. Generator Expressions
    25. Self Check
    26. Filter, Map and Reduce
    27. Self Check
    28. Other Sequence Processing Functions
    29. Self Check
    30. Two-Dimensional Lists
    31. Self Check
    32. Intro to Data Science: Simulation and Static Visualizations
    33. Sample Graphs for 600, 60,000 and 6,000,000 Die Rolls
    34. Visualizing Die-Roll Frequencies and Percentages--Part 1
    35. Visualizing Die-Roll Frequencies and Percentages--Part 2
    36. Visualizing Die-Roll Frequencies and Percentages--Part 3
    37. Visualizing Die-Roll Frequencies and Percentages--Part 4
  9. Lesson 06: Dictionaries and Sets
    1. Lesson 06 Overview: Dictionaries and Sets
    2. Dictionaries
    3. Creating a Dictionary
    4. Self Check
    5. Iterating through a Dictionary
    6. Basic Dictionary Operarations
    7. Self Check
    8. Dictionary Methods keys and values
    9. Self Check
    10. Dictionary Comparisons
    11. Example: Dictionary of Student Grades
    12. Example: Word Counts
    13. Python Standard Library Module collections
    14. Self Check
    15. Dictionary Method update
    16. Dictionary Comprehensions
    17. Self Check
    18. Sets
    19. Self Check
    20. Comparing Sets
    21. Self Check
    22. Mathematical Set Operations
    23. Self Check
    24. Mutable Set Operators and Methods
    25. Set Comprehensions
    26. Intro to Data Science: Dynamic Visualizations--Using Simulation and Dynamic Visualization to Demonstrate the Law of Large Numbers
    27. Intro to Data Science: Dynamic Visualizations--Implementing Dynamic Visualization, Part 1
  10. Lesson 07: Array-Oriented Programming with Numpy
    1. Lesson 07 Overview: Array-Oriented Programming with Numpy; Intro to Pandas
    2. Creating arrays from Existing Data
    3. Self Check
    4. array Attributes
    5. Self Check
    6. Filling arrays with Specific Values
    7. Creating arrays from Ranges
    8. Self Check
    9. List vs. array Performance: Introducing %timeit
    10. Self Check
    11. array Operators
    12. Self Check
    13. NumPy Calculation Methods
    14. Self Check
    15. Universal Functions
    16. Self Check
    17. Indexing and Slicing
    18. Self Check
    19. Views: Shallow Copies
    20. Deep Copies
    21. Reshaping and Transposing: reshape vs. resize
    22. Reshaping and Transposing: flatten vs. ravel
    23. Reshaping and Transposing: Transposing Rows and Columns
    24. Reshaping and Transposing: Horizontal and Vertical Stacking
    25. Self Check
    26. Intro to Data Science: pandas Series and DataFrames
    27. Intro to Data Science: pandas Series and DataFrames--pandas Series Part 1
    28. Intro to Data Science: pandas Series and DataFrames--pandas Series Part 2
    29. Self Check
    30. Intro to Data Science: pandas Series and DataFrames--Creating DataFrames and Customizing Indices
    31. Intro to Data Science: pandas Series and DataFrames--Accessing a DataFrame's Columns
    32. Intro to Data Science: pandas Series and DataFrames--Selecting Rows via the loc and iloc Attributes
    33. Intro to Data Science: pandas Series and DataFrames--Selecting Rows via Slices and Lists with the loc and iloc Attributes
    34. Intro to Data Science: pandas Series and DataFrames--Selecting Subsets of the Rows and Columns
    35. Intro to Data Science: pandas Series and DataFrames--Boolean Indexing
    36. Intro to Data Science: pandas Series and DataFrames--Accessing a Specific DataFrame Cell by Row and Column
    37. Intro to Data Science: pandas Series and DataFrames--Descriptive Statistics
    38. Intro to Data Science: pandas Series and DataFrames--Transposing the DataFrame with the T Attribute
    39. Intro to Data Science: pandas Series and DataFrames--Sorting by Indices
    40. Intro to Data Science: pandas Series and DataFrames--Sorting by Column Values
    41. Self Check
  11. Part 3
    1. Introduction to Python Fundamentals: Part 3
  12. Lesson 08: Strings--A Deeper Look
    1. Lesson 08 Overview: Strings--A Deeper Look; Pandas, Regular Expressions and Data Munging
    2. Formatting Strings--Presentation Types
    3. Self Check
    4. Formatting Strings--Field Widths and Alignment
    5. Self Check
    6. Formatting Strings--Numeric Formatting
    7. Self Check
    8. Formatting Strings--String's format Method
    9. Self Check
    10. Concatenating and Repeating Strings
    11. Self Check
    12. Stripping Whitespace from Strings
    13. Self Check
    14. Changing Character Case
    15. Self Check
    16. Comparison Operators for Strings
    17. Searching for Substrings
    18. Self Check
    19. Replacing Substrings
    20. Self Check
    21. Splitting and Joining Strings
    22. Self Check
    23. Characters and Character-Testing Methods
    24. Raw Strings
    25. Introduction to Regular Expressions
    26. re Module and Function fullmatch Part 1--Matching Literal Characters
    27. re Module and Function fullmatch Part 2--Metacharacters, Character Classes and Quantifiers
    28. re Module and Function fullmatch Part 3--Custom Character Classes
    29. re Module and Function fullmatch Part 1--Quantifiers
    30. Self Check
    31. Replacing Substrings and Splitting Strings
    32. Self Check
    33. Other Search Functions; Accessing Matches--Function search: Finding the First Match Anywhere in a String
    34. Other Search Functions; Accessing Matches--Ignoring Case with the Optional flags Keyword Argument
    35. Other Search Functions; Accessing Matches--Metacharacters that Restrict Matches to the Beginning or End of a String
    36. Other Search Functions; Accessing Matches--Functions findall and finditer: Finding All Matches in a String
    37. Other Search Functions; Accessing Matches--Capturing Substrings in a Match
    38. Self Check
    39. Intro to Data Science: Pandas, Regular Expressions and Data Munging Part 1: Introduction
    40. Intro to Data Science: Pandas, Regular Expressions and Data Munging Part 3: Data Validation
    41. Intro to Data Science: Pandas, Regular Expressions and Data Munging Part 4: Reformatting Your Data
    42. Self Check
  13. Lesson 09: Files and Exceptions
    1. Lesson 09 Overview: Files and Exceptions; Pandas, CSV Files and Simple Data Analysis
    2. Files
    3. Text-File Processing--Writing to a Text File: Introducing the with Statement
    4. Self Check
    5. Text-File Processing--Reading Data from a Text File
    6. Self Check
    7. Updating Text Files
    8. Self Check
    9. Serialization with JSON--JSON Data Format
    10. Serialization with JSON--Serializing an Object to JSON
    11. Serialization with JSON--Deserializing a JSON Object into Python
    12. Serialization with JSON--Displaying JSON Text
    13. Self Check
    14. File Open Modes
    15. Handling Exceptions
    16. Division by Zero and Invalid Input
    17. try Statements
    18. Self Check
    19. finally Clause
    20. Self Check
    21. Explicitly Raising an Exception
    22. Stack Unwinding and Tracebacks
    23. Intro to Data Science: Working with CSV Files--Python Standard Library Module csv
    24. Self Check
    25. Intro to Data Science: Working with CSV Files--Reading CSV Files into Pandas DataFrames
    26. Intro to Data Science: Working with CSV Files--Reading the Titanic Disaster Dataset
    27. Intro to Data Science: Working with CSV Files--Simple Data Analysis with the Titanic Disaster Dataset
    28. Intro to Data Science: Working with CSV Files--Passenger Age Histogram
  14. Part 4
    1. Introduction to Python Fundamentals: Part 4
  15. Lesson 10: Object-Oriented Programming
    1. Lesson 10 Overview: Object-Oriented Programming
    2. Custom Class Account--Test-Driving Class Account
    3. Custom Class Account--Account Class Definition
    4. Self Check
    5. Controlling Access to Attributes
    6. Properties for Data Access--Test-Driving Class Time
    7. Properties for Data Access--Class Time Definition
    8. Self Check
    9. Properties for Data Access--Class Time Definition Notes
    10. Simulating Private Attributes
    11. Case Study: Card Shuffling and Dealing Simulation--Test Driving Classes Card and DeckOfCards
    12. Case Study: Card Shuffling and Dealing Simulation--Class Card and an Introduction to Class Attributes
    13. Case Study: Card Shuffling and Dealing Simulation--Class DeckOfCards
    14. Case Study: Card Shuffling and Dealing Simulation--Displaying Card Images with Matplotlib
    15. Self Check
    16. Inheritance: Base Classes and Subclasses
    17. Building an Inheritance Hierarchy and Introducing Polymorphism--Base Class CommissionEmployee
    18. Building an Inheritance Hierarchy and Introducing Polymorphism--Sublass SalariedCommissionEmployee
    19. Building an Inheritance Hierarchy and Introducing Polymorphism--Processing CommissionEmployees and SalariedCommissionEmployees Polymorphically
    20. Duck Typing and Polymorphism
    21. Operator Overloading
    22. Test-Driving Class Complex
    23. Class Complex Definition
    24. Self Check
    25. Named Tuples
    26. A Brief Intro to Python 3.7's New Data Classes
    27. A Brief Intro to Python 3.7's New Data Classes--Creating a Card Data Class
    28. A Brief Intro to Python 3.7's New Data Classes--Using the Card Data Class
    29. Self Check
    30. A Brief Intro to Python 3.7's New Data Classes--Advantages Over Named Tuples and Traditional Classes
    31. Unit Testing with Docstrings and doctest
    32. Self Check
    33. Namespaces and Scopes
    34. Intro to Data Science: Time Series and Simple Linear Regression--Introduction
    35. Intro to Data Science: Time Series and Simple Linear Regression--Components of the Simple Linear Regression Calculation
    36. Intro to Data Science: Time Series and Simple Linear Regression--Loading the Average High Temperatures into a DataFrame
    37. Intro to Data Science: Time Series and Simple Linear Regression--Cleaning the Data
    38. Intro to Data Science: Time Series and Simple Linear Regression--Calculating Basic Descriptive Statistics for the Dataset
    39. Intro to Data Science: Time Series and Simple Linear Regression--Forecasting Future January Average High Temperatures
    40. Intro to Data Science: Time Series and Simple Linear Regression--Plotting the Average High Temperatures and a Regression Line
  16. Lesson 11: Natural Language Processing
    1. Lesson 11 Overview: Natural Language Processing (NLP)
    2. Introduction
    3. TextBlob
    4. Create a TextBlob
    5. Tokenizing Text into Sentences and Words
    6. Parts-of-Speech Tagging
    7. Extracting Noun Phrases
    8. Sentiment Analysis with TextBlob's Default Sentiment Analyzer
    9. Sentiment Analysis with the NaiveBayesAnalyzer
    10. Language Detection and Translation
    11. Inflection: Pluralization and Singularization
    12. Spell Checking and Correction
    13. Normalization: Stemming and Lemmatization
    14. Word Frequencies
    15. Getting Definitions, Synonyms and Antonyms from WordNet
    16. Deleting Stop Word
    17. n-grams
    18. Visualizing Word Frequencies with Pandas
    19. Visualizing Word Frequencies with Word Clouds
    20. Readability Assessment with Textatistic
    21. Named Entity Recognition with spaCy
    22. Similarity Detection with spaCy
  17. Lesson 12: Data Mining Twitter
    1. Lesson 12 Overview: Data Mining Twitter
    2. Introduction
    3. Overview of the Twitter APIs
    4. Creating a Twitter Developer Account
    5. Getting Twitter Credentials--Creating an App
    6. What's in a Tweet?
    7. Tweepy
    8. Authenticating with Twitter Via Tweepy
    9. Getting Information About a Twitter Account
    10. Self Check
    11. Introduction to Tweepy Cursors: Getting an Account's Followers and Friends
    12. Determining an Account's Followers
    13. Self Check
    14. Determining Whom an Account Follows
    15. Getting a User's Recent Tweets
    16. Self Check
    17. Searching Recent Tweets
    18. Self Check
    19. Spotting Trends: Twitter Trends API
    20. Places with Trending Topics
    21. Getting a List of Trending Topics
    22. Self Check
    23. Create a Word Cloud from Trending Topics
    24. Self Check
    25. Cleaning/Preprocessing Tweets for Analysis
    26. Twitter Streaming API
    27. Creating a Subclass of StreamListener
    28. Initiating Stream Processing
    29. Twitter Restrictions Note
    30. Tweet Sentiment Analysis
    31. Geocoding and Mapping
    32. Getting and Mapping the Tweets
    33. Utility Functions in tweetutilities.py and Class LocationListener
  18. Lesson 13: IBM Watson and Cognitive Computing; Building a Speech-to-Speech Translator
    1. Lesson 13 Overview: IBM Watson and Cognitive Computing; Building a Speech-to-Speech Translator
    2. Introduction to Watson
    3. IBM Cloud Account and Cloud Console
    4. Watson Services: Watson Assistant Demo
    5. Watson Services: Visual Recognition
    6. Watson Services: Speech to Text
    7. Watson Services: Text to Speech
    8. Watson Services: Language Translator
    9. Watson Services: Natural Language Understanding
    10. Watson Services: Personality Insights
    11. Additional Services and Tools
    12. Watson Developer Cloud Python SDK
    13. Case Study: Traveler's Companion Translation App
    14. Before You run the App
    15. Before You run the App: Registering for the Speech to Text Service
    16. Before You run the App: Registering for the Text to Speech Service
    17. Before You run the App: Registering for the Language Translator Service
    18. Test-Driving the App
    19. SimpleLanguageTranslator.py Script Walkthrough
    20. SimpleLanguageTranslator.py Script Walkthrough: Importing Watson SDK Classes from the ibm_watson Module
    21. SimpleLanguageTranslator.py Script Walkthrough: Other Imported Modules
    22. SimpleLanguageTranslator.py Script Walkthrough: Main Program: Function run_translator
    23. SimpleLanguageTranslator.py Script Walkthrough: Function speech_to_text
    24. SimpleLanguageTranslator.py Script Walkthrough: Function translate
    25. SimpleLanguageTranslator.py Script Walkthrough: Function text_to_speech
    26. SimpleLanguageTranslator.py Script Walkthrough: Function record_audio
    27. SimpleLanguageTranslator.py Script Walkthrough: Function play_audio
    28. Watson Resources
  19. Lesson 14, Machine Learning: Classification, Regression and Clustering
    1. Lesson 14 Overview: Machine Learning: Classification, Regression and Clustering
    2. Introduction to Machine Learning
    3. Case Study: Classification with k-Nearest Neighbors and the Digits Dataset, Part 1
    4. k-Nearest Neighbors Algorithm
    5. k-Nearest Neighbors Algorithm: Hyperparameters and Hyperparameter Tuning
    6. Loading the Dataset
    7. Loading the Dataset: Displaying the Description
    8. Loading the Dataset: Checking the Sample and Target Sizes
    9. Loading the Dataset: A Sample Digit Image
    10. Loading the Dataset: Preparing the Data for Use with Scikit-Learn
    11. Visualizing the Data
    12. Splitting the Data for Training and Testing
    13. Creating the Model
    14. Training the Model
    15. Predicting Digit Classes
    16. Case Study: Classification with k-Nearest Neighbors and the Digits Dataset, Part 2
    17. Metrics for Model Accuracy: Estimator Method score
    18. Metrics for Model Accuracy: Confusion Matrix
    19. Metrics for Model Accuracy: Classification Report
    20. Metrics for Model Accuracy: Visualizing the Confusion Matrix
    21. K-Fold Cross-Validation
    22. Running Multiple Models to Find the Best One
    23. Hyperparameter Tuning
    24. Case Study: Time Series and Simple Linear Regression
    25. Loading the Average High Temperatures into a DataFrame
    26. Splitting the Data for Training and Testing
    27. Training the Model
    28. Testing the Model
    29. Predicting Future Temperatures and Estimating Past Temperatures
    30. Visualizing the Dataset with the Regression Line
    31. Overfitting/Underfitting
    32. Case Study: Multiple Linear Regression with the California Housing Dataset
    33. Loading the Dataset
    34. Exploring the Data with Pandas
    35. Visualizing the Features
    36. Splitting the Data for Training and Testing
    37. Training the Model
    38. Testing the Model
    39. Visualizing the Expected vs. Predicted Prices
    40. Regression Model Metrics
    41. Choosing the Best Model
    42. Case Study: Unsupervised Machine Learning, Part 1--Dimensionality Reduction
    43. Loading the Digits Dataset
    44. Creating a TSNE Estimator for Dimensionality Reduction
    45. Transforming the Digits Dataset's Features into Two Dimensions
    46. Visualizing the Reduced Data
    47. Visualizing the Reduced Data with Different Colors for Each Digit
    48. Visualizing the Reduced Data in 3D
    49. Case Study: Unsupervised Machine Learning, Part 2--k-Means Clustering
    50. Loading the Iris Dataset
    51. Exploring the Iris Dataset: Descriptive Statistics with Pandas
    52. Visualizing the Dataset with a Seaborn pairplot
    53. Using a KMeans Estimator
    54. Dimensionality Reduction with Principal Component Analysis
    55. Choosing the Best Clustering Estimator
  20. Lesson 15: Deep Learning
    1. Lesson 15 Overview: Deep Learning
    2. Introduction
    3. Deep Learning Applications
    4. Deep Learning Demos
    5. Keras Resources
    6. Keras Built-In Datasets
    7. Custom Anaconda Environments
    8. Neural Networks
    9. Tensors
    10. Convolutional Neural Networks for Vision; Multi-Classification with the MNIST Dataset
    11. Reproducibility in Keras and Deep Learning
    12. Basic Keras Neural Network
    13. Loading the MNIST Dataset
    14. Data Exploration
    15. Visualizing Digits
    16. Reshaping the Image Data
    17. Normalizing the Image Data
    18. One-Hot Encoding: Converting the Labels From Integers to Categorical Data
    19. Creating the Neural Network
    20. Adding Layers to the Network
    21. Convolution
    22. Adding a Conv2D Convolution Layer to Our Model
    23. Dimensionality of the First Convolution Layer’s Output
    24. Overfitting
    25. Adding a Pooling Layer
    26. Adding Another Convolutional Layer and Pooling Layer
    27. Flattening the Results to One Dimension with a Keras Flatten Layer
    28. Adding a Dense Layer to Reduce the Number of Features
    29. Adding Another Dense Layer to Produce the Final Output
    30. Printing the Model's Summary
    31. Visualizing a Model’s Structure
    32. Compiling the Model
    33. Training and Evaluating the Model
    34. Evaluating the Model on Unseen Data
    35. Making Predictions
    36. Locating the Incorrect Predictions
    37. Visualizing Incorrect Predictions
    38. Displaying the Probabilities for Several Incorrect Predictions
    39. Saving and Loading a Model
    40. Visualizing Neural Network Training with TensorBoard
    41. ConvnetJS: Browser-Based Deep-Learning Training and Visualization
    42. Recurrent Neural Networks for Sequences; Sentiment Analysis with the IMDb Dataset
    43. Loading the IMDb Movie Reviews Dataset
    44. Data Exploration
    45. Movie Review Encodings and Decoding a Review
    46. Data Preparation
    47. Creating the Neural Network
    48. Adding an Embedding Layer
    49. Adding an LSTM Layer
    50. Adding a Dense Output Layer
    51. Compiling the Model and Displaying the Summary
    52. Training and Evaluating the Model (1 of 2)
    53. Training and Evaluating the Model (2 of 2)
    54. Tuning Deep Learning Models
  21. Lesson 16: Big Data: Hadoop, Spark, NoSQL (MongoDB) and IoT
    1. Lesson 16 Overview: Big Data: Hadoop, Spark, NoSQL (MongoDB) and IoT
    2. Introduction--Databases
    3. Introduction--Apache Hadoop and Apache Spark
    4. Introduction--Internet of Things
    5. Introduction--Experience Cloud and Desktop Big-Data Software
    6. Introduction--Big Data Sources
    7. Relational Databases and Structured Query Language (SQL)
    8. A books Database
    9. SELECT Queries
    10. WHERE Clause
    11. ORDER BY Clause
    12. Merging Data from Multiple Tables: INNER JOIN
    13. INSERT INTO Statement
    14. UPDATE Statement
    15. DELETE FROM Statement
    16. NoSQL and NewSQL Big-Data Databases: A Brief Tour
    17. NoSQL Key-Value Databases
    18. NoSQL Document Databases
    19. NoSQL Columnar Databases
    20. NoSQL Graph Databases
    21. NewSQL Databases
    22. Case Study: A MongoDB JSON Document Database
    23. Creating the MongoDB Atlas Cluster
    24. Streaming Tweets into MongoDB
    25. Hadoop
    26. Hadoop Overview
    27. Summarizing Word Lengths in Romeo and Juliet via MapReduce
    28. Creating an Apache Hadoop Cluster in Microsoft Azure HDInsight: Part 1
    29. Creating an Apache Hadoop Cluster in Microsoft Azure HDInsight: Part 2
    30. Hadoop Streaming
    31. Implementing the Mapper
    32. Implementing the Reducer
    33. Preparing to Run the MapReduce Example
    34. Running the MapReduce Job
    35. Spark Overview
    36. Docker and the Jupyter Docker Stacks
    37. Word Count with Spark
    38. Spark Word Count on Microsoft Azure
    39. Spark Streaming: Counting Twitter Hashtags Using the pysparknotebook Docker Stack
    40. Streaming Tweets to a Socket
    41. Summarizing Tweet Hashtags; Introducing Spark SQL
    42. Internet of Things and Dashboards
    43. Publish and Subscribe
    44. Visualizing a PubNub Sample Live Stream with a Freeboard Dashboard
    45. Simulating an Internet-Connected Thermostat in Python and Creating a Dashbboard in Freeboard.io
    46. Creating a Python PubNub Subscriber

Product information

  • Title: Python Fundamentals
  • Author(s): Paul J. Deitel
  • Release date: August 2019
  • Publisher(s): Pearson
  • ISBN: 0135917417