Python is a beneficial language for use in a lot of development projects, particularly Java/C++ development. In this course, you'll learn the basics of Python programming. You'll start by installing Python on your local machine and practice writing code using the Python shell. Next, you'll perform basic math and logical operations in Python. You'll create Python variables and see how you can assign and access values stored in these variables. You'll then use built-in functions, which are part of the core Python programming language, to perform simple calculations and operations. Finally, you'll explore strings in Python work, creating strings using single, double, and triple quotes depending on the use case. You'll then briefly examine the use of complex data types, such as lists, tuples, sets, and dictionaries. When you're finished with this course, you'll be able to execute simple Python commands on Jupiter notebooks.

All values in Python are classified into data types. One of these, known as complex data types, facilitates using complex numbers. In this course, you'll learn how to work with complex data types in Python. You'll start by exploring the list data type, which contains an ordered collection of elements. You'll then perform several different operations on lists, such as accessing, adding, and removing elements and implementing slicing operations. Next, you'll work with tuples and examine how tuples contain an ordered collection of elements but are immutable in nature. You'll also work with sets and dictionaries. Finally, you'll explore the nuances of the copy operation for complex data types. When you're finished with this course, you'll be able to use the right Python data type to store your data and perform basic operations using these complex data types.

A handy procedure in Python for controlling the execution order of program statements is to implement branching operations using conditional statements, such as 'if' and 'else'. In this course, you'll learn how to use statements, loops, and comprehensions. First, you'll implement the conditional if statement. Then you'll use the else and elif statements. Moving on, you'll use Python's looping constructs, including the for-loop to iterate over elements in complex data types as well as over lists, tuples, and dictionaries. You'll use the while-loop and the break, continue, and pass keywords to further control loop execution. Finally, you'll implement list comprehension in Python, an elegant and efficient way of generating lists using 'for loops.' When you're finished with this course, you'll be able to write conditional statements in your code and perform looping and branching operations using for and while loops.

In Python, functions are essentially first-class citizens. They are objects in Python, just like other primitive and complex data types, and have a valuable purpose. In this course, you'll learn how to define and invoke functions in Python. First, you'll define a function using the def keyword and specify input arguments and return values from functions. You'll then work with positional arguments and keyword arguments. Next, you'll define functions with default values for arguments and a variable number of arguments. Along the way, you'll also examine how arguments can be pass-by-value or pass-by-reference. Finally, you'll explore the characteristics of Python functions that make them first-class citizens. When you're finished with this course, you'll have a solid grasp of the foundations of support for functions in Python and be able to use Python functions in your development work.

Lambdas are great for on-off use and, once stored in a variable, behave exactly like other function objects in Python. In this course, you'll learn how to create anonymous functions in Python using lambdas. You'll start by creating generator functions in Python to generate infinite sequences using the yield keyword. You'll then illustrate how these generator functions can be resumed from just after the previous yielded value. Moving along, you'll demonstrate how closures in Python are nested functions that keep track of local variables in the outer function. You'll also illustrate how decorators - bits of code allowing you to modify other pre-existing code in your program - can be implemented using closures. When you're finished with this course, you'll have a good grip of functions in Python, which allow you to perform some incredibly complex and powerful operations.

Python classes act like blueprints for establishing a new type of object with its own set of properties and methods. In this course, you'll learn how to define and instantiate classes in Python. You'll start by using the init() method to initialize your class's member variables and the self keyword to reference a class's current instance. You'll then illustrate the differences between the self keyword in Python and the "this" keyword in Java. Next, you'll examine how errors in Python can be handled using the try-except-finally block and how the error handling mechanism in Python is similar to Java exception handling. Finally, you'll import other Python libraries into your current Python program, using classes and functions defined in one Python file in another file using the import statement. When you're finished with this course, you'll be able to set up Python classes for various uses in your development projects.

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

