One particular element of computer science that has seen a large evolution is the programming language section, which is an integral part of machines and comprises instructions that allow the machines to perform different tasks. Python is one high-level programming language that has immensely grown and is being used in multiple sectors of the industry.

However, Python itself is vast and can be implemented in several different flavors, which shall also be the topic of our discussion in this article, and where we will be looking at the different implementations that currently exist of Python.

Different Implementations of Python

We have been using the term “implementation” for a while now. What does this mean? Well, implementation refers to the way the interpreter was written – what languages were used and what is the purpose of that specific interpreter.

Now, let us look at some of the different implementations of Python.

1) CPython

CPython is the default and most widely used interpreter or implementation of Python, written in C. It is the original Python version, which users download from its official website, Python.org. It can be better described as a mixture of both an interpreter and compiler as it converts your written Python source code into bytecode. By bytecode, we refer to a program code that gets compiled and processed into a low-level language that can be used as instructions for the interpreter. It is this bytecode that gets executed on the CPython Virtual Machine.

Since it is the original Python implementation, CPython has the highest compatibility with a variety of Python packages and modules and is the best choice if users need to write code that completely matches the Python standards.

2) Jython

Jython is another Python implementation that has been written in the Java language whose implementation can run in Java platforms. Similar to CPython, it first converts the source code into bytecode, which, as mentioned before, are a set of instructions that are needed by an interpreter. In Jython, these are written in Java and can run on the Java Virtual Machine, which is the same environment that Java itself uses. Jython allows users to easily work with Java programs since you can call, as well as utilize, your Java functions and classes directly from Jython without any additional effort which is immensely beneficial as Python users can get access into the enormous ecosystem of libraries and frameworks that come along with Java. The same is true on the opposite end.

3) IronPython

Similar to how Jython has been developed for Java users, IronPython is the popular Python implementation that has been written in C-Sharp (C#) and has been designed to run on the .NET platform. It creates a bridge between the Python and .NET universe and allows Python users to get access to C-sharp functions and classes, as well as .NET libraries and frameworks directly from IronPython. IronPython excels for programs that make use of threading and can be found on the ironpython.net website.

4) PyPy

PyPy is the Python implementation that has been written in the Python language itself and is another alternative to CPython. Since it has been created while keeping in mind the specifications of the Python language, it is most compatible with CPython, allowing it to run web frameworks like Django and Flask, and even adds a few improvements on the top of it. PyPy makes use of the concept called Just-in-time (JIT) compilation, which allows it to compile the source code during the execution of the program. This, in turn, has made it several times faster than CPython, in which its runtime speed being slow was a common complaint among users. PyPy completely improves this part of CPython.

5) Cython

Unlike the other implementations of Python mentioned in the list, Cython is not a Python interpreter but rather a superset of the Python language that allows users to compile programs in the C language. The amazing thing is that it provides you with the combined power of both Python and C, and this, therefore, is why it can be used for writing C extensions as well as transform and tune your Python code into C. Hence, Cython overcomes many limitations of Python and still maintains the convenience and comfort that comes with Python.

Conclusion:

Python has enormously grown and expanded into various implementations, all of which have been developed to the cater the needs of different users. Throughout the time frame in which users might be working with the Python interface, they might come across several of these implementations, and therefore, it is important to know what exactly each of these is and where does their expertise lie.

Different parts of Django Logging

Django logging contains four types of configurations which are explained below.

1. Django Logger
The logger records the events when the application is executed, and the logging is called. The log entries are stored in a file by categorizing them in different log levels. Every log level indicates the severity of the events. The purposes of these log levels are mentioned below:

1. DEBUG
   It provides low-level system information for debugging.

2. INFO
   It provides general information.

3. ERROR
   It provides information about the major problem of the application.

4. WARNING
   It provides information about the minor problem of the application.

5. CRITICAL
   It provides information about the critical problem of the application.

2. Django Handler
The main task of the handler is to transmit the log information that is stored in the log file. The logging module contains many types of handlers and multiple of them can be defined for the same logger.

3. Django Formatter
It is used to format the log data. The data of the handler cannot be sent directly to the log file and the handler data requires it to be converted by using the formatter before sending. The formatter converts the log records into the string. The format of the data depends on the business logic of the handler.

4. Django Filter
It is used to filter the log messages. It is unnecessary to store all log messages into the log file. Different handlers can be used for different messages and the required log messages can be filtered using the required filters.

Prerequisites

Before practicing the script of this tutorial, you must complete the following tasks:

