Trending December 2023 # Guide To How To Declare And Initialize Variables In Sql # Suggested January 2024 # Top 19 Popular

You are reading the article Guide To How To Declare And Initialize Variables In Sql updated in December 2023 on the website Bellydancehcm.com. We hope that the information we have shared is helpful to you. If you find the content interesting and meaningful, please share it with your friends and continue to follow and support us for the latest updates. Suggested January 2024 Guide To How To Declare And Initialize Variables In Sql

Introduction to SQL Variables

Variables in standard query language (SQL) are named locations in the memory which are used by the SQL query or program to manipulate the data. These named memory locations act as placeholders for the value of the variable. The size of the memory location depends upon the data type of variable. We can have multiple types of variables in SQL based on the data type of the data that it can hold such as varchar, text, int, numeric, date, timestamp, etc.

Start Your Free Data Science Course

Hadoop, Data Science, Statistics & others

How to declare and initialize variables in SQL?

Initialization and declaration of variables in SQL differ slightly based on the SQL database management server you are using. For example, a variable declaration starts with @ for user-defined variables and @@ for system-defined variables in SQL Server and MS SQL whereas in PL/PgSQL the declaration does not involve such symbols. For more information and syntax, you can refer to the documentation of respective database management servers. In this exercise, we will be working on postgreSQL or pgSQL.

Here are some examples of variable declarations.

DECLARE counter INTEGER ; student_name VARCHAR(50) ; email VARCHAR(225)';

Next, initialization is specifying an initial value for the variable. We can do it while declaring the variable as well as later on while using the variable.

When we initialize a variable during the declaration, it looks like something as shown below.

DECLARE counter INTEGER := 101 ; student_name VARCHAR(50) := 'Radhika Sharma' ; email VARCHAR(225)' := '[email protected]';

The entire code snippet for variable declaration and initialization in pgSQL looks something as shown below.

DO $$ DECLARE counter INTEGER := 101 ; student_name VARCHAR(255) := 'Radhika Sharma'; email VARCHAR(225) := '[email protected]'; BEGIN RAISE NOTICE 'The student name for counter 101 is : %', student_name; END $$;

In the above example, we made an inline function, where we have declared three variables namely,

counter with data type INTEGER with ‘101’ as the initial value

student_name with data type varchar or varying character with ‘Radhika Sharma’ as its initialization

the email with data type varchar or varying character with ‘[email protected]’ as an initial value

Examples of SQL Variables

Let’s discuss more examples to understand variable declaration, initialization, and working across some frequently used data types.

Example #1

Working with variables of integer data type

In this example, we have declared three variables x, y, and z, and initialized the former two. We have tried to assign z the result of x and y ‘s subtraction. The code snippet for the same looks as shown below.

Code:

DO $$ DECLARE x integer := 30; y integer := 20; z integer; BEGIN z := x - y; RAISE NOTICE 'Value of z: %', z; END $$;

Output:

Example #2

Working with variables of DATE and TIME data types

Code:

DO $$ DECLARE created_date DATE := NOW(); BEGIN RAISE NOTICE 'This program was created on %', created_date; END $$;

Output:

In this particular example, we have declared a variable of DATE data type and initialized it with current time using the built-in NOW() function. Let’s see some variations of the same.

Code:

DO $$ DECLARE created_at TIME := NOW(); process_date DATE := '2023-04-30'; BEGIN RAISE NOTICE 'This program was created at % and will be processed on %',created_at, process_date; END $$;

Output:

In the above illustration, we have created the ‘created_at’ variable of the TIME data type. It is different from the date in the manner that it gives a timestamp without the date. Next, we have a ‘process_date’ variable which has an initialized date.

Example #3

Working with variables of NUMERIC data types

Most of the SQL database management servers provide for a variety of numeric data types. The most commonly used numeric data types are SMALLINT, INTEGER, BIGINT, REAL, DOUBLE PRECISION, and NUMERIC(p,s). The first three of the mentioned data types can only hold integer values. We have already discussed integers in example 1. In this section, we will discuss REAL, PRECISION, and NUMERIC(p,s) data types.

Code:

DO $$ DECLARE x float := 40; y real := 3; z numeric(11,2); BEGIN z := x / y; RAISE NOTICE 'Value of z: %', z; END $$;