The wealth of Python data visualization libraries makes it hard to decide the best choice for each use case. However, if you're looking for statistical plots that are easy to build and visually appealing, Seaborn is the obvious choice. You'll begin this course by using Seaborn to construct simple univariate histograms and use kernel density estimation, or KDE, to visualize the probability distribution of your data. You'll then work with bivariate histograms and KDE curves. Next, you'll use box plots to concisely represent the median and the inter-quartile range (IQR) and define outliers in data. You'll work with boxen plots, which are conceptually similar to box plots but employ percentile markers rather than whiskers. Finally, you'll use Violin plots to represent the entire probability density function, obtained via a KDE estimation, for your data.

Seaborn's smartly designed interface lets you illuminate data through aesthetically pleasing statistical graphics that are incredibly easy to build. In this course, you'll discover Seaborn's capabilities. You'll begin using strip plots and swarm plots and recognizing how they work together using low-intensity noise. You'll then work with time series data through various techniques, like resampling data at different time frequencies and plotting with confidence intervals and other types of error bars. Next, you'll visualize both logistic and linear regression curves. Moving on, you'll use the pairplot function to visualize the relationships between columns in your data, taken two at a time, in a grid format. You'll change the chart type being visualized and create pair plots with multiple chart types in each plot. Lastly, you'll create and format a heatmap of a correlation matrix to identify relationships between dataset columns.

This course will introduce you to a breadth of charts available in Altair and how you can use them to get an all-round understanding of your data. The focus is to get you familiar with the wide variety of graphs that are available. You'll begin by visualizing a distribution of numeric values using box plots and violin charts, each of which has its own strengths and limitations when analyzing distributions. You'll then move on to bar charts to analyze numbers associated with categories in your data. While doing so, you will get to explore a variety of aggregate operations that are available in Altair in order to calculate a sum, mean, median, and so on. You'll then use line charts to visualize the changes in a particular value over a period of time and also its related visual - the area chart. Finally, you'll produce scatter plots to visualize the relationship between a pair of fields in your data. Throughout this course, you'll delve into a number of customizations which are available in Altair for each of the graphs which you plot.

This course will get you familiar with the building blocks of Altair visualizations and some of the important chart settings. You will touch upon some of the fundamentals of plotting graphs in Altair. You'll start off by learning about the basic data structures that can form the basis of Altair visualizations, including JSON data and Pandas DataFrames in both wide-form and long-form. You'll then move on to plotting one of the simpler graphs, histograms, to visualize the distribution of values for a quantitative field in your dataset. While doing so, you'll get to explore the different ways in which Altair graphs can be customized including augmenting your chart with text, layering histograms to view two distributions together, and making histograms interactive.

This course introduces you to the use of Altair visualizations which can convey very detailed information for specialized datasets. You will cover some of the graphs that can be used to convey the information in very specific kinds of datasets, while also giving you some hands-on experience with advanced chart configurations. You'll begin by plotting information on a map, both to mark locations of places as well as to convey numerical information about regions. You'll then build a heatmap to analyze the numbers associated with a combination of two categorical variables. Next, you'll implement candlestick charts to visualize stock price movements, dot plots to analyze the range of movement for some values, and Gantt charts to view a project plan. Finally, you'll explore the use of window functions to analyze the top K elements in each category of your dataset.

With Dash, you can create interactive web apps with elements such as buttons, dropdowns, sliders, range sliders, checkboxes, date pickers, and more. In this course, you'll learn how to get started with Dash, beginning with installing Dash and various extension libraries using the pip package installer. You'll move on to building web apps using Dash and the Plotly Express library. You'll also work with two other important Dash extension libraries - the Dash Core Components library and the Dash HTML Components library. You'll put all of these libraries together while exploring some of the default interactivity features, such as zooming and panning charts. You'll create a callback app where the title of a chart updates based on the values on a range slider before creating a more refined app with a callback that updates the chart itself and not just the title. Finally, you'll build a fully-fledged interactive scatter plot.