1. Install the Django version 3+ on Ubuntu 20+ (preferably)
2. Create a Django project
3. Run the Django server to check the server is working properly or not.

Setup a Django app

1. Run the following command to create a Django app named logapp.

2. Run the following command to create the user for accessing the Django database. If you have created the user before then don’t need to run the command.

3. Add the app name in the INSTALLED_APP part of the py file.

Set the Logging Information in settings.py

Open the settings.py file from the Django project folder and add the following content to define the logging information. The properties of the handlers and loggers are set here. According to the logging property values, DEBUG level logging information will be stored in a log file named djangoapp.log when the Django app will be executed.

Open the djangoapp.log file to check log entries are stored in the file or not.

Set the Logging Information in views.py

Logging information can be defined using the view file also. Open the views.py file from the logapp folder and replace the content with the following script. In this script, formatters, handlers, and loggers parts of Django logging are defined in the config.dictConfig() method. DEBUG level logging information will be stored in a log file named djangoapp.log and will be printed in the console when the Django app will be executed. index() function is used to send a simple headline text to the browser and the display_log() function is defined to send a simple text in the terminal and a headline text to the browser.

views.py

Modify the content of the urls.py file with the following script. In the script, the empty path(”) path is defined to call the index() function of the views and the ‘log/’ path is used to call the display_log() function of the views.

urls.py

Run the following URL to display the index page.

http://localhost:8000

Run the following URL to call the display_log() method that will display a text message in the browser and a text message in the terminal. Log entries will be appended in the djangoapp.log file.

Conclusion

Two ways of using python logging in the Django application to keep the DEBUG level logging information are shown in this tutorial. The basic concept regarding Django logging is expected to be understood by the readers after reading this tutorial.

Prerequisites

Before practicing the examples of this tutorial, you must complete the following tasks:

1. Install the Django version 3+ on Ubuntu 20+ (preferably)
2. Create a Django project
3. Run the Django server to check the server is working properly or not.

Setup a Django App

A. Run the following command to create a Django app named filterapp.

B. Run the following command to create the user for accessing the Django database. If you have created the user before then don’t need to run the command.

C. Add the app name in the INSTALLED_APP part of the py file.

D. Create a folder named templates inside the filterapp folder and set the template’s location of the app in the TEMPLATES part of the py file.

Create a Model for the Database Table

Open the models.py file from the filterapp folder and add the following script to define the structure of employees tables. Employee class is defined to create a table named employees with name, post, email, department, and joining_date fields. Here, name, post, and department fields will store character data, the email field will store the email address and the joining_date field will store date data.

models.py

Run the makemigrations command to create a new migration based on the changes made by the models.

Run the migrate command to execute the SQL commands and create all tables in the database that are defined in the models.py file.

Modify the content of the admin.py file with the following content. Here, the Employee class of the models is registered using the register() method to display the records of employees tables in the Django administration dashboard.

admin.py

Run the following URL to open the Django admin login page. Provide the valid username and password to open the Django Administration Dashboard to access the database tables.

Insert two or more Employee records to apply the filter on the data. Here five records are inserted.

Create the search.html file inside the filterapp/templates/ folder with the following script. The data from the employee table will be displayed in this template file. for loop is used to read the content of the object_list variable that will be passed from the view file. The name, post, and department values of the employees table will be displayed by using the list.

search.html

Open the views.py file from the filterapp folder and modify the content of the file with the following script. Model and template names are defined in the script.

views.py

Modify the content of the urls.py file with the following content. In the script, the ‘searchEmp’ path is defined to call the SearchEmployee.as_view() method that will send all data and the filtered data of the employees table to the template file.

urls.py

The following output will appear without applying any filtering for the following URL.

http://localhost:8000/SerachEmp

Filter Data by Simple Filtering

Add the following line at the end of the views.py file to filter the records of the employees table where the value of the post field is ‘Accountant’.

The following output will appear after applying basic filtering.

Filter Data with Multiple Fields

Add the following line at the end of the views.py file to filter the records of the employees table where the value of the department field is ‘HT’ and the email field is ‘ali@gmail.com’.

The following output will appear after applying multiple filtering.

Filter Data with Q Object

Add the following line at the end of the views.py file to filter the records of the employees table where the value of the post field is ‘Manager’ or the value of the department field is ‘Sales’.

The following output will appear after applying Q object filtering.

Filter Data by Using Filter Chaining

Add the following line at the end of the views.py file to filter the records of the employees table where the value of the department field will be checked first and if it returns true then the value of the name field will be checked.

The following output will appear after applying filter chaining.

Conclusion