Output:

Example #4

Copying data type of a column to a variable

Some SQL databases allow us to copy the data type of a column in the database table to a variable.

The syntax for the same in postgreSQL is as follows :

variable_name table_name.column_name%TYPE;

For illustration purposes consider the “product_details” table with columns like product_id, product_name, variations, price, etc.

Here, we want to copy the data type of column_name product_name to a variable called “new_product”.

Code:

DO $$ DECLARE new_product product_details.product_name%type := 'Books'; BEGIN RAISE NOTICE 'The recently added product in the store is %', new_product; END $$;

Output:

Conclusion

Variables in any programming language acts are specific memory locations that act as placeholders for its actual value. This is true for SQL variables also. The size of the memory location depends upon the data type of the value that the particular variable can hold.

Top 10 Mistakes To Avoid In Sql Query

This article was published as a part of the Data Science Blogathon.

Introduction

We all make mistakes and learn from them. It is a good practice to make mistakes but not repeat them in the future. While learning, we often encounter mistakes and try to resolve them, but at the beginning, we need guidance on which process to follow and which not to follow.

This article will describe all the common mistakes we can avoid by practicing SQL often and how to resolve them.

Top SQL Mistakes to Avoid

Explanation of Data

SalesId: This column represents the sales ID of a particular product.

SalesAmount: This column represents the sales amount of that particular product.

SalesDate: This column represent when that sale was made with respect to date.

Let’s discuss some of the most common mistakes we do and see how to improve them for the proper execution.

One of the crucial points that should not be ignored at any cost is the order of execution of a particular query. The order needs to be in the below format, or the output won’t be the desired one, and sometimes it even creates an error in the query.

Getting the Data (From, Join)

Filtering the Row (Where)

Grouping (Group by)

Group Filter (Having)

Return Expressions (Select)

Order & Paging (Order by & Limit / Offset)

Save yourself the trouble by planning and executing the command for the big queries. The last thing you want to do is execute a big query with too many nested loops.

Always make a habit of planning and structuring the query format and even testing out the query with the sample data.

Choose the right data type

In general, selecting the right data type for each column in the table is crucial. However, it is possible that an overflow can happen and the situation might not look pretty. Also, data type conversion will increase the query execution time, so it is a good habit to try to avoid data type conversions in your query if possible.

Never use Select *

Using the select * query for all the columns in the data elevates the execution time period of the query, and it is an expensive operation for humongous data. Not to use select * is mainly for performance and security reasons. For the following example.

# Wrong way SELECT * FROM Sales

The proper way for output is to select the relevant columns from the output table and select the relevant columns from table. For the following example.

# Optimal way SELECT SalesID, SalesAmount FROM Sales

For example, if we want to get the sales id from the sales table, then we should select only the SalesID column instead of selecting all the columns using select *, which will help to execute the query fast. The above statement query defines each column, and it also limits the size of every record.

Don’t Use the Distinct

The Distinct statement finds the unique rows corresponding to the selected columns by dropping duplicated rows from the table. The distinct clause is a cumbersome operation with the time in SQL, but we have an easy option for the problem.

# Wrong Way SELECT count(distinct SalesID) FROM Sales

We can use group by instead of distinct in SQL query to make the process faster and smoother. For example, the below queries find the count unique SalesID from the Sales details table.

# Optimal Way SELECT count(*) FROM (SELECT SalesID FROM Sales group by SalesID) Preview your Result

Imagine running a massive query, a computationally heavy query that returns Millions (M) of rows, only to realize at the end that we are calculating the wrong way and it is not the desired output.

# Wrong Way SELECT SalesID, SalesAmount FROM Sales

To resolve this problem, we use TOP / LIMIT to preview the result first to ensure we have desired results and are not wasting our time on the problem.

# Optimial Way SELECT TOP 100 SalesID, SalesAmount FROM Sales Don’t use Having

We mostly use having clause to apply a filter on the aggregated columns having operations such as (sum, min, max, etc.) created using the group by operation. But sometimes, we use the ‘having’ clause instead of the ‘where’ clause to filter out the data from the table. For example, using having query.

# Wrong way SELECT count(SalesId), SalesAmount, SalesDate FROM Sales group by SalesDate having EmployeeID = 5

For example, to find the total sales by the total employees having employee id 5, let’s do while using group by for the result.

# Optimial Way SELECT count(SalesId), SalesAmount, SalesDate FROM Sales where EmployeeID = 5 group by SalesDate Be careful of Joins

For assumptions, there can be multiple departments in sales with no employees. Let’s write a query to find the count of the number of employees in a particular department.

SELECT s.SalesName, COUNT(*) as EmployeeCnt FROM SalesID s LEFT JOIN dept_emp de ON d.dept_no = de.dept_no GROUP BY d.dept_name

Notice that if we hadn’t done a left outer join on Dept_emp, it would’ve excluded the departments with no employees because there are no records with that dept_no in Dept_emp. On the other hand, if you don’t want to include those ghost departments in your result, then doing a left join would be redundant and wasteful.

Use

EXISTS

() Instead of COUNT()

Know the correct operator Precedence

The order of precedence matters a lot while executing the query when we have more than one table which is joined with the join operation or any other operation. If we do not follow the order of precedence from the operator, we will not get the desired output as the query reading will be different. For example, we want to get the details of every employee having their first name “Ana” or “Joey”, with each having a salary of at least $10,000.

The correct query would look like this.

SELECT e.emp_no, e.first_name, e.last_name, s.salary FROM employees e JOIN salaries s ON e.emp_no = s.emp_no WHERE (e.first_name = "Ana" OR e.first_name = "Joey")

Because without the parentheses in the query, AND operators would be executed first. Then the result will be all the Ana, regardless of salaries, and all the Joey who make at least $10,000.

We saw how we can make silly mistakes while writing the query through the article.

We saw how to avoid this problem using the proper order of SQL query.

Moreover, we need to use the correct parentheses in the query as it determines the format.

Well, sometimes, we might forget how we need to write the SQL query for the required question. For example, while writing a query for joins misplace the query format or even not use the proper join format query.

We even saw some simple query alternatives for a faster and better approach.

The media shown in this article is not owned by Analytics Vidhya and is used at the Author’s discretion.

How To Format Text In Photoshop (Complete Guide)

Learning how to format text in Photoshop is one of the most essential skills for graphic design work in the program. After all, what good is it to create a piece of text if you don’t know how to format it as you want? Luckily, learning how to do this is very simple.

So in this tutorial, I will walk you through not only the Character Panel but also ways to format text with the Type Tool and the Paragraph Panel as well.

Understanding The Paragraph & The Character Panels In Photoshop

The Type Tool, Paragraph panel, and Character panel are the most important Photoshop functions when using text.

All three functions offer great formatting features to help ensure a professional typographic design in Photoshop. It’s good to know what each function offers.

The Options Bar

I want to first discuss the Options Bar. This is the first port of call after selecting the Type Tool (T). There are minimal text formatting options here, but they might come in handy.

When the Type Tool is selected, the Options Bar will display various settings at the top of your Photoshop window.

There are dropdown menus for font choice and font styles, a font size menu, paragraph alignment options, and a color swatch.

All of the settings in the Options Bar are also available, along with more, within the Character and Paragraph panels.

The Paragraph Panel

The Paragraph panel is used for formatting paragraph text. This is best for adjusting large amounts of body text to fit into your design.

When enabled, the Paragraph panel button appears on the vertical toolbar on the right-hand side of the workspace, alongside other panels that you can choose to display, making it easy to hide or show when needed.

Within the Paragraph panel, there are the three alignment options for left, center, and right like the ones found in the Options Bar. Next to those are four justification options to justify text: left, center, right, and all.

The other settings in the Paragraph panel are for setting left and right margins and indents, adding spaces before or after paragraphs, and adding hyphenation for long words. Each of these settings helps you present your text in ways to best fit the space provided while retaining readability and a professional standard.

The Character Panel

The Character panel is similar to the Paragraph panel, only its tools focus on settings for the characters within the text rather than the text as a whole.

Some of the tools in the Character panel are similar to those found in the Options Bar. Standard type settings like font type, font style, font size, and color are found in both.

But there are some tools that you can only find in the Character panel, and they can be helpful with formatting your text, such as leading, kerning, and tracking, as well as vertical and horizontal scaling tools.

You’ll also find some extra font styles like bold, italics, underline, strikethrough, and superscript to add some style to your text. Under the font styles are further stylish offerings of ligatures — if the font includes them — as well as a language tool to avoid spelling errors.

How To Align Text In Photoshop

Text alignment sets which edge the text always starts from and is usually based on how the language is read — for example, English is read left-to-right, so most text is left-aligned to allow for easier reading.

As I’ve previously mentioned, you can find the three alignment options in both the Options Bar when the Type Tool is selected as well as any time you open the Paragraph panel.

Align Text Using The Options Bar

To set the alignment using the Options bar, select the Type Tool (T).

Then in the Options Bar, select one of the three alignment options — right, center, or left-aligned — to align your text.

Standard alignment for most English text is aligned flush left and ragged right.

Align Text Using The Paragraph Panel

You can also use the Paragraph panel to align text. The benefit of using this instead of the Options Bar is that you can open the Paragraph panel even when using another tool, which is helpful if you need to make a quick change and then carry on with the previous tool.

First, in the Layers panel, select your text layer. If you have multiple text layers, you can select all the text layers you wish to apply the same alignment to.

The direction aligns the text flush to the chosen side giving the other side a ragged edge.

The center-aligned text has a ragged edge on both edges.

Justify Text Using The Paragraph Panel

Next to the alignment options are the justification options which are different from alignment. Justified text horizontally fills the text box which gives flush text on both sides. To ensure both sides of text have flush edges, unlike the ragged edge that comes from using non-justified text, extra gaps may appear in between words.

The left, right, or center-justified text options only move the last line — known as the orphan or widow — of text to either direction.

How To Center Text To Objects In Photoshop

You can center your texts to objects or the canvas itself, to create a center-balanced design. Whether your object is a shape, image, or even another text box, it’s easy to center it to your text.

This technique is best done with point text rather than paragraph text; using paragraph text will center from the text box, which may not be the center of your text itself. Using point text will center on the true center of the text.

I will show you how to center text to an object; I’m using the Ellipse tool (U) for my shape.

Then select the Move Tool (V) which will bring up alignment options in the Options Bar.

You can also align the text or an image to the center of the canvas in the same way as long as you select the Background layer in the Layers panel along with the other layer you want to align.

How To Indent Paragraphs In Photoshop

Using the Paragraph panel, you can format indents and margins to your written paragraphs. These are an important part of layout design and are very easy to implement.

In the Paragraph panel, change the indent setting to set a paragraph indent, which moves the first line of text inwards.

To create separate paragraphs, press Enter on your keyboard and the indent will appear at the beginning of all paragraphs. You can also set a specific spacing above paragraphs by changing the point value.

How To Edit Character & Line Spacing In Photoshop

You can use the Character panel to edit spacing between text including individual characters or whole words. There are three main ways to edit spacing: kerning, tracking, and leading. Changing any of these three adds to the finer details of your text formatting, so what are these settings for?

What Is Kerning?

Kerning determines the space between individual letters in a word. Sometimes the gaps between letters in a standard font look unnaturally large or small which negatively affects the readability of a word. You can see the inconsistent spacing between the letters d, i, and p in my example below.

In the Character panel, adjust the kerning settings up or down until you’re satisfied.

The result after kerning is often subtle, but it can make a huge difference in the finer details of text formatting.

What Is Tracking?

Tracking determines an entire word’s spacing, rather than individual spaces. Sometimes adjusting the tracking can help with fitting words into a small space without changing the font size.

Adjusting the tracking rather than the font size keeps your design elements balanced and saves you from having to redesign your text.

Tracking is, again, found in the Character panel.

To apply tracking, highlight the word you wish to affect. You can apply tracking to letter groups, full words, or groups of words. Whatever is highlighted will be affected.

I set the tracking to -50, which has decreased the spacing of the highlighted word. Now it’s narrow enough that it fits at the end of the previous line. You can use tracking as an artistic effect with tight or loose spacing or for functional uses, like my example.

What Is Leading?

Leading determines the spaces between lines of text. When writing a paragraph, you may need more or less space between lines for better readability or design style.

You can change the leading to affect all the lines or you can highlight an individual line to increase or decrease the space above it. Leading only affects the space above the highlighted line, not the space below it.

The Leading setting is found in the Character panel above tracking.

Default leading is set to auto for any given font. But if your paragraph has multiple font sizes, you’ll have to manually change the leading.

Leading values are the same as font-size values. The dropdown menu has a list of point sizes.

Highlight any lines of text you wish to change the spacing between, and choose a leading value in the dropdown menu.

Guide To How To Implement Array_Agg()

Introduction to PostgreSQL ARRAY_AGG()

The PostgreSQL provides various aggregate functions; the PostgreSQL ARRAY_AGG() aggregate function is used to get an array with each value of the input set added to an array element. This aggregate Function accepts a set of values as input, and the Function includes NULL values into the array while concatenating the input values. We use the ORDER BY clause with this aggregate Function in order to sort the result.

Start Your Free Data Science Course

Hadoop, Data Science, Statistics & others

Consider the following syntax of the PostgreSQL ARRAY_AGG() aggregate Function:

ARRAY_AGG(): The PostgreSQL ARRAY_AGG() aggregate Function takes the number of values as an input and then returns an array.

ORDER BY: This is an optional clause. This clause is used when we want the results sorted, which are processed in the aggregation, which results to sort the elements in the result array.

Examples to Implement PostgreSQL ARRAY_AGG()

We will create two tables of name ‘student’ and ‘department’ by using the CREATE TABLE statement as follows to understand the examples:

create table student ( stud_id serial PRIMARY KEY, stud_fname VARCHAR(80) NOT NULL, stud_lname VARCHAR(80) NOT NULL, department_id int NOT NULL ); create table department ( department_id serial PRIMARY KEY, department_name VARCHAR(80) NOT NULL );

We will insert data into the department table using the INSERT INTO statement as follows.

INSERT INTO department(department_name) VALUES ('Computer'), ('Electrical'), ('IT'), ('Civil'), ('Chemical'), ('Mechanical');

Illustrate the result of the above INSERT INTO statement by using the following SQL statement and snapshot.

Code:

select * from department;

Output:

We will insert some data into the student table using the INSERT INTO statement as follows.

INSERT INTO student(stud_fname, stud_lname, department_id) VALUES ('Smith','Johnson',1), ('Williams','Jones',1), ('Harper','James',2), ('Jack','Liam',2), ('Harry','Mason',3), ('Jacob','Oscar',3), ('Michael','Charlie',4), ('William','Joe',4), ('Oliver','John',5), ('Jack','Richard',5), ('Harry','Joseph',5), ('George','Thomas',6), ('Brown','Charles',6);

Illustrate the result of the above INSERT INTO statement by using the following SQL statement and snapshot.

Code:

select * from student;

Output:

Example #1

Without ORDER BY clause in PostgreSQL ARRAY_AGG, () aggregate Function Consider the following SQL statement, which will use the Function to return the list of names of the department and the list of names of the students studying in each department:

Code:

SELECT department_name, FROM department INNER JOIN student USING (department_id) GROUP BY department_name ORDER BY Department_name;

Illustrate the result of the above SQL statement by using the following snapshot.

From the above example, we can see that each department’s students are randomly ordered; to sort the students by their last name or first name, we have to define the ORDER BY clause in this Function.

Example #2

ORDER BY clause with PostgreSQL ARRAY_AGG() aggregate Function

Consider the following example to get the list of students for each department, which is sorted by the student’s first name as shown in the following SQL statement:

Code:

SELECT department_name, ARRAY_AGG ( ORDER BY stud_fname ) students FROM department INNER JOIN student USING (department_id) GROUP BY department_name ORDER BY department_name;

Example #3

ORDER BY clause with PostgreSQL ARRAY_AGG() aggregate Function

Consider the following example to sort the list of students for each department by student’s first and last name, as shown in the following SQL statement:

Code:

SELECT department_name, ARRAY_AGG ( ORDER BY stud_fname ASC, stud_lname DESC ) student FROM department INNER JOIN student USING (department_id) GROUP BY department_name ORDER BY department_name;

Illustrate the result of the above SQL statement by using the following snapshot.

Conclusion

From the above article, we hope you understand how to use the PostgreSQL ARRAY_AGG() aggregate Function and how the aggregate Function works. Also, we have added several examples of aggregate functions to understand them in detail.

Usage And Different Examples Of Sql Max()

Introduction to SQL MAX()

SQL MAX() is one of the aggregate functions available in SQL that helps us fetch the greatest value among multiple values specified in the column values of records, the expression consisting of the column that is mentioned. When a query is used to retrieve the data that report related and contains a group by a statement, the MAX() function is used to get the greatest value of a particular column or columns based on the grouping function.

Start Your Free Data Science Course

Hadoop, Data Science, Statistics & others

Syntax and Usage

The syntax of the MAX function in SQL is given below:

SELECT MAX(expression) FROM table_name [WHERE restriction];

Where expression can be any name of the column of the table or a formula built up using column names and static literal values or variables, the table_name is the name of the table from which you want to retrieve the records and calculate the greatest value from one of their columns. The use of the FROM table name clause is required. One optional thing is the use of a where clause to mention the conditions and restrictions that the records of the table should fulfil to consider that record’s column value for fetching the greatest value.

Examples of SQL MAX()

Given below are the examples of SQL MAX():

Example #1 – Using a single column.

Let us firstly consider a simple example that we used above. We will calculate the greatest value of SQL numbers using the MAX() function. Let us create one simple table named numbers and store the num column value in it.

We will use the following query statement to create our table.

Code:

CREATE TABLE numbers (num INT) ;

Now, we will insert the above records in the table.

Code:

INSERT INTO numbers(num) VALUES (50), (100), (150), (200);

Let us now retrieve the records once.

Code:

SELECT * FROM numbers ;

Output:

Now, we will calculate the greatest of num column of numbers table using MAX() function using the following query statement.

Code:

SELECT MAX(num) FROM numbers ;

Output:

Example #2 – Using the distinct function.

We can use the distinct function in MAX() function to consider the column’s repetitive values only once while fetching the greatest value. Suppose that we insert some more records in the numbers table using the following query statement.

Code:

INSERT INTO numbers(num) VALUES (350), (800), (150), (300),(450), (100), (250); select * from numbers;

If we use SELECT MAX(num) FROM numbers; statement to calculate the greatest value of num column, then each of the values will be considered while fetching the greatest value.

Code:

SELECT MAX(DISTINCT(num)) FROM numbers ;

The output will be the same as that of the first query without a distinct function but internally the calculation of greatest value by MAX() function will only consider the column values that are repeated such as 100 and 150 only once.

The output of both of the above queries is as shown below.

Output:

Example #3 – Using formula.

We can use the MAX() function expressions to consider the value evaluated by fetching each of the formula or expression values containing column value to calculate the greatest value.

Let us consider one example; we will calculate the greatest of all the columns after they are multiplied by 10 and added by 1.

Code:

SELECT MAX((num * 10) + 1) FROM numbers ;

Output:

We can even use the existing functions such as SUM() and COUNT() inside the MAX() function.

Example #4 – Using group by.

When we have complex tables and relations between multiple tables, we have to query those tables using joins to retrieve data, usually for reporting purposes that consist of summarized data. Even in some scenarios, the data from a single table need to be manipulated to get summarized data. Suppose that we have one table named workers consisting of the following records in it that are retrieved by executing a simple select query on that table.

Code:

SELECT * FROM workers;

Output:

Now, the situation is such that we have to calculate the greatest salary of the workers per team. The output should consist of the team id and the greatest salary of that team. For this, we will have to use the group by statement and group the records based on team id and calculate the greatest salary by using MAX() function.

Code:

SELECT team_id, MAX(salary) FROM workers GROUP BY team_id ;

The execution of the above query statement will give the following output along with team ids and their respective greatest salaries.

Output:

Conclusion

We can use the MAX() function in SQL to fetch the greatest value of the columns of the tables or greatest of expressions that involve column values and even calculate the greatest value of columns in the grouped manner using the GROUP BY statement.

How To Call Functions In Python: A Complete Guide (Examples)

To call a function in Python, add parenthesis after the function name.

For example, if you have a function called greet, you can call it by:

greet()

And if the function takes arguments, specify them inside the parenthesis:

greet("Nick")

Let’s take a deeper dive into functions and how to call them in Python. More specifically, we are going to take a look at how to call functions:

With no arguments.

With arguments.

With keyword arguments.

With any number of arguments.

With any number of keyword arguments.

From another file.

1. How to call a function without arguments in Python

This is a basic example of how to call a function in Python.

A function that takes no arguments can be called by adding parenthesis after the name of the function.

For example, let’s create a function greet.

def greet(): print("Hello world!")

And now you can call the function by:

greet()

This results in the following output to the console:

Hello world! 2. How to call a function with arguments in Python

It is common for a function to accept an argument or arguments to work with.

To call a function that takes arguments, specify the arguments inside the parenthesis when calling the function.

For example, let’s create a function that accepts one argument:

def greet(name): print("Hello,", name)

And let’s call this function:

greet("Nick")

This results in the following output to the console:

Hello, Nick

Let’s also demonstrate functions that take more than one argument:

def greet(firstname, lastname): print("Hello,", firstname, lastname)

Now you can call the function by:

greet("Nick", "Jones")

This produces the following output:

Hello, Nick Jones 3. How to call a function with keyword arguments in Python

Python functions can accept two types of arguments:

Positional arguments

Keyword arguments

When it comes to positional arguments, order matters.

For example, in the previous example, the function took two positional arguments:

def greet(firstname, lastname): print("Hello,", firstname, lastname)

The function expects these arguments to be in the right order. The first argument should be the first name and the last argument should be the last name.

However, if you pass the arguments as keyword arguments, you may swap their order freely.

A keyword argument is an argument where you name the argument you pass into a function.

Let’s call the greet function from the previous example by providing it with the arguments as keyword arguments:

greet(lastname="Jones", firstname="Nick")

Output:

Hello, Nick Jones

As you can see, using keywords allowed you to swap the order of the arguments.

4. How to call a function with any number of arguments in Python

Sometimes you don’t know how many arguments you want to pass into a function. Thus, it is possible to call a function with an arbitrary number of arguments.

To demonstrate, let’s create a function that accepts any number of arguments. To make this possible, the function argument needs to be preceded by an asterisk *:

def greet(*args): for name in args: print("Hello,", name)

Now you can call the function with any number of arguments

greet("Nick") greet("Matt", "Sophie", "Jon")

Output

Hello, Nick Hello, Matt Hello, Sophie Hello, Jon

You can also pass the arguments as an array. But if you do this, add the asterisk before the array to unpack the arguments for the function:

greet(*["Matt", "Sophie", "Jon"]) Hello, Matt Hello, Sophie Hello, Jon 5. How to call a function with any number of keyword arguments in Python

You may not know how many keyword arguments to pass into a function. But this is no problem. Python lets you design functions in such a way that you can pass any number of keyword arguments into it.

To demonstrate, let’s create a function that accepts any number of keyword arguments. To make this possible, the argument needs to be preceded by a double asterisk **:

def greet(**kwargs): for literal, name in kwargs.items(): print("Hello,", name)

Now you can call the function with any number of keyword arguments, and name the arguments however you like:

greet(name="Marie") greet(name="Jane", otherName="Ann")

Output:

Hello, Marie Hello, Jane Hello, Ann

You can also call this function by passing a dictionary as an argument. If you do this, remember to unpack the dictionary with the double-asterisk **:

greet(**{"name": "Jane", "otherName": "Ann"})

Output:

Hello, Jane Hello, Ann 6. How to call a function from another file in Python

To call a function from another Python file, you need to import the file and call the functions from it.

Here is an illustration where a function is called from another file:

Here, the sayHi function is imported from the chúng tôi file to the chúng tôi and called from there.

If you want to import a specific function from another file, you can specify the name of the function in the import statement as seen above.

But if you want to import all the functions from another file, use * in the import statement.

For example:

from somefile import * Conclusion

Today you learned how to call a function in Python.

To recap, functions allow for grouping useful code and logic into a reusable block of code. When you call a function in Python, you’re running the code inside the function.

In Python, you can call functions with:

No arguments.

Arguments.

Keyword arguments.

Any number of arguments.

Any number of keyword arguments.

Another file.

Thanks for reading. I hope you enjoy it.

Happy coding.