If you've used Dash before, you'll know how quickly the native HTML table abstraction from dash_html_components can become complicated and cumbersome due to the need to create a TR tag for each row and then individual TD tags within each TR tag for each cell value. Using the dash DataTable abstraction mitigates all of these weaknesses. In this course, you'll practice this technique before using the Dash data table to display data in the form of tables in Dash apps. You may also know that you can harness the power of Dash using HTML components or components from the Dash Core Component library. In this course, you'll also get a chance to work with user input and buttons in Dash apps using the most appropriate components.

The Dash DAQ library can be used to represent data in ways that correspond to real-world physical measurement mechanisms, such as switches, thermometers, knobs, dials, gauges, LED displays, and tanks. In this course, you'll learn how to work with this library. In addition, you'll practice creating widgets using Dash core components. You'll also create Dropdowns, TextAreas, RadioButtons, and Checklists. Finally, you'll cover two important aspects of building web apps - building tabbed apps with different controls on each tab and accepting user upload of files. You'll build a web app that accepts a file for upload, either via drag-and-drop or via direct user navigation, and then checks whether the file is a .csv file and if so, displays the contents of that file in a DataTable.

Final Exam: Data Visualization for Web Apps Using Python will test your knowledge and application of the topics presented throughout the Data Visualization for Web Apps Using Python track of the Skillsoft Aspire Pythonista to Python Master Journey.

There are many advantages to using SQLAlchemy, including using native Python language constructs for queries, transactions, and stored procedures and easily porting code between database servers. You begin this course by installing MySQL on both Windows and Macintosh platforms. You'll then learn how to access a database from SQLAlchemy using the create_engine method, and how to specify the driver, dialect, and server information correctly. You move on to creating database tables as well as associated constraints from Python using SQLAlchemy's Core API and the Table abstraction. You'll then query that table using a fluent-style API from SQLAlchemy's SQL Expression Language. You'll also learn how to specify primary key, unique, and not null constraints. At the end of the course, you'll have a solid handle on basic functionalities of the core APIs of SQLAlchemy.

When you need access to data in a relational database while coding in Python, SQLAlchemy provides an ideal abstraction layer. SQLAlchemy supports several database types. In this course, you'll work with MySQL. You'll start by learning how to construct and invoke select-from-where queries from Python using the SQLAlchemy core API. You'll then use the and_, or_, and not_ functions from the Expressions API, before learning how to alter tables by adding and dropping columns and constraints. Following on, you'll practice deleting data and drop tables from SQLAlchemy. You'll then specify foreign key constraints to define parent-child relationships. To finish off, you'll perform simple select-from-where queries with logical and relational operators from SQLAlchemy, add and drop columns and constraints, and define foreign-key constraints and parent-child relationships.

With a good grip on the use of SQLAlchemy in querying data in SQL tables, you are now ready to perform multi-table joins and use more powerful SQL abstractions. In this course, you'll perform multi-table joins by chaining the .join methods on different tables. You'll also simplify join syntax using aliases. You'll then create and query views and learn how insertions into views are propagated from the view to the underlying tables. Moving on, you'll create indexes and examine their metadata. You'll then differentiate between simple and composite indexes. By the end of the course, you'll be able to perform multi-table joins by chaining .join methods, create and query views, correctly insert data into underlying tables using views, create indexes, and interpret index metadata.

Triggers are used for asynchronous execution and react to specific conditions in your database. Stored procedures can be used to achieve code reuse and code composition of SQL commands. In ths course, you'll learn about some of these procedural constructs of SQL, including triggers, stored procedures, and transactions. You'll start by learn how to define triggers to perform specific operations before or after insert, update, or delete operations on specific tables. You'll also define stored procedures and invoke them using raw DBAPI connection objects. Moving forward, you'll define and invoke stored procedures that take in input arguments. You'll also create, commit, and rollback transactions to enforce all-or-nothing execution of a group of SQL commands. To finish up, you'll learn how DDL operations, such as create, drop, and alter operations, are not reversed by transaction rollback. By the end of this course, you'll be able to create and test trigger executions, correctly invoke stored procedures using DBAPI connections, achieve code re-use with parameterized stored procedures, and work with transactions from Python using with blocks and transaction objects.

