shape in python assignment expert

NumPy shape in Python [3 Examples]

In this Python tutorial, I will discuss what the NumPy shape in Python is, and what is meant by shape 0 and shape 1. And, how shape is different from the reshape function in Python.

To find the shape of an array, we can use the NumPy shape in Python. The NumPy shape() function returns a Python tuple indicating the size of the array in each dimension. the np.shape[0], and np.shape[1] returns the size of the row and the size of the column respectively.

Table of Contents

NumPy shape in Python

In NumPy, the shape of an array is a Python tuple that indicates the size of the array in each dimension. It is a property that defines the structure of a Python array, that is, the number of rows, columns, and so forth, depending on the dimensionality of the array.

Syntax: The syntax for accessing the shape attribute in Python is as follows:

• array_name : input array, whose shapes we want to find.
• Returns: The values of the shape function always give the length of the adjacent np.array in Python.

Example: Let’s take an example to check how to implement NumPy shape in Python

Output: In the above example the array returns (2,6) which means that the array has 2 dimensions, and each dimension has 6 values.

Here is the Screenshot of the following given Python code:

This is the basic use of the NumPy shape in Python.

Python shape function in NumPy

• The NumPy module provides a shape function to represent the shape and size of an array in Python. The shape of an array is the no. of elements in each dimension.
• The shape attribute always returns a tuple, that represents the length of each dimension.

Syntax: Here is the Syntax of the Python numpy shape function

• arr: input array
• Returns: The values of the shape tuple give the lengths of the adjacent array dimensions.

Example: Let’s take an example to check how to implement the NumPy shape in Python.

Output: In the above code first, we import a NumPy library in Python and create a 1-D array, it is a tuple with one value instead of an integer value. A tuple with one element has a sequence comma.

NumPy shape 0 Python

• Shape[0] in np.shape is a tuple that always gives dimensions of the array in Python. The shape is a tuple that gives us an indication of the no. of dimensions in the array.
• The shape function for NumPy arrays returns the dimensions of the Python array.
• If Y has u rows and v columns, then Y.shape is (u,v). So Y.shape[0] is v.

Example: Let’s take an example to check how to implement numpy shape 0

Output: In the above example, we have to use the function np.shape to give:

Here is the Screenshot of the following given Python code

NumPy shape[1] Python

• In Python NumPy, some of the functions return in the format of shape(R,1) but some return as (R,) .
• This will make matrix multiplication more complex since an explicit reshape is required.
• Shape[1] in np.shape is a tuple that always gives dimensions of the array in Python. The shape function is a tuple that gives us an arrangement of the number of dimensions in the array.
• If Y has w rows and z columns, then Y.shape is (w,z). So Y.shape[1] is z.

Example: Let’s take an example to check how to implement Python NumPy shape 1

Output: In the above code, we will import a NumPy library in Python and create an array using the function numpy.array . Now we can easily use the function np.shape() and pass the value 1 as a parameter. The output will display the columns in an array.

Python numpy shape vs reshape

• np.reshape will copy the data if it cannot make a proper view, whereas getting the shape will raise an error instead of copying the data.
• The np.shape function will always give a tuple of array dimensions in Python and can easily be used to change the dimensions of an array.
• The reshape function gives a new shape to an array without changing its value. It creates a new array and does not update the original array itself.
• The shape function always returns a tuple that tells us the length of each dimension while in the case of the reshape function, returns a new value on the existing data if possible rather than creating a full copy of the original array in Python.

Output: In the above code, we will import a NumPy library and create an array using the function numpy. array. Now, we can use an np.reshape() function to display the new array in the form of a 2*2 matrix. Along with that, we will equate with the function and it will return the array of dimensions in the form shape.

Understanding the NumPy shape in Python , is a fundamental skill when working with data. It enables a clearer understanding of array dimensions, which is critical when performing array operations, reshaping arrays, and utilizing broadcasting.

Mastering NumPy shapes can lead to more efficient and readable code, especially when handling complex multi-dimensional data. By taking advantage of the numerous functions provided by NumPy to manipulate shapes, one can fully leverage the power and flexibility of this essential Python library.

You may like the following Python tutorials:

• Python NumPy to list
• Python dictionary filter
• Python NumPy Replace
• Python NumPy round

I am Bijay Kumar, a Microsoft MVP in SharePoint. Apart from SharePoint, I started working on Python, Machine learning, and artificial intelligence for the last 5 years. During this time I got expertise in various Python libraries also like Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… for various clients in the United States, Canada, the United Kingdom, Australia, New Zealand, etc. Check out my profile .

Adventures in Machine Learning

Mastering the shape function: understanding python’s data dimensions, understanding the shape function in python.

Have you ever come across the “shape function” in Python and wondered what it means? In programming, a shape function is used to determine the number of dimensions of an array or a dataset.

It is a valuable tool for analyzing data and making decisions based on the dimensions of the dataset. In this article, we will go through the definition and purpose of the shape function in Python, its usage in Pandas DataFrames, and NumPy arrays.

We will also provide examples and outputs to help you understand this concept better.

Definition and Purpose

The shape function is a Python function used to determine the dimensions of an array or a dataset. It returns a tuple with the number of rows and columns (for a 2-dimensional dataset) and the number of elements (for a 1-dimensional dataset).

The shape function is extremely useful when working with datasets, as it helps identify the number of dimensions, rows, and columns in the data. This information is essential when analyzing, visualizing, and manipulating the data.

Usage in Pandas DataFrames

In Pandas, a DataFrame is a two-dimensional labeled data structure with columns of potentially different types. You can think of it like a spreadsheet or a SQL table.

The shape function is incredibly useful for checking the dimensions of a DataFrame. To use the shape function in a Pandas DataFrame, you simply call the “shape” attribute after the DataFrame variable.

This program creates a DataFrame with two columns – Name and Age – and three rows of data. When we call the shape function on this DataFrame, it returns a tuple with two values: the number of rows (3) and the number of columns (2).

Usage in NumPy Arrays

In NumPy, an array is a collection of elements that are of the same type. The shape function is equally valuable when working with NumPy arrays.

It returns the dimensions of the array in the form of a tuple that contains the number of elements along each axis. To use the shape function in a NumPy array, you just need to call the “shape” attribute of the array variable.

This program creates a NumPy array with three rows and two columns and then calls the shape function. The shape attribute returns (3,2), indicating that the array has three rows and two columns.

Examples and Outputs

Example 1: 1-dimensional numpy array.

Output: (4,)

Explanation: This program creates a 1-dimensional NumPy array with four elements and then calls the shape function. The shape attribute returns a tuple with a single value (4) because there is only one axis.

Example 2: 3-Dimensional NumPy Array

Output: (2, 2, 2)

Explanation: This program creates a 3-dimensional NumPy array with two axes and two elements in each axis. The shape attribute returns a tuple with three values indicating the number of elements in each dimension.

Using the Shape Function in Pandas

Creating a dataframe.

To create a DataFrame in Pandas, you can use the pd.DataFrame() function. You can create a DataFrame from a dictionary, list, or a NumPy array.

Checking Dimensions of a DataFrame

To check the dimensions of a DataFrame, you can use the shape attribute. Here’s an example of how to check the dimensions of the DataFrame created above.

Output: (3, 2)

Checking Dimensions of an Empty DataFrame

You can also use the shape attribute to check the dimensions of an empty DataFrame. Here’s an example of how to create and check the dimensions of an empty DataFrame.

Output: (0, 2)

In summary, understanding the shape function in Python is essential for working with datasets. It allows you to determine the number of dimensions, rows, and columns, which is necessary for data analysis.

The shape function is widely used in Pandas DataFrames and NumPy arrays. In Pandas, the shape attribute helps users check the dimensions of their data, while NumPy uses the shape attribute to return the dimensions of an array.

By knowing how to use the shape function in Python, you can work with data more efficiently and effectively.

Using the Shape Function in NumPy

NumPy is a Python package that provides advanced mathematical functions and features for arrays and datasets. NumPy provides a fast and powerful way to work with arrays and is widely used in scientific computing, data analysis, and machine learning.

The shape function is an essential feature in NumPy that helps analysts and programmers check dimensions and sizes of arrays or datasets. In this article, we will go into detail about creating a NumPy array, checking dimensions of a NumPy array, checking dimensions of a NumPy array with zero dimensions, and checking dimensions of a NumPy array with one dimension and zero elements.

Creating a NumPy Array

To create a NumPy array in Python, you must first import the NumPy package. Once imported, you can create an array by using the array() function.

This function takes a list, tuple, or ndarray as input. The following code shows how to create a simple 1-dimensional NumPy array containing the numbers 1 through 5:

Output: [1 2 3 4 5]

Checking Dimensions of a NumPy Array

To check the dimensions of a NumPy array, you can use the shape attribute. The shape attribute is a tuple representing the number of elements in each direction of the array.

In the case of a 1-dimensional array, the shape attribute will return a tuple with the number of elements in it. The following code shows how to use the shape attribute to check the dimensions of the arr1 array:

Output: (5,)

Checking Dimensions of a NumPy Array with Zero Dimensions

NumPy arrays can also have zero dimensions. A zero-dimensional array is usually created by specifying an empty tuple as the shape of the array.

The following code shows how to create a zero-dimensional NumPy array:

When you run the code, you will see that the shape attribute returns an empty tuple, indicating that the array has zero dimensions.

Checking Dimensions of a NumPy Array with One Dimension and Zero Elements

A NumPy array can also have one dimension with zero elements in it. This is simply an empty array or a list.

The following code shows how to create a NumPy array with one dimension and zero elements:

Output: (0,)

By running the code, you can see the shape attribute returns a tuple with the number of elements in each direction of the array. Since the array has only one dimension and that dimension has zero elements in it, the tuple returned has only one value, which is 0.

FAQs about Shape Function

What is the definition and purpose of the shape function.

The shape function is a NumPy array attribute that returns a tuple indicating the dimensions of the array.

It represents the number of elements in each direction (or axis) of the array. The purpose of the shape function is to help you identify and analyze your dataset and to ensure that it is optimized for data analysis and machine learning.

How is the Shape Function Used in Pandas and NumPy?

The shape function is widely used in both Pandas and NumPy. In Pandas, it helps users check the dimensions of their DataFrame.

In NumPy, it returns the dimensions of the array. This is especially useful when working with datasets, which typically require the manipulation, analysis, and visualization of data.

How to Use the Shape Function?

To use the shape function, you need to call the “shape” attribute of the array variable.

This will return a tuple that contains the number of elements in each dimension. In Pandas, you can use the shape attribute to check the dimensions of the DataFrame.

The shape attribute is a useful tool that enables analysts and programmers to check dimensions, create new arrays or dataframes, or modify existing ones.

Summary and Applications

In summary, the shape function is a valuable function in Python that is widely used in data analysis projects. In Pandas, it helps users check the dimensions of the DataFrame, which is crucial when working with datasets.

In NumPy, it helps programmers determine the dimensions of an array, which is vital when computing mathematical and statistical operations. You can apply the shape function to optimize your data analysis projects, ensure data accuracy, and analyze the data with more precision.

By using the shape function, you can save time and effort that you would otherwise spend trying to figure out the dimensions and structure of your dataset. In conclusion, understanding the shape function in Python is crucial for data analysis projects as it helps determine the dimensions, rows, and columns of an array or dataset.

It is a valuable tool for optimizing data accuracy and analysis, and it is widely used in Pandas and NumPy. Creating a NumPy array and checking its dimensions, including zero-dimensional and one-dimensional arrays, is essential for computing mathematical and statistical operations. By using the shape function, data analysts and programmers can save time and perform their tasks with more efficiency and precision.

Takeaways from this article include how crucial it is to be familiar with the shape function to carry out successful data analysis projects.

Popular Posts

Efficiently storing and accessing large data arrays with numpy’s npy format, master arrays with numpyediff1d() – tips and examples, mastering pandas dataframes: avoiding common filtering errors.

• Terms & Conditions
• Privacy Policy

Python Object-Oriented Programming: Shape class with area and perimeter calculation

Python oop: exercise-4 with solution.

Write a Python program to create a class that represents a shape. Include methods to calculate its area and perimeter. Implement subclasses for different shapes like circle, triangle, and square.

Sample Solution:

Python Code:

Sample Output:

Explanation:

In this above exercise,

• we define a base class called Shape that provides the blueprint for other shapes. It includes two methods, calculate_area and calculate_perimeter, which are overridden by subclasses.
• The Circle class is a subclass of Shape and includes logic designed to calculate the area and perimeter of a circle using the provided radius.
• Rectangles, another subclass of Shape, include length and width attributes that enable them to calculate their area and perimeter.
• The Triangle class is also a subclass of Shape and includes the necessary attributes (base, height, and side lengths) to calculate a triangle's area and perimeter.
• In the example usage section, we create instances of each subclass and call the calculate_area and calculate_perimeter methods to obtain the area and perimeter values. The results are then printed.

Python Code Editor:

Previous: Calculator class for basic arithmetic. Next: Binary search tree class with insertion and search methods.

What is the difficulty level of this exercise?

Test your Programming skills with w3resource's quiz.

Follow us on Facebook and Twitter for latest update.

• Weekly Trends and Language Statistics

• 12. Functions »
• Area Calculator
• View page source

Area Calculator ¶

Write a program to calculate the area of four different geometric shapes: triangles, squares, rectangles, and circles. You must use functions. Here are the functions you should create:

Name your file area_calculator.py

Your program should present a menu for the human to choose which shape to calculate, then ask them for the appropriate values (length, width, radius, etc.). Then it should pass those values to the appropriate function and display the resulting area.

Notice that you must not input the values inside the functions, and you must not display the values inside the functions. All input and output must be in the main() function, and values must be passed to the functions and returned from them.

You will need to construct your own main function and use the magical if __name__ == "__main__": statement as seen in previous assignments.

You’ll need the value of π for area_circle() ; feel free to use the math library’s pi variable.

The menu should keep looping until the human chooses to quit.

©2021 Daniel Gallo

This assignment is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 United States License .

Adapted for Python from Graham Mitchell’s Programming By Doing

Python Shape Function: Find Dimensions of Arrays and DataFrames

The shape function in Python is used to determine the dimensions of arrays and dataframes. This information is provided in the form of a tuple . Typically, the shape method is applied to Python objects such as numpy.array or pandas.DataFrame .

The number of elements in the tuple returned by the shape function corresponds to the dimensions of the Python object. Each element within the tuple signifies the number of elements pertaining to the given Python object.

Python Shape Function

The shape function in Python yields a tuple that signifies the dimensions of a NumPy array or a Pandas DataFrame. In the case of a DataFrame, the tuple indicates the quantity of rows and columns. For a NumPy array, the tuple reveals the count of elements across every dimension. This function is beneficial for comprehending the structure and magnitude of data objects within Python.

The shape function in Pandas provides the dimensions (rows & columns) of the DataFrame as a tuple.

Example 1: Check the dimensions of a DataFrame

In this illustration, we’ll be generating a Pandas DataFrame utilizing a Python list and employing the shape function to examine its dimensions.

This enables us to grasp the quantity of rows and columns present in the DataFrame, which proves beneficial when handling extensive datasets or during the preprocessing phase for data analysis.

The shape method has returned a tuple (3, 4) with two elements depicting the DataFrame has two dimensions with three rows and four columns.

Example 2: Check the Dimensions of an Empty DataFrame

In this example, we’ll explore how to utilize the shape attribute on an empty DataFrame to verify its emptiness by examining its dimensions. This technique can be particularly useful for ensuring that a DataFrame is indeed empty before performing further operations or analysis.

The shape method has returned a tuple (0, 0) with two elements depicting the DataFrame has two dimensions with zero rows and zero columns.

Using Shape in NumPy

The shape function in NumPy provides the dimensions of the numpy array as a tuple.

Example 3: Check the Dimensions of an Array

In this example, we will create a three-dimensional NumPy array and use the shape function to find its dimensions. The output tuple will have three elements, each representing the number of elements in the respective dimension of the array.

The shape method has returned a tuple (1, 2, 3) with three elements depicting the array has three dimensions where each dimension has one, two, and three elements respectively.

Example 4: Check the Dimensions of a NumPy Array with Zero Dimensions

In certain situations, you might encounter an array with zero dimensions. This can happen when you create an array with a single scalar value. In this example, we will demonstrate how to check the dimensions of such a NumPy array.

The shape method has returned an empty tuple () with zero elements depicting the array has zero dimensions.

Example 5: Check the Dimensions of a NumPy Array with One Dimension and Zero Elements

In this example, we will create an array with only one dimension but containing zero elements. This can occur when you initialize an array from an empty list or when you need a placeholder for data that will be added later. We will then use the shape function to examine its dimensions.

The shape method has returned a tuple (0,) with one element depicting the array has only one dimension with zero elements.

What does shape function do in python?

The shape function in Python is used to find the dimensions of data structures, such as NumPy arrays and Pandas DataFrames. It returns a tuple representing the dimensions, with each tuple element corresponding to the number of elements in that dimension. This function is useful for understanding the structure and size of data objects in Python.

How to use shape function in python?

To use the shape function in Python, first import the Pandas library with import pandas as pd and create a DataFrame using df = pd.DataFrame(data). Then, obtain the dimensions as a tuple using dimensions = df.shape. For NumPy arrays, import the NumPy library using import numpy as np, create an array with arr = np.array(data), and get the dimensions with dimensions = arr.shape. The shape function returns a tuple representing the dimensions of the Python data structure.

In this tutorial, we’ve learned how to use the shape function in Python to find the dimensions of NumPy arrays and Pandas DataFrames. This versatile function is essential for understanding the structure and size of your data objects. How might you apply this in your next data analysis project?

References:

• Official Documentation

Python Enhancement Proposals

• Python »
• PEP Index »

PEP 572 – Assignment Expressions

The importance of real code, exceptional cases, scope of the target, relative precedence of :=, change to evaluation order, differences between assignment expressions and assignment statements, specification changes during implementation, _pydecimal.py, datetime.py, sysconfig.py, simplifying list comprehensions, capturing condition values, changing the scope rules for comprehensions, alternative spellings, special-casing conditional statements, special-casing comprehensions, lowering operator precedence, allowing commas to the right, always requiring parentheses, why not just turn existing assignment into an expression, with assignment expressions, why bother with assignment statements, why not use a sublocal scope and prevent namespace pollution, style guide recommendations, acknowledgements, a numeric example, appendix b: rough code translations for comprehensions, appendix c: no changes to scope semantics.

This is a proposal for creating a way to assign to variables within an expression using the notation NAME := expr .

As part of this change, there is also an update to dictionary comprehension evaluation order to ensure key expressions are executed before value expressions (allowing the key to be bound to a name and then re-used as part of calculating the corresponding value).

During discussion of this PEP, the operator became informally known as “the walrus operator”. The construct’s formal name is “Assignment Expressions” (as per the PEP title), but they may also be referred to as “Named Expressions” (e.g. the CPython reference implementation uses that name internally).

Naming the result of an expression is an important part of programming, allowing a descriptive name to be used in place of a longer expression, and permitting reuse. Currently, this feature is available only in statement form, making it unavailable in list comprehensions and other expression contexts.

Additionally, naming sub-parts of a large expression can assist an interactive debugger, providing useful display hooks and partial results. Without a way to capture sub-expressions inline, this would require refactoring of the original code; with assignment expressions, this merely requires the insertion of a few name := markers. Removing the need to refactor reduces the likelihood that the code be inadvertently changed as part of debugging (a common cause of Heisenbugs), and is easier to dictate to another programmer.

During the development of this PEP many people (supporters and critics both) have had a tendency to focus on toy examples on the one hand, and on overly complex examples on the other.

The danger of toy examples is twofold: they are often too abstract to make anyone go “ooh, that’s compelling”, and they are easily refuted with “I would never write it that way anyway”.

The danger of overly complex examples is that they provide a convenient strawman for critics of the proposal to shoot down (“that’s obfuscated”).

Yet there is some use for both extremely simple and extremely complex examples: they are helpful to clarify the intended semantics. Therefore, there will be some of each below.

However, in order to be compelling , examples should be rooted in real code, i.e. code that was written without any thought of this PEP, as part of a useful application, however large or small. Tim Peters has been extremely helpful by going over his own personal code repository and picking examples of code he had written that (in his view) would have been clearer if rewritten with (sparing) use of assignment expressions. His conclusion: the current proposal would have allowed a modest but clear improvement in quite a few bits of code.

Another use of real code is to observe indirectly how much value programmers place on compactness. Guido van Rossum searched through a Dropbox code base and discovered some evidence that programmers value writing fewer lines over shorter lines.

Case in point: Guido found several examples where a programmer repeated a subexpression, slowing down the program, in order to save one line of code, e.g. instead of writing:

they would write:

Another example illustrates that programmers sometimes do more work to save an extra level of indentation:

This code tries to match pattern2 even if pattern1 has a match (in which case the match on pattern2 is never used). The more efficient rewrite would have been:

Syntax and semantics

In most contexts where arbitrary Python expressions can be used, a named expression can appear. This is of the form NAME := expr where expr is any valid Python expression other than an unparenthesized tuple, and NAME is an identifier.

The value of such a named expression is the same as the incorporated expression, with the additional side-effect that the target is assigned that value:

There are a few places where assignment expressions are not allowed, in order to avoid ambiguities or user confusion:

This rule is included to simplify the choice for the user between an assignment statement and an assignment expression – there is no syntactic position where both are valid.

Again, this rule is included to avoid two visually similar ways of saying the same thing.

This rule is included to disallow excessively confusing code, and because parsing keyword arguments is complex enough already.

This rule is included to discourage side effects in a position whose exact semantics are already confusing to many users (cf. the common style recommendation against mutable default values), and also to echo the similar prohibition in calls (the previous bullet).

The reasoning here is similar to the two previous cases; this ungrouped assortment of symbols and operators composed of : and = is hard to read correctly.

This allows lambda to always bind less tightly than := ; having a name binding at the top level inside a lambda function is unlikely to be of value, as there is no way to make use of it. In cases where the name will be used more than once, the expression is likely to need parenthesizing anyway, so this prohibition will rarely affect code.

This shows that what looks like an assignment operator in an f-string is not always an assignment operator. The f-string parser uses : to indicate formatting options. To preserve backwards compatibility, assignment operator usage inside of f-strings must be parenthesized. As noted above, this usage of the assignment operator is not recommended.

An assignment expression does not introduce a new scope. In most cases the scope in which the target will be bound is self-explanatory: it is the current scope. If this scope contains a nonlocal or global declaration for the target, the assignment expression honors that. A lambda (being an explicit, if anonymous, function definition) counts as a scope for this purpose.

There is one special case: an assignment expression occurring in a list, set or dict comprehension or in a generator expression (below collectively referred to as “comprehensions”) binds the target in the containing scope, honoring a nonlocal or global declaration for the target in that scope, if one exists. For the purpose of this rule the containing scope of a nested comprehension is the scope that contains the outermost comprehension. A lambda counts as a containing scope.

The motivation for this special case is twofold. First, it allows us to conveniently capture a “witness” for an any() expression, or a counterexample for all() , for example:

Second, it allows a compact way of updating mutable state from a comprehension, for example:

However, an assignment expression target name cannot be the same as a for -target name appearing in any comprehension containing the assignment expression. The latter names are local to the comprehension in which they appear, so it would be contradictory for a contained use of the same name to refer to the scope containing the outermost comprehension instead.

For example, [i := i+1 for i in range(5)] is invalid: the for i part establishes that i is local to the comprehension, but the i := part insists that i is not local to the comprehension. The same reason makes these examples invalid too:

While it’s technically possible to assign consistent semantics to these cases, it’s difficult to determine whether those semantics actually make sense in the absence of real use cases. Accordingly, the reference implementation [1] will ensure that such cases raise SyntaxError , rather than executing with implementation defined behaviour.

This restriction applies even if the assignment expression is never executed:

For the comprehension body (the part before the first “for” keyword) and the filter expression (the part after “if” and before any nested “for”), this restriction applies solely to target names that are also used as iteration variables in the comprehension. Lambda expressions appearing in these positions introduce a new explicit function scope, and hence may use assignment expressions with no additional restrictions.

Due to design constraints in the reference implementation (the symbol table analyser cannot easily detect when names are re-used between the leftmost comprehension iterable expression and the rest of the comprehension), named expressions are disallowed entirely as part of comprehension iterable expressions (the part after each “in”, and before any subsequent “if” or “for” keyword):

A further exception applies when an assignment expression occurs in a comprehension whose containing scope is a class scope. If the rules above were to result in the target being assigned in that class’s scope, the assignment expression is expressly invalid. This case also raises SyntaxError :

(The reason for the latter exception is the implicit function scope created for comprehensions – there is currently no runtime mechanism for a function to refer to a variable in the containing class scope, and we do not want to add such a mechanism. If this issue ever gets resolved this special case may be removed from the specification of assignment expressions. Note that the problem already exists for using a variable defined in the class scope from a comprehension.)

See Appendix B for some examples of how the rules for targets in comprehensions translate to equivalent code.

The := operator groups more tightly than a comma in all syntactic positions where it is legal, but less tightly than all other operators, including or , and , not , and conditional expressions ( A if C else B ). As follows from section “Exceptional cases” above, it is never allowed at the same level as = . In case a different grouping is desired, parentheses should be used.

The := operator may be used directly in a positional function call argument; however it is invalid directly in a keyword argument.

Some examples to clarify what’s technically valid or invalid:

Most of the “valid” examples above are not recommended, since human readers of Python source code who are quickly glancing at some code may miss the distinction. But simple cases are not objectionable:

This PEP recommends always putting spaces around := , similar to PEP 8 ’s recommendation for = when used for assignment, whereas the latter disallows spaces around = used for keyword arguments.)

In order to have precisely defined semantics, the proposal requires evaluation order to be well-defined. This is technically not a new requirement, as function calls may already have side effects. Python already has a rule that subexpressions are generally evaluated from left to right. However, assignment expressions make these side effects more visible, and we propose a single change to the current evaluation order:

• In a dict comprehension {X: Y for ...} , Y is currently evaluated before X . We propose to change this so that X is evaluated before Y . (In a dict display like {X: Y} this is already the case, and also in dict((X, Y) for ...) which should clearly be equivalent to the dict comprehension.)

Most importantly, since := is an expression, it can be used in contexts where statements are illegal, including lambda functions and comprehensions.

Conversely, assignment expressions don’t support the advanced features found in assignment statements:

• Multiple targets are not directly supported: x = y = z = 0 # Equivalent: (z := (y := (x := 0)))
• Single assignment targets other than a single NAME are not supported: # No equivalent a [ i ] = x self . rest = []
• Priority around commas is different: x = 1 , 2 # Sets x to (1, 2) ( x := 1 , 2 ) # Sets x to 1
• Iterable packing and unpacking (both regular or extended forms) are not supported: # Equivalent needs extra parentheses loc = x , y # Use (loc := (x, y)) info = name , phone , * rest # Use (info := (name, phone, *rest)) # No equivalent px , py , pz = position name , phone , email , * other_info = contact
• Inline type annotations are not supported: # Closest equivalent is "p: Optional[int]" as a separate declaration p : Optional [ int ] = None
• Augmented assignment is not supported: total += tax # Equivalent: (total := total + tax)

The following changes have been made based on implementation experience and additional review after the PEP was first accepted and before Python 3.8 was released:

• for consistency with other similar exceptions, and to avoid locking in an exception name that is not necessarily going to improve clarity for end users, the originally proposed TargetScopeError subclass of SyntaxError was dropped in favour of just raising SyntaxError directly. [3]
• due to a limitation in CPython’s symbol table analysis process, the reference implementation raises SyntaxError for all uses of named expressions inside comprehension iterable expressions, rather than only raising them when the named expression target conflicts with one of the iteration variables in the comprehension. This could be revisited given sufficiently compelling examples, but the extra complexity needed to implement the more selective restriction doesn’t seem worthwhile for purely hypothetical use cases.

Examples from the Python standard library

env_base is only used on these lines, putting its assignment on the if moves it as the “header” of the block.

• Current: env_base = os . environ . get ( "PYTHONUSERBASE" , None ) if env_base : return env_base
• Improved: if env_base := os . environ . get ( "PYTHONUSERBASE" , None ): return env_base

Avoid nested if and remove one indentation level.

• Current: if self . _is_special : ans = self . _check_nans ( context = context ) if ans : return ans
• Improved: if self . _is_special and ( ans := self . _check_nans ( context = context )): return ans

Code looks more regular and avoid multiple nested if. (See Appendix A for the origin of this example.)

• Current: reductor = dispatch_table . get ( cls ) if reductor : rv = reductor ( x ) else : reductor = getattr ( x , "__reduce_ex__" , None ) if reductor : rv = reductor ( 4 ) else : reductor = getattr ( x , "__reduce__" , None ) if reductor : rv = reductor () else : raise Error ( "un(deep)copyable object of type %s " % cls )
• Improved: if reductor := dispatch_table . get ( cls ): rv = reductor ( x ) elif reductor := getattr ( x , "__reduce_ex__" , None ): rv = reductor ( 4 ) elif reductor := getattr ( x , "__reduce__" , None ): rv = reductor () else : raise Error ( "un(deep)copyable object of type %s " % cls )

tz is only used for s += tz , moving its assignment inside the if helps to show its scope.

• Current: s = _format_time ( self . _hour , self . _minute , self . _second , self . _microsecond , timespec ) tz = self . _tzstr () if tz : s += tz return s
• Improved: s = _format_time ( self . _hour , self . _minute , self . _second , self . _microsecond , timespec ) if tz := self . _tzstr (): s += tz return s

Calling fp.readline() in the while condition and calling .match() on the if lines make the code more compact without making it harder to understand.

• Current: while True : line = fp . readline () if not line : break m = define_rx . match ( line ) if m : n , v = m . group ( 1 , 2 ) try : v = int ( v ) except ValueError : pass vars [ n ] = v else : m = undef_rx . match ( line ) if m : vars [ m . group ( 1 )] = 0
• Improved: while line := fp . readline (): if m := define_rx . match ( line ): n , v = m . group ( 1 , 2 ) try : v = int ( v ) except ValueError : pass vars [ n ] = v elif m := undef_rx . match ( line ): vars [ m . group ( 1 )] = 0

A list comprehension can map and filter efficiently by capturing the condition:

Similarly, a subexpression can be reused within the main expression, by giving it a name on first use:

Note that in both cases the variable y is bound in the containing scope (i.e. at the same level as results or stuff ).

Assignment expressions can be used to good effect in the header of an if or while statement:

Particularly with the while loop, this can remove the need to have an infinite loop, an assignment, and a condition. It also creates a smooth parallel between a loop which simply uses a function call as its condition, and one which uses that as its condition but also uses the actual value.

An example from the low-level UNIX world:

Rejected alternative proposals

Proposals broadly similar to this one have come up frequently on python-ideas. Below are a number of alternative syntaxes, some of them specific to comprehensions, which have been rejected in favour of the one given above.

A previous version of this PEP proposed subtle changes to the scope rules for comprehensions, to make them more usable in class scope and to unify the scope of the “outermost iterable” and the rest of the comprehension. However, this part of the proposal would have caused backwards incompatibilities, and has been withdrawn so the PEP can focus on assignment expressions.

Broadly the same semantics as the current proposal, but spelled differently.

Since EXPR as NAME already has meaning in import , except and with statements (with different semantics), this would create unnecessary confusion or require special-casing (e.g. to forbid assignment within the headers of these statements).

(Note that with EXPR as VAR does not simply assign the value of EXPR to VAR – it calls EXPR.__enter__() and assigns the result of that to VAR .)

Additional reasons to prefer := over this spelling include:

• In if f(x) as y the assignment target doesn’t jump out at you – it just reads like if f x blah blah and it is too similar visually to if f(x) and y .
• import foo as bar
• except Exc as var
• with ctxmgr() as var

To the contrary, the assignment expression does not belong to the if or while that starts the line, and we intentionally allow assignment expressions in other contexts as well.

• NAME = EXPR
• if NAME := EXPR

reinforces the visual recognition of assignment expressions.

This syntax is inspired by languages such as R and Haskell, and some programmable calculators. (Note that a left-facing arrow y <- f(x) is not possible in Python, as it would be interpreted as less-than and unary minus.) This syntax has a slight advantage over ‘as’ in that it does not conflict with with , except and import , but otherwise is equivalent. But it is entirely unrelated to Python’s other use of -> (function return type annotations), and compared to := (which dates back to Algol-58) it has a much weaker tradition.

This has the advantage that leaked usage can be readily detected, removing some forms of syntactic ambiguity. However, this would be the only place in Python where a variable’s scope is encoded into its name, making refactoring harder.

Execution order is inverted (the indented body is performed first, followed by the “header”). This requires a new keyword, unless an existing keyword is repurposed (most likely with: ). See PEP 3150 for prior discussion on this subject (with the proposed keyword being given: ).

This syntax has fewer conflicts than as does (conflicting only with the raise Exc from Exc notation), but is otherwise comparable to it. Instead of paralleling with expr as target: (which can be useful but can also be confusing), this has no parallels, but is evocative.

One of the most popular use-cases is if and while statements. Instead of a more general solution, this proposal enhances the syntax of these two statements to add a means of capturing the compared value:

This works beautifully if and ONLY if the desired condition is based on the truthiness of the captured value. It is thus effective for specific use-cases (regex matches, socket reads that return '' when done), and completely useless in more complicated cases (e.g. where the condition is f(x) < 0 and you want to capture the value of f(x) ). It also has no benefit to list comprehensions.

Advantages: No syntactic ambiguities. Disadvantages: Answers only a fraction of possible use-cases, even in if / while statements.

Another common use-case is comprehensions (list/set/dict, and genexps). As above, proposals have been made for comprehension-specific solutions.

This brings the subexpression to a location in between the ‘for’ loop and the expression. It introduces an additional language keyword, which creates conflicts. Of the three, where reads the most cleanly, but also has the greatest potential for conflict (e.g. SQLAlchemy and numpy have where methods, as does tkinter.dnd.Icon in the standard library).

As above, but reusing the with keyword. Doesn’t read too badly, and needs no additional language keyword. Is restricted to comprehensions, though, and cannot as easily be transformed into “longhand” for-loop syntax. Has the C problem that an equals sign in an expression can now create a name binding, rather than performing a comparison. Would raise the question of why “with NAME = EXPR:” cannot be used as a statement on its own.

As per option 2, but using as rather than an equals sign. Aligns syntactically with other uses of as for name binding, but a simple transformation to for-loop longhand would create drastically different semantics; the meaning of with inside a comprehension would be completely different from the meaning as a stand-alone statement, while retaining identical syntax.

Regardless of the spelling chosen, this introduces a stark difference between comprehensions and the equivalent unrolled long-hand form of the loop. It is no longer possible to unwrap the loop into statement form without reworking any name bindings. The only keyword that can be repurposed to this task is with , thus giving it sneakily different semantics in a comprehension than in a statement; alternatively, a new keyword is needed, with all the costs therein.

There are two logical precedences for the := operator. Either it should bind as loosely as possible, as does statement-assignment; or it should bind more tightly than comparison operators. Placing its precedence between the comparison and arithmetic operators (to be precise: just lower than bitwise OR) allows most uses inside while and if conditions to be spelled without parentheses, as it is most likely that you wish to capture the value of something, then perform a comparison on it:

Once find() returns -1, the loop terminates. If := binds as loosely as = does, this would capture the result of the comparison (generally either True or False ), which is less useful.

While this behaviour would be convenient in many situations, it is also harder to explain than “the := operator behaves just like the assignment statement”, and as such, the precedence for := has been made as close as possible to that of = (with the exception that it binds tighter than comma).

Some critics have claimed that the assignment expressions should allow unparenthesized tuples on the right, so that these two would be equivalent:

(With the current version of the proposal, the latter would be equivalent to ((point := x), y) .)

However, adopting this stance would logically lead to the conclusion that when used in a function call, assignment expressions also bind less tight than comma, so we’d have the following confusing equivalence:

The less confusing option is to make := bind more tightly than comma.

It’s been proposed to just always require parentheses around an assignment expression. This would resolve many ambiguities, and indeed parentheses will frequently be needed to extract the desired subexpression. But in the following cases the extra parentheses feel redundant:

Frequently Raised Objections

C and its derivatives define the = operator as an expression, rather than a statement as is Python’s way. This allows assignments in more contexts, including contexts where comparisons are more common. The syntactic similarity between if (x == y) and if (x = y) belies their drastically different semantics. Thus this proposal uses := to clarify the distinction.

The two forms have different flexibilities. The := operator can be used inside a larger expression; the = statement can be augmented to += and its friends, can be chained, and can assign to attributes and subscripts.

Previous revisions of this proposal involved sublocal scope (restricted to a single statement), preventing name leakage and namespace pollution. While a definite advantage in a number of situations, this increases complexity in many others, and the costs are not justified by the benefits. In the interests of language simplicity, the name bindings created here are exactly equivalent to any other name bindings, including that usage at class or module scope will create externally-visible names. This is no different from for loops or other constructs, and can be solved the same way: del the name once it is no longer needed, or prefix it with an underscore.

(The author wishes to thank Guido van Rossum and Christoph Groth for their suggestions to move the proposal in this direction. [2] )

As expression assignments can sometimes be used equivalently to statement assignments, the question of which should be preferred will arise. For the benefit of style guides such as PEP 8 , two recommendations are suggested.

• If either assignment statements or assignment expressions can be used, prefer statements; they are a clear declaration of intent.
• If using assignment expressions would lead to ambiguity about execution order, restructure it to use statements instead.

The authors wish to thank Alyssa Coghlan and Steven D’Aprano for their considerable contributions to this proposal, and members of the core-mentorship mailing list for assistance with implementation.

Appendix A: Tim Peters’s findings

Here’s a brief essay Tim Peters wrote on the topic.

I dislike “busy” lines of code, and also dislike putting conceptually unrelated logic on a single line. So, for example, instead of:

instead. So I suspected I’d find few places I’d want to use assignment expressions. I didn’t even consider them for lines already stretching halfway across the screen. In other cases, “unrelated” ruled:

is a vast improvement over the briefer:

The original two statements are doing entirely different conceptual things, and slamming them together is conceptually insane.

In other cases, combining related logic made it harder to understand, such as rewriting:

as the briefer:

The while test there is too subtle, crucially relying on strict left-to-right evaluation in a non-short-circuiting or method-chaining context. My brain isn’t wired that way.

But cases like that were rare. Name binding is very frequent, and “sparse is better than dense” does not mean “almost empty is better than sparse”. For example, I have many functions that return None or 0 to communicate “I have nothing useful to return in this case, but since that’s expected often I’m not going to annoy you with an exception”. This is essentially the same as regular expression search functions returning None when there is no match. So there was lots of code of the form:

I find that clearer, and certainly a bit less typing and pattern-matching reading, as:

It’s also nice to trade away a small amount of horizontal whitespace to get another _line_ of surrounding code on screen. I didn’t give much weight to this at first, but it was so very frequent it added up, and I soon enough became annoyed that I couldn’t actually run the briefer code. That surprised me!

There are other cases where assignment expressions really shine. Rather than pick another from my code, Kirill Balunov gave a lovely example from the standard library’s copy() function in copy.py :

The ever-increasing indentation is semantically misleading: the logic is conceptually flat, “the first test that succeeds wins”:

Using easy assignment expressions allows the visual structure of the code to emphasize the conceptual flatness of the logic; ever-increasing indentation obscured it.

A smaller example from my code delighted me, both allowing to put inherently related logic in a single line, and allowing to remove an annoying “artificial” indentation level:

That if is about as long as I want my lines to get, but remains easy to follow.

So, in all, in most lines binding a name, I wouldn’t use assignment expressions, but because that construct is so very frequent, that leaves many places I would. In most of the latter, I found a small win that adds up due to how often it occurs, and in the rest I found a moderate to major win. I’d certainly use it more often than ternary if , but significantly less often than augmented assignment.

I have another example that quite impressed me at the time.

Where all variables are positive integers, and a is at least as large as the n’th root of x, this algorithm returns the floor of the n’th root of x (and roughly doubling the number of accurate bits per iteration):

It’s not obvious why that works, but is no more obvious in the “loop and a half” form. It’s hard to prove correctness without building on the right insight (the “arithmetic mean - geometric mean inequality”), and knowing some non-trivial things about how nested floor functions behave. That is, the challenges are in the math, not really in the coding.

If you do know all that, then the assignment-expression form is easily read as “while the current guess is too large, get a smaller guess”, where the “too large?” test and the new guess share an expensive sub-expression.

To my eyes, the original form is harder to understand:

This appendix attempts to clarify (though not specify) the rules when a target occurs in a comprehension or in a generator expression. For a number of illustrative examples we show the original code, containing a comprehension, and the translation, where the comprehension has been replaced by an equivalent generator function plus some scaffolding.

Since [x for ...] is equivalent to list(x for ...) these examples all use list comprehensions without loss of generality. And since these examples are meant to clarify edge cases of the rules, they aren’t trying to look like real code.

Note: comprehensions are already implemented via synthesizing nested generator functions like those in this appendix. The new part is adding appropriate declarations to establish the intended scope of assignment expression targets (the same scope they resolve to as if the assignment were performed in the block containing the outermost comprehension). For type inference purposes, these illustrative expansions do not imply that assignment expression targets are always Optional (but they do indicate the target binding scope).

Let’s start with a reminder of what code is generated for a generator expression without assignment expression.

• Original code (EXPR usually references VAR): def f (): a = [ EXPR for VAR in ITERABLE ]
• Translation (let’s not worry about name conflicts): def f (): def genexpr ( iterator ): for VAR in iterator : yield EXPR a = list ( genexpr ( iter ( ITERABLE )))

Let’s add a simple assignment expression.

• Original code: def f (): a = [ TARGET := EXPR for VAR in ITERABLE ]
• Translation: def f (): if False : TARGET = None # Dead code to ensure TARGET is a local variable def genexpr ( iterator ): nonlocal TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Let’s add a global TARGET declaration in f() .

• Original code: def f (): global TARGET a = [ TARGET := EXPR for VAR in ITERABLE ]
• Translation: def f (): global TARGET def genexpr ( iterator ): global TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Or instead let’s add a nonlocal TARGET declaration in f() .

• Original code: def g (): TARGET = ... def f (): nonlocal TARGET a = [ TARGET := EXPR for VAR in ITERABLE ]
• Translation: def g (): TARGET = ... def f (): nonlocal TARGET def genexpr ( iterator ): nonlocal TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Finally, let’s nest two comprehensions.

• Original code: def f (): a = [[ TARGET := i for i in range ( 3 )] for j in range ( 2 )] # I.e., a = [[0, 1, 2], [0, 1, 2]] print ( TARGET ) # prints 2
• Translation: def f (): if False : TARGET = None def outer_genexpr ( outer_iterator ): nonlocal TARGET def inner_generator ( inner_iterator ): nonlocal TARGET for i in inner_iterator : TARGET = i yield i for j in outer_iterator : yield list ( inner_generator ( range ( 3 ))) a = list ( outer_genexpr ( range ( 2 ))) print ( TARGET )

Because it has been a point of confusion, note that nothing about Python’s scoping semantics is changed. Function-local scopes continue to be resolved at compile time, and to have indefinite temporal extent at run time (“full closures”). Example:

This document has been placed in the public domain.

Source: https://github.com/python/peps/blob/main/peps/pep-0572.rst

Last modified: 2023-10-11 12:05:51 GMT

SOLID Principles: Improve Object-Oriented Design in Python

Table of Contents

Object-Oriented Design in Python: The SOLID Principles

Single-responsibility principle (srp), open-closed principle (ocp), liskov substitution principle (lsp), interface segregation principle (isp), dependency inversion principle (dip).

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Design and Guidance: Object-Oriented Programming in Python

When you build a Python project using object-oriented programming (OOP) , planning how the different classes and objects will interact to solve your specific problems is an important part of the job. This planning is known as object-oriented design (OOD) , and getting it right can be a challenge. If you’re stuck while designing your Python classes, then the SOLID principles can help you out.

SOLID is a set of five object-oriented design principles that can help you write more maintainable, flexible, and scalable code based on well-designed, cleanly structured classes. These principles are a fundamental part of object-oriented design best practices.

In this tutorial, you’ll:

• Understand the meaning and purpose of each SOLID principle
• Identify Python code that violates some of the SOLID principles
• Apply the SOLID principles to refactor your Python code and improve its design

Throughout your learning journey, you’ll code practical examples to discover how the SOLID principles can lead to well-organized, flexible, maintainable, and scalable code.

To get the most out of this tutorial, you must have a good understanding of Python object-oriented programming concepts, such as classes , interfaces , and inheritance .

Free Bonus: Click here to download sample code so you can build clean, maintainable classes with the SOLID Principles in Python.

When it comes to writing classes and designing their interactions in Python, you can follow a series of principles that will help you build better object-oriented code. One of the most popular and widely accepted sets of standards for object-oriented design (OOD) is known as the SOLID principles.

If you’re coming from C++ or Java , you may already be familiar with these principles. Maybe you’re wondering if the SOLID principles also apply to Python code. To that question, the answer is a resounding yes . If you’re writing object-oriented code, then you should consider applying these principles to your OOD.

But what are these SOLID principles? SOLID is an acronym that groups five core principles that apply to object-oriented design. These principles are the following:

• S ingle-responsibility principle (SRP)
• O pen–closed principle (OCP)
• L iskov substitution principle (LSP)
• I nterface segregation principle (ISP)
• D ependency inversion principle (DIP)

You’ll explore each of these principles in detail and code real-world examples of how to apply them in Python. In the process, you’ll gain a strong understanding of how to write more straightforward, organized, scalable, and reusable object-oriented code by applying the SOLID principles. To kick things off, you’ll start with the first principle on the list.

The single-responsibility principle (SRP) comes from Robert C. Martin , more commonly known by his nickname Uncle Bob, who’s a well-respected figure in the software engineering world and one of the original signatories of the Agile Manifesto . In fact, he coined the term SOLID.

The single-responsibility principle states that:

A class should have only one reason to change.

This means that a class should have only one responsibility , as expressed through its methods. If a class takes care of more than one task, then you should separate those tasks into separate classes.

Note: You’ll find the SOLID principles worded in various ways out there. In this tutorial, you’ll refer to them following the wording that Uncle Bob uses in his book Agile Software Development: Principles, Patterns, and Practices . So, all the direct quotes come from this book.

If you want to read alternate wordings in a quick roundup of these and related principles, then check out Uncle Bob’s The Principles of OOD .

This principle is closely related to the concept of separation of concerns , which suggests that you should split your programs into different sections. Each section must address a separate concern.

To illustrate the single-responsibility principle and how it can help you improve your object-oriented design, say that you have the following FileManager class:

In this example, your FileManager class has two different responsibilities. It uses the .read() and .write() methods to manage the file. It also deals with ZIP archives by providing the .compress() and .decompress() methods.

This class violates the single-responsibility principle because it has two reasons for changing its internal implementation. To fix this issue and make your design more robust, you can split the class into two smaller, more focused classes, each with its own specific concern:

Now you have two smaller classes, each having only a single responsibility. FileManager takes care of managing a file, while ZipFileManager handles the compression and decompression of a file using the ZIP format. These two classes are smaller, so they’re more manageable. They’re also easier to reason about, test, and debug.

The concept of responsibility in this context may be pretty subjective. Having a single responsibility doesn’t necessarily mean having a single method. Responsibility isn’t directly tied to the number of methods but to the core task that your class is responsible for, depending on your idea of what the class represents in your code. However, that subjectivity shouldn’t stop you from striving to use the SRP.

The open-closed principle (OCP) for object-oriented design was originally introduced by Bertrand Meyer in 1988 and means that:

Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification.

To understand what the open-closed principle is all about, consider the following Shape class:

The initializer of Shape takes a shape_type argument that can be either "rectangle" or "circle" . It also takes a specific set of keyword arguments using the **kwargs syntax. If you set the shape type to "rectangle" , then you should also pass the width and height keyword arguments so that you can construct a proper rectangle.

In contrast, if you set the shape type to "circle" , then you must also pass a radius argument to construct a circle.

Note: This example may seem a bit extreme. Its intention is to clearly expose the core idea behind the open-closed principle.

Shape also has a .calculate_area() method that computes the area of the current shape according to its .shape_type :

The class works. You can create circles and rectangles, compute their area, and so on. However, the class looks pretty bad. Something seems wrong with it at first sight.

Imagine that you need to add a new shape, maybe a square. How would you do that? Well, the option here is to add another elif clause to .__init__() and to .calculate_area() so that you can address the requirements of a square shape.

Having to make these changes to create new shapes means that your class is open to modification. That violates the open-closed principle. How can you fix your class to make it open to extension but closed to modification? Here’s a possible solution:

In this code, you completely refactored the Shape class, turning it into an abstract base class (ABC) . This class provides the required interface (API) for any shape that you’d like to define. That interface consists of a .shape_type attribute and a .calculate_area() method that you must override in all the subclasses.

Note: The example above and some examples in the next sections use Python’s ABCs to provide what’s called interface inheritance . In this type of inheritance, subclasses inherit interfaces rather than functionality. In contrast, when classes inherit functionality, then you’re presented with implementation inheritance .

This update closes the class to modifications. Now you can add new shapes to your class design without the need to modify Shape . In every case, you’ll have to implement the required interface, which also makes your classes polymorphic .

The Liskov substitution principle (LSP) was introduced by Barbara Liskov at an OOPSLA conference in 1987. Since then, this principle has been a fundamental part of object-oriented programming. The principle states that:

Subtypes must be substitutable for their base types.

For example, if you have a piece of code that works with a Shape class, then you should be able to substitute that class with any of its subclasses, such as Circle or Rectangle , without breaking the code.

Note: You can read the conference proceedings from the keynote where Barbara Liskov first shared this principle, or you can watch a short fragment of an interview with her for more context.

In practice, this principle is about making your subclasses behave like their base classes without breaking anyone’s expectations when they call the same methods. To continue with shape-related examples, say you have a Rectangle class like the following:

In Rectangle , you’ve provided the .calculate_area() method, which operates with the .width and .height instance attributes .

Because a square is a special case of a rectangle with equal sides, you think of deriving a Square class from Rectangle in order to reuse the code. Then, you override the setter method for the .width and .height attributes so that when one side changes, the other side also changes:

In this snippet of code, you’ve defined Square as a subclass of Rectangle . As a user might expect, the class constructor takes only the side of the square as an argument. Internally, the .__init__() method initializes the parent’s attributes, .width and .height , with the side argument.

You’ve also defined a special method , .__setattr__() , to hook into Python’s attribute-setting mechanism and intercept the assignment of a new value to either the .width or .height attribute. Specifically, when you set one of those attributes, the other attribute is also set to the same value:

Now you’ve ensured that the Square object always remains a valid square, making your life easier for the small price of a bit of wasted memory. Unfortunately, this violates the Liskov substitution principle because you can’t replace instances of Rectangle with their Square counterparts.

When someone expects a rectangle object in their code, they might assume that it’ll behave like one by exposing two independent .width and .height attributes. Meanwhile, your Square class breaks that assumption by changing the behavior promised by the object’s interface. That could have surprising and unwanted consequences, which would likely be hard to debug .

While a square is a specific type of rectangle in mathematics, the classes that represent those shapes shouldn’t be in a parent-child relationship if you want them to comply with the Liskov substitution principle. One way to solve this problem is to create a base class for both Rectangle and Square to extend:

Shape becomes the type that you can substitute through polymorphism with either Rectangle or Square , which are now siblings rather than a parent and a child. Notice that both concrete shape types have distinct sets of attributes, different initializer methods, and could potentially implement even more separate behaviors. The only thing that they have in common is the ability to calculate their area.

With this implementation in place, you can use the Shape type interchangeably with its Square and Rectangle subtypes when you only care about their common behavior:

Here, you pass a pair consisting of a rectangle and a square into a function that calculates their total area. Because the function only cares about the .calculate_area() method, it doesn’t matter that the shapes are different. This is the essence of the Liskov substitution principle.

The interface segregation principle (ISP) comes from the same mind as the single-responsibility principle. Yes, it’s another feather in Uncle Bob’s cap. The principle’s main idea is that:

Clients should not be forced to depend upon methods that they do not use. Interfaces belong to clients, not to hierarchies.

In this case, clients are classes and subclasses, and interfaces consist of methods and attributes. In other words, if a class doesn’t use particular methods or attributes, then those methods and attributes should be segregated into more specific classes.

Consider the following example of class hierarchy to model printing machines:

In this example, the base class, Printer , provides the interface that its subclasses must implement. OldPrinter inherits from Printer and must implement the same interface. However, OldPrinter doesn’t use the .fax() and .scan() methods because this type of printer doesn’t support these functionalities.

This implementation violates the ISP because it forces OldPrinter to expose an interface that the class doesn’t implement or need. To fix this issue, you should separate the interfaces into smaller and more specific classes. Then you can create concrete classes by inheriting from multiple interface classes as needed:

Now Printer , Fax , and Scanner are base classes that provide specific interfaces with a single responsibility each. To create OldPrinter , you only inherit the Printer interface. This way, the class won’t have unused methods. To create the ModernPrinter class, you need to inherit from all the interfaces. In short, you’ve segregated the Printer interface.

This class design allows you to create different machines with different sets of functionalities, making your design more flexible and extensible.

The dependency inversion principle (DIP) is the last principle in the SOLID set. This principle states that:

Abstractions should not depend upon details. Details should depend upon abstractions.

That sounds pretty complex. Here’s an example that will help to clarify it. Say you’re building an application and have a FrontEnd class to display data to the users in a friendly way. The app currently gets its data from a database, so you end up with the following code:

In this example, the FrontEnd class depends on the BackEnd class and its concrete implementation. You can say that both classes are tightly coupled. This coupling can lead to scalability issues. For example, say that your app is growing fast, and you want the app to be able to read data from a REST API . How would you do that?

You may think of adding a new method to BackEnd to retrieve the data from the REST API. However, that will also require you to modify FrontEnd , which should be closed to modification, according to the open-closed principle .

To fix the issue, you can apply the dependency inversion principle and make your classes depend on abstractions rather than on concrete implementations like BackEnd . In this specific example, you can introduce a DataSource class that provides the interface to use in your concrete classes:

In this redesign of your classes, you’ve added a DataSource class as an abstraction that provides the required interface, or the .get_data() method. Note how FrontEnd now depends on the interface provided by DataSource , which is an abstraction.

Then you define the Database class, which is a concrete implementation for those cases where you want to retrieve the data from your database. This class depends on the DataSource abstraction through inheritance. Finally, you define the API class to support retrieving the data from the REST API. This class also depends on the DataSource abstraction.

Here’s how you can use the FrontEnd class in your code:

Here, you first initialize FrontEnd using a Database object and then again using an API object. Every time you call .display_data() , the result will depend on the concrete data source that you use. Note that you can also change the data source dynamically by reassigning the .data_source attribute in your FrontEnd instance.

You’ve learned a lot about the five SOLID principles , including how to identify code that violates them and how to refactor the code in adherence to best design practices. You saw good and bad examples related to each principle and learned that applying the SOLID principles can help you improve your object-oriented design in Python.

In this tutorial, you’ve learned how to:

• Identify class designs that violate some of the SOLID principles in Python
• Use the SOLID principles to help you refactor Python code and improve its OOD

With this knowledge, you have a strong foundation of well-established best practices that you should apply when designing your classes and their relationships in Python. By applying these principles, you can create code that’s more maintainable, extensible, scalable, and testable.

🐍 Python Tricks 💌

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About Leodanis Pozo Ramos

Leodanis is an industrial engineer who loves Python and software development. He's a self-taught Python developer with 6+ years of experience. He's an avid technical writer with a growing number of articles published on Real Python and other sites.

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

What Do You Think?

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal . Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session . Happy Pythoning!

Keep Learning

Related Topics: intermediate best-practices python

Recommended Video Course: Design and Guidance: Object-Oriented Programming in Python

Keep reading Real Python by creating a free account or signing in:

Already have an account? Sign-In

Almost there! Complete this form and click the button below to gain instant access:

SOLID Principles: Improve Object-Oriented Design in Python (Sample Code)

🔒 No spam. We take your privacy seriously.

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Printing Simple Diamond Pattern in Python

I would like to print the following pattern in Python 3.5 (I'm new to coding):

But I only know how to print the following using the code below, but not sure how to invert it to make it a complete diamond:

Any help would be appreciated!

• Consider that every line you print is a combination of spaces and asterisks (in your example, first line is 4 spaces, 1 asterisk, second line is 3 spaces, 3 astersisks, etc). All you have to do is to find out how many spaces and asterisks should be there on each line. –  Pavel Gurkov Commented Sep 17, 2016 at 14:52
• How can I print the spaces? –  Ali R. Commented Sep 17, 2016 at 15:05
• 2 The exact same way you print asterisks. –  Pavel Gurkov Commented Sep 17, 2016 at 15:07
• Never mind! I was using ("") instead of (" ")! I'll try to do it now and update you if it works out! –  Ali R. Commented Sep 17, 2016 at 15:09

19 Answers 19

Since the middle and largest row of stars has 9 stars, you should make n equal to 9. You were able to print out half of the diamond, but now you have to try to make a function that prints a specific number of spaces, then a specific number of stars. So try to develop a pattern with the number of spaces and stars in each row,

So what can you deduce? From row 1 to (n+1)/2, the number of spaces decreases as the number of stars increase. So from 1 to 5, the # of stars = ( row number * 2) - 1, while # of spaces before stars = 5 - row number .

Now from row (n+1)/2 + 1 to row 9, the number of spaces increase while the number of stars decrease. So from 6 to n, the # of stars = ((n+1 - row number ) * 2) - 1, while # of spaces before stars = row number - 5.

From this information, you should be able to make a program that looks like this,

Note that you can replace n with any odd number to create a perfect diamond of that many lines.

• Another way to look at it is this way (below), but it is similar to the half diamond where n is for row 1 to the maximum asterisks, and not to the total number of rows. This way it eliminates the odd shape when using even numbers. I looked at the way you explained it and tried to come up with another method instead of having division, and following a strategy similar to the half diamond. for b1 in range (n): for b2 in range (n-b1): print(" ", end="") for b3 in range ((b1*2)-1): print("*", end="") print() –  Ali R. Commented Sep 17, 2016 at 15:47
• Of course, your repeat again for for b1 in range(n,0,-1) –  Ali R. Commented Sep 17, 2016 at 15:52

Here is a solution base on height equals to top to the middle, or half of the height. For example, height is entered as 4(7) or 5(9) below. This method will yield odd number actual height

Here is another solution base on height equals to top to the bottom, or the actual total height. For example, height is entered as 7 or 9 below. When the user enters an even number for height, the diamond will be slightly slanted.

• 4 There is no need to use eval , use int instead. –  sanyassh Commented Feb 28, 2019 at 15:41
• @sanyassh because eval is a security risk, I edited the code instead in accordance with your suggestion. –  Karl Knechtel Commented Nov 14, 2021 at 10:55

I learned a very simple solution today and would like to share it. :)

The logic is the following: (A space is represented as "0" here.)

The result would be the following:

As pointed out by Martin Evans in his post: https://stackoverflow.com/a/32613884/4779556 a possible solution to the diamond pattern could be:

side = int(input("Please input side length of diamond: ")) for x in list(range(side)) + list(reversed(range(side-1))): print('{: <{w1}}{:*<{w2}}'.format('', '', w1=side-x-1, w2=x*2+1))

• As I said I'm new to Python, I haven't learned that method yet and only know some commands. –  Ali R. Commented Sep 17, 2016 at 15:41
• 1 @Ali R - this is a beginner's solution and it's easier than the one above. The curly brackets in the print statement look complicated, but they're actually simple once you learn them. –  Shaken_not_stirred. Commented Sep 7, 2018 at 9:36

Simplest Answer

Hope this helps some one

Another possibility. Depending on which (space or star) one uses, (I used space) convert it to absolute value. This implementation doesn't require splitting the diamond into two loops (upper and lower halves).

There are two version of this

Space between Stars

Without Space between Stars

if you want both upper part and down side to be same change the count += 2 to count += 1

• While this code may answer the question, providing additional context regarding why and/or how this code answers the question improves its long-term value. –  Alex Riabov Commented Jul 25, 2018 at 15:43

simple way ...

Or using reverse method, first one is diamond, second one is series of diamond

Here is a simple code using f-string formatting language

Not the answer you're looking for? Browse other questions tagged python or ask your own question .

• The Overflow Blog
• The hidden cost of speed
• The creator of Jenkins discusses CI/CD and balancing business with open source
• Featured on Meta
• Announcing a change to the data-dump process
• Bringing clarity to status tag usage on meta sites
• What does a new user need in a homepage experience on Stack Overflow?
• Feedback requested: How do you use tag hover descriptions for curating and do...
• Staging Ground Reviewer Motivation

Hot Network Questions

• What should I do if my student has quarrel with my collaborator
• An error in formula proposed by Riley et al to calculate the sample size
• What should I consider when hiring a graphic designer to digitize my scientific plots?
• How to clean a female disconnect connector
• Default umask for NFS user nobody
• How to Interpret Statistically Non-Significant Estimates and Rule Out Large Effects?
• I'm not quite sure I understand this daily puzzle on Lichess (9/6/24)
• What`s this? (Found among circulating tumor cells)
• A seven letter *
• Star Trek: The Next Generation episode that talks about life and death
• Sylvester primes
• Why does this theta function value yield such a good Riemann sum approximation?
• Why would op-amp shoot up to positive rail during power on?
• Does the average income in the US drop by $9,500 if you exclude the ten richest Americans?
• What's the radius of Mars over Mount Olympus?
• Is there a problem known to have no fastest algorithm, up to polynomials?
• What does "dare not" mean in a literary context?
• How was this character killed in Deadpool and Wolverine?
• Can I Use A Server In International Waters To Provide Illegal Content Without Getting Arrested?
• I'm a little embarrassed by the research of one of my recommenders
• How would you format to be cleaner and explain the steps better? Do I have any no no's in my latex?
• Gravitational potential energy of a water column
• Why didn't Air Force Ones have camouflage?
• Can you equip or unequip a weapon before or after a Bonus Action?

• How it works
• Homework answers

Answer to Question #176600 in Python for adhi chinna

Sandglass Star

Given an integer N, write a program to print the sandglass star pattern, similar to the pattern shown below.

The input will be a single line containing a positive integer (N).Output

The output should contain the asterisk(*) characters in the sandglass star pattern.

Note: There is a space after each asterisk(*) character.Explanation

For example, if the given number is 5, the pattern should contain 9 rows and 9 columns as shown below.

Need a fast expert's response?

and get a quick answer at the best price

for any assignment or question with DETAILED EXPLANATIONS !

Dear Navya post a new task

please help in solving below programs. 1.Alphabetic Symbol Write a program to print the right alphabetic triangle up to the given N rows. Input The input will be a single line containing a positive integer (N). Output The output should be N rows with letters. Note: There is a space after each letter. Explanation For example, if the given number of rows is 4, your code should print the following pattern.

Leave a comment

Ask your question, related questions.

• 1. ADASSIGNMENT - 2DESCRIPTIONHINTS & SOLUTIONSUBMISSIONSDISCUSSHollow DiamondGiven the number of r
• 2. Sum of Non-PrimesWrite a program to print the sum of non-primes in the given N numbers. The numbers
• 3. Given a string in camel case, write a python program to convert the given string from camel case to
• 4. Right TriangleGiven a number N, write a program to print a triangular pattern of N lines with number
• 5. Alphabetic SymbolWrite a program to print the right alphabetic triangle up to the given N rows.Input
• 6. One ColorGiven a string of length N, made up of only uppercase characters 'R' and 'G&
• 7. Special CharactersWrite a program to count Vowels and Consonants in string.InputThe input will be a
• Programming
• Engineering

Who Can Help Me with My Assignment

There are three certainties in this world: Death, Taxes and Homework Assignments. No matter where you study, and no matter…

How to Finish Assignments When You Can’t

Crunch time is coming, deadlines need to be met, essays need to be submitted, and tests should be studied for.…

How to Effectively Study for a Math Test

Numbers and figures are an essential part of our world, necessary for almost everything we do every day. As important…

• DSA Tutorial
• Data Structures
• Linked List
• Dynamic Programming
• Binary Tree
• Binary Search Tree
• Divide & Conquer
• Mathematical
• Backtracking
• Branch and Bound
• Pattern Searching

Program to print the arrow pattern

Given the value of n, print the arrow pattern. Examples :    

Below is the program to print the arrow pattern:  

Output:    

Time Complexity: O(n 2 )

Auxiliary Space: O(1) Another method:    

Time Complexity: O(N 2 )

Auxiliary Space: O(1)  

Please Login to comment...

Similar reads.

• Basic Coding Problems
• pattern-printing
• Best Twitch Extensions for 2024: Top Tools for Viewers and Streamers
• Discord Emojis List 2024: Copy and Paste
• Best Adblockers for Twitch TV: Enjoy Ad-Free Streaming in 2024
• PS4 vs. PS5: Which PlayStation Should You Buy in 2024?
• 15 Most Important Aptitude Topics For Placements [2024]

Improve your Coding Skills with Practice

What kind of Experience do you want to share?