Last updated 7/2017MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHzLanguage: English | Size: 2.10 GB | Duration: 19h 44m

 

A journey from being a novice to a professional Python developer

What you'll learn

See the intricate details of the Python syntax and how to use it to your advantage

Learn to manipulate data effectively using built-in data structures

Get acquainted with advanced programming techniques in Python

Equip yourself with functional and statistical programming features

Take advantage of Python's metaprogramming and programmable syntax features

Understand how to handle high I/O loads with asynchronous I/O to get a smoother performance

Get familiar with Python’s metaprogramming and programmable syntax features

Learn the concepts of reactive programming and RxPy

Requirements

Basic programming knowledge is needed.

Description

If you are looking for a complete course on Python programming, then go for this Learning Path. Python is the preferred choice of developers, eeers, data scientists, and hobbyists everywhere. It is a great scripting language that can power your applications and provide speed, safety, and scalability.

We will b this learning journey by understanding the basic concepts of Python such as statements and syntax along with using numbers, strings, and tuples. We will then explore various function definition techniques along with learning the basics of classes and objects.

Going ahead, we will understand the intermediate concepts such as functional and reactive programming in Python. We will also explore statistical programming and regression.

Next, you will uncover the advanced topics in Python, will learn to implement real-world test cases to your programs along with integrating different applications.

By the end of this Video Learning Path, you will become proficient in Python.

About the Authors

Steven F. Lott has been programming since the 70s, when computers were large, expensive, and rare. As a contract software developer and architect, he has worked on hundreds of projects, from very small to very large. He's been using Python to solve business problems for over 10 years. He’s currently leveraging Python to implement microservices and ETL pipelines. His other titles with Packt Publishing include Python Essentials, Mastering Object-Oriented Python, Functional Python Programming, and Python for Secret Agents. Steven is currently a technomad who lives in various places on the east coast of the U.S.

Daniel Arbuckle gained his PhD in Computer Science from the University of Southern California. He has published numerous papers along with several books and video courses, and he is both a teacher of computer science and a professional programmer.

Overview

Section 1: Modern Python Solutions Part 1

Lecture 1 The Course Overview

Lecture 2 Creating Meaningful Names and Using Variables

Lecture 3 Working with Large and Small Integers

Lecture 4 Choosing between Float, Decimal, and Fraction

Lecture 5 Choosing between True Division and Floor Division

Lecture 6 Rewriting an Immutable String

Lecture 7 String Parsing with Regular Expressions

Lecture 8 Building Complex Strings with “template”.format

Lecture 9 Building Complex Strings from Lists of Characters

Lecture 10 Using the Unicode Characters that aren't on Our Keyboards

Lecture 11 Encoding Strings-Creating ASCII and UTF8 Bytes

Lecture 12 Decoding Bytes, How to Get Proper Characters from Some Bytes

Lecture 13 Using Tuples of Items

Lecture 14 Writing Python Script and Module Files

Lecture 15 Writing Long Lines of Code

Lecture 16 Including Descriptions and Documentation

Lecture 17 Writing Better RST Markup in docstring

Lecture 18 Designing Complex if…elif Chains

Lecture 19 Designing a While Statement that Teates Properly

Lecture 20 Avoiding a Potential Problem with Break Statements

Lecture 21 Leveraging the Exception Matching Rules

Lecture 22 Avoiding a Potential Problem With an Except:Clause

Lecture 23 Chaining Exceptions with the Raise from Statement

Lecture 24 Managing a Context Using the With Statement

Lecture 25 Designing Functions with Optional Parameters

Lecture 26 Using Super Flexible Keyword Parameter

Lecture 27 Forcing Keyword-only Argument with the * Separator

Lecture 28 Writing Explicit Types on Function Parameters

Lecture 29 Picking an Order for Parameters Based on Partial Functions

Lecture 30 Writing Clear Documentation Strings

Lecture 31 Designing Recursive Functions Around Python’s Stack Limit