The SQLAlchemy Object Relational Mapping (ORM) module treats each database table as a class, and each row in that table as an instance or object of that class. These classes are very easy to define and use via base classes provided in the ORM API. In this course, you'll start by defining check constraints and using them to enforce generic conditions on data in a column. You'll then use cascading update and delete with foreign keys to propagate changes from the parent table to child table. Next, you'll illustrate how the SQLAlchemy ORM treats each table in a database as a class, and rows in that table as objects of that class. You'll identify how the declarative_base class is suitable for creating new tables, while the automap_base is ideal for reading in pre-existing tables from a database. Upon finishing this course, you'll be able to create and enforce check constraints, enable cascading delete and update on foreign key constraints, use the ORM API to model tables as classes, correctly extend the declarative_base and automap_base classes from the ORM API and use them to perform SQL commands.

Extract, Transform, and Load (ETL) tasks help in collecting and manipulating data from diverse sources to fit the user's requirements. In this course, you'll explore different interfaces available in the petl library and perform basic ETL tasks using petl. You will begin by examining how to import data from various data sources, including delimited text files, Microsoft Excel, and structured JSON data. You'll also recognize how to load and save data in these formats. Next, you'll outline how to integrate petl with a relational database using SQLAlchemy and SQLite3. Finally, you'll perform transform operations on data using different petl features to filter specific data needed by you. Once you have completed this course, you'll have a clear understanding of the role played by petl in simplifying ETL tasks.

Software development often requires manipulation of data that has been extracted from different data sources to make it compatible with the user's specifications and requirements. petl's data transformation features can help achieve this. In this course, you'll investigate fundamental data transformations that can be performed using the petl library. You'll demonstrate how to load data into a petl table, filter columns, and combine multiple tables using different forms of concatenation operations. Next, you'll outline how to convert data in a petl table into a form that is compatible with your requirements. This includes transforming strings to numbers, applying calculations to numeric fields, and replacing specific values in the table. Lastly, you'll explore ways to filter content in petl tables using the facet() function and different select operations.

Petl facilitates and streamlines tasks related to data extraction and manipulation, often required by software developers to make data fit for actionable business intelligence (BI). In this course, you'll work with complex operations in petl and outline how to extract data from a source and convert it to a format that complies with your requirements. You'll begin by investigating the use of regular expressions to analyze, search, and extract specific rows and columns in a petl table. You'll then create transform functions and apply them to your data. These include operations on numeric as well as string fields. Moving on, you'll implement sort operations to organize data in a petl table and arrange it in a sequence that suits your purposes. Finally, you'll investigate how to perform joins and set operations on data tables and meaningfully reduce the data in them using aggregation functions.

Experience making and processing HTTP requests using HTTPX will help you integrate such requests into your web applications. In this entirely hands-on course, you'll dive into the mechanics of HTTP requests and responses using the HTTPX library. You'll begin by invoking basic GET requests to request data from a remote server. You'll then explore the different possible forms of responses - ranging from HTML content and structured JSON data to binary data, such as images and videos. Moving on, you'll learn to use POST requests to submit information to a remote server. Lastly, you'll cover a host of other HTTP requests that can be invoked with HTTPX, namely HEAD requests to retrieve headers, OPTIONS requests to get communication information, PUT requests to create or update resources, and DELETE requests to remove them.

Various HTTPX features are used to optimize the processing of HTTP requests. This course introduces you to some advanced techniques that use HTTPX to send and process HTTP requests. You'll start by looking at HTTPX streams, which allow the processing of large responses in chunks to reduce the load on memory resources. You'll then examine the HTTP response content that can determine how our application's subsequent actions are defined, including HTTP status codes, HTTP headers, and cookie usage. Next, you'll configure requests to handle redirects on the server side, set timeout values to prevent long waits due to network or server issues, and touch upon the compatibility of the Python Requests library with HTTPX. Finally, you'll focus on an essential feature of HTTPX - sending and asynchronously processing HTTP requests, which can significantly improve app performance.

