Ontwikkel je van Python Novice naar Pythonista (Update) (incl. begeleiding)

This 15-video course lets learners explore the basics of how to use the Python programming language. You will learn to set up with an interactive environment that allows you to develop and run Python scripts on your machine. Begin by installing Anaconda, an open-source distribution of the Python and R programming languages. You will learn to write your first meaningful program in Python, then create a Jupyter notebook, the most popular tool for writing and running Python code. You will learn how to do simple coding by using Python's Jupyter notebooks, and explore different Jupyter functionalities, including built-in functions. Learners will explore how to use a Python variable to store values, and learn to differentiate between variables of different types, and the different ways to assign values to variables. You will examine how variables act as containers, and you will learn how to change values that are inside a container. Finally, you will learn to use integers, floating-point numbers, strings, and to work with Boolean values.

Learn how to work with lists, tuples, and strings in Jupyter notebook in Python in this 14-video course. You will discover similarities and differences between tuples and lists and see how strings are essentially just a list of characters. Begin with an introduction to lists, and then create and initialize lists in Python. You will then access and update list elements; add, remove, sort, and reverse elements from a list; execute built-in functions with lists, and create new lists from existing lists by using slicing operations. Next, examine how to extract specific elements from the original list using step size; perform list functions on strings; invoke functions on the string object; and access substrings with slicing operations. Receive an introduction to tuples, exploring the similarities between lists and tuples, then move on to understanding tuple immutability by specifying differences between lists and tuples. Then an introduction to other complex data types and using dictionaries and sets in Python. The concluding exercise concerns recalling differences and similarities between lists and tuples.

This 9-video course helps learners explore dictionary data type in Python. Dictionaries are associative containers used to store key-value pairs. Given a key, finding the associated value is optimized by Python to be extremely efficient. First, receive an introduction to dictionaries in Jupyter Notebook in Python. You will learn how to create and initialize dictionaries, then learn about nesting complex data types within dictionaries. Continuing with the study of Python dictionaries, you will explore what functions and methods can be invoked on these dictionaries, such as modifying and updating dictionaries using dictionary methods. Next, you will be introduced to sets, another commonly used complex data type that Python supports. You will then create and initialize sets. This leads on to performing set operations such as union, intersection difference, and other set operations. You will also examine nested lists, and work with nested types within other complex data types. In the final tutorial, you will learn how to convert lists to dictionaries and vice versa. The concluding exercise entails recalling features of dictionaries and sets.

Explore copying operations on containers in Python in this 9-vdeo course, which examines the subtle distinction between shallow and deep copies. Changes made to shallow copies affect the original whereas with deep copies they do not. Learners begin by observing Jupyter notebook in Python, where you will be performing shallow and deep copies of Python strings. You will learn how to create shallow copies of lists, and then create deep copies of lists where changes to the copy do not affect the original. Following this, you will begin working with tuples, a process which you will discover is quite simple because tuples are immutable. So you will learn how to create shallow and deep copies of tuples. You will also learn how deep copies of dictionaries work, and perform shallow and deep copies of sets. In the closing exercise, learners are asked to recall how shallow and deep copies work for complex data types.

Learners will explore implementations of the order of precedence of operators, using if-elif-else statements to evaluate multiple conditions and conversions between various data types in Python, in this 15-video course. Key concepts covered here include how conditions in Python work, and how to evaluate conditions by involving primitive data types using if statements and complex data types using if statements. Next, evaluate multiple conditions for decision making with nested control structures; identify how to use the if-else statement to make decisions involving complex data types such as lists, tuples, and dictionaries; and learn how to convert an integer to a float and a float or an integer to a string, and vice-versa. Learners then observe how to convert primitive data types to complex data types, to convert between various complex data types, and to convert between various complex data types and view base conversions with Python built-in functions; and to solve various programming problems with Python built-in methods. Finally, you will learn to solve various programming problems by using if-elif-else statements and nested if-else statements.

Loops are one way to perform the same operations repeatedly in a program. For loops are the control structure to use when the repeated operations are performed on a sequence such as a list or a tuple. In this 9-video course, you will explore different ways to iterate over a sequence using for loops. Key concepts covered in this course include how to use for loops to process elements in a list and characters in a string; and how to code for loops to iterate over values in a tuple and the keys and values in a dictionary. Next, learn the function of associating an else block with a Python for loop; include if-else statements and other for loops within a for loop; how to generate a sequence of consecutive integers with the range function; and how to use the range function to iterate over a large range of values and apply it within nested for loops. Finally, observe how to write for loops in order to iterate over 1-dimensional and 2-dimensional sequences.