The data can be filtered in Django in many ways based on the application requirements. Four different ways of filtering were explained in this tutorial to understand the basics of Django filtering. These are simple filtering, multiple filtering, filtering with Q object, and filter chaining.

How the Django template can be created and how the DTL can be used to add static or dynamic content to the template have been shown in this tutorial.

Advantages of using DTL:

There are many benefits of using DTL in Django templates. Some of them are mentioned below.

1. The logical part and the presentational part of the application are created separately.
2. It becomes easier to extend the application.
3. It helps reduce the redundancy of the data.
4. It assures the application’s security.

Prerequisites:

Before practicing the script of this tutorial, you have to complete the following tasks:

1. Install the Django version 3+ on Ubuntu 20+ (preferably)
2. Create a Django project
3. Run the Django server to check whether the server is working properly or not

Setup a Django app:

Run the following command to create a Django app named tempapp:

Run the following command to create the user for accessing the Django database, but if you have created the user before, then don’t need to run the command shown below:

Add the app name in the INSTALLED_APP part of the settings.py file, as shown below:

Create a folder named templates inside the tempapp folder and set the template’s location of the app in the TEMPLATES part of the settings.py file, as shown below:

Create a Simple Django Template:

Create the index.html file inside the tempapp/templates/ folder with the following HTML script to display the formatted static text of two lines in the browser. HTML file can’t be displayed directly in the browser and the views.py file is used to render the HTML file in the Django application.

index.html

Open the views.py file from tempapp folder and add the following script. The rander() method is used in the views.py file to display any template file into the browser.

In the following script, the index() function is defined to display the content of the index.html file. When this function call from the urls.py file, then the template file will be displayed in the browser.

views.py

Modify the content of the urls.py file with the following script. According to the script, the index() function of the views.py will be called for the path, ‘index/’.

urls.py

Run the following URL from the browser to get the following output. The static data is displayed in the output.

http://localhost:8000/index/

Create a Django Template with DTL:

Create the customers.html file inside the tempapp/templates/ folder with the following HTML script. DTL is used in this script to display the data of the dictionary variable that is initialized by the data of nested lists in the views2.py file. The first for loop is used to read the values of the outer list and the second for loop is used to read the values of the inner list.

customers.html

Create another view file named views2.py under tempapp folder with the following script. A dictionary variable named data is declared in the script that contains a nested list to generate tabular data of 4 rows and 4 columns. The data variable will be sent to the template when the customers() function of this script will be called from the urls.py file.

views2.py

Modify the urls.py file with the following script. ‘customers/’ path is defined in the script to load the customers.html file in the browser with the data of the dictionary.

urls.py

Run the following URL from the browser to get the following output. The records of all customers from the database tables have been displayed in the browser using the DTL.

http://localhost:8000/customers/

Conclusion:

The ways of creating a simple template and a template with Django Template Language (DTL) have been shown in this tutorial. The new Django users will be able to create the template for the Django app properly after practicing the script of this tutorial.

How HTML form can be used to take data from the user, read the input values, and print the values in the browser using Django is shown in this tutorial.

Prerequisites:

You have to create a Django project before creating the Django form. To create a new Django project and go to the project folder, run the following commands:

To create necessary files and apply migrations for the project, run the following command:

To check if the Django server is working properly or not, run the following command:

To create the formapp under django_pro project, run the following command:

Create HTML Form Using Django:

Open the views.py file that is inside formapp folder and modify its content with the following content. The following script will check whether the form is submitted or not. If the form is submitted then the value of the request.method will be POST and request.POST.get() method is used to read its submitted values. The is_valid() function will check whether the data of the form is valid or not. If this function returns true, then a success message with the valid user’s data will be printed in the browser, otherwise, the error message that appears on the particular field of the form will be displayed. Other than that, the render() method is used to load the form in the browser and HttpResponse() method is used to send the response from the server to the browser after submitting the form.

Create forms.py inside the formapp folder and add the following content. The following script will create a form of four fields. The name field is defined to take the character data and it can be 40 characters long. The email field is defined to take any valid email address using the character data and it can be 50 characters long. The username field is defined to take the character data, and it can be 20 characters long. The password field is defined to take the character data and it can be a minimum of 10 characters and a maximum of 20 characters long. The forms.PasswordInput widget is used for the password field to hide the content of the password field.

Create a folder named templates inside the formapp folder. Go to the TEMPLATES section of the settings.py file and set the location of the template folder for the DIRS property.

settings.py

Create form.html inside the template folder with the following content.

