In this article, you’ll learn how to download an image from the web in Python.

To make it more fun, we have the following running scenario:

Sven, a Journalist from Greeland, is writing about Glacier Calving. His editor would like photos of iceberg collapses in the area accompanying his article. Unfortunately, Sven is not tech-savvy and needs your help.

Question: How would we write Python code to perform image downloads?

We can accomplish this task by one of the following options:

• Method 1: Use requests.get() and write()
• Method 2: Use requests.get() and Image
• Method 3: Use requests.get() and shutil
• Method 4: Use urllib.request.urlretrieve()
• Bonus: Download all images using a For loop

Quick Solution

Short on time? Here’s a one-paragraph answer:

To download an image in Python, import the requests library and pass the URL of the image into the requests.get(url) function to get a response object from the server. Its response.content attribute gets you the binary image content. Finally, use the open() and write() functions to write the binary content to a new file.

Here’s the quick code solution:

import requests

url = "https://example.com/image.jpg"
response = requests.get(url)

with open("image.jpg", "wb") as f:
    f.write(response.content)

Preparation and Library Installation

Before our code executes successfully, two (2) new libraries will require installation.

• The requests library is used to send and receive HTTP requests.
• The pillow (PIL) library is used to retrieve and process images.

To install these libraries, navigate to an IDE terminal. At the command prompt ($), execute the code below. For the terminal used in this example, the command prompt is a dollar sign ($). Your terminal prompt may be different.

$ pip install requests

Hit the <Enter> key on the keyboard to start the installation process.

$ pip install pillow

Hit the <Enter> key on the keyboard to start the installation process.

If the installations were successful, a message displays in the terminal indicating the same.

Feel free to view the PyCharm installation guide for the required libraries.

• How to install Requests on PyCharm
• How to install Pillow on PyCharm

Add the following code to the top of each code snippet. This snippet will allow the code in this article to run error-free.

import requests
from PIL import Image
import shutil
import urllib

 Note: The additional libraries indicated above do not require installation as they come built-in to Python.

Method 1: Use requests.get() and write()

The requests.get() function is used with file open() and write() to download and save the specified file.

img_url = 'https://blog.finxter.com/wp-content/uploads/2022/04/greenland_01a.jpg'
response = requests.get(img_url)
if response.status_code:
    fp = open('greenland_01a.png', 'wb')
    fp.write(response.content)
    fp.close()

The above code attempts to connect to the stated URL (img_url). If successful, a Status Code of 200 is returned. This image is then opened and written to the specified file and saved to the current working directory.

Output

Method 2: Use requests.get() and Image()

The requests library is used with the PIL library’s open() and requests.get() functions to download and save the specified file.

img_url = 'https://blog.finxter.com/wp-content/uploads/2022/04/greenland_02a.jpg'
img = Image.open(requests.get(img_url, stream = True).raw)
img.save('greenland_02a.png')

The above code connects to the stated URL (img_url). This image is then opened and written in raw format to img. Finally, it is saved to the current working directory as an image file.

Output:

Method 3: Use requests.get() and shutil

The requests library is used with the shutil and requests.get() functions to copy, download and save the specified file.

img_url = 'https://blog.finxter.com/wp-content/uploads/2022/04/greenland_03a.jpg'
response = requests.get(img_url, stream=True)
with open('greenland_03a.png', 'wb') as out_file:
    shutil.copyfileobj(response.raw, out_file)
del response

This code retrieves the specified URL, then opens and creates a file object. This object saves the file stated in open() to the current working directory. To clean up, the response object is removed.

Output

Method 4: Use urllib.request.urlretrieve()

This code uses the urllib and requests libraries to connect, retrieve, process, and save the image. For example, we call urllib.request.urlretrieve(img_url, "greenland_04a.png") to download the image at the given URL.

Here’s the full example:

img_url = 'https://blog.finxter.com/wp-content/uploads/2022/04/greenland_04a.jpg'
urllib.request.urlretrieve(img_url, "greenland_04a.png")

On one line of code, this code calls the requests and urllib libraries to perform all the tasks to retrieve, process, and save the indicated image to the current working directory.

Output

Bonus:

This code grabs all the URLs above and pastes them to a list. Next, the list is referenced in a for loop. Finally, each image is retrieved, processed, and saved to the current working directory.

import urllib
import requests

imgs = ['https://blog.finxter.com/wp-content/uploads/2022/04/greenland_01a.jpg',
        'https://blog.finxter.com/wp-content/uploads/2022/04/greenland_02a.jpg',
        'https://blog.finxter.com/wp-content/uploads/2022/04/greenland_03a.jpg',
        'https://blog.finxter.com/wp-content/uploads/2022/04/greenland_04a.jpg']

icount=1
for i in imgs:
    urllib.request.urlretrieve(i, f'greenland_0{str(icount)}b.png')
    icount += 1

Thanks

These four (4) methods of downloading and saving images should give you enough information to select the best one for your coding requirements.

Feel free to check out our free email academy here:

Good Luck & Happy Coding!

Image Sources.

The post 5 Easy Ways to Download an Image from a URL in Python appeared first on Be on the Right Side of Change.

This article will show you how to create a Virtual Environment inside the Visual Studio Code, the VSC Editor.

Virtual Environments are best used when a coder or several coders work together to develop medium to large-scale applications. The best approach is to keep this code and associated libraries and dependencies separate. This is where a Virtual Environment comes in!

Setting up the Environment

Open the Visual Studio Code Editor and create a new folder that will house the Python script to be worked on.

Create a blank script file called sales.py and place this file into this directory.

From the View menu, select Command Pallette or press CTRL+SHIFT+P on the keyboard for the same result.

The above action displays a dropdown box. Start typing the word Python: Create Environment, or if visible, click to select this option.

The above action displays another dropdown box. For this article, the first option was selected (Venv).

The above action displays another dropdown box. For this article, the second option was selected (Python 3.11.0 64-bit).

The above action starts the installation of the Virtual Environment. Wait for this process to complete.

Once the Virtual Environment is installed, the following occurs:

• A message in the status bar indicates the name of the Virtual Environment (.venv:env)
• A new folder called .venv is created.

Next, locate and open the activate.bat from the .venv\Scripts folder. From the Main Menu, Click Run → Start Debugging or press F5 on the keyboard.

If successful, the command prompt changes similar to below.

You are now officially working in a Virtual Environment.

Note: If an error is generated when running this .bat file, you may need to install an extension that reads Batch files. For this article, Batch Runner was installed.

Install Required Library

For this article, our sales.py file reads in the sales.csv file. This means that the pandas library will need to be installed. To perform this task, navigate to the terminal window and run the following code.

pip install pandas

If successful, the pandas library is now installed in the Virtual Environment and if we run sales.py there should be no errors.

Note: Install any other required libraries the same way.

• How to Install a Python Library
• How to Install Pandas?

Generate a Requirements File

A Requirements File can be created at any time during the development cycle. This file is a checklist for the Python application in question. It lists all libraries and associated versions used in the app.

To generate a requirements.txt file, navigate to the terminal and run the following code:

pip freeze > requirements.txt

This action generates the above-noted file and places it into, for this example, the SALES_APP folder. Open this file and scroll down to see the pandas library listed, including the version number. This is handy when deploying to another Virtual Environment to ensure the correct library versions are installed.

Deactivating the Virtual Environment

To deactivate the Virtual Environment, click the (.venv:env) link in the bottom-right of the IDE. This action displays the Interpreter dropdown box. Select Python 3.11.0 64-bit or any other option that does not contain the (.venv:env) words.

If successful, the status bar no longer has the (.venv:env) link, and the prompt no longer contains that as well.

While still in the Virtual Environment, another option is to navigate to the Scripts folder, open and run deactivate.bat file

Summary

This article showed you how to setup, activate, and de-activate a Virtual Environment in the VS Code IDE.

The post Setup a Virtual Environment with Visual Studio Code in Python appeared first on Be on the Right Side of Change.

This article shows how to generate a formatted PDF file from a CSV file using the ReportLab and Pandas libraries in conjunction with slicing.