Final Exam: Dynamic Data Handling with Python will test your knowledge and application of the topics presented throughout the Dynamic Data Handling with Python track of the Skillsoft Aspire Pythonista to Python Master Journey.

Flask-RESTful is the extension for Flask that contains functions and support you'll use to develop REST APIs. Python developers will enjoy the ease and speed of a minimal set up before moving on to explore Flask-RESTful's built-in template library. Using templates as a jumping off point during development is a great way to quickly and easily develop REST APIs, and it has the additional benefit of guiding you to consistently follow API development best practices. In this course, you'll learn to set up your environment to build a RESTful API server. You'll install the Flask-RESTful libraries on Windows and macOS and you'll also work with the CURL command-line utility to make API calls. Next you'll implement a simple API server that responds to HTTP GET requests and then how to configure responses for GET, POST, PUT, and DELETE requests. Moving on, you'll configure your API server to accept parameters as part of the URL path and send data to your server using the request body in POST requests. Upon finishing this course, you'll be able to configure a simple API server using Flask-RESTful to respond to your HTTP requests.

A major benefit when building REST APIs in Flask-RESTful, is unlimited access to use the built-in request parser any time you want to parse and validate input arguments to your API server. Python developers will find the flexibility and extensibility of Flask-RESTful very useful. In this course, you'll learn to effectively use a request parser object to parse and extract input arguments from user requests. You'll validate input arguments using the right configuration before setting up custom help messages for the parser arguments. Next, you'll examine how your request parser can look beyond the request body - in the query string, cookies, and other locations, for input arguments. You'll explore how to inherit from an existing parser object and how to modify a parser to suit your needs. Finally, you'll investigate how to make errors returned by the parser more user-friendly by choosing to bundle them together to return as a group in a JSON response.

Learn more about Flask-RESTful, which connects to the ORM libraries you use to connect to your database. You'll set up APIs to perform create, read, update, and delete (CRUD) operations. You'll then implement APIs using an in-memory dictionary before integrating them with a MySQL database back end. You'll set up a MySQL database and work with MySQL Workbench. You'll install and use the Advanced REST Client.

This course introduces you to a breadth of features available in the Molten framework to help you build HTTP APIs. You'll begin by creating a virtual environment, installing Molten and various other libraries such as Pytest to test out your Molten apps, and installing Gunicorn to serve your apps. You'll then move on to creating REST APIs using the Molten framework. You'll create a very basic REST API with only one route that maps to a function and the API to process an HTTP GET request. You'll also explore the use of a QueryParam object to handle query parameters passed in an HTTP request. You'll next test your Molten APIs using Pytest by writing some simple tests to ensure an HTTP 200 status code is returned when a correct request is sent to the server and an error code is returned with the response otherwise. You'll also learn how these tests can be executed and how to analyze their outputs. You'll learn about the processing of POST requests, how to ensure the validity of POST data using a Molten Schema instance, different ways to define a schema, and how to use a forward reference. You'll explore the built-in objects available in the Molten framework and how to pass in a plain Python dictionary containing settings for an app. Finally, you'll see how settings can be saved in an external JSON file and then imported into a Molten app and how to load settings defined within a TOML file.

This course covers the use of features in the Molten framework to make your HTTP APIs meaningful and easy to use and test. You'll begin by connecting your Molten application to a SQLite database, including the creation of a cursor to work with the database. You'll then wire up your app so that all the data sent in using POST requests to a specific route is written out to the database. You'll also define handlers for GET requests for that same data by reading from the database. Next, you'll then look at adding middleware into your app and set this middleware to check request headers for the authorization to invoke requests. You'll also tweak the middleware to distinguish between certain types of requests so that authorization is only required for some of them. You'll also see how you can dynamically generate documentation for your Molten application using the OpenAPIHandler. You'll explore how you can use the OpenAPIUIHandler to produce a Swagger UI, which can be used by developers to test the application and also by users to figure out exactly how to use your APIs. Finally, you'll learn how you can serve images to clients using Molten, including attaching a local file to a Response object and returning it to the client.