{% csrf_token %} is used in the HTML script to prevent CSRF(Cross-Site Request Forgeries) attacks. {{ form.as_p }} will load the Django form that is designed by the forms.py file. When the Submit button is pressed, the form data will be submitted to the server.

Open the urls.py from the django_pro folder and modify the content with the following content.

Here, the ‘register/’ path is used to load the form in the browser.

Open any browser and type the following URL to load the user registration form in the browser.

http://localhost:8000/register

The following output will appear after running the URL. The validation for the empty field, the maximum length value of name, email, and password fields, and the minimum and maximum length values of the password field will be checked after submitting the form.

The following output shows that the password field is invalid. According to the form, the length of the password value must be within 10 to 20 characters. 5 characters have been given as input in the following form. For this, the form is showing the error message.

After entering the valid output in every field of the form, the following output will appear.

Conclusion:

The way of creating a very simple user registration form in the Django application has been shown in this tutorial. Django has many methods for creating different types of fields of the form, such as CharField(), EmailField(), TextFiled, etc. The form validation task becomes very easier when the form is designed by Django form.

Django framework can be used to create a web application with a database by writing script in models.py and views.py files of the Django app. The data can be inserted into the database tables by using Django Administration Dashboard or by writing a script in the views.py file. Django Administration Dashboard requires a login for an authenticated user to access the tables of the database. Single or multiple records can be inserted into the database tables by writing a script. bulk_create() method is one of the ways to insert multiple records in the database table. How the bulk_create() method is used to insert the multiple data in a Django database table will be shown in this tutorial.

Prerequisites:

Before practicing the script of this tutorial, you have to complete the following tasks:

1. Install the Django version 3+ on Ubuntu 20+ (preferably)
2. Create a Django project
3. Run the Django server to check the server is working properly or not

Setup a Django app:

Run the following command to create a Django app named bookapp.

Run the following command to create the user to access the Django database. If you already created one, then you don’t need to run the command.

Add the app name in the INSTALLED_APP part of the settings.py file.

Create a folder named templates inside the bookapp folder and set the template’s location of the app in the TEMPLATES part of the settings.py file.

Create a model for the database table:

Open the models.py file from the bookapp folder and add the following script to define the structure of books tables. Book class is defined to create a table named books with title, author, price, and published_year fields. According to the script, title and author fields will store character data, and price and published_year fields will store the integer data. Here, the title field is defined with the unique attribute. That means that the value of the title field will not accept any duplicate data.

models.py

Run the makemigrations command to create a new migration based on the changes made by the models.

Run the migrate command to execute the SQL commands and create all tables in the database that are defined in the models.py file.

Modify the content of the admin.py file with the following content. Here, the Book class of the models is registered using the register() method to display the books tables in the Django administration dashboard.

admin.py

Create a template file named DisplayBookList.html inside the bookapp/templates/ folder with the following script. This script will display all data of books table in tabular form. Other than that, for loop is used in the script to iterate the data passed from the views.py file.

DisplayBookList.html

Modify the content of the views.py file with the following script. The model and template names are defined in the BulkInsert class. get_queryset() method of the class is defined in the script to return all records of the books table. On the other hand, Book.objects.all() method is used to return all records of the books table. exists() method is used in the script to check the books table is empty or not. If this method returns False then five records will be inserted into the books table using the bulk_create() method.

views.py

Modify the content of the urls.py file with the following script. In the script, the ‘admin/’ path is defined to open the Django Administration Dashboard and the ‘books/’ path is defined to call the BulkInsert.as_view() method that will insert five records to the books table and return the records to the template file.

urls.py

Open the Django Administration Dashboard to check whether the data is inserted properly or not using the bulk_create() function.

The inserted records of the books table will be displayed in the browser after executing the following URL.

http://localhost:8000/books/

Conclusion:

Multiple records can be inserted into the Django database table in different ways using the bulk_create(). A simple way of inserting multiple records in the database table using this method was shown in this tutorial to help Django users understand the logic behind the process.

Prerequisites

Before practicing the script shown in this tutorial, be sure to complete the following tasks.

• Install Django version 3+ on Ubuntu 20+ (preferably)
• Create a Django project
• Run the Django server to check whether the server is working properly

Set Up a Django App

Run the following command to create a Django app named socketapp:

Run the following command to install the channel:

Add the channels and app name to the INSTALLED_APP part of the settings.py file:

Define the value of ASGI_APPLICATION in the settings.py file:

Create a folder named templates inside the socketapp folder and set the template’s location of the app in the TEMPLATES part of the settings.py file:

The following output will appear in the terminal after running the Django server. The output shows that ASGI/Channels version 3.0.3 is running.