Explore how iterating over elements using for loops can be controlled using the break and continue statements in Python. Creating sequences from other sequences using comprehensions is also covered in this 9-video course. Key concepts covered here include how to terminate a for loop when a specific condition is met using the break statement; learning how the break statement affects the code in the else block of a for loop; and observing how to skip an iteration of a for loop when a specific condition is met using the continue statement. Next, learn how to use the continue statement along with the break statement within the same for loop; learn the fact that no action is performed under specific conditions by using the pass statement; and create a list out of the contents of another list using a comprehension. Finally, you will learn about conditions in list comprehensions in order to filter elements used in the source list and to define values in the newly created list.

Explore how Python facilitates code reuse by using functions in this 17-video course, which shows learners how to define functions, learn passing arguments to functions, and returning values from functions. The functions you will examine change the state of the program, may have side effects, and have observable effects other than their return values. Since functions with side effects are hard to parallelize and use in a distributed environment, you will learn correct ways of returning values from functions. First, you will learn how to invoke functions by using both positional and keyword arguments. You will next work with positional input arguments in custom functions, and learn that these are required arguments, and how to order these arguments to invoke your function. You will next learn to use variable length arguments in defining custom functions. Finally, you will learn how keyword arguments or named arguments are a way to make the intent behind function invocation absolutely explicit, and help prevent bugs in programs that are especially hard to detect.

While loops are one way to keep repeating a set of actions until a specific condition is met in Python. In this 11-video course, learners explore the use of while loops, considerations when implementing while loops, and use cases for while loops and for loops. Key concepts covered here include implementing a basic while loop and recognizing what conditions cause it to become an infinite loop; learning to use while loops to carry out actions while evaluating expressions based on numerical and string data; and examining while loops whose iterations depend on user input data. Next, learn syntax for defining while loops within a single line; learn to iterate over a list of elements with while loops; and learn to iterate over multiple lists and tuples with while loops. Learn when it is appropriate to use break keyword to stop a while loop, and learn to break out of a while loop and recognize use of the pass keyword within such loops. Finally, learn skip steps in individual iterations of a while loop using the continue statement.

This 13-video course offers learners an in-depth exploration of Python functions, by focusing on nuances such as argument passing by value and reference, and local and global variables. In this course, you will examine how functions are first-class citizens in Python, as with other data types. You will examine how Python allows functions to be stored in variables, passed into other functions as arguments, and returned from functions as return values. Next, you will learn how to identify and apply differences between parsing arguments by value and reference. Examine how Python treats functions on par with other data types, a key attribute of a program seeking to support the functional programming paradigm; and learn how to work with use and throw functions by using lam das. This course then covers how lightweight functions for one-off use called lambda functions or anonymous functions play an important role in keeping Python code both succinct and readable. Finally, you will learn how to appropriately choose between local and global variables for use in your program.

This course explores advanced Python function topics such as recursion, closures, and using generator functions to generate sequences. In 12 videos, you will learn how to use decorators to add functionality to code; examine how recursion can be used to construct code to solve complex problems; and learn to write a terminating condition for a recursive function. Next, you will learn how to use an Iterator to respond to a built-in next () function. Learners will also examine closures, and how as functions they maintain their own lexical environment; and explore how closures are functions that can yield dramatic results in the distributed processing of code, and are widely used in the implementation of distributed processing frameworks. Then you will learn how to use generator functions to generate sequences. You will learn how sequences can iterated upon by other parts of your program. Finally, you will learn that using decorators offers simple ways of invoking higher-order functions.

In this practice lab, learners will be presented with a series of exercises to practice developing in Python. Exercises include tasks such formatting data types, implementing flow control and conditionals, copying containers, and performing loops with list comprehension methods. Learners will also practice converting data types, working with global and local variables within functions, invoking functions with varying parameters and implementing recursive functions and closures.

Learners can also use the environment as an open sandbox. No installation or configuration is required, so you can gain immediate hands-on experience. Create new files or upload your own from a storage location of your choice, such as GitHub, and you can practice coding right away! You can even download a copy of your work when you’re done.

Whether you’re looking to dive into the code presented within our courses or you want to work on your own coding projects, this lab environment will provide you with everything you need. So, go ahead and start coding today!

Final Exam: Python Novice will test your knowledge and application of the topics presented throughout the Python Novice track of the Skillsoft Aspire Python Novice to Pythonista Journey.

Python includes functions and modules that simplify working with files. In this 11-video course, explore operations for standard text files and handling of formatted data such as JSON and CSV by using Python modules designed for such data. Learners begin with a look at some of the file operations in Python. Use Python's open function to open a file for reading, and differentiate between the read(), readline(), and readlines() functions. View differences between opening a file in write mode and append mode in Python. This leads on to distinguishing between the r+ and a+ modes to read from and write to a file; using load and loads functions of the json module to parse JSON data, and converting Python dictionaries and lists into JSON strings and files. Next, learn how to identify file formats that can be handled by the CSV module in Python, and convert Python dictionaries and lists into CSV files. The final tutorial concerns defining a customized file format, creating a CSV dialect, and using that to parse and write data.

