Your complete guide to data science. Unleash the true potential of Python by learning basic programming and high-end data science techniques.Python has become the language of choice for most data analysts/data scientists to perform various tasks of data science. If you’re looking forward to implementing Python in your data science projects to enhance data discovery, then this is the perfect Learning Path is for you. Starting out at the basic level, this Learning Path will take you through all the stages of data science in a step-by-step manner.Packt’s Video Learning Paths are a series of individual video products put together in a logical and stepwise manner such that each video builds on the skills learned in the video before it.We begin this journey with nailing down the fundamentals of Python. You’ll be introduced to basic and advanced programming concepts of Python before moving on to data science topics. Then, you’ll learn how to perform data analysis by taking advantage of the core data science libraries in the Python ecosystem. You’ll also understand the data visualization concepts better, learn how to apply them and overcome any challenges that you might face while implementing them. Moving ahead, you’ll learn to use a wide variety of machine learning algorithms to solve real-world problems. Finally, you’ll learn deep learning along with a brief introduction to TensorFlow.By the end of the Learning Path, you’ll be able to improve the efficiency of your data science projects using Python.Meet Your Experts:We have combined the best works of the following esteemed authors to ensure that your learning journey is smooth:Daniel Arbuckle got his Ph.D. in Computer Science from the University of Southern California.Benjamin Hoff spent 3 years working as a software engineer and team leader doing graphics processing, desktop application development, and scientific facility simulation using a mixture of C++ and Python.
Facilities
Location
Start date
Online
Start date
Different dates availableEnrolment now open
About this course
Familiarize yourself with Python
Learn data analysis using modern processing techniques with NumPy, SciPy, and Pandas
Determine different approaches to data visualization, and how to choose the most appropriate one for your needs
Make 3D visualizations mainly using mplot3d
Work with image data and build systems for image recognition and biometric face recognition
Grasp how to use deep neural networks to build an optical character recognition system
Questions & Answers
Add your question
Our advisors and other users will be able to reply to you
We are verifying your question adjusts to our publishing rules. According to your answers, we noticed you might not be elegible to enroll into this course, possibly because of: qualification requirements, location or others. It is important you consult this with the Centre.
Thank you!
We are reviewing your question. We will publish it shortly.
Or do you prefer the center to contact you?
Reviews
Have you taken this course? Share your opinion
This centre's achievements
2021
All courses are up to date
The average rating is higher than 3.7
More than 50 reviews in the last 12 months
This centre has featured on Emagister for 4 years
Subjects
Install
Programming
Writing
Web
Syntax
Works
Testing
Course programme
Mastering Python - Second Edition.
51 lectures05:21:07Mastering Python - Second EditionThe Course Overview This video provides an overview of the entire course.Python Basic Syntax and Block Structure The goal of this video is to provide a basic understanding of the Python language constructs.
• Understand basic grammar elements
• Understand functions and classes
• Explain the reasoning behind Python's differences from other languagesBuilt-in Data Structures and Comprehensions The goal of this video is to ensure we have the basic ability to operate with Python's most common data structures.
• Learn to create data structures
• Learn how the structures organize data
• Learn to use comprehensions to operate on all members of a data structureFirst-Class Functions and Classes People used to lower-level languages are unfamiliar with First-class functions and classes; we'll take a look at them in this video.
• Define first-class objects
• Explain the implications of first-class functions
• Explain the implications of first-class classesExtensive Standard Library Python comes with a lot of tools. We need to be familiar with them in order to make the best use of the language. That's the topic we will be covering in this video.
• Take a look at data structures and data storage
• Understand encoding and decoding formats
• Interact with low-level operating system servicesNew in Python 3.5 The goal of this video is to look at the overview of recent language changes in Python.
• Look at the syntax changes
• Understand the library additions
• Take a tour of the other changesDownloading and Installing Python In this video, we are going to download and install the correct version of Python and make sure it's functional.
• Select the proper installer to download
• Install the Python runtime and libraries
• Test that everything is working correctlyUsing the Command-Line and the Interactive Shell The fastest way to get rolling is to use a textual interface, so we need to make sure we know how to use it. That's the goal in this video
• Open a command window
• Run the Python iterative shell
• Practice evaluating Python expressionsInstalling Packages with pip Python has good support for installing and managing third-party code packages; let's take a look at them in this video.
• Install packages
• Manage installed packages
• Search available packagesFinding Packages in the Python Package Index There's a lot of good code available. How do we find it? Let's take a look in this video.
• Understand keyword searches
• Know browsing categories
• Look at searching through PipCreating an Empty Package The goal of this video is to know how to create the structure of a Python program.
• Explore the relationship with filesystem directories
• Learn about __init__.py
• Try importing our new packageAdding Modules to the Package A package containing no code isn't of much use. How do we make it do something? Let's take a look at it in this video.
• Explore valid filenames for code modules
• Take a look at the contents of a code module
• Build up a programming interface from module partsImporting One of the Package's Modules from Another The goal in this video is to understand how we can make code in separate modules of the package interact.
• Understand absolute imports
• Learn relative imports
• Check out how to avoid dependency cyclesAdding Static Data Files to the Package A complete program usually involves static data files along with the code. How do we integrate non-python files in a package? Let's find out!
• Understand where to put data files
• Use pkgutil.get_data
• Load text dataMastering Python - Second EditionPEP 8 and Writing Readable Code The computer can read our code as long as the syntax is correct, but humans require more care. Let's see how we can write readable code in Python.
• Understand why tabs and spaces should not be mixed, and spaces are preferred
• Explain style conventions
• Explain naming conventionsUsing Version Control If more than one programmer is working on a project, version control is a necessity. Even for a single programmer, version control is useful. We will take a look at it in this video.
• Initialize Git
• Use Git as an undo log
• Branch, merge, and pullUsing venv to Create a Stable and Isolated Work Area In this video, we will see how writing a program can take a while, and it's best that external changes to the development system do not impact the process.
• Set up a virtual environment
• Activate a virtual environment
• Install packages locally in a virtual environmentGetting the Most Out of docstrings 1: PEP 257 and docutils Properly formatted docstrings can be automatically used by IDEs and transformed into HTML. Let's take a peek into it in this video.
• Understand basic docstring structure
• Understand reStructuredText for rich formatting
• Take a look at the Sphinx documentation compilerGetting the Most Out of docstrings 2: doctest The goal of this video is to understand why it's important that examples in the documentation stay consistent with the code.
• Understand how to write examples
• Learn how to check examples with doctest
• If the test fails, either the documentation is wrong or the code is; see how to rectifyMaking a Package Executable via python -m Writing Python code packages is all well and good, but how to we make a program? We will take a look at it in this video.
• Understand what python-m means
• Take a look at the __main__ module
• Recognize when the program is being run and when it is being importedHandling Command-Line Arguments with argparse It's useful to be able to read data from the program command line. The argparse package makes it easy. Let's see it in action in this video.
• Instantiate an argument parser object
• Configure a argument parser object
• Access the parsed dataInteracting with the User What do we do when we need information to flow both ways with the user?
• Get to know the basics of print() and input()
• Get introduced to the special cases: getpass and pprint
• Work on interactive interfaces with the cmd packageExecuting Other Programs with Subprocess Running other programs from within a program is often useful, especially, for system automation. We'll look at how to do it.
• Know more about the subprocess.call function and its variants
• Get to know the subprocess.Popen class
• Communicate with a background processUsing Shell Scripts or Batch Files to Run Our Programs It's often useful to have a launcher file for a program, which can be double-clicked in a GUI or used a shorthand from the command line. A simple script or batch file does the trick, let's see how.
• Create a shell script for Mac or Unix/Linux
• Create a batch file for Windows
• Use shell scripts or batch files to launch Python programsUsing concurrent.futures Parallel processing has pitfalls, but Python's high-level parallel processing framework makes it easy to dodge them. Let's look at it in this video.
• Learn the map and submit operations
• Understand Futures
• Know what to avoid for efficient data transfer between processesUsing Multiprocessing When our program doesn't fit the conceptual model of concurrent.futures, we can use multiprocessing to define our own model. Let's see how.
• Get to know the Process class
• Learn inter-process communication
• Understand synchronization between processesUnderstanding Why This Isn't Like Parallel Processing At first glance, Python's coroutine scheduling looks a lot like multiprocessing or multithreading. What's the difference? Let's get to know this better.
• See how coroutine scheduling operates in a single process
• Understand why coroutine scheduling has lower overhead per stream of execution
• Explore why coroutine scheduling is good for I/O bound programs, especially serversUsing the asyncio Event Loop and Coroutine Scheduler The goal of this video is to set up and run the asyncio asyncio coroutine scheduler
• Get the default scheduler
• Add coroutine tasks to the scheduler
• Run the scheduler to execute the tasksWaiting for Data to Become Available In this video we will see how do we actually use asyncio's Future objects.
• Wait for Future to arrive and retrieve the value
• Check if Future has arrived, then retrieve the value
• Loop over a sequence of Future dataSynchronizing Multiple Tasks The goal of this video is to understand how to keep coroutines from jamming each other up and locking the program.
• Know the standard synchronization primitives
• Understand why synchronization is not always needed
• Use queues for inter-coroutine communicationCommunicating Across the Network In this video, we will see how do asyncio's actual I/O facilities work
• Create a client
• Create a server
• Know when to stop serving a clientUsing Function Decorators Functions are very useful, but it would be nice to be able to tweak them to suit our specific needs. Enter function decorators.
• Understand what is a decorator and what does it does
• Define a wrapper inside a decorator
• Understand parameterized decoratorsFunction Annotations If we're going to be using functions as data, it would be nice to have metadata for the functions too. Function annotations give us that.
• Add metadata about function parameters
• Add metadata about the function's return value
• Annotations as input to function decoratorsClass Decorators Class objects are basically data structures, so it would be useful to be able to rewrite them as they're defined. Class decorators let us do that.
• Know that class decorators work just like function decorators
• Understand that classes are not functions, so the possibilities are different
• Rewrite classes as they're definedMetaclasses Class decorators take effect after Python has created a class object. If we want our code involved before the class object is created, we need to use a metaclass.
• Understand that classes are objects, and these objects are instances of other classes
• Control class object creation
• Make custom handling inheritableContext Managers Pieces of code often come in matched pairs, with one piece needing to run before something happens and the matching piece after. Context managers make sure the pieces match up.
• Context managers plug into the with statement
• Know the two ways to define a synchronous context manager
• Understand that asynchronous context managers are also an optionDescriptors We can plug code into Python's attribute access mechanism to control what it means to read, write, or delete a member variable.
• Use @property to create simple descriptors
• Write descriptors as classes
• Apply descriptors to simplify a complex I/O taskUnderstanding the Principles of Unit Testing Testing is critical, but it can feel like a burden. Automated unit testing and test-driven development can solve this problem.
• See how automated testing makes it quick and easy to run tests
• Understand why tests can motivate development rather than the other way around
• Check out that when we reduce the difficulty and increase the frequency, tests are more usefulUsing the unittest Package The unittest package provides a framework for writing automatic tests; let's check it out.
• Learn how we structure a test file
• Know how to compare what happens to what should happen
• Learn we run our testsUsing unittest.mock We need to separate the code we're testing from everything else. When the code interacts with other objects, we can replace them with mock objects. Let's see how.
• Replace an object with a mock
• Make a mock object imitate the behavior of a real object.
• Check whether a mock object is a userUsing unittest's Test Discovery As a test suite grows, running the tests individually becomes impractical. We need the system to find and run them in large swaths.
• Too many tests in one file becomes a problem, so break it up
• See why running each test individually would be annoying
• Take a look at the test discovery tool that finds all the tests and runs themUsing Nose for Unified Test Discover and Reporting Sometimes we want a more flexible test runner than the one built in to unittest. Nose to the rescue.
• Run tests with Nose
• Get a code coverage report
• Run tests in parallelWhat Does Reactive Programming Mean? For the newcomer, it can be difficult to figure out exactly what other people are talking about when they say "reactive programming".
• Publish/subscribe event handling
• Understand stateless functional composition
• Learn asynchronous executionBuilding a Simple Reactive Programming Framework Many of the discussions of reactive programming are highly theoretical. Building a reactive programming system for ourselves will help show how simple the basic ideas are.
• Wiring Observable
• Write Observer
• Write a demo applicationUsing the Reactive Extensions for Python (RxPY) Creating a complete and correct reactive programming framework takes a lot of time and effort. Since somebody's already done it, let's take a look at the result.
• Install RxPY
• Translate our demo
• Learn more RxPY featuresMicroservices and the Advantages of Process Isolation We need our web server to scale up and maintain high availability. Let's see how we can do that.
• Add Flexibility
• Add Scalability
• Add DurabilityBuilding a High-Level Microservice with Flask We need a microservice that works well with the web infrastructure or perhaps is even directly accessible to JavaScript running in web browsers...
Additional information
Basic knowledge of any programming language (preferably Python)
Some knowledge of linear algebra and statistics would be helpful, but is not mandatory