Django, an advanced Python web framework, allows quick development of secure and sustainable websites. In this course, you'll discover how Django web requests work, which will involve using HTTP protocols, formatting content as HTML pages, using web servers to process requests, and distinguishing between static and dynamic websites. Moving on, you'll identify the steps involved in creating websites, which include reusing HTML elements over multiple pages on a website, customizing user experience by maintaining sessions, and querying databases for content. Next, you'll explore the features provided by web frameworks, particularly Django, that support and greatly simplify all these operations. You'll also investigate the use of Django templates. Finally, you'll become familiar with the migration process within Django and the use of the Django Model class to create subclasses that map to tables in a relational database.

The Django web framework simplifies creating websites and REST APIs through a wide variety of built-in features. In this course, you'll learn how to use some of these built-in features to create websites and apps. You'll start by installing the Django web framework inside a virtual environment. You'll then explore Django's out-of-the-box features, including the project structure, the shell, and the built-in admin app. Next, you'll build a Hello World website using a custom Django app. This process includes defining a URL that maps to a view, which then returns an HTTP response that can be viewed from a browser. Moving on, you'll explore the use of Django templates, which includes the use of base and derived templates. Finally, you'll work with the built-in admin app, examining how to administer users and groups and assign permissions.

Creating websites and REST APIs is simplified through Django's built-in features. In this course, you'll learn how to use some of these features to build highly-performant websites and apps. You'll begin by examining how Django models are defined, migrated to a linked database, and registered with the built-in admin app. You'll then move on to using the Django ModelForm base class, which allows you to create a web page to create instances of your Django model. You'll then explore how to create a sign-in page for your Django website users and present signed-in users with a different view of the site. Finally, you'll cover how users can be allowed to sign out of your website.

The robust websites and apps produced using Django suggest a much more complicated framework than is used. In this course, you'll build on your existing Django knowledge to perform some Django template language operations. You'll start this course by performing various query operations on your Django model instances from the Python shell. You'll also use the Django admin website to work with your models. You'll implement class-based views in Django, first using the ListView class to view multiple instances of a model before using the DetailView class to view individual records. Moving along, you'll use CreateView and UpdateView to generate and modify instances and implement a DeleteView for their easy removal. You'll round off this course by briefly exploring how to improve the aesthetics of your class-based views by incorporating HTML elements, such as tables, in their corresponding templates.

A Django project is simply a web application consisting of one or more apps within it. Django's features ensure you can link multiple related project apps, create apps that accept and store user information, and trigger actions, such as sending emails. In this course, you'll practice carrying out these tasks in Django. You'll start by illustrating how images are incorporated within Django models, displayed on a web page, and stored on a file system while their paths are saved in the database. Next, you'll implement multiple separate but related apps within a Django project. Finally, you'll learn how to ensure a user's selection from a set of checkboxes is stored by your model and work with a user's email credentials to send them an email.

Among Django's many out-of-the-box tools is the REST Framework package, which includes libraries to build APIs. In this course, you'll install and work with this package to allow users to access and submit data to your web application. You'll start by defining a simple model whose instances can be accessed and manipulated using REST APIs. To make this happen, you'll use the built-in Django ModelSerializer class. You'll then wire up your Django REST API to return a list of JSON values from your Django model whenever a GET request is sent. You'll also use the Django REST framework's built-in web UI and the curl command-line utility to send POST requests to submit data to the server and use it to create model instances. Moving on, you'll briefly examine the use of HEAD and OPTION requests before wrapping up with a short exploration of PUT and DELETE requests.

Final Exam: Building Restful Web Services with Python will test your knowledge and application of the topics presented throughout the Building Restful Web Services with Python track of the Skillsoft Aspire Pythonista to Python Master Journey.