In this 11-video course, learners can examine different types of exceptions that can be raised in Python and how they can be handled with except blocks. Explore execution of Python scripts from the command line, including use and parsing of command-line arguments. To begin, use a try and except block to handle a Python exception, then learn how to handle exceptions that your code may raise. Explore how exceptions are defined in a hierarchy and how related exceptions are caught and handled. Next, define multiple except blocks to handle various exceptions that can be raised by code; convert code prototyped in a Jupyter notebook into a Python script that can be executed from a shell, and run code from the Python shell and execute single-line and multi-line commands. Learn about parsing command line arguments, and use the sys and argparse module to access command-line arguments to a Python script, then parse and use the arguments passed to a Python script from the command line. Finally, learn to define command-line arguments by using argparse.

Learners can explore built-in Python modules that allow you to perform many common operations without having to write the associated code, in this 9-video course. These operations range from random number generation to frequently used math calculations. You will learn how to recognize the features available in popular Python libraries such as NumPy, random, and datetime. Also, you will take a look at the steps involved in packaging Python code into a tar archive for distribution to end users; use pip to install a module in your environment and import it into your Python applications, and learn how to install the virtualenv tool and use it to create a virtual environment for Python applications. In the final two tutorials in this course, you will discover how to activate and run Python scripts from within virtual environments, and then install different packages in different virtual environments and recognize how they are isolated from each other.

In this 7-video course, learners discover key differences between Python 2 and Python 3, as well as learn how to perform a Python 2 migration to Python 3. Several other topics are also covered. Begin by observing how to set up the Jupyter Notebook integrated developer environment (IDE) to run and develop Python 2 code by installing a kernel for it. The next two tutorials will examine the differences between Python 2 and Python 3-part 1 will recall the variations in syntax and output for various operations such as print, division, and round for Python 2 versus Python 3; and part 2 explores differences in the round function behavior and different ways to accept user input in Python versions 2 and 3. Next, use the 2to3 conversion tool to identify the lines in your Python 2 scripts that need to be altered for Python 3 compatibility, and finally, explore how to convert a Python 2 script to be Python 3 compatible by using the 2to3 conversion tool.

In this 7-video course, learners will explore the concept of logical units, such as classes, and how they are used to hold state and behavior. Examine the modeling of is-a relationships by using inheritance and the advantages of object-oriented programming. You will begin with an introduction to classes, which are an integral part of Python programming. In this first tutorial, learn how state and behavior can be encapsulated in a single unit. This leads learners to examine how classes can be used as blueprints to create objects, and then to compare objects and instances to classes. Following on from this, you will take a look at inheritance, and model is-a relationship using inheritance. In the final tutorial in this course, you will explore the advantages of using object-oriented programming. In the concluding exercise, you will be asked to describe classes, define how state and behavior of a class are represented, list characteristics of class objects or instances, describe class inheritance, and list advantages of object-oriented programing with classes.

Explore implementations of Python classes, methods, and instance and class variables in this 15-video course. Learn how to implement private variables in Python classes and program problems with classes. Key concepts covered here include how to create classes by using Python; how to assign attributes to objects of classes; and how to initialize class variables by using the init special method. Next, you will observe how to initialize values for a class when you create objects; how to pass arguments to initialize the state of a class object; and additional methods in a class, as well as how class variables work. Learners will examine how class variables are different from instance variables and how class variables share memory across objects of a class; and work with variables that have their own memory in each object. Then examine getters and setters for each instance variable; learn to prevent inadvertent modification of instance variables; and learn to create a class to represent a real-world entity. Finally, observe how to parse information to create classes with a dictionary.

In this 12-video course, learners will discover how to implement inheritance by using Python classes and explore coding examples of concepts such as base classes, derived classes, overriding methods, and polymorphism. Key concepts covered in this course include the default base class for all Python classes; how to model an is-a relationship by using inheritance; and how to invoke base class methods from subclasses. Next, you will observe how to define implementations for base class methods; learn to work with superclass and subclass hierarchies; and learn to define methods in a subclass and the idea of subclasses having additional attributes. Continue by learning about multiple inheritance levels in classes; multiple base classes for a single subclass; and polymorphism, an important characteristic of objects in object-oriented programming. Then you will learn to implement polymorphism in Python; learn about class inheritance and polymorphism; and learn to implement base and derived classes. Finally, learn to specify an init method to initialize member variables; learn about getters and setters for member variables; and learn to override a method.

Examine the advanced features that you can implement by using classes in Python, such as special methods, iterators, class properties, and abstract base classes. Key concepts covered in this 14-video course include how to represent objects by using customized strings; performing addition operations on custom objects; and performing subtraction operations on custom objects. Next, observe how to perform multiplication operations on custom objects and perform floor division, modulo, and power-of operations. Then study learn built-in functions to work with custom data types; learn to execute for-loops on custom data types; and learn about properties on classes for intuitive use. Learn about properties using a simpler syntax; work with class methods to access and update class state; work with utility methods on classes; and learn how to use the abstract method to make classes that are not instantiable base classes. Finally, learners will be shown special methods and what they represent; learn to define a class and create a property within it; and observe how to differentiate between class methods and static methods.

In this practice lab, learners will be presented with a series of exercises to practice developing in Python. Exercises include tasks such as file handling, implementing polymorphism, implementing special method names, as well as implementing an abstract class and using static methods. Learners will also practice using a Python list as a stack, performing queue operations, implementing a graph as an adjacency matrix, and traversing a Binary Search Tree (BST).

Learners can also use the environment as an open sandbox. No installation or configuration is required, so you can gain immediate hands-on experience. Create new files or upload your own from a storage location of your choice, such as GitHub, and you can practice coding right away! You can even download a copy of your work when you’re done.

Whether you’re looking to dive into the code presented within our courses or you want to work on your own coding projects, this lab environment will provide you with everything you need. So, go ahead and start coding today!

Explore Python data structures and delve into the details of some of the basic structures, such as linked lists, stacks, and queues. Key concepts covered in this 12-video course include the metrics on which algorithms and operations on data are evaluated; learning how the performance of operations and algorithms is expressed in terms of size of input; and learning about linked lists and their contents and structure. Next, study different ways in which nodes can be added to a linked list and how search operations work on this data structure; learn methods to remove nodes from a linked list and the process of reversing the order of nodes in this data structure; and learn techniques used to keep track of numbers of elements in linked lists. You will examine workings of a stack data structure, including the addition and removal of elements; learn some of the operations on stacks, such as ISEMPTY and ISFULL, and the complexities of different stack operations; and learn the queue data structure and how to compare it to stacks.

Examine operations that have different values of time complexity and delve into implementation of basic data structures, such as linked lists, stacks, and queues in Python, in this 13-video course. Key concepts covered here include operations that run in constant time regardless of input; code whose time complexity varies directly with value of input; and tasks whose time complexity varies linearly with size of input. Next, you will learn about operations whose time complexity varies as the square of input size; how to use native queue class of Python and perform standard queue operations; and how to code a queue class for many standard queue operations, such as enqueue and dequeue. Then, learn how a Python list can be used as a stack by loading and unloading elements, and how to implement a custom stack class for common stack operations. Finally, study code functions to perform search and delete operations in linked lists and reverse the ordering of its nodes; and create a linked list and test out various operations that have been defined.

In this 11-video course, learners explore workings of some of the most widely used sorting algorithms in Python and examine how their performance affects various measures. Key concepts covered here include various properties of sorting algorithms when selecting the right one for your data; the operations involved when sorting a list of values by using the selection sort algorithm; and the process of a bubble sort when applied to a list of values. Next, you will learn about the performance of the bubble sort on various measures such as time, space, and number of swaps; how to describe the steps involved in performing an insertion sort and compare it to the bubble sort; and learn the workings of the shell sort and the performance metrics of this divide and conquer algorithm. Finally, you will learn the process of sorting a list of elements using merge sort and list the complexity of this algorithm on various measures; and learn how the quicksort algorithm partitions and sorts a list of elements.

Examine the Python implementation of common sorting algorithms such as selection sort, bubble sort, and insertion sort, as well as divide and conquer sorts such as shell sort, merge sort, and quicksort, in this 10-video course. Key concepts covered in this course include how to write the code to implement a selection sort; how to implement the bubble sort algorithm in Python; and how to code a function to implement the insertion sort algorithm. Next, you will observe how to write the code to implement the divide-and-conquer shell sort algorithm; how to invoke the shell sort algorithm on an array of integers and examine the output at each iteration to understand how it works; and how to code a function to implement the merge sort algorithm and test it on an array of integers. Finally, learn how to write the partition and quicksort functions in order to implement a quicksort; and how to apply quicksort on an array of integers and analyze the results at each iteration to understand how the algorithm works.

This 13-video course explores the theory of graph and tree data structures in Python. Learners will examine a specific type of tree: the binary search tree, its structures and properties. You will then observe how to execute common tasks in binary tree; examine the binary search algorithm; and review data structures of linked lists, stacks, and queues. Next, learners will examine how a binary tree structure offers several applications that cannot be done by using stacks or queues. The course demonstrates different depth first traversals, including pre-order, in-order traversals, and post-order traversals. Explore graphs, which are data structures used to model relationships, and different representations of a graph, and learn to model a vertex. Learners continue by observing how to represent an adjacency list as a graph, and examining the adjacency matrix, the adjacency list, and the adjacency set. Then you will explore graph traversal algorithms, including the topological sort. Finally, learn how to traverse through each of the vertices in a graph.

Explore implementing trees and graphs in Python in this 14-video, hands-on course that contains only labs. In this course, learners will use Python 3 and Jupyter Notebooks as their IDE (integrated development environment). In the course labs, you will implement a binary search, define a binary search tree, and use code functions to work with those data structures. Next, you will implement algorithms to traverse trees, including how to perform a breadth-first traversal and depth-first traversal of the tree. Continue by examining graph data structure, and implementing different representations of graphs in Python by using an abstract class for a graph to represent graphs as both an adjacency set and an adjacency matrix. You will implement algorithms to traverse such graphs, including a breadth-first traversal and a depth-first traversal. This course then demonstrates how to run a test to check its implementation. Finally, learners observe how to implement a topological sort for a specific type of graph which is both directed as well as acyclic.

Final Exam: Python Apprentice will test your knowledge and application of the topics presented throughout the Python Apprentice track of the Skillsoft Aspire Python Novice to Pythonista Journey.

This 8-video course explores the unit-test framework in Python. To take this course, you should have experience in Python programming and the use of the Linux shell. The unit-test framework (also known as PyUnit) is modeled on JUnit and simplifies the automation of tests for Python applications. You will learn to use the unit-test framework to define tests for your application source code to ensure that it behaves in a specified manner. In this course, learners will write a sample test, and then expand the test scripts to include multiple tests. You will learn how to sequence the execution of tests in scripts, and how to filter out tests which do not require a specific run. Next, you will learn how to pass the output of test executions to identify the results of your tests, and how to diagnose test failures. You will learn how to run specific tests from among multiple tests in your scripts. Finally, this course demonstrates how to skip the execution of tests by using the skip decorator.

This 10-video course explores advanced features of Python testing uses of the unit-test Framework, and will examine several ways to optimize tests. A labs-only course using Linux Shell, it explores the unit-test framework, the pytest, and the doctest, and how to use them to automate the testing of all the functions in Python applications. You will learn how to bundle common operations for multiple tests into a special function or fixture, which make test scripts easier to view and maintain. Next, you will learn to adjust the scope of fixture functions to execute before each individual test, or to execute just once for the entire test case. Learners will examine how to create and execute a collection of test cases called test suites. You will explore the PyCharm IDE (integrated development environment), which includes support for several different testing frameworks. Finally, you will explore how PyCharm IDE simplifies the creation of tests by generating boilerplate code for test scripts with just a few clicks.

Explore several types of testing frameworks for Python applications, including the unittest framework, pytest, and doctest, in this 12-video course. First, you will learn how to define and run tests, and how to streamline tests by using fixtures. You will learn the important features of the pytest framework to create small test units, and to define and run individual tests. Next, you will learn to group tests into multiple scripts, and how to execute multiple test scripts within a single run. Learners will observe how to create a simple test, and learn to increase the complexity by defining test scripts to cover multiple tests for your application. You will explore the execution and skipping of specific tests in scripts, then learn to simplify tests by using parameterization. You will learn how to apply filters on different tests, and to execute tests with a certain string in the test name, and examine the use of markers in a test. Finally, you will learn how to use fixtures to run operations common to multiple tests.

This 8-video course explores several Python applications for testing, including the unit-test framework, pytest, and doctest. To take this course, you should have prior experience with Python programming, and familiarity with running commands from a Linux shell. This course focuses on doctests, and examines how the doctest module allows the definition of simple python tests within the docstrings in your source code. You will examine what syntax is needed when manually running tests from a Python shell, and how to copy over shells. Next, you will learn to capture the output and use it in your source file, then how to create an executable document for your source. This course demonstrates packaging a readme file, and the tests for a Python module. Learners will examine the bundling of documentation and tests into a single executable file. You will learn how to Ellipsis directive to address unpredictable outputs. Finally, you will learn to instruct your doctests to ignore whitespace characters within the outputs of a test by using the normalized whitespace directive.

Learners can explore how to use the Python Request package which has simplified the task of constructing HTTP requests in this 16-video lab course, which explores different types of HTTP requests, and examines several ways to handle responses to those requests. Begin by learning how to use the Python request package to make a GET request for data from a server. Then you will observe how to construct a POST request to submit data to a host, and how to send it to a URL. Continue by learning how to use a HEAD request to check the resource information before downloading it by using GET, and how to examine request and response headers. Next, learners will examine a PUT request which has the same effect whether one makes the request once or multiple times, and which is used to overwrite an existing resource. You will learn to use DELETE requests. Finally, you will learn to address responses to requests in both JSON formatted or images.

Explore the steps involved in a web request and the role of web applications in this web development process in this 8-video course examining various pieces that can make up a web application, and the role of the web framework in defining it. Begin by observing a widely used framework, often defined as a microframework, written in the Python language, which is Flask. You will then explore the features of the Flask framework that are available either out of the box or via extensions. Following on from this, you will delve into the roles of routes in a Flask application and the options available when defining a route function. You will learn how to recognize the need for templates when defining a web site and describe the use of jinja for this purpose. The final tutorial in this course focuses on some of the commonly used extensions in the Flask applications and recalls the purposes they serve.

You will begin this 12-video course by learning how to install Flask-a widely used web framework written in Python language-in a virtual environment on your development machine, and then write the code for a simple "Hello World" website by using Flask. You will explore how route definitions can be altered and the benefits of running your Flask app in debug mode. Next, define a route that renders an HTML page when a URL is accessed; download and use some boilerplate HTML files so your website definition need not begin from scratch, and modify the boilerplate cascading style sheet (CSS) and HTML definitions to customize the look of a website. Learn how to generate URLs dynamically by using the url_for function; create a base Jinja template that can be inherited by other templates, along with placeholders that can be overridden; and explore how to inherit the elements from a base Jinja template in a child template HTML file. Finally, learn how to define multiple routes to point to the same route function.

In this 12-video course, learners discover how to handle errors in Flask-a widely used web framework written in Python language-by serving a custom error page whenever a 404 error is invoked on a website. Learn how to configure a route in your Flask app so that POST requests can be submitted. Next, use the Flask debugger to record information in your application's log; convey the invocation of an operation to end users by using message flashing, and then highlight flashed messages by defining a style for them in a cascading style sheet (CSS) file. Next, explore how to install and use WTForms in Flask application to accept user input for registration, and define a login page by using field definitions and built-in form validations available in WTForms. Then include the two pages defined by using WTForms in the Flask application, and invoke the validators defined for WTForm elements to ensure that the user input is in the correct form. Finally, ensure that all built-in validators applied on the WTForm elements work as expected.

In this 14-video course, titled "User Authentication in Flask Applications," you will begin with an introduction to SQL Alchemy, then install it and use it to connect the Flask application-a widely used web framework written in Python language-to a SQLite database. You will observe how to use SQL Alchemy to generate relational database tables for each model defined in an application; execute queries against tables by using a SQL Alchemy model; and how to structure a Flask application for maintenance. Then you will modify import statements to account for restructuring of Flask app and test that functionality has not been affected. Use Bcrypt package to generate hashes of passwords so that they can be stored securely, and create a bespoke validator for fields in your WTForms. Next, learn how to enable users to log in and log out of a Flask application. You will access and display the three most recent reviews posted on your Flask website; learn how to test feedback display functionality; and display images in your Flask website.

Explore the general theory of concurrent programming, and examine how to have multiple tasks active at any given point in time. This 14-video course offers an in-depth examination of concurrent programming by using the Python programming language. First, learners will examine the two main forms of concurrent programming, multithreading and multiprocessing, and examine their differences and use cases. Next, you will examine executing multitask sequentially, and with multithreading to save time, and how to use multiprocessing to manage a collection of tasks efficiently. Continue by exploring challenges that programmers encounter when adopting concurrency such as synchronization issues and deadlocks, and how to address these issues. You will examine issues that arise when writing concurrent code, and you will learn how to fix these by using the built-in objects available in Python. Finally, this course examines several of the objects available in the Python language such as queues and pools, which simplify the task of building multithreading and multiprocessing applications.

This course is a lab-only exploration of the creation and management of processes in Python to speed up the execution of your programs. In this 10-video course, learners will use Jupyter notebooks to execute all programs demonstrated. First, you will learn how to create initialized threads, and how to do the same with processes in Python. Then you will examine different thread-safe data structures in Python to implement queues, stacks, and priority queues. Next, you will learn how to use Python for synchronization mechanisms and inter-process communication, and will see a comparison of processes to threads. You will learn to use Python's built-in queue data structure for multithreaded applications, and how to implement multiprocessing. Continue by learning how processes are created and executed and how they differ from threads when one is using shared resources. You will explore how to use a manager class, or service process manager to share any Python types. Finally, you will examine the available mechanisms in Python for communication and synchronization between processes.

This course offers an in-depth exploration of the creation and management of concurrent threads in Python. In its 14 videos, you will learn how to significantly improve the performance and responsiveness of your apps by using concurrent threads. Begin by examining how threads are created in Python from their initialization to their execution; then learn how to use the various synchronization mechanisms such as locks, semaphores, and events. Next, you will examine how concurrent execution could occur in two ways: multithreading and parallel. You will learn to use multithreading to run chunks of each task at one time, and then switch between them regularly. You will learn multiprocessing of threads by executing tasks in parallel. Learners will examine concurrent execution of threads, and some of the issues that arise when these threads are not synchronized. Finally, you will examine several threads of synchronization mechanisms available in Python such as locks, semaphores, events, and conditions and explore the properties and use cases for each of these objects.

This 9-video course offers a lab-only exploration and introduction to the libraries available in Python to run tasks asynchronously by using both processes and threads. To take this course, you should have prior knowledge of how to spawn and manage processes in Python. First, you will learn how to significantly improve the performance and responsiveness of your application by running them concurrently, then learn how to create a process pool, and how to use multiprocessing to execute tasks in parallel. Next, you will learn to use multithreading to run chunks of a task at one time, and to switch between the chunks regularly. Learners will then examine the concurrent.futures module, which contains objects to run threads and processes in an asynchronous manner, and to monitor their progress while they are still executing. Continue by learning how to use ThreadPoolExecutor, available in the concurrent.futures module. Finally, you examine the asyncio module in Python, which provides lightweight mechanisms for asynchronous executions of tasks.

In this practice lab, learners will be presented with a series of exercises to practice developing in Python. Exercises include tasks such as testing with pytest, making HTTP requests, serving HTTP requests with a Flask endpoint, and rendering a jinja template. Learners will also practice using multithreading and multiprocessing with Python, processing data in a queue and creating and executing a coroutine with Asyncio.

Learners can also use the environment as an open sandbox. No installation or configuration is required, so you can gain immediate hands-on experience. Create new files or upload your own from a storage location of your choice, such as GitHub, and you can practice coding right away! You can even download a copy of your work when you’re done.

Whether you’re looking to dive into the code presented within our courses or you want to work on your own coding projects, this lab environment will provide you with everything you need. So, go ahead and start coding today!

This final exam will test your understanding and application of the skills covered in the Python Journeyman track of the Python Novice to Pythonista Aspire Journey.

PyCharm is one of the most intuitive and feature-rich integrated development environments (IDEs) available for Python development. Explore some of the important features of this IDE, such as debugging with breakpoints, Python package installation, and customizing syntax highlighting, in this 11-video course. Key concepts covered here include how to install and configure the PyCharm IDE on your system; how to customize syntax highlighting for various source files in Python project and how to minimize typing errors by using the auto-complete feature. Next, learn to apply name changes to variables and functions to all their references; learn the state of an application in the middle of code execution with the use of breakpoints; and use the step into feature to get inside function calls and step over to run them in one go. Finally, learn to pause code execution at a line only under a specified condition; and learn to use the resume button to ensure that code execution only pauses at breakpoints.

This 13-video course explores how Microsoft Excel spreadsheets can be created, opened, and modified programmatically from within Python. Learners will review the Microsoft Excel object model, the attributes of the worksheet cell object which can be leveraged to create and modify workbooks programmatically. First, you will review VBA (Visual Basic for Applications) technology, before exploring how Python and its ecosystem of libraries are fast emerging as a popular choice for easy spreadsheet automation. Then you will learn how to use openpyxl (open pixel library) to manipulate Excel's object model programmatically from within Python. Continue by learning how to write spreadsheets by using openpyxl, and examining how existing Excel workbooks can be opened, as well as how new spreadsheet files can be created, and written out to disk. Finally, you will learn how Python iterators and indexing can be used to access and manipulate individual cells, ranges consisting of many cells, as well as entire rows and columns.

Learners can explore complex operations in Microsoft Excel workbooks, including the use of conditional formatting, named ranges, and merged cells, in this 17-video course. Microsoft Excel is the best prototyping tool for data analysis, an interactive functional programming environment, and a forerunner of Python. Begin by exploring how Python and its ecosystem of libraries are fast emerging as a popular choice for easy spreadsheet automation. Then observe the formatting, alignment, and other aesthetics in Python. You will work with the Python library openpyxl; examine data analysis, the use of pivot tables, and the locking of cell references by using the $ operator; and learn how to perform complex data analysis operations using pivot tables, sorting and filtering, and formulae with both absolute and relative cell references to enable efficient copy paste. You will learn to control the workbook appearance using conditional formatting and styles. Finally, this course demonstrates how to leverage the Python Pandas library to read a spreadsheet, to group and analyze data.

This course explores how to use Python's openpyxl library to build visualizations such as line, bar, and bubble charts in Excel. In its 11 videos, you will examine how Python and its ecosystem of libraries are fast emerging as a popular choice for easy spreadsheet automation, before learning how to create line and bar charts in Excel, and learning how to use Python to control several properties of those charts, including line weights and style, data for the reference axes, formatting, and the position of ticks on those axes. Learners will observe how to construct data visualizations in Excel using Python. This course then demonstrates common types of visualizations that are supported in Excel, and how to programmatically replicate those visualizations from within Python. Finally, learners will observe demonstrations of the use of bubble charts to display three dimensions on a two-dimensional chart as well as stock charts to represent the opening, high, low, and closing prices of stocks in a single data visualization for the financial markets.

Learners can explore basic concepts of Python socket programming, and how to communicate small amounts of data between Python applications by using either the same machine or over a network, in this 9-video course. Begin by learning how to use Python language to set up a communication line by creating a socket. Then learn to initialize a simple socket, and use it to transfer text data from one application to another. This course next demonstrates how to create a client app and server app in Python, and how each app uses a socket to communicate. Learners will observe a demonstration of how to transmit a Python dictionary and custom object over a socket connection. You will learn how to use a socket model to set up a simple TCP (transmission control protocol) socket to transfer text between applications. Next, learners will examine other properties of Python sockets, including its use with the context manager and the setting of a time-out for connections. Finally, you will learn to use the Pickle library to convey Python objects over a socket connection.

Explore how the SOLID principles can help to make software designs easier to understand and maintain for Python developers. In this 14-video course, learners will examine the five SOLID principles-Single Responsibility, Open/Closed, Liskov's Substitution, Interface Segregation, and Dependency Inversion-as well as creational, structural, and behavioral design patterns. Key concepts covered here include the basic principles of good design in code; learning the Single Responsibility and Open/Closed principles of good design; and learning the Liskov's Substitution, Interface Segregation, and Dependency Inversion principles of good design. Next, learners will examine the principle of Least Knowledge and the Hollywood principle of good design; examine issues that may arise when classes do not implement the principle of Single Responsibility; and observe how to implement the principles of Single Responsibility and Open/Closed. Continue by learning how to design and implement the Liskov's Substitution principle, the Interface Segregation principle, and the Dependency Inversion principle. Finally, learners will study the three broad categories of design patterns and when to use each of them.

In this 16-video course, learners will explore the details and implementation of five commonly used creational design patterns: Singleton, Factory, Abstract Factory, Builder, and Object Pool. Key concepts covered here include how the Singleton pattern works and when to use it; how to write code for a simple implementation of the Singleton pattern; and how to implement the Singleton pattern by using a more Pythonic style and global objects in Python. Next, learn how the Factory and Abstract Factory patterns work; how to iteratively improve the design of code using refactoring; and how to design and implement the serializer with the Factory pattern. Continue by learning how to apply the Abstract Factory pattern to create a family of objects; how the Builder pattern works and how to implement a simple design for the Builder pattern; and how the Object Pool pattern works and how to implement the Object Pool pattern to limit the number of instances. Finally, learn how to improve the Object Pool pattern by making the object pool a singleton.

Explore the design and implementation of five commonly used structural Python design patterns: Adapter, Decorator, Facade, Proxy, and Flyweight. In this 14-video course, learners examine how these patterns can be used for tasks such as working with legacy components, dynamically adding responsibilities, offering a simple client interface, controlling object access, and efficiently using lightweight resources. Key concepts covered here include design of the Adapter pattern and need for the pattern when working with legacy components; learning how to write code for the Adapter pattern to offer a consistent interface to clients; and learning design of the Decorator pattern and the importance for adding responsibilities dynamically. Continue by observing how to implement the Decorator pattern to allow adding responsibilities at runtime. Next, you will learn about the design of the Façade pattern and implementing the pattern to offer a simple interface to clients; learn to design and implement the Proxy pattern to control access to an object; and learn the design of the Flyweight pattern and how to implement the pattern to efficiently use lightweight resources.

Explore the design and implementation of five commonly used behavioral design patterns: Strategy, Chain of Responsibility, Observer, Command, and Iterator. Examine how these patterns can be used in Python built-in functions, in simple and complex use cases, for performing undo operations, and with Python special methods. Key concepts covered in this course include the Strategy pattern, how to design and implement the pattern, and how it is used in Python built-in functions; and learning the Chain of Responsibility pattern and how to write code to implement the pattern. Next, you will learn about the Observer pattern and how to implement the pattern for a simple use case and how to implement the pattern for a more complex use case. Finally, learners will study the Command pattern and how to implement the pattern to perform undo operations; and learn the Iterator pattern and its applications and learn to design an Iterator by using special methods in Python.

In this practice lab, learners will be presented with a series of exercises to practice developing in Python. Exercises include tasks such implementing good design principles and writing applications that can communicate using TPC sockets. Learners will also practice working with Singleton, Observer and Factory design patterns and implementing iterators using special methods.

Learners can also use the environment as an open sandbox. No installation or configuration is required, so you can gain immediate hands-on experience. Create new files or upload your own from a storage location of your choice, such as GitHub, and you can practice coding right away! You can even download a copy of your work when you’re done.

Whether you’re looking to dive into the code presented within our courses or you want to work on your own coding projects, this lab environment will provide you with everything you need. So, go ahead and start coding today!

Final Exam: Pythonista will test your knowledge and application of the topics presented throughout the Pythonista track of the Skillsoft Aspire Python Novice to Pythonista Journey.