Create a template file named index.html in the defined template location to display the data sent by the WebSocket. The socket object that is created using JavaScript will read the data using the JSON.parse() method, then pass the value into the content of the <h1> tag that contains the ID value, ‘msg.’

index.html

Modify the views.py file of the socketapp with the following content. The index.html template file will be displayed in the browser with the text variable when the index() method of this script is called from the urls.py file. If no message is transmitted from the socket, then the text ‘LinuxHint’ will be displayed in the browser.

views.py

Modify the urls.py file of the socketapp with the following content. Two paths are defined in the script: the ‘admin/’ path is used to open the Django Administration Dashboard, and the ‘msg/‘ path is used to read the WebSocket message.

urls.py

When the following URL is executed without defining the consumer and routing files, the HTTP protocol will work and the following output will appear.

http://localhost:8000/msg

Now, create a consumers.py file inside the socketapp folder with the following script. The connect() method of ws_consumer will be used to accept the socket connection, read the current time value every second, and send the current time in JSON format via WebSocket when this method is called from the routing file.

consumers.py

Create the routing.py inside the socketapp folder with the following script. The ‘msg/’ path is defined in the script to call the consumer for sending the data to the socket.

routing.py

Modify the asgi.py file with the following script. The modules that are required to handle HTTP and WebSocket requests are imported in the script.

asgi.py

Now, run the following URL from the browser again to read the data from the WebSocket.

http://localhost:8000/msg/

If the consumer and router are working properly, then the following digital clock will be displayed in the browser. Here, the router has sent the WebSocket request using the ‘msg/‘ path to the consumer that has accepted the request and sent the data to the template to show the digital clock in the browser where the second value of the current time is updating every second.

Conclusion

This tutorial showed you how to implement a real-time application using the Django framework and channels by creating a simple digital clock. Other types of real-time applications can also be implemented using Django and channels, such as online chatting systems. The scripts used in this tutorial work for Django versions 3+ and Channel versions 3+ only. So, if you are using an earlier Django or Channel version, then you will need to upgrade the version before testing the script provided in this tutorial.

In this article, we will explore various data plotting methods by using the Pandas python. We have executed all examples on the pycharm source code editor by using the matplotlib.pyplot package.

Plotting in Pandas Python

In Pandas, the .plot() has several parameters that you can use based on your needs. Mostly, using the ‘kind’ parameter, you can define which type of plot you will create.

The Syntax for Plotting Data using Pandas Python

The following syntax is used to plot a DataFrame in Pandas Python:

You can also define the plot kind by using the kind parameter as follows:

Pandas DataFrames objects have the following plot methods for plotting:

• Scatter Plotting: plot.scatter()
• Bar Plotting:  plot.bar() , plot.barh() where h represents horizontal bars plot.
• Line Plotting: plot.line()
• Pie Plotting: plot.pie()

If a user only uses the plot() method without using any parameter then, it creates the default line graph.

We will now elaborate on some major types of plotting in detail with the help of some examples.

Scatter Plotting in Pandas

In this type of plotting, we have represented the relationship between two variables. Let’s take an example.

Example

For example, we have data of correlation between two variables GDP_growth and Oil_price. To plot the relation between two variables, we have executed the following piece of code on our source code editor:

Line Charts Plotting in Pandas  

The line chart plot is a basic type of plotting in which given information displays in a  data points series that are further connected by segments of straight lines. Using the Line charts, you can also show the trends of information overtime.

Example

In the below-mentioned example, we have taken the data about the past year’s inflation rate. First, prepare the data and then create DataFrame. The following source code plots the line graph of the available data:

In the above example, you need to set the kind= ‘line’ for line chart plotting.

Method 2# Using plot.line() method

The above example, you can also implement using the following method:

The following line graph will display after running the above code:

Bar Chart Plotting in Pandas

The bar chart plotting is used to represent the categorical data. In this type of plot, the rectangular bars with different heights are plotted based on the given information. The bar chart can be plotted in two different horizontal or vertical directions.

Example

We have taken the literacy rate of several countries in the following example. DataFrames are created in which ‘Country_Names’ and ‘literacy_Rate’ are the two columns of a DataFrame. Using Pandas, you can plot the information in the bar graph shape as follows:

You can also implement the above example using the following method. Set the kind=’bar’ for bar chart plotting in this line:

Horizontal bar chart plotting

You can also plot the data on horizontal bars by executing the following code:

In df.plot.barh(), the barh is used for horizontal plotting. After running the above code, the following bar chart displays on the window:

Pie Chart Plotting in Pandas