Python offers numerous ways to generate a PDF file. One option is to use the ReportLab library. The article selected the path that used the least amount of code.

To make it more interesting, we have the following running scenario:

Example Scenario: KarTek, a car dealership in Toronto, previously asked you to import their CSV file into a Database. They would like this data converted to a PDF format to email out to their Sales Staff daily.

To follow along with this article, download and place the cars.csv file into the current working directory:

Download and save the logo file to the current working directory as car_logo.png.

Question: How would we write code to generate a PDF from a CSV file?

We can create a PDF from a CSV file by performing the following steps:

1. Install ReportLab and Pandas Libraries
2. Add Library References
3. Read CSV File
4. Calculate Total Pages
5. Get Stylesheet and Template
6. Create Page Header
7. Paginate the Data
8. Build the PDF
9. Generate the PDF

Step 1: Install ReportLab and Pandas Libraries

Before moving forward, the ReportLab and Pandas libraries must be installed. To install these libraries, run the following code at the command prompt.

The ReportLab library is needed to generate a PDF, and the Pandas library is required to read and manipulate the cars.csv file.

pip install reportlab
pip install pandas

Step 2: Add Library References

To run this code error-free, references to the required modules must be added.

To add these references, navigate to the IDE. Create a file called pdf.py and place this file into the current working directory.

Copy the code snippet below and paste this code into the above-created file.

from reportlab.platypus import *
from reportlab.lib.styles import *
from reportlab.lib import *
from reportlab.platypus import *
import pandas as pd
import math 

An alternate option would be to reference precisely what is needed.

from reportlab.lib.styles import getSampleStyleSheet
from reportlab.platypus import PageBreak
from reportlab.platypus import SimpleDocTemplate, Table, PageBreak, Image, Paragraph, Spacer
from reportlab.lib import colors
import pandas as pd
import math 

The first option is much cleaner. There are pros and cons for each selection. However, the choice is up to you.

Save this file.

Step 3: Read CSV File

The next step is to read the CSV file and extract the heading row.

Copy and paste this code snippet to the bottom of the pdf.py file.

df_cars = pd.read_csv('cars.csv', sep=';').head(60)
df_data = [df_cars.columns[:,].values.astype(str).tolist()] + df_cars.values.tolist()
pg_data = df_data[1:]

The first line in the above code snippet reads in the first 60 rows (head(60)) of the cars.csv file. In this file, the field separator character is a semi-colon (;) and must be specified, as read_csv() assumes the separator character is a comma (,). The results save to df_cars.

The following line casts all data types to strings astype(str) and splits the data into lists. The result saves to df_data. If output to the terminal, the data would display as shown below (a snippet of the file).

[['Car', 'MPG', 'Cylinders', 'Displacement', 'Horsepower', 'Weight', 'Acceleration', 'Model', 'Origin'], 
 ['Chevrolet Chevelle Malibu', 18.0, 8, 307.0, 130.0, 3504.0, 12.0, 70, 'US'], 
 ['Buick Skylark 320', 15.0, 8, 350.0, 165.0, 3693.0, 11.5, 70, 'US'], 
 ['Plymouth Satellite', 18.0, 8, 318.0, 150.0, 3436.0, 11.0, 70, 'US'], ...]

The last line removes the header row using slicing, leaving only the data. The results save to pg_data. If output to the terminal, the data would display as shown below (a snippet of the file).

[['Chevrolet Chevelle Malibu', 18.0, 8, 307.0, 130.0, 3504.0, 12.0, 70, 'US'], ['Buick Skylark 320', 15.0, 8, 350.0, 165.0, 3693.0, 11.5, 70, 'US'], ['Plymouth Satellite', 18.0, 8, 318.0, 150.0, 3436.0, 11.0, 70, 'US'], ['AMC Rebel SST', 16.0, 8, 304.0, 150.0, 3433.0, 12.0, 70, 'US'], ...]

Save this file.

Step 4: Calculate Total Pages

This code snippet is used to calculate how many pages the PDF will be.

elements = []
recs_pg = 39
tot_pgs = math.ceil(len(df_data) / recs_pg)

The first line in the above code snippet declares an empty list called elements. This list will hold all the page formatting for the PDF.

The following line declares how many records per page will display (not including the header row). The results save to recs_pg.

The last line uses the ceil() function from the math library to calculate how many pages this PDF will be. This function returns an integer value. The results save to tot_pgs. If output to the terminal, the following will display.

2

Save this file.

Step 5: Get Stylesheet and Template

This code snippet is used to set the styles and a template for the PDF.

styles = getSampleStyleSheet()
doc = SimpleDocTemplate('inventory.pdf', rightMargin=0, leftMargin=0, topMargin=0, bottomMargin=0)

The first line in the above code snippet gets the getSampleStyleSheet() function. This function gives us access to default styles, such as Title, Heading1, Heading2, etc. Additional styles can be found here.

The following line calls the SimpleDocTemplate() function and passes it five (5) arguments: the filename of the PDF to generate and the page margins. The results save to doc.

Save this file.

Step 6: Create Page Header

This code snippet creates a header for each page of the PDF.

def createPageHeader():
    elements.append(Spacer(1, 10))
    elements.append(Image('car_logo.png', 100, 25))
    elements.append(Paragraph("Inventory", styles['Title']))
    elements.append(Spacer(1, 8))

This first line in the above code snippet declares the function createPageHeader(). The contents of this function will appear at the top of each page.

The following line adds spacing from the top of the page using the Spacer() function and passing it two (2) arguments: the width and height. The results are appended to elements, declared at the beginning of the code.

To achieve the offset, the topMargin argument could also be adjusted. However, we wanted to show another way to achieve the same result.

The next line calls the Image() function and passes it three (3) arguments: the image, and the x and y positions, respectively.

The results are appended to elements, declared at the beginning of the code.

Then, a heading of Inventory is called using the Paragraph() function and passing it two (2) arguments: the text and the style for the text. The results are appended to elements, declared at the beginning of the code.

The last line appends another Spacer().

Save this file.

Step 7: Paginate the Data

This code snippet shows how the data for each page is paginated.

def paginateInventory(start, stop):
    tbl = Table(df_data[0:1] + pg_data[start:stop])  
    tbl.setStyle(TableStyle([('BACKGROUND', (0, 0), (-1, 0), '#F5F5F5'),
                              ('FONTSIZE', (0, 0), (-1, 0), 8),
                              ('GRID', (0, 0), (-1, -1), .5, '#a7a5a5')])) 
    elements.append(tbl)

The line in the above code snippet declares the function paginateInventory() which accepts two (2) arguments: a start and stop position.

The following line creates the data for the page. The Table() function is called and passed one (1) argument: the header row from df_data (df_data[0:1]), plus the data for the specified page (pg_data[start:stop]). These results save to tbl.

The next line sets out the format for the table on the page. This line does the following:

• Change the background color of the header row.
• Changes the font size.
• Sets up the grid lines between all the cols/rows,

The tbl is then appended to elements, declared at the beginning of the code.

Save this file.

Step 8: Build the PDF

This code snippet creates a function to loop through the paginated data and builds a PDF.

def generatePDF():
    cur_pg = 0
    start_pos = 0
    stop_pos = recs_pg

    for cur_pg in range(tot_pgs):
        createPageHeader()
        paginateInventory(start_pos, stop_pos)
        elements.append(PageBreak())
        start_pos += recs_pg
        stop_pos += recs_pg
    doc.build(elements)

The first line in the above code snippet declares the function generatePDF().

The following three (3) lines declare three (3) variables and their initial positions.

• cur_pg, which keeps track of the page we are currently on.
• start_pos, which is where the data initially starts.
• stop_pos, which is where the data initially ends (recs_pg, or 39).

The following section does all the work! It declares a for loop, which loops through all pre-determined pages (tot_pgs, or 2 in this case). Then, the following creates a page by:

• Executing the createPageHeader() function.
• Outputting the page data using slicing (paginateInventory(start_pos, stop_pos)).
• Adds a Page Break (PageBreak()).
• Re-calculate the start_pos and stop_pos variables.

This loop continues until all pages have been generated,

The last line in this code snippet, builds the PDF.

Save this file.

Step 9: Generate a PDF

This code snippet generates the PDF built earlier.

If you ran the above code, no PDF file would be generated. This is because the following code needs to be appended to the end of the pdf.py file.

The first line is mainly used to declare the top-level starting point of a program.

if __name__ == '__main__':
    generatePDF()

An alternative is to just call the function.

generatePDF()

There are pros and cons to both options. However, the choice is up to you.

Save and run this file.

If successful, the inventory.pdf file will be saved to the current working directory.

The Full Code

from reportlab.platypus import *
from reportlab.lib.styles import *
from reportlab.lib import *
from reportlab.platypus import *
import pandas as pd
import math 

df_cars = pd.read_csv('cars.csv', sep=';').head(60)
df_data = [df_cars.columns[:,].values.astype(str).tolist()] + df_cars.values.tolist()
pg_data = df_data[1:]

elements = []
recs_pg = 39
tot_pgs = math.ceil(len(df_data) / recs_pg)

styles = getSampleStyleSheet()
doc = SimpleDocTemplate('inventory.pdf', rightMargin=0, leftMargin=0, topMargin=0, bottomMargin=0)

def createPageHeader():
    elements.append(Spacer(1, 10))
    elements.append(Image('car_logo.png', 100, 25))
    elements.append(Paragraph("Inventory", styles['Title']))
    elements.append(Spacer(1, 8))

def paginateInventory(start, stop):
    tbl = Table(df_data[0:1] + pg_data[start:stop])  
    tbl.setStyle(TableStyle([('BACKGROUND', (0, 0), (-1, 0), '#F5F5F5'),
                              ('FONTSIZE', (0, 0), (-1, 0), 8),
                              ('GRID', (0, 0), (-1, -1), .5, '#a7a5a5')])) 
    elements.append(tbl)

def generatePDF():
    cur_pg = 0
    start_pos = 0
    stop_pos = recs_pg

    for cur_pg in range(tot_pgs):
        createPageHeader()
        paginateInventory(start_pos, stop_pos)
        elements.append(PageBreak())
        start_pos += recs_pg
        stop_pos += recs_pg
    doc.build(elements)
generatePDF()

Summary

This article has shown you a compact way to generate a customized PDF file.

Good Luck & Happy Coding!

The post Generate a Simple PDF using Python ReportLab (9 Steps) appeared first on Be on the Right Side of Change.

This article will show you how to import external Python code and use this code in another Python script.

To make it more interesting, we have the following running scenario:

Fun Example: Pam, a High School Teacher, wants an easier way to calculate exam totals and produce student averages. The functions to produce these results are located in an external Python file. She has asked for your help.

To follow along, create a file called calcs.py. Copy and paste the contents shown below into this file. Save and place this file into the current working directory.

Contents of calcs.py:

def ClassAverage(lst):
    return sum(lst) / len(lst)

def IncreaseGrades(lst):
    return [x+2 for x in lst]

def DecreaseGrades(lst):
    return [x-3 for x in lst]

def DecreaseGrades(lst):
    return [x-3 for x in lst]

def FailStudent(sname, el):
    return (f'Sorry {sname[el]} you failed.')

Question: How would we write code to import and call these functions from another file?

We can accomplish this task by one of the following options:

• Method 1: Use from file import function
• Method 2: Use from file import *
• Method 3: Use exec()
• Method 4: Use import file
• Method 5: Run from a subfolder

Method 1: Use “from file import function”

This example calls in one (1) specific function from the calcs.py file, ClassAverage(). This code does not have access to any other functions from this file.

This code calculates the average grade for the Class.

from calcs import ClassAverage

std_grades = [76, 53, 68, 49, 81]
class_avg = ClassAverage(std_grades)
print(f'The Average Grade for the Class is {class_avg}%.')

The first line in the above code snippet imports the ClassAverage() function from the calcs.py file.

The following line declares a list of student grades. The results save to std_grades.

The next line calls in the ClassAverage() function and passes it one (1) argument, std_grades. The results of this calculation save to class_avg and are output to the terminal.

The Average Grade for the Class is 65.4%.

Note: To import additional functions, place a comma after the first function as follows: from calcs import Class Average, IncreaseGrades.

Method 2: Use “from file import *”

This example uses import *. This lets Python know that all functions are available to use.

This code increases the students’ grades by two (2) grade points.

from calcs import *

std_grades = [76, 53, 68, 49, 81]
new_grades = IncreaseGrades(std_grades)
print(new_grades)

The first line in the above code snippet imports all functions from the calcs.py file.

The following line declares a list of student grades. The results save to std_grades.

The next line calls the IncreaseGrades() function and passes it one (1) argument, std_grades. The results of this calculation save to new_grades and are output to the terminal.

[78, 55, 70, 51, 83]

Method 3: Use exec() and file.read()

This example uses exec() and with open to read in the contents of the calcs.py file.

This code decreases the students’ grades and re-calculates the average grade.

with open('calcs.py') as fp: exec(fp.read())

std_grades = [76, 53, 68, 49, 81]
new_grades = DecreaseGrades(std_grades)
class_avg = ClassAverage(new_grades)

print(new_grades)
print(class_avg)

The first line in the above code snippet reads in the calcs.py file and saves this as a File Object, fp. If output to the terminal, a File Object similar to below would display.

<_io.TextIOWrapper name='calcs.py' mode='r' encoding='cp1252'>

Then exec() is called and passed one (1) argument, fp.read(), which reads the contents of the file.

The following line declares a list of student grades. The results save to std_grades.

The next line calls the DecreaseGrades() function and passes it one (1) argument, std_grades. The results of this calculation save to new_grades.

Then, the ClassAverage() function is called and passed one (1) argument, new_grades. The results of this calculation save to class_avg.

The contents of the above variables are output to the terminal.

[73, 50, 65, 46, 78]
62.4

Method 4: Use “import file”

This example uses from import. To access the functions from the calcs.py file, you need a direct reference, such as calcs.function().

This code informs the specified student they have failed.

import calcs

std_names = ['Amy', 'Ben', 'Art', 'Joe', 'Zoe']
std_grades = [76, 53, 68, 49, 81]
std_failed = calcs.FailStudent(std_names, 3)
print(std_failed)

The first line in the above code snippet imports all functions from the calcs.py file.

The following two (2) lines declare a list of students and a corresponding list of grades. These results save to std_names and std_grades, respectively.

The next line calls the file name imported earlier (calc) and appends the function FailStudent(). This function is passed two (2) arguments, std_names and the index number of the failing student. The results save to std_failed and are output to the terminal.

Sorry Joe you failed.

Method 5: Run from a sub-folder

This example places the calcs.py file inside the test folder. This file is then referenced in the code.

import os
import sys

subfolder = "test/"
sys.path.append(os.path.abspath(subfolder))

import calcs

std_grades = [76, 53, 68, 49, 81]
new_grades = calcs.DecreaseGrades(std_grades)
class_avg = calcs.ClassAverage(new_grades)
print(class_avg)

The first (2) lines in the above code snippet import the os and the sys libraries used to locate the sub-folder.

The following two (2) lines let the code know to set the location to the subfolder (test). For this example, the calcs.py file resides in this folder.

The following line imports calcs.

To confirm this works, the final four (4) lines declare a list of students’ grades and calculates the Class Average. The results are output to the terminal.

62.4

Note: The above code is the same code used in Method 3 above.

Summary

This article has provided five (5) ways to import a Python file to select the best fit for your coding requirements.

Good Luck & Happy Coding!

The post How to Import External Code in Python appeared first on Be on the Right Side of Change.

This article will show you how to create, update and query a SQLite database using Python.

The SQLite database is a great choice! It is self-contained, easy to use, easy to learn, and works on other devices, such as game consoles, mobile phones, and so on!

To make it more interesting, we have the following running scenario:

KarTech, a used car dealership in Toronto, currently has its inventory of cars saved as a CSV file format. However, they would like this imported into a database. For simplicity, they selected SQLite.

To follow along with this article, download and place the cars.csv file into the current working directory:

Question: How would we write code to create and work with a SQLite Database?

We can accomplish this task by performing the following these steps:

• Preparation
• Declare Variables
• Create SQLite Database and Table
• Retrieve Table Column Names
• Execute Select Query
• Execute Insert Query
• Execute Delete Query
• Close Connections

Preparation

The first step is to import and install the required library to ensure the code in this article will run error-free.

If the pandas library is not installed. Click here for instructions.

Next, create a Python file in the current working directory called cars-sql.py and paste the following code to the top of this file.

import pandas as pd
import sqlite3
from os.path import exists as file_exists

The first line in the above code snippet calls in the pandas library, which is required to access and manipulate the cars.csv file downloaded earlier.

The following line imports Python’s built-in sqlite3 library required to access and manipulate the SQLite database.

The last line also imports Python’s built-in os library that checks for the existence of the Database file.

Save this file.

Declare Variables

This section creates and assigns variables for the Database, its associated Table, and the cars.csv file downloaded earlier.

Paste the following lines to the bottom of the cars-sql.py file.

dbase_name = 'cars.db'
table_name = 'inventory'
csv_file = 'cars.csv'

Save this file.

Create Database and Table

This section does all the heavy lifting! It creates a Database if it does not already exist and attempts to connect to the same!

Paste the following lines to the bottom of the cars-sql.py file.

if file_exists(dbase_name):
    conn = sqlite3.connect(dbase_name)
else:
    conn = sqlite3.connect(dbase_name)
    df = pd.read_csv('cars.csv', sep=';')
    df.to_sql(f'{table_name}', conn)
cur = conn.cursor()

The first line in the above code snippet checks to see if the Database exists in the current working directory (cars.db). If this file exists, a Connection Object is created (conn), allowing access to the Database (shown below).

Connection Object: <sqlite3.Connection object at 0x000001E8653DAB40>

If the Database does not exist, code execution falls inside the else statement where the following occurs:

• A Database is created, and a Connection object to the same saves to conn.
• The cars.csv file is read in (notice the separator character). The results save to the DataFrame, df.
• Then the contents of df are imported into the table specified earlier (inventory).

The last line creates a Cursor Object (cur) from the Connection Object (conn). The Cursor Object allows access to commands, such as SQL, which can be applied against the Database and/or Table.

Cursor Object: <sqlite3.Cursor object at 0x0000024D38B562C0>

Save this file.

If successful, the cars.db SQLite database should now reside in the current working directory.

Retrieve Table Column Names

This section shows how to retrieve a list of the Column Names in the Table.

Paste the following lines to the bottom of the cars-sql.py file.

cols = conn.execute('SELECT * FROM inventory')
conn.commit()

col_names = list(map(lambda x: x[0], cols.description))

The first two (2) lines in the above code snippet execute and commit a SQL command that receives all rows from the inventory Table. A Cursor Object is created from these results and saved to cols. If output to the terminal, the following would display.

Cols Object: <sqlite3.Cursor object at 0x0000022582C9CBC0>

The following lines access and retrieve the cols.description field using a lambda, a map(), and a list. This action retrieves the Field Names from the Table and saves the results to tbl_fields. If output to the terminal, the following would display.

['index', 'Car', 'MPG', 'Cylinders', 'Displacement', 'Horsepower', 'Weight', 'Acceleration', 'Model', 'Origin']

Save this file.

Note: The commit() command saves changes invoked by a SQL query to the database. Click here to learn more.

Execute Select Query

This section shows how to create and execute a SELECT query.

Paste the following lines to the bottom of the cars-sql.py file.

When executing a SELECT query, this task can be performed using the read_sql() function and passing it two (2) arguments, a SQL statement and a Connection Object (conn).

query = pd.read_sql(f'SELECT Car, MPG, Cylinders FROM {table_name} LIMIT 5', conn)

This SQL query selects and retrieves three (3) columns and five (5) rows from the inventory table. The results save to query. If output to the terminal, the following would display.

   Car                                                    MPG      Cylinders
0  Chevrolet Chevelle Malibu                18.0             8
1  Buick Skylark 320                             15.0             8
2  Plymouth Satellite                             18.0             8
3  AMC Rebel SST                                16.0             8
4  Ford Torino                                        17.0             8

Save this file.

Note: The above method is commonly used for SELECT queries as we are not altering the Database or the Table, such as performing an update, insert, delete, drop, or alter command. Click here to learn more about SQL.

Execute Insert Query

This section outlines how to create and execute an INSERT query

Paste the following lines to the bottom of the cars-sql.py file.

cur.execute('''INSERT INTO inventory
             VALUES('Citroen', '28.0', '8', '', '', '', '', '', '', '')''')

print(cur.lastrowid)
conn.commit()

The first line in the above code snippet creates and executes a SQL statement that INSERTS one (1) record into the inventory Table.

The following line retrieves the Row ID and is output to the terminal. If this returns an integer value, then the INSERT was successful.

408

Execute Delete Query

This section outlines how to create and execute a DELETE query

Paste the following lines to the bottom of the cars-sql.py file.

cur.execute('''DELETE FROM inventory WHERE MPG = 28.0''')
conn.commit()

The first line in the above code snippet creates and executes a SQL statement that DELETES all records matching the criteria from the inventory Table.

The following line commits the changes to the Database.

Note: Run a SELECT query to see if the record(s) were successfully deleted.

Close the Connections

The final step is to close any open connections.

Paste the following lines to the bottom of the cars-sql.py file.

cur.close()
conn.close()

The Entire Script

import pandas as pd
import sqlite3
from os.path import exists as file_exists

dbase_name = 'cars.db'
table_name = 'inventory'
csv_file = 'cars.csv'

if file_exists(dbase_name):
    conn = sqlite3.connect(dbase_name)
else:
    conn = sqlite3.connect(dbase_name)
    df = pd.read_csv('cars.csv', sep=';')
    df.to_sql(f'{table_name}', conn)
cur = conn.cursor()


# Get Column Names
cols = conn.execute('SELECT * FROM inventory')
conn.commit()
col_names = list(map(lambda x: x[0], cols.description))

# SELECT
query = pd.read_sql(f'SELECT Car, MPG, Cylinders FROM {table_name} LIMIT 5', conn)
print(query)

# INSERT
cur.execute('''INSERT INTO inventory
             VALUES('Citroen', '28.0', '8', '', '', '', '', '', '', '')''')

print(cur.lastrowid)
conn.commit()

# DELETE
cur.execute('''DELETE FROM inventory WHERE MPG = 28.0''')
conn.commit()

cur.close()
conn.close()

Summary

This article has shown you how to work with a SQLite Database.

Good Luck & Happy Coding!

The post How to Create, Update, and Query an SQLite Database in Python? appeared first on Be on the Right Side of Change.

This article will show you how to interpolate strings in Python.

Interpolation is used when a string contains a placeholder for a variable or a calculation. The string is evaluated, and the placeholder is replaced by the passed data.

To make it more interesting, we have the following running scenario:

Derek, a mortgage broker, wants to write a form email to his clients about the latest hike in mortgage rates. Your job is to create the body of the form email, and Derek will take care of the rest.

Question: How would we write code to interpolate strings in Python?

We can accomplish this task by one of the following options:

• Method 1: Use template() and substitute()
• Method 2: Use f-string
• Method 3: Use the % operator
• Method 4: Use format()
• Bonus: Putting it Together

Method 1: Use template() and substitute()

This method calls string.Template() and uses a dollar sign ($) and a variable name to define a placeholder ($first_name). Whereas substitute() replaces that placeholder with the specified data.

import string

clients = ['Bill', 'Micah', 'Philip', 'Josiah']
salutation = string.Template('Dear $first_name,\n')

for fname in clients:
    print(salutation.substitute(first_name=fname))

The first line in the above code snippet imports the string library. This is required because string.Template() and substitute() are being called.

The following line declares a list of client names. The results save to clients.

The highlighted line declares string.Template() and passes this one (1) argument: the formatted salutation. This string consists of the word Dear and a placeholder, $first_name, followed by a comma and a newline character (,\n).

In the following two (2) lines, a for loop iterates through this list, substituting the salutation placeholder with the client’s first name. The results are then output to the terminal.

Dear Bill,

Dear Micah,

Dear Philip,

Dear Josiah,

Method 2: Use f-string

This method uses an f-string with the curly braces ({}) as a placeholder. This placeholder is replaced with the specified data.

clients = ['Bill', 'Micah', 'Philip', 'Josiah']

for fname in clients:
    print(f'{fname}, I just wanted to touch base with you.\n')

The first line in the above code snippet declares a list of client names. The results save to clients.

In the following two (2) lines, a for loop iterates through this list, substituting the {fname} placeholder with the client’s name followed by a period and a newline character (.\n). The results are then output to the terminal.

Bill, I just wanted to touch base with you.

Micah, I just wanted to touch base with you.

Philip, I just wanted to touch base with you.

Josiah, I just wanted to touch base with you.

Note: In this example, the f-string is called inside the print() statement to indicate to Python to expect a placeholder substitution and output the results to the terminal.

Method 3: Use the Percentage Operator %

The % operator, although an older method, still works and can be used as a placeholder.

m_rates = [3.725, 4.122, 5.398, 2.409]

for r in m_rates:
    print('Your current mortgage rate is %.3f.\n' % (r))

The first line in the above code snippet declares a list of mortgage rates associated to the clients list created earlier. The results save to m_rates.

In the following two (2) lines, a for loop iterates through this list, substituting the % placeholder with the client’s mortgage rate (with 3 decimal places) followed by a period and a newline character (,\n). The results are then output to the terminal.

Your current mortgage rate is 3.73.

Your current mortgage rate is 4.12.

Your current mortgage rate is 5.40.

Your current mortgage rate is 2.41.

Method 4: Use format()

This method uses empty curly braces({}) as a placeholder and calls format() to identify the field(s) to replace with the specified data.

clients = ['Bill', 'Micah', 'Philip', 'Josiah']
new_rate = 7.876

for fname in clients:
    print('Your mortgage is renewing soon, and the new rate is {}%.\n'.format(new_rate))

The first two lines in the above code snippet declare a list of client names and the new mortgage. These save to clients and new_rate, respectively.

In the following two (2) lines, a for loop iterates through the client list, substituting the () placeholder with the client’s new rate followed by a percent sign, a period, and a newline character (,\n). The results are then output to the terminal.

Your mortgage is renewing soon, and the new rate is 7.876%.

Your mortgage is renewing soon, and the new rate is 7.876%.

Your mortgage is renewing soon, and the new rate is 7.876%.

Your mortgage is renewing soon, and the new rate is 7.876%.

Bonus: Putting it Together

This code loops through the list of clients to create a customized body for each email.

clients = ['Bill', 'Micah', 'Philip', 'Josiah']
m_rates = [3.725, 4.122, 5.398, 2.409]
new_rate = 7.876
i = 0

for c in clients:
    body_text = ''
    str1 = f'Dear {c},\n\n'
    str2 = f'{c}, I just wanted to touch base with you.\n'
    str3 = f'Your current mortgage rate is {m_rates[i]}%.\n'
    str4 = f'Your mortgage is up for renewal and new rate is {new_rate}%.\n'
    str5 = 'Contact me for alternate rates.\n\n'
    body_text += str1 + str2 + str3 + str4 + str5
    print(body_text)
    i += 1

The result is output to the terminal.

Dear Bill,

Bill, I just wanted to touch base with you.
Your current mortgage rate is 3.725%.
Your mortgage is up for renewal and new rate is 7.876%.
Contact me for alternate rates.


Dear Micah,

Micah, I just wanted to touch base with you.
Your current mortgage rate is 4.122%.
Your mortgage is up for renewal and new rate is 7.876%.
Contact me for alternate rates.


Dear Philip,

Philip, I just wanted to touch base with you.
Your current mortgage rate is 5.398%.
Your mortgage is up for renewal and new rate is 7.876%.
Contact me for alternate rates.


Dear Josiah,

Josiah, I just wanted to touch base with you.
Your current mortgage rate is 2.409%.
Your mortgage is up for renewal and new rate is 7.876%.
Contact me for alternate rates.

Summary

This article has provided four (4) ways to interpolate strings to select the best fit for your coding requirements.

Good Luck & Happy Coding!

Programming Humor – Python

The post How to Interpolate Strings appeared first on Be on the Right Side of Change.

This article will show you how to copy a Dictionary in Python 7 different ways.

To make it more interesting, we have the following running scenario:

Mr. Smith, a High School Math Teacher, has developed an exciting way to grade multiple-choice exams. He has designed a Dictionary with the exam question number and answer as key:value pairs. How can Mr. Smith make a copy of this structure to modify for future exams?

exam_format = {1: 'B', 2: 'E', 3: 'C', 4: 'D', 5: 'D'}

Question: How would we write code to create a copy of a Dictionary in Python?

We can accomplish this task using one of the following options:

• Method 1: Use dict() and Dictionary Comprehension
• Method 2: Use Dictionary Comprehension
• Method 3: Use update()
• Method 4: Use Unpacking
• Method 5: Use copy()
• Method 6: Use deepcopy()

Method 1: Use dict() and Dictionary Comprehension

This method uses the dict() function to create and return a new Dictionary object

Example 1:

q1_exam = dict(exam_format)

q1_exam[1] = 'C'
q1_exam[2] = 'D'
q1_exam[5] = 'A'
print(q1_exam)

The first line in the above code snippet uses the dict() function and passes it one (1) argument: exam_format (created earlier). These results save to q1_exam.

The following lines modify three (3) values for the q1_exam. The results are output to the terminal.

q1_exam:        {1: 'B', 2: 'E', 3: 'C', 4: 'D', 5: 'D'}

Example 2:

Alternatively, we could call the dict() function and pass it Dictionary Comprehension as an argument to the same.

q1_exam = dict((k,v) for k, v in exam_format.items())

q1_exam[1] = 'C'
q1_exam[2] = 'D'
q1_exam[5] = 'A'
print(q1_exam)  

The output is identical to that shown above.

Method 2: Use Dictionary Comprehension

This method uses Dictionary Comprehension to create and return a new Dictionary object.

q2_exam = {k:v for k,v in exam_format.items()}

q2_exam[2] = 'B'
q2_exam[3] = 'E'
q2_exam[5] = 'A'

print(q2_exam) 

The first line in the above code snippet uses Dictionary Comprehension to create a copy of the exam_format (created earlier). These results save to q2_exam.

The following lines modify three (3) values for the q2_exam. These results are then output to the terminal.

q2_exam:        {1: 'B', 2: 'B', 3: 'E', 4: 'D', 5: 'A'}

Method 3: Use update()

This method uses the update() function to create and return a new Dictionary object.

q3_exam = {}
q3_exam.update(exam_format)
print(q3_exam)  

The first line in the above code snippet declares an empty Dictionary. These results save to q3_exam.

The following line calls q3_exam and appends the update() function to it. This function is passed one (1) argument: exam_format (created earlier). These results are then output to the terminal.

q3_exam:        {1: 'B', 2: 'E', 3: 'C', 4: 'D', 5: 'D'}

Method 4: Use unpacking()

This method uses the unpacking function to create and return a new Dictionary object.

q4_exam = {**exam_format}
print(q4_exam)  

The first line in the above code snippet creates a Dictionary and, using unpacking, passes all elements of exam_format. These results save to q4_exam. How Pythonic!

The results are output to the terminal.

q4_exam:        {1: 'B', 2: 'E', 3: 'C', 4: 'D', 5: 'D'}

A Finxter Favourite!

Method 5: Use copy()

This method uses the copy() function to create and return a new Dictionary object. This function is referred to as a shallow copy as it creates references to the original Dictionary.

import copy

exam_format2 = {1: [1, 2, 3], 2: [1, 2, 3], 3: [1, 2, 3]}
mid_term = exam_format2.copy()
print(mid_term)

mid_term[1].append(4)
print(exam_format2)
print(mid_term)

The first line in the above code snippet imports the copy library. This allows access to the copy() function.

The following line declares a new exam format for Mid Term exams. The results save to exam_format2. Next, a shallow copy of this Dictionary is made by appending the copy() function to exam_format2. These results save to mid_term and are then output to the terminal.

mid_term:        {1: [1, 2, 3], 2: [1, 2, 3], 3: [1, 2, 3]}

The following highlighted section adds a new element to mid_term then, exam_format2 and mid_term are then output to the terminal.

exam_format2:     {1: [1, 2, 3, 4], 2: [1, 2, 3], 3: [1, 2, 3]}
mid_term:         {1: [1, 2, 3, 4], 2: [1, 2, 3], 3: [1, 2, 3]}

Notice how both are updated. When coding, be careful with this option, as it may cause issues.

Method 6: deepcopy()

This method uses the deepcopy() function to create and return a new Dictionary object. This function is called a deep copy as it creates a new Dictionary object.

import copy

exam_format2 = {1: [1, 2, 3], 2: [1, 2, 3], 3: [1, 2, 3]}
mid_term = copy.deepcopy(exam_format2)
print(mid_term)

mid_term[1].append(4)
print(exam_format2)
print(mid_term)

The above code snippet is almost the same as in Method 5 (copy()). However, this code calls the deepcopy() function and passes it one (1) argument: exam_format2. The results save to mid_term and are then output to the terminal.

mid_term:        {1: [1, 2, 3], 2: [1, 2, 3], 3: [1, 2, 3]}

The following highlighted section adds a new element to mid_term then, exam_format2 and mid_term are then output to the terminal.

exam_format2:     {1: [1, 2, 3], 2: [1, 2, 3], 3: [1, 2, 3]}
mid_term:         {1: [1, 2, 3, 4], 2: [1, 2, 3], 3: [1, 2, 3]}

Using deepcopy(), only mid_term was updated.

Bonus: Putting it Together

We decided that Method 4 was the best way to go, and we wrote the code below using this option.

The grade is automatically calculated when Mr. Smith retrieves his students’ results from his online multiple-choice exams. The only change would be the answers in exam_format for any future exams.

exam_format = {1: 'B', 2: 'E', 3: 'C', 4: 'D', 5: 'D'}
q4_exam = {**exam_format}

students = {'Amy': {1: 'B', 2: 'E', 3: 'C', 4: 'B', 5: 'D'},
            'Ben': {1: 'C', 2: 'E', 3: 'A', 4: 'D', 5: 'D'},
            'Joe': {1: 'E', 2: 'C', 3: 'A', 4: 'B', 5: 'D'}}

for s_name, s_answers in students.items():
    correct = 0

    for s_num in s_answers:
        for exam_q in exam_format:
            if (s_num == exam_q) and (s_answers[s_num] == exam_format[exam_q]):
                correct += 1
    print(s_name, correct)

Summary

This article has provided seven (7) ways to copy a Dictionary to select the best fit for your coding requirements.

Good Luck & Happy Coding!

The post 7 Pythonic Ways to Copy a Dictionary appeared first on Be on the Right Side of Change.

SQL, an acronym for Structured Query Language, is the language of the Database! This standardized language is used to manage databases, tables and the data they hold. A must-have in the coding world.

This language allows coders to select a database, a table, query data, export data and much more! The possibilities are endless! This language can be called within phpMyAdmin or directly from a Python script.

Story: Let’s say you have taken over for Sven, the IT Manager at Ignite: a used car dealership in Medford, Oregon. Ignite wants the details of all cars in their inventory. They have asked you to export this data from their server into a CSV file. How can you accomplish this? Follow along with our article to discover how!

This article assumes you have phpMyAdmin installed and a database and table to work with.

1. Overview
2. Use phpMyAdmin and Export Tab
3. Use phpMyAdmin and the SQL Tab
4. Use mysql.connector
5. Use pymysql

Overview

Before you export the data, let’s look at how and where this data is stored. As you can see from the image below, this data is being held, for this example, in the inventory table of the ignite_db database in phpMyAdmin.

phpMyAdmin is a 3rd party tool that manages databases, tables and the data within. It is used in administering MySQL across the web, is free to use, and can be installed locally. Upon installation, keep the URL and login credentials handy, as they will be needed later.

If you have phpMyAdmin installed, navigate to and log in. From the home page, click to select the ignite_db database.

With ignite_db selected, click the Browse hyperlink on the right-hand side.

This action opens and populates the grid to display rows of data from the inventory table. These results will be paginated if the table contains more than 25 rows.

Note: By default, the number of rows/page is 25. Click the Number of rows dropdown to modify.

Use phpMyAdmin and Export Tab

The data from the inventory table can be exported into a CSV file directly from phpMyAdmin using the Export Tab. You can’t see it from the interface; however, this uses MySQL to extract the data from the inventory table.

From phpMyAdmin, click the Export Tab.

Click the Format dropdown box to display a list of available file types. For this example, select CSV to export the data as a CSV file.

Click the Go button to execute. This action displays the Save As dialogue box.

Select a location and file name from this dialogue box, or accept the default values. Click the Save button to complete this task.

For this example, this file was saved as inventory.csv to the desktop. When opened, the data from the inventory table displays (snippet of actual file).

Use phpMyAdmin and the SQL Tab

What happens if you want to use phpMyAdmin and export a filtered result? You can accomplish this by using the SQL Tab and running a MySQL query.

From phpMyAdmin, click the SQL Tab. By default, a query is already started for you. Clear the contents.

Enter the query shown below, which asks the question…
Give me all records in the inventory table where the car’s MPG is greater than 40.

SELECT * FROM inventory WHERE MPG > 40

When creating a query, to select a Column name, double-click the desired name in the Columns list or manually enter it. Once the query is complete, click the Go button to execute.

This query results in the following output of nine (9) records.

To export these results, scroll down the page until you see the Export hyperlink. Click this hyperlink.

This action forwards you to the Export Tab (outlined earlier). Complete the same steps above to export the filtered data to a CSV file.

If successful, the exported CSV file, inventory_filtered.csv, should now contain the data shown below.

Use mysql.connector

This section shows you how to filter and export data from a MySQL database to a CSV file using mysql.connector and Python.

Before we start, two (2) libraries require installation:

• The mysql.connector library which allows access to the database and table created earlier.
• The pandas library which allows access to the CSV writer.

Navigate to an IDE and run the following code:

pip install mysql.connector
pip install pandas

Next, copy and paste the code below into a blank Python file, modify the credentials, and save.

import mysql.connector
from mysql.connector import errorcode
import csv

mpg_hdr = ['Cars', 'MPG', 'Cylinders']

try:
    con = mysql.connector.connect(user='root', password='', host='127.0.0.1', database='ignite_db')
except mysql.connector.Error as err:
    print(err)
    exit()

cursor = con.cursor()
mpg_query = ('SELECT Car, MPG, Cylinders FROM inventory WHERE MPG > 40')
cursor.execute(mpg_query)

with open('filtered.csv', 'w', newline='') as fp:
    writer = csv.writer(fp)
    writer.writerow(mpg_hdr)

    for (Car, MPG, Cylinders) in cursor:
        writer.writerow([Car, MPG, Cylinders])

con.close()

Import Libraries

The first three (3) lines in the above code snippet import the libraries and functions required to successfully run this code.

Declare Variable

This line creates a list containing the three (3) column names to be used as the header row for the CSV file. The results save to the variable mpg_hdr.

Try/Except

This section uses the try/except statement to attempt to connect to ignite_db using the credentials passed. If an error occurs, this code falls into the except section where a message outputs to the terminal indicating the error, and the script ends.

1044 (42000): Access denied for user ''@'localhost' to database 'ignite_db'

If successful, the script continues.

Create a Cursor

The first line in this section creates a cursor() class. This allows the code to execute queries against the ignite_db database and/or the inventory table. The following line creates this query, saves it to mpg_query, and executes it on the next line.

Write Results to CSV

This section opens a file in write (w) mode and saves this as a File Object, fp. The File Object allows access to the filtered.csv file. If fp was output to the terminal, an Object similar to the one below displays.

<_io.TextIOWrapper name='filtered.csv' mode='w' encoding='utf8'>

Next, the header columns for the CSV file are written to this file using the mpg_hdr variable. Then a for loop is instantiated to iterate through each query result, format the row data, and append it as a list to the CSV file.

Once complete, the connection is closed and the script ends.

Output

If successful, the filtered.csv file resides in the current working directory containing the following query results.

Use pymysql

This section shows you how to filter and export data from a MySQL database to a CSV file using pymysql and Python.

Before we start, one (1) library requires installation:

• The pymysql library which allows access to the database and table created earlier.

Navigate to an IDE and run the following code:

pip install pymysql

Next, copy and paste the code below into a blank Python file and save.

Run this code to connect and export the inventory table as a CSV file to the current working directory. Change the details as needed.

import pymysql
import csv

conn_details = {'user':'rot', 'password':'', 'host':'127.0.0.1', 'database':'ignite_db'}
conn = pymysql.connect(**conn_details)
cur = conn.cursor()

all_cars = 'SELECT * from inventory'
cur.execute(all_cars)
rows = cur.fetchall()

with open('inventory.csv', 'w', newline='') as fp:
    myFile = csv.writer(fp)
    myFile.writerows(rows)
conn.close()

Import Libraries

The first two (2) lines in the above code snippet import the libraries required to successfully run this code.

Connect & Create Cursor

The first line in this section saves the credentials needed to connect to ignite_db. The result saves to conn_details. The following line uses these credentials to connect. If successful, the result saves to conn. The following line creates a cursor() class allowing the code to execute queries against the ignite_db database and/or the inventory table.

Execute Query

The first line in this section declares the query, all_cars. The following line executes this query. Then, the next line fetches the query results and saves them to the variable rows.

Write Results to CSV

This section opens a file (inventory.csv) in write (w) mode and saves this as a File Object, fp. The File Object allows access to the inventory.csv file. If fp was output to the terminal, an Object similar to the one below displays.

<_io.TextIOWrapper name='inventory.csv' mode='w' encoding='cp1252'>

The following two (2) lines write the query results to inventory.csv, and the script ends.

Output

If successful, the inventory.csv file resides in the current working directory containing the following query results.

Summary

This article has shown four (4) ways to export MySQL to a CSV to select the best fit for your coding requirements.

Good Luck & Happy Coding!

Programmer Humor – Blockchain

The post How to Export MySQL to a CSV (Dashboard+Python) appeared first on Be on the Right Side of Change.

This article shows you how to execute Python commands in the Shell.

The Shell is known as a command-line interface because it interacts with the Operating System. In Windows, it is referred to as the Command Prompt. In Linux, the Terminal.

Let’s start learning how to use the Shell!

1. Access the Shell
2. Close the Shell
3. Enter and Run Python Commands from the Shell
4. Run a .bat File from the Shell using subprocess
5. Execute Python Scripts using os.system()

Access the Shell

This section shows you how to access the Shell using the VSC IDE.

Open the VSC IDE. Then, navigate to View → Terminal, or use the key combination (CTRL+J).

Either of the above actions opens a Terminal window.

To start the Shell, type python at the prompt (similar to below) and press the <Enter> key.

The above action displays the command prompt (>>>).

Close the Python Shell

This section touches on various ways to close the Shell and terminate code execution.

Below outlines the four (4) available options to perform the above task:

1. At the command prompt (>>>), enter the key combination CTRL+Z and press the <Enter> key. To terminate code execution, this is the best option.
2. At the command prompt (>>>),, enter exit() and press the <Enter> key.
3. At the command prompt (>>>), enter quit() and press the <Enter> key.
4. In the terminal window, click the delete (trashcan) icon on the right-hand side.

Your IDE options may differ slightly.

Note: To show/hide the Shell, click the CTRL+J key combination.

Enter and Run Python Code from the Shell

This section shows how to run Python code directly from the Shell.

Example 1: Perform Mathematical Operations

Not only can you run Python code, but you can also perform mathematical operations. From the command prompt (>>>), enter 5+7. Press the <Enter> key to execute.

If successful, 7 is output to the terminal window.

Example 2: Print a String

This example executes Python’s print() statement. From the command prompt (>>>), enter print('The Finxter Academy'). Press the <Enter> key to execute.

If successful, the string inside the print() statement is output to the terminal window.

Example 3: Iterate and Output Dictionary Keys

For this example, we have a Dictionary of employees saved to the variable staff. This code, when executed, outputs the key of each Dictionary entry to the terminal window.

To see this code in action, copy the code snippet below to the Windows clipboard. Navigate to the command prompt (>>>). Then right-mouse click to paste the code from the Windows clipboard to the terminal window.

staff = {'Amy': 55093, 'Joe': 44094, 'Sue': 3786}
for s in staff: 
   print(s)

In this example, the above action displays a pop-up box.

To prevent this pop-up from displaying, place a checkmark in the Do not show again checkbox. Click the Paste button to paste this code from the Windows clipboard to the terminal window.

Press the <Enter> key to execute.

Example 4: Determine Installed Library Version

This section outputs the currently installed version of the Pandas library to the terminal window. This library must be installed before running this code.

To see this code in action, copy the code snippet below to the Windows clipboard. Navigate to the command prompt (>>>). Right-mouse click to paste the code from the Windows clipboard to the terminal window.

import pandas
pandas.__version__

Press the <Enter> key to execute.

If successful, the currently installed version of the Pandas library is output to the terminal window.

Run a Batch (.bat) File from the Shell using subprocess()

This section shows how to execute a .bat script from the Shell using a subprocess.

For this example, a .bat (batch) file will be created and ran from the Shell.

First, create a Python file called counter.py. Copy and paste the contents of the code snippet below into this file and save it.

This code iterates through a while loop and outputs a string with the value of lift_off on each iteration and pauses for two (2) seconds. This continues until the value of lift_off is greater than zero (0).

from datetime import datetime
from time import sleep

lift_off = 5

while lift_off > 0:
    print (f'Lift Off in {lift_off} seconds!')
    sleep(2)
    lift_off -= 1

Next, create a file called counter.bat. Copy and paste the contents of the code snippet below into this file and save it. The first line hides any output (except for that in the counter.py file).

• The first argument on the following line is the full path to python.exe.
• The second argument is the full path to the .bat file.

Modify as needed.

@echo off
"C:\Python\python.exe" "C:\PYTHON_CODE\counter.py"

Next, navigate to the command prompt (>>>). Copy and paste the contents of the code snippet below to the terminal window. This snippet imports the subprocess library and passes the full path of the .bat file as an argument

import subprocess
subprocess.call([r'C:\\PYTHON_CODE\\P_TRAINING\\LEARN\\CHRIS\WORK\\counter.bat'])

Python’s subprocess library runs applications by creating a process. This allows an application to execute by passing it as an argument, such as a .bat file or another application.

Press the <Enter> key to execute.

If successful, the following output displays.

Execute Commands using os

This section shows how to execute Python code using the os library.

To execute this code, navigate to the command prompt (>>>). Copy and paste the code snippet below into the terminal window.

This code imports the os library and calls the os.system() function. This calls and executes the counter.py file.

import os
os.system("python counter.py")

Press the <Enter> key to execute.

If successful, the following output displays.

Summary

This article has shown you how to work with the Shell in Python. To learn more about the Shell, click here.

Good Luck & Happy Coding!

Programming Humor

Programming is 10% science, 20% ingenuity, and 70% getting the ingenuity to work with the science.

~~~

• Question: Why do Java programmers wear glasses?
• Answer: Because they cannot C# …!

Feel free to check out our blog article with more coding jokes.

The post How to Execute Python Shell Commands appeared first on Be on the Right Side of Change.

This article will show you various ways to work with an XML file.

XML is an acronym for Extensible Markup Language. This file type is similar to HTML. However, XML does not have pre-defined tags like HTML. Instead, a coder can define their own tags to meet specific requirements. XML is a great way to transmit and share data, either locally or via the internet. This file can be parsed based on standardized XML if structured correctly.

To make it more interesting, we have the following running scenario:

Jan, a Bookstore Owner, wants to know the top three (3) selling Books in her store. This data is currently saved in an XML format.

Question: How would we write code to read in and extract data from an XML file into a Python script?

We can accomplish this by performing the following steps:

• Method 1: Use xmltodict()
• Method 2: Use minidom.parse()
• Method 3: Use etree
• Method 4: Use untangle.parse()

Method 1: Use xmltodict()

This method uses the xmltodict() function to read an XML file, convert it to a Dictionary and extract the data.

In the current working directory, create an XML file called books.xml. Copy and paste the code snippet below into this file and save it.

<bookstore>
    <book>
        <title>Surrender</title>
        <author>Bono</author>
        <sales>21987</sales>
    </book>
    <book>
        <title>Going Rogue</title>
        <author>Janet Evanovich</author>
        <sales>15986</sales>
    </book>
    <book>
        <title>Triple Cross</title>
        <author>James Patterson</author>
        <sales>11311</sales>
    </book>
</bookstore>

In the current working directory, create a Python file called books.py. Copy and paste the code snippet below into this file and save it. This code reads in and parses the above XML file. If necessary, install the xmltodict library.

import xmltodict

with open('books.xml', 'r') as fp:
    books_dict =  xmltodict.parse(fp.read())
    fp.close()

for i in books_dict:
    for j in books_dict[i]:
        for k in books_dict[i][j]:
            print(f'Title: {k["title"]} \t Sales: {k["sales"]}')

The first line in the above code snippet imports the xmltodict library. This library is needed to access and parse the XML file.

The following highlighted section opens books.xml in read mode (r) and saves it as a File Object, fp. If fp was output to the terminal, an object similar to the one below would display.

<_io.TextIOWrapper name='books.xml' mode='r' encoding='cp1252'>

Next, the xmltodict.parse() function is called and passed one (1) argument, fp.read(), which reads in and parses the contents of the XML file. The results save to books_dict as a Dictionary, and the file is closed. The contents of books_dict are shown below.

{'bookstore': 
  {'book': [{'title': Surrender', 'author': 'Bono', 'sales': '21987'}, 
              {'title': 'Going Rogue', 'author': 'Janet Evanovich', 'sales': '15986'}, 
              {'title': 'Triple Cross', 'author': 'James Patterson', 'sales': '11311'}]}}

The final highlighted section loops through the above Dictionary and extracts each book’s Title and Sales.

Title: Surrender         Sales: 21987
Title: Going Rogue    Sales: 15986
Title: Triple Cross      Sales: 11311

Note: The \t character represents the <Tab> key on the keyboard.

Method 2: Use minidom.parse()

This method uses the minidom.parse() function to read and parse an XML file. This example extracts the ID, Title and Sales for each book.

This example differs from Method 1 as this XML file contains an additional line at the top (<?xml version="1.0"?>) of the file and each <book> tag now has an id (attribute) assigned to it.

In the current working directory, create an XML file called books2.xml. Copy and paste the code snippet below into this file and save it.

<?xml version="1.0"?>
<bookstore>
	<storename>Jan's Best Sellers List</storename>
	<book id="21237">
		<title>Surrender</title>
                <author>Bono</author>
		<sales>21987</sales>
	</book>
	<book id="21946">
		<title>Going Rogue</title>
                <author>Janet Evanovich</author>
		<sales>15986</sales>
	</book>
	<book id="18241">
		<title>Triple Cross</title>
                <author>James Patterson</author>
		<sales>11311</sales>
	</book>
</bookstore>

In the current working directory, create a Python file called books2.py. Copy and paste the code snippet below into this file and save it.

from xml.dom import minidom

doc = minidom.parse('books2.xml')
name = doc.getElementsByTagName('storename')[0]
books = doc.getElementsByTagName('book')

for b in books:
        bid    = b.getAttribute('id')
        title  = b.getElementsByTagName('title')[0]
        sales  = b.getElementsByTagName('sales')[0]
        print(f'{bid} {title.firstChild.data} {sales.firstChild.data}')

The first line in the above code snippet imports the minidom library. This allows access to various functions to parse the XML file and retrieve tags and attributes.

The first section of highlighted lines performs the following:

• Reads and parse the books2.xml file and saves the results to doc. This action creates the Object shown as (1) below.
• Retrieves the <storename> tag and saves the results to name. This action creates an Object shown as (2) below.
• Retrieves the <book> tag for each book and saves the results to books. This action creates a List of three (3) Objects: one for each book shown as (3) below.

(1) <xml.dom.minidom.Document object at 0x0000022D764AFEE0> 
(2) <DOM Element: storename at 0x22d764f0ee0> 
(3) [<DOM Element: book at 0x22d764f3a30>, 
<DOM Element: book at 0x22d764f3c70>, 
<DOM Element: book at 0x22d764f3eb0>]

The last section of highlighted lines loop through the books Object and outputs the results to the terminal.

21237 Surrender 21987
21946 Going Rogue 15986
18241 Triple Cross 11311

Method 3: Use etree

This method uses etree to read in and parses an XML file. This example extracts the Title and Sales data for each book.

The etree considers the XML file as a tree structure. Each element represents a node of said tree. Accessing elements is done on an element level.

This example reads in and parses the books2.xml file created earlier.

import xml.etree.ElementTree as ET

xml_data = ET.parse('books2.xml')
root = xml_data.getroot()

for books in root.findall('book'):
    title = books.find('title').text
    author = books.find('author').text
    sales = books.find('sales').text
    print(title, author, sales)

The first line in the above code snippet imports the etree library. This allows access to all nodes of the XML <tag> structure.

The following line reads in and parses books2.xml. The results save as an XML Object to xml_data. If output to the terminal, an Object similar to the one below displays.

<Element 'bookstore' at 0x000001E45E9442C0>

The following highlighted section uses a for loop to iterate through each <book> tag, extracting the <title>, <author> and <sales> tags for each book and outputting them to the terminal.

Surrender Bono 21987
Going Rogue Janet Evanovich 15986
Triple Cross James Patterson 11311

To retrieve the attribute of the <book> tag, run the following code.

This code extracts the id attribute from each <book> tag and outputs it to the terminal.

{'id': '21237'}
{'id': '21946'}
{'id': '18241'}

To extract the values, run the following code.

for id in root.iter('book'):
    vals = id.attrib.values()
    for v in vals:
        print(vals)

21237
21946
18241

Method 4: Use untangle.parse()

This method uses untangle.parse() to parse an XML string.

This example reads in and parses the books3.xml file shown below. If necessary, install the untangle library.

The untangle library converts an XML file to a Python object. This is a good option when you have a group of items, such as book names.

In the current working directory, create an XML file called books3.xml. Copy and paste the code snippet below into this file and save it. If necessary, install the untangle library.

<?xml version="1.0"?>
<root>
    <book name="Surrender"/>
    <book name="Going Rogue"/>
    <book name="Triple Cross"/>
</root>

In the current working directory, create a Python file called books3.py. Copy and paste the code snippet below into this file and save it.

import untangle

book_obj = untangle.parse('books3.xml')
books = ','.join([book['name'] for book in book_obj.root.book])

for b in books.split(','):
    print(b)

The first line in the above code snippet imports the untangle library allowing access to the XML file structure.

The following line reads in and parses the books3.xml file. The results save to book_obj.

The next line calls the join() function and passes it one (1) argument: List Comprehension. This code iterates through and retrieves the name of each book and saves the results to books. If output to the terminal, the following displays:

 Surrender,Going Rogue,Triple Cross

The next line instantiates a for loop, iterates through each book name, and sends it to the terminal.

Surrender
Going Rogue
Triple Cross

Summary

This article has shown four (4) ways to work with XML files to select the best fit for your coding requirements.

Good Luck & Happy Coding!

Programmer Humor – Blockchain

The post Parsing XML Files in Python – 4 Simple Ways appeared first on Be on the Right Side of Change.