However, the term “not and” operator might be a bit misleading, as there isn’t a direct “not and” operator in Python.

Instead, Python provides individual operators for not, and and. But if we delve into the realm of bitwise operations, we find operators that might resemble this behavior: the bitwise NOT (~) and the bitwise AND (&).

Let’s explore the dunder methods associated with these operators.

Bitwise NOT (~) and its Dunder Method __invert__

The bitwise NOT operator flips the bits of a number. For a custom class, if you want to define or override the behavior of the ~ operator, you’d use the __invert__ method.

class BitwiseNumber:
    def __init__(self, value):
        self.value = value

    def __invert__(self):
        return BitwiseNumber(~self.value)

    def __repr__(self):
        return str(self.value)

number = BitwiseNumber(5)
print(~number)  # Outputs: -6

In the above example, the __invert__ method returns a new BitwiseNumber object with its value inverted.

Bitwise AND (&) and its Dunder Method __and__

The bitwise AND operator performs a bitwise AND operation between two numbers. For custom classes, the behavior of the & operator can be defined or overridden using the __and__ method.

class BitwiseNumber:
    def __init__(self, value):
        self.value = value

    def __and__(self, other):
        if isinstance(other, BitwiseNumber):
            return BitwiseNumber(self.value & other.value)
        return NotImplemented

    def __repr__(self):
        return str(self.value)

number1 = BitwiseNumber(5)  # Binary: 101
number2 = BitwiseNumber(3)  # Binary: 011
print(number1 & number2)    # Outputs: 1 (Binary: 001)

In this example, the __and__ method checks if the other object is an instance of BitwiseNumber and then performs a bitwise AND operation.

TLDR

While there isn’t a direct “not and” operator in Python, leveraging the __invert__ and __and__ methods, you can define how the bitwise NOT and AND operations work for custom objects, respectively.

The post What is the Python Dunder Method for the “not and” Operator? appeared first on Be on the Right Side of Change.

Boolean operators in Python help you create conditional statements to control the flow of your program. Python provides three basic Boolean operators: and, or, and not. These operators help you construct sophisticated expressions to evaluate the truth or falsity of different conditions.

And Operator

The and operator returns True if both of its operands are true, and False otherwise. You can use it to check multiple conditions at once.

Here is a simple example involving the and operator:

age = 25
income = 50000

if age >= 18 and income >= 30000:
    print("Eligible for loan")
else:
    print("Not eligible for loan")

In this example, the condition age >= 18 and income >= 30000 must be True for the program to print "Eligible for loan". If either age is less than 18 or income is less than 30,000, the condition evaluates to False, and the program will print "Not eligible for loan".

Or Operator

The or operator returns True as long as at least one of its operands is true. You can use it to specify alternatives in your code.

Here’s an example of how to use the or operator:

student_score = 80
extra_credit = 5

if student_score >= 90 or extra_credit >= 10:
    print("Student grade: A")
else:
    print("Student grade: B")

In this case, if the student_score is 90 or higher, or if the student has completed 10 or more extra credit, the program will print “Student grade: A”. Otherwise, it will print "Student grade: B".

Not Operator

The not operator inverts the truth value of the expression that follows it. It takes only one operand and returns True if the operand is False, and vice versa. The not operator can be used to check if a certain condition is not met.

Here is an example:

message = "Hello, World!"

if not message.startswith("Hi"):
    print("Message does not start with 'Hi'")
else:
    print("Message starts with 'Hi'")

In this example, the program checks whether the message does not start with the string "Hi". If it doesn’t, the condition not message.startswith("Hi") evaluates to True, and the program prints "Message does not start with 'Hi'". If the condition is False, the program prints "Message starts with 'Hi'".

Boolean Values in Python

In Python, Boolean values represent one of two states: True or False. These values are essential for making decisions and controlling the flow of your program. This section covers the basics of Boolean values, the None value, and how to convert different data types into Boolean values.

True and False Values

Boolean values in Python can be represented using the keywords True and False. They are instances of the bool class and can be used with various types of operators such as logical, comparison, and equality operators.

Here’s an example using Boolean values with the logical and operator:

x = True
y = False
result = x and y
print(result)  # Output: False

None Value

In addition to True and False, Python provides a special value called None. None is used to represent the absence of a value or a null value. While it’s not a Boolean value, it is considered falsy when used in a Boolean context:

if None:
    print("This won't be printed.")

Converting to Boolean Type

In Python, various data types such as numbers, strings, sets, lists, and tuples can also be converted to Boolean values using the bool() function. When converted, these data types will yield a Truthy or Falsy value:

• Numbers: Any non-zero number will be True, whereas 0 will be False.
• Strings: Non-empty strings will be True, and an empty string '' will be False.
• Sets, Lists, and Tuples: Non-empty collections will be True, and empty collections will be False.

Here are a few examples of converting different data types into Boolean values:

# Converting numbers
print(bool(10))  # Output: True
print(bool(0))   # Output: False

# Converting strings
print(bool("Hello"))  # Output: True
print(bool(""))       # Output: False

# Converting lists
print(bool([1, 2, 3]))  # Output: True
print(bool([]))         # Output: False

Recommended: How to Check If a Python List is Empty?

Working with Boolean Expressions