A cross-platform library, OpenCV facilitates image processing and analysis. In this course, you'll discover fundamental concepts related to computer vision and the basic operations which can be performed on images using OpenCV. You'll begin by outlining how to read images from your file system into your Python source in the form of arrays and then save an image array into a local file. Next, you'll explore color images represented as a combination of blue, green, and red channels, how to convert color images to grayscale, and how grayscale images are defined. Finally, you'll perform basic operations on images by investigating how to combine two images using an add operation and make one of the added images more prominent than the other using a weighted addition. Conversely, you'll also perform a subtract operation using two images.

Images often require to be manipulated to extract meaningful portions of an image or prepare them for a machine learning pipeline. OpenCV can help with this. In this course, you'll investigate a variety of image manipulation operations using OpenCV. You'll begin by recognizing how to filter certain portions of an image using bitwise operations. Next, you'll explore the concept of masks and how to use them while extracting parts of an image. You'll then outline how to apply geometrical operations by resizing an image to specific dimensions and discover challenges that such operations present. You'll finish the course by examining image transformations such as rotations and translations to help orient an image to your requirements. Finally, you'll discover how to flip and warp images to present them from a different perspective.

Many image processing operations involve complex math, but when using OpenCV, much of that is abstracted from the developer. In this course, you'll gain a high-level understanding of advanced image operations in OpenCV. You'll begin by recognizing how to apply different blur operations to an image. These range from simple blurs to Gaussian and median blurs. While doing so, you'll examine their specific advantages and disadvantages and how to distinguish between them. Moving on, you'll outline how to highlight objects in an image using edge detection and augment images by adding shapes and objects to them. Finally, you'll discover how to work with pre-trained classifiers to detect people in an image and perform morphological transformations to emphasize or suppress specific parts of an image.

Faust is a stream processing library that allows you to write code to process data available as streams. In this course, you'll explore the basics of stream processing and how it fundamentally differs from batch processing. You'll start by examining the components of a stream processing system architecture, specifically the role of stream transport. You'll then investigate the Faust stream processing library, which uses native Python code for transformations on streaming data. Moving on, you'll explore what's meant by producers, consumers, and topics in Apache Kafka. You'll install Faust on your local machine as well as the Apache Kafka messaging service. You'll then use these to write a stream processing application. When you're finished with this course, you'll be able to clearly articulate the characteristics of stream processing and work with Apache Kafka and Faust to perform simple operations on input streams.

Stream processing in Faust uses native Python code, meaning you don't have to learn a new domain-specific language to perform data transformations. All you need to know is how existing concepts, such as models, work within a Faust context. Faust models allow you to specify fields and their data types and use this well-defined data structure to access streaming data. In this course, you'll learn how to represent the individual elements of a stream using Faust models. You'll work with agents, which are at the heart of every Faust stream processing application. You'll perform operations using agents and invoke agents synchronously and asynchronously from within your application. You'll then work with channels in Faust. At the end of this course, you'll have the confidence to use models, agents, and channels in the right way to build a successful application.

Faust streams support a wide range of operations. In this course, you'll learn how to perform several of these. You'll also work with Faust tables - which store state in the form of key-value pairs and allow for the recovery of failed processing, making Faust fault-tolerant. You'll start off by using the group by operation to designate a key used to repartition an input stream and create a new topic in Kafka. You'll then use the items() operation to access the key and message value and take() operation to buffer multiple elements in a stream. Next, you'll work with tables to conduct stateful stream processing, illustrating how table data is stored in an embedded RocksDB database. When you've finished this course, you'll be able to apply a wide range of operations on input streams and perform stateful stream processing using tables.

When working with data, windows are a handy tool to accumulate data subsets from input streams and perform aggregation operations on this specific data. In this course, you'll learn how to perform stream processing through windowing operations in Faust. You'll start by examining the different windowing operations possible on input streams, including tumbling, sliding, count, session, and global windows. Next, you'll distinguish the three notions of time associated with streaming events: event, ingestion, and processing time. You'll then use Faust window features to perform windowing operations on input streams and emit aggregation results for every window. Finally, you'll use the REST API server, which all Faust applications have, to make streaming code metrics and table data accessible to the user. Once you're done with this course, you'll be able to use windowing operations via Faust and expose metrics using web views.

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