Lecture 32 Writing Reusable Script with the Script Library Switch

Lecture 33 Choosing a Data Structure

Lecture 34 Building Lists – Literals, Appending, and Comprehensions

Lecture 35 Slicing And Dicing a List

Lecture 36 Deleting From a List

Lecture 37 Reversing a Copy of a List

Lecture 38 Using Set Methods and Operators

Lecture 39 Removing Items from a Set

Lecture 40 Creating Dictionaries

Lecture 41 Removing from Dictionaries

Lecture 42 Controlling the Order of the Dict Keys

Lecture 43 Handling Dictionaries and Sets in doctest Examples

Lecture 44 Understanding Variables, References, and Assignment

Lecture 45 Making Shallow and Deep Copies of Objects

Lecture 46 Avoiding Mutable Default Values for Function Parameters

Lecture 47 Using Features of the print Functions

Lecture 48 Using input and getpass for User Input

Lecture 49 Debugging with “Format”.Format_Map(Vars)

Lecture 50 Using Argparse to Get Command-line Input

Lecture 51 Using CMD for Creating Command-line Applications

Lecture 52 Using the OS Environment Settings

Section 2: Modern Python Solutions - Part 2

Lecture 53 The Course Overview

Lecture 54 Using a Class to Encapsulate Data and Processing

Lecture 55 Designing Classes with Lotsof Processing

Lecture 56 Designing Classes with Little Unique Processing

Lecture 57 Optimizing Small Objects with _slots_

Lecture 58 Using More Sophisticated Collections

Lecture 59 Extending a Collection

Lecture 60 Using Properties for Lazy Attributes

Lecture 61 Using Settable Properties to Update Eager Attributes

Lecture 62 Choosing Between Inheritance and Extension

Lecture 63 Separating Concerns via Multiple Inheritance

Lecture 64 Leveraging Python's Duck Typing

Lecture 65 Managing Global and Singleton Objects

Lecture 66 Using more Complex Structures

Lecture 67 Creating a Class that Has Orderable Object

Lecture 68 Defining an Ordered Collection

Lecture 69 Deleting from a List of Mappings

Lecture 70 Writing Generator Functions with the Yield Statement

Lecture 71 Using Stacked Generator Expression

Lecture 72 Applying Transformations to a Collection

Lecture 73 Picking a Subset

Lecture 74 Summarizing a Collection

Lecture 75 Combining Map and Reduce Transformations

Lecture 76 Implementing “There Exists” Processing

Lecture 77 Creating a Partial Function

Lecture 78 Simplifying Complex Algorithms with Immutable Data Structures

Lecture 79 Writing Recursive Generator Functions with the Yield from Statement

Lecture 80 Using pathlib to Work with Filenames

Lecture 81 Reading and Writing Files with Context Managers

Lecture 82 Replacing a File While Preserving the Previous Version

Lecture 83 Reading Delimited Files with the CSV Module

Lecture 84 Reading Complex Formats Using Regular Expressions

Lecture 85 Reading JSON Documents

Lecture 86 Reading XML Documents

Lecture 87 Reading HTML Documents

Lecture 88 Upgrading CSV from DictReader to the namedtuple Reader

Lecture 89 Upgrading CSV from a DictReader to a Namespace Reader

Lecture 90 Using Multiple Contexts for Reading and Writing Files

Lecture 91 Using the Built-in Statistic Library

Lecture 92 Average of Values in a Counter

Lecture 93 Computing the Coefficient of a Correlation

Lecture 94 Computing Regression Parameters

Lecture 95 Computing an Autocorrelation

Lecture 96 Config that the Data is Random – the Null Hypothesis

Lecture 97 Locating Outliers

Lecture 98 Analyzing Many Variables in One Pass

Section 3: Modern Python Solutions - Part 3

Lecture 99 The Course Overview

Lecture 100 Using docstring for Testing

Lecture 101 Testing Functions that Raise Exceptions

Lecture 102 Handling Common doctest Issues