In Python, Boolean operators (and, or, not) allow you to create and manipulate Boolean expressions to control the flow of your code. This section will cover creating Boolean expressions and using them in if statements.

Creating Boolean Expressions

A Boolean expression is a statement that yields a truth value, either True or False. You can create Boolean expressions by combining conditions using the and, or, and not operators, along with comparison operators such as ==, !=, >, <, >=, and <=.

Here are some examples:

a = 10
b = 20

# Expression with "and" operator
expr1 = a > 5 and b > 30

# Expression with "or" operator
expr2 = a > 5 or b > 15

# Expression with "not" operator
expr3 = not (a == b)

In the above code snippet, expr1 evaluates to True, expr2 evaluates to True, and expr3 evaluates to True. You can also create complex expressions by combining multiple operators:

expr4 = (a > 5 and b < 30) or not (a == b)

This expression yields True, since both (a > 5 and b < 30) and not (a == b) evaluate to True.

Using Boolean Expressions in If Statements

Boolean expressions are commonly used in if statements to control the execution path of your code. You can use a single expression or combine multiple expressions to check various conditions before executing a particular block of code.

Here’s an example:

x = 10
y = 20

if x > 5 and y > 30:
    print("Both conditions are met.")
elif x > 5 or y > 15:
    print("At least one condition is met.")
else:
    print("Neither condition is met.")

In this example, the if statement checks if both conditions are met (x > 5 and y < 30); if true, it prints "Both conditions are met". If that expression is false, it checks the elif statement (x > 5 or y > 15); if true, it prints "At least one condition is met." If both expressions are false, it prints "Neither condition is met."

Logical Operators and Precedence

In Python, there are three main logical operators: and, or, and not. These operators are used to perform logical operations, such as comparing values and testing conditions in your code.

Operator Precedence

Operator precedence determines the order in which these logical operators are evaluated in a complex expression. Python follows a specific order for logical operators:

1. not
2. and
3. or

Here is an example to illustrate precedence:

result = True and False or True

In this case, and has a higher precedence than or, so it is evaluated first. The result would be:

result = (True and False) or True

After the and operation, it becomes:

result = False or True

Finally, the result will be True after evaluating the or operation.

Applying Parentheses

You can use parentheses to change the order of evaluation or make your expressions more readable. When using parentheses, operations enclosed within them are evaluated first, regardless of precedence rules.

Let’s modify our previous example:

result = True and (False or True)

Now the or operation is performed first, resulting in:

result = True and True

And the final result is True.

Truthy and Falsy Values

Tip: In Python, values can be considered either “truthy” or “falsy” when they are used in a boolean context, such as in an if statement or a while loop. Truthy values evaluate to True, while falsy values evaluate to False. Various data types, like numerics, strings, lists, tuples, dictionaries, sets, and other sequences, can have truthy or falsy values.

Determining Truthy and Falsy Values

When determining the truth value of an object in Python, the following rules apply:

• Numeric types (int, float, complex): Zero values are falsy, while non-zero values are truthy.
• Strings: Empty strings are falsy, whereas non-empty strings are truthy.
• Lists, tuples, dictionaries, sets, and other sequences: Empty sequences are falsy, while non-empty sequences are truthy.

Here are some examples:

if 42: # truthy (non-zero integer)
    pass

if "hello": # truthy (non-empty string)
    pass

if [1, 2, 3]: # truthy (non-empty list)
    pass

if (None,): # truthy (non-empty tuple)
    pass

if {}: # falsy (empty dictionary)
    pass

Using __bool__() and __len__()

Python classes can control their truth value by implementing the __bool__() or __len__() methods.

Expert Knowledge: If a class defines the __bool__() method, it should return a boolean value representing the object’s truth value. If the class does not define __bool__(), Python uses the __len__() method to determine the truth value: if the length of an object is nonzero, the object is truthy; otherwise, it is falsy.

Here’s an example of a custom class implementing both __bool__() and __len__():

class CustomClass:
    def __init__(self, data):
        self.data = data

    def __bool__(self):
        return bool(self.data) # custom truth value based on data

    def __len__(self):
        return len(self.data) # custom length based on data

custom_obj = CustomClass([1, 2, 3])

if custom_obj: # truthy because custom_obj.data is a non-empty list
    pass

Comparisons and Boolean Expressions

In Python, boolean expressions are formed using comparison operators such as greater than, less than, and equality. Understanding these operators can help you write more efficient and logical code. In this section, we will dive into the different comparison operators and how they work with various expressions in Python.

Combining Comparisons

Some common comparison operators in Python include:

• >: Greater than
• <: Less than
• >=: Greater than or equal to
• <=: Less than or equal to
• ==: Equality
• !=: Inequality

To combine multiple comparisons, you can use logical operators like and, or, and not. These operators can be used to create more complex conditions with multiple operands.

Here’s an example:

x = 5
y = 10
z = 15

if x > y and y < z:
    print("All conditions are true")

In this example, the and operator checks if both conditions are True. If so, it prints the message. We can also use the or operator, which checks if any one of the conditions is True:

if x > y or y < z:
    print("At least one condition is true")

Short-Circuit Evaluation

Python uses short-circuit evaluation for boolean expressions, meaning that it will stop evaluating further expressions as soon as it finds one that determines the final result. This can help improve the efficiency of your code.

For instance, when using the and operator, if the first operand is False, Python will not evaluate the second operand, because it knows the entire condition will be False:

if False and expensive_function():
    # This won't execute because the first operand is False
    pass

Similarly, when using the or operator, if the first operand is True, Python will not evaluate the second operand because it knows the entire condition will be True:

if True or expensive_function():
    # This will execute because the first operand is True
    pass

Common Applications of Boolean Operations

In Python, Boolean operations are an essential part of programming, with and, or, not being the most common operators. They play a crucial role in decision-making processes like determining the execution paths that your program will follow. In this section, we will explore two major applications of Boolean operations – Conditional Statements and While Loops.

Conditional Statements

Conditional statements in Python, like if, elif, and else, are often used along with Boolean operators to compare values and determine which block of code will be executed. For example:

x = 5
y = 10

if x > 0 and y > 0:
    print("Both x and y are positive")
elif x < 0 or y < 0:
    print("Either x or y is negative (or both)")
else:
    print("Both x and y are zero or one is positive and the other is negative")

Here, the and operator checks if both x and y are positive, while the or operator checks if either x or y is negative. These operations allow your code to make complex decisions based on multiple conditions.

While Loops

While loops in Python are often paired with Boolean operations to carry out a specific task until a condition is met. The loop continues as long as the test condition remains True. For example:

count = 0

while count < 10:
    if count % 2 == 0:
        print(f"{count} is an even number")
    else:
        print(f"{count} is an odd number")
    count += 1

In this case, the while loop iterates through the numbers 0 to 9, using the not operator to check if the number is even or odd. The loop stops when the variable count reaches 10.

Frequently Asked Questions

How do you use ‘and’, ‘or’, ‘not’ in Python boolean expressions?

In Python, and, or, and not are used to combine or modify boolean expressions.

• and: Returns True if both operands are True, otherwise returns False.
• or: Returns True if at least one of the operands is True, otherwise returns False.
• not: Negates the boolean value.

Example:

a = True
b = False

print(a and b) # False
print(a or b)  # True
print(not a)   # False

How are boolean values assigned in Python?

In Python, boolean values can be assigned using the keywords True and False. They are both instances of the bool type. For example:

is_true = True
is_false = False

What are the differences between ‘and’, ‘or’, and ‘and-not’ operators in Python?

and and or are both binary operators that work with two boolean expressions, while and-not is not a single operator but a combination of and and not. Examples:

a = True
b = False

print(a and b)     # False
print(a or b)      # True
print(a and not b) # True (since 'not b' is True)

How do I use the ‘not equal’ relational operator in Python?

In Python, the not equal relational operator is represented by the symbol !=. It returns True if the two operands are different and False if they are equal. Example:

x = 5
y = 7

print(x != y) # True

What are the common mistakes with Python’s boolean and operator usage?

Common mistakes include misunderstanding operator precedence and mixing and, or, and not without proper grouping using parentheses.

Example:

a = True
b = False
c = True

print(a and b or c)    # True (because 'and' is evaluated before 'or')
print(a and (b or c))  # False (using parentheses to change precedence)

How is the ‘//’ floor division operator related to boolean operators in Python?

The // floor division operator is not directly related to boolean operators. It’s an arithmetic operator that performs division and rounds the result down to the nearest integer. However, you can use it in boolean expressions as part of a condition, like any other operator.

Example:

x = 9
y = 4

is_divisible = x // y == 2
print(is_divisible) # True

The post Boolean Operators in Python (and, or, not): Mastering Logical Expressions appeared first on Be on the Right Side of Change.

Answer

The Python “==” operator compares equality of values whereas the Python “is” operator compares identity of objects, i.e., do the two operands point to the same object in memory.

For example, the expression [1, 2, 3] == [1, 2, 3] returns True because both lists contain the same elements, they are equal. But the expression [1, 2, 3] is [1, 2, 3] returns False because they are two different lists that point to different objects in memory, they are not identical.

>>> [1, 2, 3] == [1, 2, 3]
True
>>> [1, 2, 3] is [1, 2, 3]
False

However, the expression 123 == 123 returns True because both integers are the same. And the expression 123 is 123 will also return True because the values point to the same object in memory!

>>> 123 == 123
True
>>> 123 is 123
True

Feel free to dive into both tutorials to learn about the is and == operators. But we’ll give a short intro at the end of this article too!

Recommended Tutorials:

• Python is Operator
• Python == Operator

Before you learn about the important concept of mutable and immutable objects in Python, as well as about both of those operators, feel free to check out our memory visualizer tool first:

Try It Yourself Example – Memory Visualization “is” vs “==”

You can try our interactive memory visualization by clicking “Next” to see how identity and equality are two different concepts:

Here’s the code for copy&paste:

lst_1 = [1, 2, 3]
lst_2 = [1, 2, 3]

print(lst_1 == lst_2)
# True

print(lst_1 is lst_2)
# False

If you change one list, the other won’t be affected by the change. After changing the initially equal but non-identical list, they become non-equal and non-identical:

# Change one list:
lst_1.append(4)

print(lst_1)
# [1, 2, 3, 4]

print(lst_2)
# [1, 2, 3]

print(lst_1 == lst_2)
# False

Similarly, you can check out equality and identity for integers where it works differently:

Here’s the code for copy&paste:

val_1 = 123
val_2 = 123

# Equality:
print(val_1 == val_2)
# True

# Identity:
print(val_1 is val_2)
# True

Let’s quickly recap the is and == operators, you can watch our two video tutorials on both operators to keep improving your understanding of Python basics!

Python “is” Operator

The Python is keyword tests if the left and right operands refer to the same object—in which case it returns True.

It returns False if they are not the same object, even if the two objects are equal.

For example, the expression [1, 2, 3] is [1, 2, 3] returns False because although both lists are equal, they are two independent objects in memory.

Recommended Tutorial: Python is Operator — Checking Identity

Python “==” Operator

The Python equal to (left==right) operator returns True when its left operand is equal to its right operand. Otherwise, it returns False.

For example, 3==3 evaluates to True, but 3==2 evaluates to False.

Recommended Tutorial: Python Equal To Operator — Checking Equality

A Word on Mutability

Why are some variables compared using equality and others using identity?

The reason why two equal lists are considered equal but not necessarily identical and two equal numbers are considered equal but necessarily identical is that lists are mutable (they can be changed) and integers are immutable (they cannot be changed).

As you can change a list object, Python must create two list objects even if they contain the same elements. Why? Because you may change one list in your code and the change should not affect the other list.

Well — you cannot change objects such as integers or strings.

So, Python may decide to optimize for memory and let both variables point to the same object in memory. No variable pointing to that immutable object can ever change the object. Thus, there is no risk of aliasing where one variable is changed and the change is visible at the other variable too.

You can learn more about mutable vs immutable objects in the following video:

Recommended Finxter Tutorials:

• Python Mutable vs Immutable Objects (1/2)
• Python Mutable vs Immutable Objects (2/2)

When to Use Which “==” vs “is”?

Use the equality operator == when comparing whether a certain variable has obtained a certain value. In fact, you’ll use the == operator in the vast majority of cases in if conditions, while loops, or ternary operators. Each time you must know if a variable has obtained a certain value programmatically or by means of user input, you’ll use the == operator.

Use the identity operator is when comparing whether two variables refer to the same object. This is usually only done in debugging when you want to uncover some aliasing problems etc., i.e., whether the change of one variable unexpectedly results in a change of another variable. Outside of debugging, you’ll seldomly use the identity operator.

The most frequent use of the identity operator would be comparing a value to None, i.e., you would write

if x is None:
    print('hello')

and not

if x == None:
    print('hello')

The reason is that there is only one instance of the None type, the None object itself. All variables set to None would point to the same None object in memory. There cannot be two variables that point to different None objects.

Thanks for Reading this Tutorial

If you want to keep learning, feel free to download my cheat sheets—they are 100% free and super helpful, promised!

The post “is” vs “==” Python Identity and Equality appeared first on Be on the Right Side of Change.

You have been given a number. How will you check if the number lies between two numbers?

When you check if a number lies between two other numbers it returns a boolean that determines if the number is greater than or equal to the minimum number and also less than or equal to the maximum number. Here’s an example that demonstrates the problem:

That explains the given problem. We will have a look at few other conditions and examples. But before we discuss complex scenarios, let us dive into the solutions to the given question.

Method 1: Use Comparison Operators

Python comparison operators can compare numerical values such as integers and floats in Python. The operators are: equal to ( == ), not equal to ( != ), greater than ( > ), less than ( < ), less than or equal to ( <= ), and greater than or equal to ( >= ).

Thus, you can use the <= and the >= operators to check if a number lies between the upper limit (maximum number) and lower limit(minimum number).

Code:

print(15 <= 25 < 35)  # True
print(1 <= 0.5 < 5)  # False
print(10 <= 10 < 20)  # True

Method 2: Using “and” Keyword with Comparison Operators

The second way of checking whether a value lies between two other values is quite similar to the one used above. The only difference, in this case, is to use the and keyword in between the two comparison operators as shown in the solution below.

print(15 <= 25 and 25 <= 35)  # True
print(1 <= 0.5 and 0.5 <= 5)  # False
print(10 <= 10 and 10 <= 20)  # True

Some of you might be thinking why use an extra keyword when the solution given before is more readable than this one! Well! That’s true. The first syntax is more readable but this solution runs faster. Let’s compare the two solutions using timeit.

~$ python3 -m timeit "10 <= 20 and 20 <= 30"
10000000 loops, best of 3: 0.0366 usec per loop

~$ python3 -m timeit "10 <= 20 <= 30"
10000000 loops, best of 3: 0.0396 usec per loop

Method 3: Using “in” Keyword with range() Function

You can use the range() function to determine the upper and lower limits/numbers by feeding in the start and stop values within it. Now, to check if the number lies between the two numbers you can simply use the in keyword to check it. So, if the number lies in the specified range then the output will be “True” else “False“.

Code:

print(25 in range(15, 36))  # True
print(0.5 in range(0, 2))  # False
print(10 in range(10, 20))  # True

Note that the stop value within the range() function should always be one greater than the given maximum number/upper limit since the range of values taken into account by the range function always lies between start to stop-1. Read more about the range() function here: Python range() Function — A Helpful Illustrated Guide

TIDBIT:

Python’s “in” operator is a reserved keyword to test membership of the left operand in the collection defined as the right operand. For example, the expression x in my_list checks if object x exists in the my_list collection, so that at least one element y exists in my_list for that x == y holds. You can check membership using the “in” operator in collections such as lists, sets, strings, and tuples.

Exercises

Before we wrap up our discussion, let’s discuss some other variations of the given problem to further stregthen our grip on the concept.

Challenge 1: How will you check if an alphabet lies between two other alphabets or not based on the alphabetical order of English language?

Example: When you check if the alphabet “Y” lies between “X” and “Z” or not, the output should be “True”.

Solution:

Python comparison operators can also compare strings in Python. The comparison ordering is given by the ord() function that returns the Unicode integer for a given character c. The operators that can be used are: equal to ( == ), not equal to ( != ), greater than ( > ), less than ( < ), less than or equal to ( <= ), and greater than or equal to ( >= ).

We will be using the < and > operators to solve the programming challenge.

print("X" < "Y" < "Z")  # True
# In case you want to ignore the case (make the letters case-insensitive)
print("x".upper() < "Y".upper() < "z".upper()) # True

Challenge 2: Consider a real-time scenario where you have to allocate a specific grade to a student based on the marks obtained by him/her. Here’s the grade allocation table that determines the range of marks that correspond to a certain grade:

How will you use the above grading system and allocate the appropriate grade to a student based on the marks received? Let’s have a quick look at three examples that explain the desired goal of the given problem. 

Question: Can you formulate a one-liner code snippet that solves the programming challenge?

Solution:

marks = 95
# One-liner
grade = 'Grade: A+' if marks > 90 else 'Grade: A' if marks > 80 else 'Grade: B' if marks > 70 else 'Grade: C' if marks > 60 else 'Grade = D' if marks > 39 else 'Fail'
# Result
print(grade)
# Grade: A+

This solution is a classic example of using a nested ternary operator. Let’s examine the one-liner to understand how it works.

If the value of marks is greater than 90, we print ‘Grade: A+’ on the shell. Otherwise, the remainder of the code gets executed, which represents a ternary operator by itself. The next condition gets evaluated and if the value of marks is greater than 80, we print ‘Grade: A’ on the shell. This is how each condition gets evaluated until a certain condition is True. Thus, if the value of marks is less than 80, then the next condition gets evaluated. Hence, if the value of marks is greater than 70, we print ‘Grade: B’ on the shell. Otherwise, the next condition is executed. If the value is greater than 60, we print ‘Grade: C’ on the shell. Otherwise, we move on to the next condition and if the value of marks is greater than 39, we print ‘Grade: D’ on the shell. Otherwise, the final else block is evaluated and we print ‘Grade: D’ on the shell.

Challenge 3: Examine the snippet given below and guess the output:

num1 = float('Inf')
num2 = float('-Inf')
print(num1 <= float('Inf') <= num2)

Answer: You cannot compare two Positive Infinite values with each other. Similarly, you cannot compare two Negative Infinite values with each other. Hence, the output will be False.

Read More: Python Infinity

Conclusion

I hope this article answers all your queries. Please subscribe and stay tuned for more interesting discussions. Meanwhile, you may want to have a look at this comprehensive guide to comparison operators in Python: Python Comparison Operators [Blog + Videos].

Happy coding!

The post Check If a Number is Between Two Numbers in Python appeared first on Be on the Right Side of Change.

In this article, you’ll learn how to repeat a string multiple times in Python.

Over your career as a Python coder, you will encounter situations when a string needs to be output/displayed a specified number of times. The examples below offer you various ways to accomplish this task.

Question: How would we write Python code that repeats a string multiple times?

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

• Method 1: Use print() and an arithmetic operator
• Method 2: Use a For Loop and range()
• Method 3: Use the input() function
• Method 4: Use itertools.repeat()
• Method 5: Use a Pandas DataFrame

Method 1: Use print() and multiplication operator

This method uses Python’s built-in print() statement combined with a multiplication operator to output a string multiple times.

saying = 'Wash. Rinse. Repeat!\t'
print(saying * 3)

Above declares the string ‘Wash. Rinse. Repeat!‘ followed by a tab character, also known as an escape character (\t). The results save to saying.

Next, the print() statement outputs the saying three (3) times, with the escape character (\t) between each saying on the same line.

Method 2: Use a For Loop and range()

This method uses a for loop with the range() function to iterate and output a string a set number of times.

for i in range(3):
    print('I never want to grow up!')

Above instantiates a For loop with the range() function. This function accepts a start position (not required), a stop position (required) and a step (not required). The start position is always zero (0) unless otherwise stated. The stop position is always stop-1.

The print() statement outputs a line to the terminal, with each iteration as shown below.

Method 3: Use the input() function

This method prompts the user to enter a specified number of times to repeat a string using the int() and input() functions.

num = int(input('Number of times to repeat a string? '))
print('Hello World!\n' * num)

Above, prompts the user to enter how many times a string will display. Their answer is converted to an integer (int()) and saved to num.

Next, the string ‘Hello World‘ is output to the terminal. The newline character is appended (\n) so the output displays on a new line each time.

For this example, the number three (3) was entered.

Note: The newline character (\n) caused the last line (line 3) to have an additional blank line.

Method 4: Use itertools.repeat()

This method uses Python’s built-in library itertools to call the repeat() function, which repeats a number or a string a stated number of times.

import itertools   
print(list(itertools.repeat('HELP ME', 3)))

Above, imports the itertools library.

Then, the repeat() function is called and passed two (2) arguments: the string to repeat and the number of times to repeat. This is then converted to a list and output to the terminal.

Method 5: Use a DataFrame

This method uses a DataFrame and an empty column to assign a default value.

The Pandas library must be installed and imported to run this code error-free. Click here for installation instructions.

To follow along, click here to download the finxters.csv file and move this file to the current working directory.

import pandas as pd 
df = pd.read_csv('finxters.csv', usecols=['FID', 'First_Name', 'Last_Name'])
df['Award'] = 'TBD'
df.to_csv('finxter1.csv')
print(df.head(3))

Above, imports the Pandas library to read in the CSV file and work with a DataFrame.

Then, only a few columns of finters.csv are read into the DataFrame df.

Next, the DataFrame df is saved to a new CSV file, finxters1.csv and placed in the current working directory.

Finally, the output is sent to the terminal. For this example, only three (3) rows are displayed.

Summary

These five (5) methods of printing a string multiple times should give you enough information to select the best one for your coding requirements.

Good Luck & Happy Coding!

Regex Humor

The post How to Repeat a String Multiple Times in Python appeared first on Be on the Right Side of Change.

Overview

Problem: What is the equivalent of &&(logical-and) in Python?

Example: Let’s have a look at the following example:

num_1 = [11, 21, 31, 41, 51]
num_2 = [15, 16, 17, 18, 19, 20, 21]
if len(num_1) % 2 == 0 && len(num_2) % 2 == 0:
    print("The lists has even number of elements")
elif len(num_1) % 2 != 0 && len(num_2) % 2 != 0:
    print("odd numbers")
else:
    print("mix of odd and even numbers")

Output: You will get the following error inside the “if” statement.

    if len(num_1) % 2 == 0 && len(num_2) % 2 == 0:
                            ^
SyntaxError: invalid syntax

Well! This can be really frustrating. You have got the logic right, yet there’s an error. Why? The answer is not as difficult as you might have thought.

We encountered the syntax error because of the usage of && operator in our code. Python does not have the provision for the && operator. Hence, when Python comes across “&&” in the program, it is unable to identify the operator and deems it as invalid. Therefore, we see the Syntax Error. 

Instant Fix: Replace the && operator with and, which will solve the issue.

Logical Operators in Python

What are Operators in Python? Operators are the special symbols that are used to perform operations on the variables and values. They carry out arithmetic and logical computations.

The logical operators in Python are used on conditional statements, i.e, either True or False. The three logical operations are:

• (i) Logical AND
• (ii) Logical OR
• (iii) Logical NOT.

Logical AND

The Logical AND operator is used to return True if both operands are True. However, if any one of the two operands is False, then it returns False. 

Let’s look at an example to understand this:

# functioning of Logical and operator
val_1 = -5
val_2 = 10  
if val_1 > 0 and val_2 > 0:
    print("The numbers are positive numbers")
elif val_1 < 0 and val_2 < 0:
    print("The numbers are negative numbers")
else:
    print("One of the given numbers is positive while the other number is negative!")

Output:

One of the given numbers is positive while the other number is negative!

Now let’s get back to our first example. When we replace the && with and the error gets solved.

Solution:

val_1 = [11, 21, 31, 41, 51]
val_2 = [15, 16, 17, 18, 19, 20, 21]
# Using logical and
if len(val_1) % 2 == 0 and len(val_2) % 2 == 0:
    print("List has Even number of elements.")
elif len(val_1) % 2 != 0 and len(val_2) % 2 != 0:
    print("List has odd number of elements.")
else:
    print("List 1 has Odd number of elements while list 2 has even number of elements!")

Output:

List has odd number of elements.

Hence, “and” is Python’s equivalent of && (logical-and) in an if-statement. In the same way, we cannot use the || operator in Python as it is not valid. We have to use its equivalent logical or which is denoted by “or” in Python.

Logical OR

The Logical OR operator is used to return True if either of the operands is True. It returns false only if both of the operands are False. 

Let’s look at one example to understand this:

# functioning of Logical or operator
num_1 = -5
num_2 = -10  
num_3 = 8
print("For the first two numbers:")
if num_1 > 0 or num_2 > 0:
    print("Either of the numbers is positive")
else:
    print("Numbers are negative numbers")
print("For the last two numbers")
if num_2 > 0 or num_3 > 0:
    print("Either of the numbers is positive")
else:
    print("Numbers are negative numbers")

Output:

For the first two numbers:
Numbers are negative numbers
For the last two numbers
Either of the numbers is positive

The Python Advantage of Logical Operators

Python is a way more user-friendly language. While you have to use symbols like “&&” and “||” in some other languages like C++ and Java, Python makes life easy for you by providing direct words like “and” , “or“, etc which make more sense and resemble normal English.

Further, logical operators (in most languages) have the advantage of being short-circuited. This means that it first evaluates the first operand, and if only the first operand defines the result, then the second operand is not evaluated at all.

Look at the following example:

def check(v):
    print(v)
    return v
temp = check(False) and check(True)

# False

In the above example, only one print statement is executed, i.e., Python evaluated only the first operand. As we know the AND operator returns False, if one of the operands is False. The first operand, in this case, was False hence Python did not evaluate the second operand.  

However, let’s look at a different situation-

def check(v):
    print(v)
    return v


print("Output for first call: ")
temp = check(True) and check(True)
print("Output for the second call:")
temp = check(True) and check(False)

Output:

Output for first call: 
True
True
Output for the second call:
True
False

In the above example, as the first operand is True we cannot determine the result for the “and” operation. Hence, Python needs to evaluate the second operand as well. 

It works similarly for the OR operand where Python first checks the first operand. As we know, the OR logical operator returns False only if both of the operands are False. So, if the first operand is False only then it evaluates the second operand. However, if the first operand is True, it concludes that the output is True without even checking the second operand.

Bonus: Pseudocode for AND and OR function is as follows:

def and(oper1, oper2):
    left = evaluate(oper1)
    if bool(left):
        return evaluate(oper2)
    else:
        return left
def or(oper1, oper2):
    left = evaluate(oper1)
    if bool(left):
        return left
    else:
        return evaluate(oper2)

Related Video

Related Questions

Here are some questions and their quick solution, which are frequently asked along with the problem discussed in this article –

How to use “and” operator to check equality between strings?

Solution:

word = "MADAM"
if word and word[::-1]:
    print("PALINDROME!")

# PALINDROME

What is the replacement for the switch statement in Python?

Solution:

def switch(x):
    return {
        "1": 'One',
        "2": 'Two'
    }.get(x, "wrong entry!")


n = input("Enter your Choice: ")
print(switch(n))

Output:

Enter your Choice: 1
One

Conclusion

In this article, we learned about the logical operators and Python’s equivalent of && (logical-and) and || (logical-or) in an if-statement. I hope this article has helped you. Please stay tuned and subscribe for more such articles.

Recommended Read: Python And Operator

The post Python’s && Equivalent: Logical And appeared first on Be on the Right Side of Change.

Syntax

class.__init_subclass__(cls)

We call this a “Dunder Method” for “Double Underscore Method” (also called “magic method”). To get a list of all dunder methods with explanation, check out our dunder cheat sheet article on this blog.

Minimal Example

The following example shows how as soon as you create a subclass Child that inherits from a Parent class, the method __init_subclass__() is called.

class Parent:
    def __init_subclass__(cls):
        print('Subclass of Parent Created!')

class Child(Parent):
    pass

Output:

Subclass of Parent Created!

Note: The method is called on the definition of the class and not on the creation of an instance of the class. For example, even if you created 1000 instances of Child, the method __init_subclass__() would be called only once on Parent.

Class Hierarchy with __init_subclass__()

What happens if a child of a child class is created—does it trigger another execution of __init_subclass__()?

The answer is yes!

class Parent:
    def __init_subclass__(cls):
        print('Subclass of Parent Created!')

class Child(Parent):
    pass

class Grandchild(Child):
    pass

Output:

Subclass of Parent Created!
Subclass of Parent Created!

Precedence of Defining __init_subclass__() on Multiple Inheritance Levels

If both a class and a subclass define the __init_subclass__() method and a subclass of the subclass is created. Which __init_subclass__() definition applies in this scenario?

The normal subclass hierarchy rules apply: The closest parent class wins! Python goes from children to parents searching for __init_subclass__(). The first occurrence of the method is called.

class Parent:
    def __init_subclass__(cls):
        print('AAA')

class Child(Parent):
    def __init_subclass__(cls):
        print('BBB')

class Grandchild(Child):
    pass

Output:

AAA  # --> Output of Child()
BBB  # --> Output of Grandchild()

Background Inheritance

Inheritance allows you to define a class that inherits all methods and properties from another class.

• Parent class, also denoted as base class, is the class you inherit from. In Python, every class can be a parent class.
• Child class, also denoted as derived class, inherits from the Parent class. In Python, you can create a child class that inherits all methods and attributes from the Parent using the class Child(Parent) syntax with the parent class enclosed in parentheses.

You can watch our related video on inheritance here:

Learn more in our detailed articles:

• Python Inheritance
• Five Types of Inheritance in Python

The post Python __init_subclass__() Magic Method appeared first on Be on the Right Side of Change.

class.__subclasscheck__(self, subclass)

Python’s class.__subclasscheck__(self, subclass) method implements the issubclass(subclass, class) built-in function. It should return True if subclass is a direct or indirect subclass of class using Python inheritance to define the subclass relationship.

We call this a “Dunder Method” for “Double Underscore Method” (also called “magic method”). To get a list of all dunder methods with explanation, check out our dunder cheat sheet article on this blog.

Example

In the following example, you create custom classes Person, Friend, Parent, and Child. Both Parent and Friend inherit from Person. Child inherits from Parent. Thus, per transitive inheritance, Child inherits from Parent as well. However, Child doesn’t inherit from Friend.

class Person:
    pass

class Friend(Person):
    pass

class Parent(Person):
    pass

class Child(Parent):
    pass


# Is Child a Parent? Yes!
print(issubclass(Child, Parent))
# True

# Is Child a Friend? No!
print(issubclass(Child, Friend))
# False

# Is Child a Person? Yes!
print(issubclass(Child, Person))
# True

The __subclasscheck__() dunder method is implemented implicitly and by default. That’s why you don’t need to define it explicitly. However, if you do so, you can manipulate the output of these function calls!

To override the __subclasscheck__ magic method, you need to define it on the metaclass as exemplified in PEP 3119.

This is how you’d override the __subclasscheck__ magic method for our example to now return False, no matter what:

class PersonMeta(type):
    def __subclasscheck__(self, subclass):
        return False
    
class Person(metaclass=PersonMeta):
    pass

class Friend(Person):
    pass

class Parent(Person):
    pass

class Child(Parent):
    pass


# Is Child a Person? Not anymore!
print(issubclass(Child, Person))
# False

Note that the same statement print(issubclass(Child, Person)) previously printed True to the standard output—but with the override, it now prints False.

Background issubclass()

Python’s built-in issubclass(X, Y) function takes a class X and a class Y and returns True if the X is an instance of Y and otherwise False. The argument Y can also be a tuple in which case it checks whether X is a subclass of any class in the tuple—such as in issubclass(X, (class_1, class_2, ...)).

Learn more in our detailed article:

• Python issubclass()

Background Inheritance

Inheritance allows you to define a class that inherits all methods and properties from another class.

• Parent class, also denoted as base class, is the class you inherit from. In Python, every class can be a parent class.
• Child class, also denoted as derived class, inherits from the Parent class. In Python, you can create a child class that inherits all methods and attributes from the Parent using the class Child(Parent) syntax with the parent class enclosed in parentheses.

You can watch our related video on inheritance here:

Learn more in our detailed articles:

• Python Inheritance
• Five Types of Inheritance in Python

The post Python __subclasscheck__() Magic Method appeared first on Be on the Right Side of Change.

object.__sizeof__(self, other)

The Python __sizeof__() method returns the size of the object in bytes. The sys.getsizeof() method internally call’s __sizeof__() and adds some additional byte overhead, e.g., for garbage collection.

Basic Example

The following code snippet creates a list object x with three integers and measures its size in bytes (104) using the x.__sizeof__() method call.

It then measures the size with overhead using sys.getsizeof(x).

>>> import sys
>>> x = [1, 2, 3]
>>> x.__sizeof__()
104
>>> sys.getsizeof(x)
120

Let’s make the list much larger to measure if it has any impact on the size in bytes.

>>> import sys
>>> x = list(range(10000))
>>> x.__sizeof__()
80040
>>> sys.getsizeof(x)
80056

This list is built using the range() function. It has 10000 integers, each needing 8 bytes with a constant overhead of 40 bytes for the list structure, the x.__sizeof__() method call results in 10000 * 8 + 40 = 80040 bytes.

You can see that in both cases, the sys.getsizeof(x) has 16 more bytes than x.__sizeof__() which seems to be the overhead on my particular machine for this particular example.

Overriding __sizeof__()

You can override the __sizeof__() method for your own custom data type by defining the __sizeof__() method with one argument self (that is passed automatically by Python).

import sys

class Data:
    def __sizeof__(self):
        return 42
    
    
x = Data()
print(x.__sizeof__())

The __sizeof__() method returns the integer 42 that was returned by us—not the number of bytes.

Let’s call the sys.getsizeof() method to see if the difference is 16 bytes for the GC overhead!

import sys

class Data:
    def __sizeof__(self):
        return 42
    
    
x = Data()

print(x.__sizeof__())
# 42

print(sys.getsizeof(x))
# 58

References:

• https://docs.python.org/3/reference/datamodel.html

Where to Go From Here?

Enough theory. Let’s get some practice!

Coders get paid six figures and more because they can solve problems more effectively using machine intelligence and automation.

To become more successful in coding, solve more real problems for real people. That’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?

You build high-value coding skills by working on practical coding projects!

Do you want to stop learning with toy projects and focus on practical code projects that earn you money and solve real problems for people?

If your answer is YES!, consider becoming a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.

If you just want to learn about the freelancing opportunity, feel free to watch my free webinar “How to Build Your High-Income Skill Python” and learn how I grew my coding business online and how you can, too—from the comfort of your own home.

Join the free webinar now!

The post Python __sizeof__() Method appeared first on Be on the Right Side of Change.

Syntax

__reversed__(self)

Let’s have a look at an example next.

Example

In the following code, you create a Person class with one name attribute. The __reversed__ dunder method uses slicing with negative step size to return the reversed string object when calling reversed(alice) on a Person object alice.

class Person:
    def __init__(self, name):
        self.name = name

    def __reversed__(self):
        return self.name[::-1]



alice = Person('alice')
print(reversed(alice))
# ecila

Note that the returned string object is an iterator, so this is a perfectly valid implementation of the __reversed__ magic method.

Background Video Reversing a List

Background Video Slicing

Where to Go From Here?

Enough theory. Let’s get some practice!

Coders get paid six figures and more because they can solve problems more effectively using machine intelligence and automation.

To become more successful in coding, solve more real problems for real people. That’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?

You build high-value coding skills by working on practical coding projects!

Do you want to stop learning with toy projects and focus on practical code projects that earn you money and solve real problems for people?

If your answer is YES!, consider becoming a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.

If you just want to learn about the freelancing opportunity, feel free to watch my free webinar “How to Build Your High-Income Skill Python” and learn how I grew my coding business online and how you can, too—from the comfort of your own home.

Join the free webinar now!

The post Python __reversed__ Magic Method appeared first on Be on the Right Side of Change.