A pie chart represents the data in a circular graphic shape in which data displays into slices based on the given quantity.

Example

In the following example, we have displayed the information about ‘Earth_material’ in different slices on the Pie chart. First, create the DataFrame, then, by using the pandas, display all details on the graph.

The above source code plots the pie graph of the available data:

Conclusion

In this article, you have seen how to plot DataFrames in Pandas python. Different kinds of plotting are performed in the above article. To plot more kinds such as box, hexbin, hist, kde, density, area, etc., you can use the same source code just by changing the plot kind.

In this article, we will walk through the basic uses of a group by function in panda’s python. All commands are executed on the Pycharm editor.

Let’s discuss the main concept of the group with the help of the employee’s data. We have created a dataframe with some useful employee details (Employee_Names, Designation, Employee_city, Age).

String Concatenation using Group by Function

Using the groupby function, you can concatenate strings. Same records can be joined with ‘,’ in a single cell.

Example

In the following example, we have sorted data based on the employees ‘Designation’ column and joined the Employees who have the same designation. The lambda function is applied on ‘Employees_Name’.

When the above code is executed, the following output displays:

Sorting Values in an ascending order

Use the groupby object into a regular dataframe by calling ‘.to_frame()’ and then use reset_index() for reindexing. Sort column values by calling sort_values().

Example

In this example, we will sort the Employee’s age in ascending order. Using the following piece of code, we have retrieved the ‘Employee_Age’ in ascending order with ‘Employee_Names’.

Use of aggregates with groupby

There are a number of functions or aggregations available that you can apply on data groups such as count(), sum(), mean(), median(), mode(), std(), min(), max().

Example

In this example, we have used a ‘count()’ function with groupby to count the Employees who belong to the same ‘Employee_city’.

As you can see the following output, under the Designation, Employee_Names, and Employee_Age columns, count numbers that belong to the same city:

Visualize data using groupby

By using the ‘import matplotlib.pyplot’, you can visualize your data into graphs.

Example

Here, the following example visualizes the ‘Employee_Age’ with ‘Employee_Nmaes’ from the given DataFrame by using the groupby statement.

Example

To plot the stacked graph using groupby, turn the ‘stacked=true’ and use the following code:

In the below-given graph, the number of employees stacked who belong to the same city.

Change Column Name with the group by

You can also change the aggregated column name with some new modified name as follows:

In the above example, the ‘Designation’ name is changed to ‘Employee_Designation’.

Retrieve Group by key or value

Using the groupby statement, you can retrieve similar records or values from the dataframe.

Example

In the below-given example, we have group data based on ‘Designation’. Then, the ‘Staff’ group is retrieved by using the .getgroup(‘Staff’).

The following result displays in the output window:

Add Value into group List

Similar data can be displayed in the form of a list by using the groupby statement. First, group the data based on a condition. Then, by applying the function, you can easily put this group into the lists.

Example

In this example, we have inserted similar records into the group list. All the employees are divided into the group based on ’Employee_city’, and then by applying the ‘Lambda’ function, this group is retrieved in the form of a list.

Use of Transform function with groupby

The employees are grouped according to their age, these values added together, and by using the ‘transform’ function new column is added in the table:

Conclusion

We have explored the different uses of groupby statement in this article. We have shown how you can divide the data into groups, and by applying different aggregations or functions, you can easily retrieve these groups.

Split Method

The “split()” method can be used to split words using a user specified separator. It returns a list of splitted words without including the separator. If no separator is specified by the user, whitespace (one or more) is used as a single separator.

For instance, the code below will return “[‘Linux’, ‘Hint’]” as output:

The code below will return “[‘LinuxHint’, ‘com’]” as output when “.” is used as separator:

The separator doesn’t have to be a single character. The split method takes two arguments:

• sep: separator to be used for splitting
• maxsplit: number of splits to do

Both these arguments are optional. As mentioned above, if the “sep” argument is not specified, whitespace is used as a separator for splitting. The “maxsplit” argument has a default value of “-1” and it splits all occurrences by default. Consider the code below:

It will return “[‘LinuxHint’, ‘co’, ‘us’]” as output. If you want to stop splitting at the first occurrence of the separator, specify “1” as the “maxsplit” argument.

The code above will return “[‘LinuxHint’, ‘co.us’]” as output. Just specify the number of occurrences where you want the split process to stop as the second argument.

Note that if there are consecutive separators, an empty string will be for returned for the remaining separators after the first split (when “maxsplit” argument is not used):

The code above will return “[‘LinuxHint’, ”, ‘com’]” as output. In case you want to remove empty strings from the resulting list, you can use the following list comprehension statement:

You will get “[‘LinuxHint’, ‘com’]” as the output after running the above code sample.

Note that the “split()” method moves from left to right to split strings into words. If you want to split string from right to left direction, use “rsplit()” instead. Its syntax, usage and arguments are exactly the same as the “split()” method.

If no separator is found in the string while using “split()” or “rsplit()” methods, the original string is returned as the sole list element.

Partition Method

The “partition()” method can be used to split strings and it works identical to the “split()” method with some differences. The most notable difference is that it retains the separator and includes it as an item in the resulting tuple containing splitted words. This is especially useful if you want to divide the string into an iterable object (tuple in this case) without removing any original characters. Consider the code below:

The above code sample will return “(‘LinuxHint’, ‘.’, ‘com’)” as the output. If you want the result to be of list type, use the following code sample instead:

You should get “[‘LinuxHint’, ‘.’, ‘com’]” as output after running the above code sample.

The “partition()” method takes only one argument called “sep”. Users can specify a separator of any length. Unlike the “split()” method, this argument is mandatory, so you can’t omit the separator. However, you can specify whitespace as a separator.

Note that the partition method stops at the first occurrence of the separator. So if your string contains multiple separators, the “partition()” method will ignore all other occurrences. Here is an example illustrating this:

The code sample will produce “[‘LinuxHint’, ‘.’, ‘co.us’]” as output. If you want to split at all occurrences of the separator and include the separator in the final list as well, you may have to use a “Regular Expression” or “RegEx” pattern. For the example mentioned above, you can use a RegEx pattern in the following way:

You will get “[‘LinuxHint’, ‘.’, ‘co’, ‘.’, ‘us’]” as output after executing the above code sample. The dot character has been escaped in the RegEx statement mentioned above. Note that while the example above works with a single dot character, it may not work with complex separators and complex strings. You may have to define your own RegEx pattern depending on your use case. The example is just mentioned here to give you some idea about the process of retaining the separator in the final list using RegEx statements.

The “partition()” method can sometimes leave empty strings, especially when the separator is not found in the string to be splitted. In such cases, you can use list comprehension statements to remove empty strings, as explained in the “split()” method section above.

After running the above code, you should get “[‘LinuxHint’]” as output.

Conclusion

For simple and straightforward splits, you can use “split()” and “partition()” methods to get iterable types. For complex strings and separators, you will need to use RegEx statements.

Pandas DataFrame is a 2D (two dimensional) annotated data structure in which data is aligned in the tabular form with different rows and columns. For easier understanding, the DataFrame behaves like a spreadsheet that contains three different components: index, columns, and data. Pandas DataFrames are the most common way to utilize the panda’s objects.

Pandas DataFrames can be created using different methods. This article will explain all possible methods through which you can create Pandas DataFrame in python. We have run all examples on the pycharm tool. Let’s start the implementation of each method one by one.

Basic Syntax

Follow the following syntax while creating DataFrames in Pandas python:

Example:Let’s explain with an example. In this case, we have stored the data of student’s names and percentages in a ‘Students_Data’ variable. Further, using the pd.DataFrame (), we have created a DataFrames for displaying student’s result.

Methods to Create Pandas DataFrames

Pandas DataFrames can be created using the different ways that we will discuss in the rest of the article. We will print the Student’s courses result in the form of DataFrames. So, using one of the following methods, you can create similar DataFrames that are represented in the following image:

Method # 01: Creating Pandas DataFrame from the dictionary of lists

In the following example, DataFrames are created from the dictionaries of lists related to student’s course results. First, import a panda’s library and then create a dictionary of lists. The dict keys represent the column names such as ‘Student_Name’, ‘Course_Title’, and ‘GPA’. Lists represent the column’s data or content. The ‘dictionary_lists’ variable contains the data of students that are further assigned to the ‘df1’ variable. Using the print statement, print the all content of DataFrames.

Example:

After executing the above code, the following output will be displayed:

Method # 02: Create Pandas DataFrame from the dictionary of NumPy array

The DataFrame can be created from the dict of array/list. For this purpose, the length must be the same as all the narray. If some index is passed, then the index length should be equal to the array’s length. If no one index is passed, then, in this case, the default index to be a range (n). Here, n represents the array’s length.

Example:

Method # 03: Creating pandas DataFrame using the list of lists

In the following code, each line represents a single row.

Example:

Method # 04: Creating pandas DataFrame using the list of dictionary

In the following code, each dictionary represents a single row and keys that represent the column names.

Example:

Method # 05: Creating pandas Dataframe from dict of pandas Series

The dict keys represent the names of columns and each Series represents column contents. In the following lines of code, we have taken three types of series: Name_series, Course_series, and GPA_series.

Example:

Method # 06: Create Pandas DataFrame by using zip() function.

Different lists can be merged through the list(zip()) function. In the following example, pandas DataFrame are created by calling pd.DataFrame() function. Three different lists are created that are merged in the form of tuples.

Example:

Conclusion

Using the above methods, you can create Pandas DataFrames in python. We have printed a student’s course GPA by creating Pandas DataFrames. Hopefully, you will get useful results after running the above-mentioned examples. All programs are commented well for better understanding. If you have more ways to create Pandas DataFrames, then do not hesitate to share them with us. Thanks for reading this tutorial.

We will explore the uses of merge function, concat function, and different types of joins operations in Pandas python in this article. All examples will be executed through the pycharm editor. Let’s start with the details!

Use of Merge Function

The basic commonly used syntax of merge () function is given-below:

Let’s explain the details of the parameters:

The first two df_obj1 and df_obj2 arguments are the names of the DataFrame objects or tables.

The “how” parameter is used for different types of join operations such as “left, right, outer, and inner”. The merge function uses “inner” join operation by default.

The argument “on” contains the column name on which the join operation is performed. This column must be present in both DataFrame objects.

In the “left_on” and “right_on” arguments, “left_on” is the name of the column name as the key in the left DataFrame. The “right_on” is the name of the column used as a key from the right DataFrame.

To elaborate on the concept of joining DataFrames, we have taken two DataFrame objects- product and customer. The following details are present in the product DataFrame:

The customer DataFrame contains the following details:

Join DataFrames on a Key

We can easily find products sold online and the customers who purchased them. So, based on a key “Product_ID”, we have performed inner join operation on both DataFrames as follows:

The following output displays on the window after running the above code:

If the columns are different in both DataFrames then, explicitly write the name of each column by the left_on and right_on arguments as follows:

The following output will show on the screen:

Join DataFrames using How Argument

In the following examples, we will explain four types of Joins operations on Pandas DataFrames:

• Inner Join
• Outer Join
• Left Join
• Right Join

Inner Join in Pandas

We can perform an inner join on multiple keys. To display more details about the product sales, take Product_ID, Seller_City from the product DataFrame and Product_ID, and “Customer_City” from the customer DataFrame to find that either seller or customer belongs to the same city. Implement the following lines of code:

The following result shows on the window after running the above code:

Full/outer join in Pandas

Outer joins return both right and left DataFrames values, which either have matches. So, to implement the outer join, set the “how” argument as outer. Let’s modify the above example by using the outer join concept. In the below code, it will return all values of both left and right DataFrames.

Set the indicator argument as “True”s. You will notice that the new “_merge” column is added at the end.

As you can see in the below screenshot, the merge column values explain which row belongs to which DataFrame.

Left Join in Pandas

Left join only display rows of the left DataFrame.  It is similar to the outer join. So, change the ‘how’ argument value with “left”. Try the following code to implement the idea of Left join:

Right Join in Pandas

The right join keeps all right DataFrame rows to the right along with the rows that are also common in the left DataFrame. In this case, the “how” argument is set as the “right” value. Run the following code to implement the right join concept:

In the following screenshot, you can see the result after running the above code:

Joining of DataFrames using the Concat () function

Two DataFrames can be joined using the concat function. The basic syntax of the concatenation function is given below:

Two DataFrames objects will pass as arguments.

Let’s join both DataFrames product and customer through the concat function. Run the following lines of code to join two DataFrames:

Conclusion:

In this article, we have discussed the implementation of merge () function, concat () functions, and joins operation in Pandas python. Using the above methods, you can easily join two DataFrames and learned. how to implement the Join operations “inner, outer, left, and right” in Pandas. Hopefully, this tutorial will guide you in implementing the join operations on different types of DataFrames. Please let us know about your difficulties in case of any error.

QTimer Usage

The following sections provide examples that illustrate how to implement two different applications using the QTimer class.

Example 1: Create a Stopwatch

The following script will implement a stopwatch application in Python using the QTimer class. This application will count the number of seconds and the number of minutes. Two buttons are used to start, stop, resume, and reset the counter. When the user clicks the Start button, the counter will start counting, and the caption of the Start button will be changed to Stop. When the user clicks the Start button with the caption Stop, the counter will stop temporarily, and the caption of the Start button will be changed to Resume to continue the counter to the next time. When the user clicks the Reset button, all the values of the counter will be initialized to 0.