Lecture 103 Creating Separate Test Modules and Packages

Lecture 104 Combining the unittest and doctest Tests

Lecture 105 Testing Things that Involve Dates and

Lecture 106 Testing Things That Involve Randomness

Lecture 107 Mocking External Resources

Lecture 108 Implementing Web Services with WSGI

Lecture 109 Using the Flask Framework for RESTful APIs

Lecture 110 Parsing the Query String in a Request

Lecture 111 Making REST Requests Using urllib

Lecture 112 Parsing the URL Path

Lecture 113 Parsing a JSON Request

Lecture 114 Implementing Authentications for Web Services

Lecture 115 Finding Configuration Files

Lecture 116 Using YAML for Configuration Files

Lecture 117 Using Python for Configuration Files

Lecture 118 Using Logging for Control and Audit Output

Lecture 119 Combining Two Applications into One

Lecture 120 Combining Many Applications Using the Command Design Pattern

Lecture 121 Controlling Complex Sequences of Steps

Section 4: Mastering Python - Second Edition

Lecture 122 The Course Overview

Lecture 123 Python Basic Syntax and Block Structure

Lecture 124 Built-in Data Structures and Comprehensions

Lecture 125 First-Class Functions and Classes

Lecture 126 Extensive Standard Library

Lecture 127 New in Python 3.5

Lecture 128 ing and Installing Python

Lecture 129 Using the Command-Line and the Interactive Shell

Lecture 130 Installing Packages with pip

Lecture 131 Finding Packages in the Python Package Index

Lecture 132 Creating an Empty Package

Lecture 133 Adding Modules to the Package

Lecture 134 Importing One of the Package's Modules from Another

Lecture 135 Adding Static Data Files to the Package

Lecture 136 PEP 8 and Writing Readable Code

Lecture 137 Using Version Control

Lecture 138 Using venv to Create a Stable and Isolated Work Area

Lecture 139 Getting the Most Out of docstrings 1: PEP 257 and docutils

Lecture 140 Getting the Most Out of docstrings 2: doctest

Lecture 141 Making a Package Executable via python -m

Lecture 142 Handling Command-Line Arguments with argparse

Lecture 143 Interacting with the User

Lecture 144 Executing Other Programs with Subprocess

Lecture 145 Using Shell Scripts or Batch Files to Run Our Programs

Lecture 146 Using concurrent.futures

Lecture 147 Using Multiprocessing

Lecture 148 Understanding Why This Isn't Like Parallel Processing

Lecture 149 Using the asyncio Event Loop and Coroutine Scheduler

Lecture 150 Waiting for Data to Become Available

Lecture 151 Synchronizing Multiple Tasks

Lecture 152 Communicating Across the Network

Lecture 153 Using Function Decorators

Lecture 154 Function Annotations

Lecture 155 Class Decorators

Lecture 156 Metaclasses

Lecture 157 Context Managers

Lecture 158 Descriptors

Lecture 159 Understanding the Principles of Unit Testing

Lecture 160 Using the unittest Package

Lecture 161 Using unittest.mock

Lecture 162 Using unittest's Test Discovery

Lecture 163 Using Nose for Unified Test Discover and Reporting

Lecture 164 What Does Reactive Programming Mean?

Lecture 165 Building a Simple Reactive Programming Framework

Lecture 166 Using the Reactive Extensions for Python (RxPY)

Lecture 167 Microservices and the Advantages of Process Isolation

Lecture 168 Building a High-Level Microservice with Flask

Lecture 169 Building a Low-Level Microservice with nameko

Lecture 170 Advantages and Disadvantages of Compiled Code

Lecture 171 Accessing a Dynamic Library Using ctypes

Lecture 172 Interfacing with C Code Using Cython

This Learning Path is for web developers, programmers, enterprise programmers, eeers, big data scientist, and so on. If you are a bner, Modern Python Recipes will get you started. If you are experienced, it will expand your knowledge base. A basic knowledge of programming would help.

HomePage: