Python 'as' Keyword

Python is well known for being flexible and readable, and it has many features that make coding easier and increase functionality. One such feature is the 'as' keyword, a useful tool for handling exceptions, aliasing, and importing. This article delves into the nuances of the 'as' keyword, examining its diverse applications and optimal methodologies.

Let's see some examples of using the 'as' keyword in Python.

Import Aliasing:

The 'as' keyword is potent for aliasing module and package names during import statements. In addition, developers can stop namespace conflicts and improve code readability by allocating an additional name using the 'as' operator. For example:

Example:

import pandas as pd
import numpy as np
radians = np.pi
sineVal = np.sin(radians)
cosineVal = np.cos(radians)
tanVal = np.tan(radians)
print("Sine of %f radians:%f"%(radians, sineValue));
print("Cosine of %f radians:%f"%(radians, cosineValue));
print("Tangent of %f radians:%f"%(radians, tanValue));

Output:

Sine of 3.141593 radians:0.000000
Cosine of 3.141593 radians:-1.000000
Tangent of 3.141593 radians:-0.000000

Code Explanation

In the above code, we have calculated sine, cosine, and tangent for an angle. As the first step, we import Pandas library for data manipulation and NumPy for numerical operations (). Then, it defines the angle as pi radians. Next, to calculate sine, cosine, and tangent of the angle and stores them in separate variables we used NumPy function. Lastly, it prints the calculated values along with the angle in a formatted string. While Pandas is included, it's not actually used in the calculations. We can say that, the above described code shows the basic trigonometric calculations with the help of NumPy library.

Renaming Attributes Feature:

After importing a module, you can use 'as' to give an additional name to an alias. This feature makes it easier to refer to the module in your code. On the other side of renaming, 'as' enables developers to modify imported functions. As an example, you can import specific functions from a module and rename them with the desired shorter names:

Code:

import numpy as np
from matplotlib import pyplot as plot

demoDimension = np.arange(0,350,20)
magnitudeDimension = np.sin(2*np.pi*demoDimension*1/350)
plot.plot(demoDimension,magnitudeDimension)

plot.title('Sinusoid')
plot.xlabel('Demo')
plot.ylabel('Dimension')
plot.show()

Output:

Explanation

The above-given code creates a sinusoidal graph. We first import all the compusory libraries such as, NumPy and Matplotlib.pyplot. Then, we have defined two arrays: demoDimension and magnitudeDimension. The DemoDimension is an array of values from 0 to 350 with a step size of 20. Next, the MagnitudeDimension is an array of sine values, which has been calculated using np.sin(2*np.pi*demoDimension*1/350) formula. The code uses matplotlib.pyplot to plot the graph, with demoDimension on the x-axis and magnitudeDimension on the y-axis. The graph is named "Sinusoid", similarly, the x-axis and y-axis are labeled with "Demo" and "Magnitude", respectively.

Exception Handling:

Python has some versatile, unique and comprehensive explanations to handle errors during program execution. Engineers or developers can use the 'as' keyword to name the raised exception differently, for example, numpy as np. This alternative name is a reference to the specific mistake. This method lets programmers get detailed information about the error occurring in code, such as the execution type, an error message, etc.

try:
    fileContents    = ""
    with open('demo.txt') as fileObject:
        fileContents = fileObject.read()
        print("Text file contents:")
        print(fileContents)   
except FileNotFoundError as demo:
    print(demo)

Output:

[Errno 2] No such file or directory: 'sample.txt'

Explanation

The above code executes to read the file's contents of a file named "demo.txt" and print them. However, the file is not found, so the code given: FileNotFoundError exception and prints the error message.

What is Context Manager?

In Python, context managers are the basic components to properly manage and maintain content objects. When the block is entered, the context manager's __enter__() method is invoked, getting the necessary stuff (e.g., opening the file and closing the database). The code in the block uses and executes the received objects. When the code terminates or after an exception occurs, the context manager's __exit__() method is called, releasing the received object (e.g., closing the file or opening the database).

Characteristics

Context managers ensure that resources will be released, restricting breaches and crucial errors, even when exceptions occur.
The method enables you to simplify managing the project by removing repetitive code for manual acquisition and release.
The __exit__() function enables you to manage exceptions, thus minimizing their impact and providing a more efficient approach to handling errors.

Example

with open('example.txt', 'r') as file:
    data = file.read()

print('Text File Contents', r)
print(data)

Output:

Text File Contents
here are some content

Explanation of the Above Code

In the above-given code, we have used with statement to open "example.txt" in reading mode using 'r'. Each and every content of the file is read into the data variable using file.read(). After that, there's a misplaced r in the first Print statement. This r is not an appropriate argument here and we need to remove this for the correct output. The second Print statement correctly prints the result without showing any error.

Customizing Class Names:

Going through with appropriate class names will be beneficial in the context of well-organized and understandable code. This practice can help to understand the project. Choosing names for classes that clearly describe the project's purpose is important. Descriptive names are preferred as they minimize confusion.

The customizing method helps in increasing readability for who are reviewing your code. You have the four common methods to customize the codes including PascalCase, camelCase, Kebab-case, and snake_case. It is important to find a middle ground between being clear and concise. We should ignore lengthy names, it is equally important to ensure that the name we you have chosen provide sufficient information.

Approach

The simple approach is when we discuss the proper naming of a function, the names must be accurately describing the function or role of the class in the system. For example, using a name instead of a generic name that states the purpose of the class.

The class is an operation, so using names that reflect these functions can be helpful. For example, if a class is responsible for transforming data, consider naming it DataTransferer. Similarly, if a class focuses primarily on sending notifications, the appropriate name could be DataSender.

Choosing appropriately descriptive names for your classes can make your code clearer and more understandable.

class Birds:
    def speak(self):
        raise NotImplementedError("Subclasses must apply this method")


class Peacock(Birds):
    def speak(self):
        return "Scream"

class Parrot(Birds):
    def speak(self):
        return "Talk"

class MyPeacock(Peacock):
    def unfurls(self):
        return "train rattling"

class MyParrot(Parrot):
    def talks(self):
        return "Talking Lovely"

my_peacock = MyPeacock()
my_parrot = MyParrot()

print("My peacock says:", my_peacock.speak())
print("My parrot says:", my_parrot.speak())
print("My peacock is", type(my_peacock).__name__)
print("My parrot is", type(my_parrot).__name__)

Output:

My peacock says: Scream
My parrot says: Talk
My peacock is MyPeacock
My parrot is MyParrot

Explanation

The above code defines a class hierarchy on the birds sound. The Birds class serves as a base or parent class defining a method speak() which raises a NotImplementedError, indicating that subclasses must implement this method. Two subclasses, Peacock and Parrot, override the speak() method with their respective behaviors, "Scream" and "Talk". Moreover, there are subclasses of Peacock and Parrot called MyPeacock and MyParrot respectively, each with their own unique methods unfurls() and talks(). After that, two instances of these subclasses are created, my_peacock and my_parrot, and their speak() methods are called, along with printing their types. This code describes inheritance and method overriding, that is showing how subclasses can extend the functionality of their parent classes.

Examples

Here are more examples related to Python applications for the 'as' keyword:

Function Aliasing

def calculate_area(length, width):
    return length * width
calculate = area
area = calculate(8, 9)
print(area)

Output:

Explanation

In the above code, we have created a function named find_surface. This function takes two inputs, height and width, and computes the result of these inputs, which denoting the surface area of a rectangular shape. Afterwards, the code executes surface as a function by supplying the arguments 8 and 9.

Module-Level Variable Aliasing

import math as m

radius = 5
perimeter = 2 * m.pi * radius
print("The perimeter of a circle including radius", radius, "is", perimeter)

Output:

The perimeter of a circle including radius 5 is 31.41592653589793

Explanation of the Above Code

In this example, we have created a variable named `radius` in the code above and assigned the value of `5` to it. This code calculates the circumference of a circle by using the formula `circumference = 2 * m.pi * radius`, where `m.pi` represents the constant pi.

Aliasing within List Comprehensions:

import numpy as np

squares = [np.square(num) for num in range(1, 6)]
print("Squares from 1 to 5:", squares)

Output:

Squares from 1 to 5: [1, 4, 9, 16, 25]

Explanation

The above-code is running the numeric code using the NumPy library. We have created a collection named squares, where it loops through numbers from 1 to 5 and figures out the square of each number using the np.square() function. It will then display the collection of squares from 1 to 5.

Using 'as' in Named Tuples:

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
pt = Point(3, 4)
x_coord, y_coord = pt

print("The x-coordinate is:", x_coord)
print("The y-coordinate is:", y_coord)

Output:

The x-coordinate is: 3
The y-coordinate is: 4

Explanation

In the above program, we have defined namedtuple called Point with fields 'x' and 'y', represents coordinates. Then creates an instance pt of the Point namedtuple along with values (3, 4) assigned to 'x' and 'y' respectively. Using sequence unpacking, it assigns the values of pt to variables x_coord and y_coord.

Customizing Enum Names:

from enum import Enum

class Color(Enum):
    Pink = 2
    Orange = 5
    Yellow = 4

clr_code = Color.Orange.value
print("The color code of Orange is:", clr_code)

Output:

The color code of Orange is: 5

Code Explanation

The above provided code used the Enum class from the enum module to define a custom enumeration called Color. It assigns integer values to each color in which Pink is assigned 2, Orange is assigned 5, and Yellow is assigned 4. Consequently, it accesses the value associated with the Orange enum member using Color.Orange.value and assigns it to the variable clr_code.

Alias in Pandas DataFrames:

import pandas as pd

value = {'Name': ['Vivek', 'Neeraj', 'Sachin'],
        'Age': [22, 23, 23]}
df = pd.DataFrame(value)
print(df)

Output:

     Name  Age
0   Vivek   22
1  Neeraj   23
2  Sachin   23

Explanation

The preceding instance starts the DataFrame with information saved in a collection labeled value, where labels symbolize column titles are \'Name\' and \'Age\' and elements are arrays having related information points. The \'Name\' column holds texts signifying titles, while the \'Age\' column holds whole numbers signifying years. The script then generates the DataFrame utilizing pd.DataFrame() with the information from the collection. Afterward, it will exhibit the DataFrame df, which reveals the information in a structured layout with rows and columns.

Renaming Imported Classes:

from sklearn.linear_model import LogisticRegression as lr

model = lr()

print("Model instantiated successfully!")

Output:

Model instantiated successfully!

Explanation

In the above-given code we have used the scikit-learn library, and imported the LogisticRegression class from the linear_model module and aliasing it as lr. After that, we create an instance of the LogisticRegression class named model using the lr() constructor. The Logistic Regression model algorithm is used for binary classification tasks. After instantiating the model, the code prints a message confirming the successful instantiation of the model instance.

Conclusion

Python programmers get to use the versatile keyword 'as' as an alias to name a module or function. When applied to imports, it acts as a form of renaming, which not only increases the readability of the code but also helps avoid potential naming conflicts. That day, aside from the materials used in "his" cases, ensure they are handled properly. It binds changes in variables effortlessly when used in different senses, simplifying complex terminology. This keyword is a valuable tool for any Python developer because it simplifies code, increases clarity, and simplifies features.

Next TopicRun function from the command line in python

← prev next →