Training: Python Novice naar Pythonista - Deel 2 Python Apprentice (Update)

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.

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.

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!

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.