Trending December 2023 # Import Module In Python With Examples # Suggested January 2024 # Top 19 Popular

You are reading the article Import Module In Python With Examples 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 Import Module In Python With Examples

What are the modules in Python?

A module is a file with python code. The code can be in the form of variables, functions, or class defined. The filename becomes the module name.

For example, if your filename is chúng tôi the module name will be guru99. With module functionality, you can break your code into different files instead of writing everything inside one file.

In this tutorial, you will learn:

What is the Python import module?

A file is considered as a module in python. To use the module, you have to import it using the import keyword. The function or variables present inside the file can be used in another file by importing the module. This functionality is available in other languages, like typescript, JavaScript, java, ruby, etc.

How to create and import a module in Python?

Now we will create a module and import it in another file.

Here is the flow to create and import the module as shown in the screenshot:

Follow the steps given to create a module in python.

The folder structure used to test the code is as follows:

modtest/ test.py display.py

Step 1) Create a file and name it test.py

Step 2) Inside chúng tôi create a function called display_message()

Def display_message(): return "Welcome to Guru99 Tutorials!"

Step 3) Now create another file display.py.

Step 4) Inside chúng tôi import the chúng tôi file, as shown below:

import test

While importing, you don’t have to mention the chúng tôi but just the name of the file.

Step5)

Then you can call the function display_message() from chúng tôi inside chúng tôi you need to make use of module_name.function_name.

For example test.display_message().

Import test print(test.display_message())

Step 6)

When you execute chúng tôi you will get the following output:

Welcome to Guru99 Tutorials! Importing a Class in Python

Earlier, we have seen a simple module with a function. Here will create a class and refer the class inside another file.

The folder structure to test the code is as follows:

myproj/ Car.py display.py

Create a file called chúng tôi with the following code:

Filename : Car.py

class Car: brand_name = "BMW" model = "Z4" manu_year = "2023" def __init__(self, brand_name, model, manu_year): self.brand_name = brand_name self.model = model self.manu_year = manu_year def car_details(self): print("Car brand is ", self.brand_name) print("Car model is ", self.model) print("Car manufacture year is ", self.manu_year) def get_Car_brand(self): print("Car brand is ", self.brand_name) def get_Car_model(self): print("Car model is ", self.model)

In the file chúng tôi , there are attributes brand_name, model and manu_year. The functions defined inside the class are car_details(), get_Car_brand(), get_Car_model().

Let us now use the file chúng tôi as a module in another file called display.py.

Filename : display.py

import Car car_det = Car.Car("BMW","Z5", 2023) print(car_det.brand_name) print(car_det.car_details()) print(car_det.get_Car_brand()) print(car_det.get_Car_model())

Output:

BMW Car brand is BMW Car model is Z5 Car manufacture year is 2023 Car brand is BMW Car model is Z5

So we can access all the variables and functions from chúng tôi using Car module.

Using from to import module

You can import only a small part of the module i.e., only the required functions and variable names from the module instead of importing full code.

When you want only specific things to be imported, you can make use of “from” keyword to import what you want.

So the syntax is

from module import your function_name , variables,... etc.

The folder structure used to test the code is as follows:

modtest/ test.py display.py

In chúng tôi there are 2 functions as shown :

Filename : test.py

defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"

Now you want display_message() function. The function or variable that you are importing can be directly accessed as shown below:

File Name : display.py

from test import display_message print(display_message())

Output:

Welcome to Guru99 Tutorials!

Now if you happen to use the function display_message1() ,it will throw an error that the function is not defined as shown below:

from test import display_message print(display_message1())

Output:

Traceback (most recent call last): print(display_message1()) Name Error: name 'display_message1' is not defined Importing everything from the module

Import allows you to import the full module by using import followed by module name, i.e., the filename or the library to be used.

Syntax:

Import module

Or by using

from module import *

The folder structure used to test the code is as follows:

modtest/ test.py display.py

Following are the code details inside test.py

my_name = "Guru99" my_address = "Mumbai" defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!" Using the import module

Using just import module name, to refer to the variables and functions inside the module, it has to prefix with module name.

Example

Filename : display.py

Import test print(test.display_message()) print(test.display_message1()) print(test.my_name) print(test.my_address)

The module name test is used to refer to the function and variables inside module test.

Output:

Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai Using import *

Let us see an example using import *. Using import *, the functions and variables are directly accessible, as shown in the example below:

from test import * print(display_message()) print(display_message1()) print(my_name) print(my_address)

Output:

Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai The dir( ) function

The dir() is a built-in-function in python. The dir() returns all the properties and methods, including the given object’s built-in properties.

So when dir() is used on the module, it will give you the variables, functions that are present inside the module.

Here is a working example of dir() on a module. We have a class called chúng tôi let us import Car and assign to dir() to see the output.

The folder structure to test the code will be as follows:

test prop/ Car.py test.py

Filename: Car.py

Filename: test.py

import Car class_contents = dir(Car) print(class_contents)

The output gives us the name of the class and all the functions defined in Car.py.

You can also try using dir() on a built-in module available in Python. Let us try the same on json module as shown in the example below. It will display all the properties and methods available in json module.

Import json json_details = dir(json) print(json_details)

Output:

['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__bu iltins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__pac kage__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_en coder', 'codecs', 'decoder', 'detect_encoding', 'dump', 'dumps', 'encoder', 'loa Packages

A package is a directory with all modules defined inside it. To make a Python interpreter treat it as a package, your directory should have the init.pyfile. The chúng tôi makes the directory as a package. Here is the layout of the package that we are going to work on.

The name of the package is my package. To start working with the package, create a directory called package/. Inside the directory, create an empty file called __init__.py. Create 3 more files chúng tôi chúng tôi and chúng tôi and define the functions as shown in the screenshot. Here are the details of module1.py,module2.py and module3.py

chúng tôi

def mod1_func1(): print("Welcome to Module1 function1") def mod1_func2(): print("Welcome to Module1 function2") def mod1_func3(): print("Welcome to Module1 function3")

chúng tôi

def mod2_func1(): print("Welcome to Module2 function1") def mod2_func2(): print("Welcome to Module2 function2") def mod2_func3(): print("Welcome to Module2 function3")

chúng tôi

def mod3_func1(): print("Welcome to Module3 function1") def mod3_func2(): print("Welcome to Module3 function2") def mod3_func3(): print("Welcome to Module3 function3")

The packages ready for use. Now call the package inside any of your file as shown below :test.py:

Here, the mypackage.module1 is imported and given an alias name as mod1. Similarly, you can use other modules chúng tôi and chúng tôi from my package.

import mypackage.module1 as mod1 print(mod1.mod1_func1()) print(mod1.mod1_func2()) print(mod1.mod1_func2())

Output:

Welcome to Module1 function1 None Welcome to Module1 function2 None Welcome to Module1 function2 None

We have just demonstrated the package with a simple module with functions inside it. As per your project, you can also package with have sub-packages. Sub-folders/ having modules with classes defined.

Python Module Search Path

During execution, when python comes across import module name, the interpreter tries to locate the module. It searches the module in the build-in module list. Later in all, the directories defined inside sys.path.

To sum up, the interpreter does the following search to locate the module:

In your current directory.

In in the build-in module list

Inside the chúng tôi directories

You can get the details of chúng tôi by importing sys module and print the sys.path. It will give you the list of directories as shown below:

importsys print(sys.path)

Output:

['Python Latest\task2', 'Users\AppData\Local\Programs\Python Python37\python37.zip', 'Users\AppData\Local\Programs\Python\P ython37\DLLs']

You can also modify the path and keep the directories as per your requirements.

Using module alias in the import

You can also convert the module name to a shorter form by giving an alias name to it. The alias can be done using the keyword.

Syntax:

import filename as alias name

The folder structure to test the code will be as follows:

Mod test/ test.py display.py

Following is the code inside test.py

my_name = "Guru99" my_address = "Mumbai" def display_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"

Now will use an alias for chúng tôi in display.py

Import test as t print(t.display_message()) print(t.display_message1()) print(t.my_name) print(t.my_address)

The alias that is used for test module is t . So the function and variables from chúng tôi can be referred using the alias t.

Output:

Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai Absolute and Relative Imports in Python

You now know how to import a file as a module inside another file. Let us now see how to manage the files available in folders. The files in the folders can be imported either by using absolute or relative imports.

Consider you have your project folder structure, as shown below:

The root folder is my project/. It has two subfolders package1 and package2.

The folder package1 has two modules, chúng tôi and module2.py.

The folder package2 has one class chúng tôi a sub-package subpkg with chúng tôi and last module4.py.

In chúng tôi there is a functioncalledmyfunc1.

In chúng tôi there is a functioncalledmyfunc2.

In chúng tôi there is a functioncalledmyfunc3.

In chúng tôi there is a functioncalledmyfunc4.

Using Absolute Imports

For Absolute imports, you need to add the entire path of your module right from the project root folder.

Let us now see how to make use of absolute imports to refer to the functions present in each of the module.

To work with the functionmyfunc1, you will need to import as follows:

from package1.module1 import myfunc1 or from package1 import module1 module1.myfunc1()

To work with the function myfunc3 you will need to import as follows:

from package1.subpkg.module3 import myfunc3 or from package1.subpkg import module3 module3.myfunc3()

It becomes easy to trace back the modules for code check.

Easy to use and very straightforward.

If the project is moved to a different path, still the imports will remain the same.

The import path can get very long in-case, the modules are nested, and if the name of the modules is lengthy.

Using Relative Imports

Considering the same folder structure mentioned below, we will see how to import the same using relative imports.

In relative import, the module to be imported is relative to the current location that is the location where the import statement is present.

Syntax:

In relative imports, you need to add a period (.) before the module name when importing using from.

It will be 2 periods (..) before the module name if the module is in the one level up from the current location.

Referring to the folder structure figure mentioned above, we have the following modules with their function, which we need to refer to.

In chúng tôi there is a functioncalledmyfunc1.

In chúng tôi there is a functioncalledmyfunc2.

In chúng tôi there is a functioncalledmyfunc3.

In chúng tôi there is a functioncalledmyfunc4.

To work with the functionmyfunc1 you will need to import as follows:

from .module1 import myfunc1

To work with the function myfunc3, you will need to import as follows:

from .subpkg.module3 import myfunc3 Advantages of Relative Imports

Advantages:

It is easy to work with relative imports.

From the current location, the imports can be shortened in comparison to absolute imports.

Using relative imports, it is difficult to trace back where the code resides

Summary:

Import in Python helps you to refer to the code, i.e., .functions/objects that are written in another file. It is also used to import python libraries/packages that are installed using pip(python package manager), and you need then to use in your code.

Import functionality is available in other languages like typescript, JavaScript, java, ruby, etc.

A module is python is the code written inside the file, for example (test.py). Inside your file, you can have your variables, functions, or your class defined. The entire file becomes a module and can be imported inside another file to refer to the code.

With module functionality, you can break your code into different files instead of writing everything inside one file. Later, using import, you can refer to the code inside the file you need.

Python has its built-in modules, and also external libraries/packages installed using a python package manager (pip), e.g., pandas, NumPy, etc. are referred to as modules.

You can import only a small part of the module, i.e., only the required functions and variable names from the module instead of importing full code.

You can also convert the module name to a shorter form by giving an alias name to it. The alias can be done using the keyword.

A package is a directory with all modules defined inside it. To make a Python interpreter treat it as a package, your directory should have the __init.pyfile. The chúng tôi makes the directory as a package. Here is the layout of the package that we are going to work on.

For Absolute imports, you need to add the entire path of your module right from the project root folder.

In relative import, the module to be imported is relative to the current location that is the location where the import statement is present.

You're reading Import Module In Python With Examples

How To Use The Subprocess Module In Python?

Understanding Process –

When you code and execute a program on Windows, MAC or Linux, your Operating System creates a process(single).It uses system resources like CPU, RAM, Disk space and also data structures in the operating system’s kernel. A process is isolated from other processes—it can’t see what other processes are doing or interfere with them.

Note: This code has to be run on Linux like sytems. When executed on windows might throw exceptions.

Goals of Operating System –

The main twin goals of OS are to spread the work of the process fairly and be responsive to the user. These are acheived by keeping a track of all the running processes, giving each a little time to run and then switching to another. You can see the state of your processes with graphical interfaces such as the Task Manager on Windows-based computers, the Mac’s Activity Monitor (macOS),or the top command in Linux.

Being a programmer, we can access the process data from our own program. But How? Simply by using standard library OS module. I will show you few examples.

# This script works only on linux/unix import os print(f" *** Process ID - {os.getpid()}") print(f" *** My User ID - {os.getuid()} and My Group ID - {os.getgid()} ") print(f" *** Current Working Directory is - {os.getcwd()}")

Running and spinning up a new system process can be quite useful to developers and system administrators who want to automate specific operating system tasks.

Python has a subprocess module, which can spin a new processes, send and receive information from the processes, and also handle error and return codes.

The official Python documentation recommends the subprocess module for accessing system commands.

The subprocess call() function waits for the called command to finish reading the output. We will see couple of examples below to extract the systems disk space information.

Below code will execute df -h command and captures the information. The output is then captured to a pandas dataframe for any further processing.

Example # python code to create a subprocess for extracting disk space on linux using df -h from io import StringIO import pandas as pd import subprocess import ast diskspace = "df" diskspace_arg = "-h" sp = subprocess.Popen([diskspace,diskspace_arg], stdout=subprocess.PIPE) df = pd.read_csv(b, sep=",") Filesystem Size Used Avail Use% Mounted on 0 devtmpfs 7.8G 0 7.8G 0% /dev 1 tmpfs 7.8G 0 7.8G 0% /dev/shm 2 tmpfs 7.8G 33M 7.8G 1% /run 3 tmpfs 7.8G 0 7.8G 0% /sys/fs/... 4 /dev/xvda2 20G 16G 4.3G 79% / 5 /dev/xvdb 246G 16G 218G 7% /tdm 6 tmpfs 1.6G 0 1.6G 0% /run/use...

To get a more detailed output with subprocess see below code.

Example from io import StringIO import pandas as pd import subprocess def uname_func(): uname = "uname" uname_arg = "-a" user_info = subprocess.call([uname, uname_arg]) return user_info def disk_func(): diskspace = "pydf" diskspace_arg = "-a" discinfo_df = diskspace stdout = subprocess.check_output([diskspace, diskspace_arg]) return stdout def main(): userinfo = uname_func() discinfo = disk_func() print("Displaying values now... ") # print(stdout.decode('utf-8')) print(discinfo.decode('utf-8')) print(type(discinfo.decode('utf-8'))) content = discinfo.decode('utf-8').split("n") print(content) main() Output Linux ip-00-000-00-000.xxxxxxxxxxxx 0.00.0-000.el7.x86_64 #1 SMP Tue Aug 18 14:50:17 EDT 2023 x86_64 x86_64 x86_64 GNU/Linux Displaying values now... Filesystem Size Used Avail Use% Mounted on /dev/xvda2 20G 16G 4318M 78.9 [#####.] / devtmpfs 7918M 0 7918M 0.0 [......] /dev hugetlbfs 0 0 0 - [......] /dev/hugepages mqueue 0 0 0 - [......] /dev/mqueue devpts 0 0 0 - [......] /dev/pts tmpfs 7942M 0 7942M 0.0 [......] /dev/shm proc 0 0 0 - [......] /proc binfmt_misc 0 0 0 - [......] /proc/sys/fs/binfmt_misc tmpfs 7942M 32M 7909M 0.4 [......] /run tmpfs 1588M 0 1588M 0.0 [......] /run/user/1000 sysfs 0 0 0 - [......] /sys tmpfs 7942M 0 7942M 0.0 [......] /sys/fs/cgroup cgroup 0 0 0 - [......] /sys/fs/cgroup/blkio cgroup 0 0 0 - [......] /sys/fs/cgroup/cpu,cpuacct cgroup 0 0 0 - [......] /sys/fs/cgroup/cpuset cgroup 0 0 0 - [......] /sys/fs/cgroup/devices cgroup 0 0 0 - [......] /sys/fs/cgroup/freezer cgroup 0 0 0 - [......] /sys/fs/cgroup/hugetlb cgroup 0 0 0 - [......] /sys/fs/cgroup/memory cgroup 0 0 0 - [......] /sys/fs/cgroup/net_cls,net_prio cgroup 0 0 0 - [......] /sys/fs/cgroup/perf_event cgroup 0 0 0 - [......] /sys/fs/cgroup/pids cgroup 0 0 0 - [......] /sys/fs/cgroup/systemd pstore 0 0 0 - [......] /sys/fs/pstore configfs 0 0 0 - [......] /sys/kernel/config debugfs 0 0 0 - [......] /sys/kernel/debug securityfs 0 0 0 - [......] /sys/kernel/security /dev/xvdb 246G 16G 218G 6.4 [......] /tdm

Python Maximum/Minimum Integer Value (With Examples)

In Python, you can use sys.maxsize from the sys module to get the maximum and minimum integer values.

The sys.maxsize gives you the maximum integer value and its negative version -sys.maxsize - 1 gives you the minimum integer value.

import sys # Get the maximum integer value max_int = sys.maxsize # Get the minimum integer value min_int = -sys.maxsize - 1 # Print the values print(f"The maximum integer value is {max_int}") print(f"The minimum integer value is {min_int}")

Notice that Python 3.0+ doesn’t limit the int data type and there’s no maximum/minimum value. But to get the practical maximum integer value for a single integer word in your operating system, use sys.maxsize as shown above.

This guide teaches you how to get the maximum and minimum integer values in Python.

You will understand why maximum and minimum integer values exist in the first place. You’ll also learn how to get the maximum/minimum integer values in Python versions earlier than 3.0 as well as Python 3.0+. Besides, you’ll learn how to get the maximum/minimum integers in NumPy.

Let’s jump into it!

Integer Value Extrema

Computer memory is limited. A typical operating system uses a 32-bit or 64-bit system for representing numbers. This means there are 2³² or 2⁶⁴ numbers the system can represent.

Notice that the maximum/minimum integer size restriction is not a Python-only thing as it depends on the capabilities of the device, not the programming language.

Let’s take a closer look at what limits the size of an integer in general.

Why Is There a Maximum/Minimum for Integers?

A maximum integer is the maximum number that a binary store can hold. Many operating systems use 32 bits for storage. This means you have to fit any number that you want to use in those 32 bits.

A bit is a binary digit whose value is either 0 or 1. If you form a line of these bits, you can get a number of different combinations of 0s and 1s.

For example, if you have 2 bits, you have 2² = 4 possible combinations:

And for N bits, you have 2^N possible combinations.

A computer that uses 32 bits to represent numbers has a total number of 2³² = 4,294,967,296 possible combinations. This means the computer can represent 2³² numbers in total such that each combination of bits corresponds to a number in the decimal number system.

But as you know, you don’t only have positive numbers but also negatives and zero. But bits don’t understand negative signs. Instead, a computer can use 1 as a negative sign and 0 as a positive sign.

In a 32-bit sequence, this means that the sign is denoted by the left-most bit (1 for negative, 0 for positive values). Because one bit is used as a sign, it leaves 31 bits for representing the actual numbers.

This means the biggest integer in a 32-bit system is 0 followed by 31 1’s. In other words, 2³⁰ + 2²⁹ + … + 2² + 2¹ + 2⁰. This is 2³¹ – 1 or 2,147,483,647. So you can count from 0 to 2,147,483,647 using this type of 32-bit signed integer system.

When it comes to negative values, the idea is exactly the same. The smallest negative value is 1 followed by 31 1’s, that is, 2³⁰ + 2²⁹ + … + 2² + 2¹ + 2⁰. As a negative value, this is -2,147,483,647. But remember, because the 0 value is already included in the range of countable positive numbers, we start counting the negative values from -1 instead of 0. This means the smallest possible negative value in the 32-bit signed integer system is actually one less than -2,147,483,647, that is, -2,147,483,648.

And if the computer uses 64 bits for storing numbers, the idea is the same.

The maximum value of a 64-bit signed integer is 2⁶³ – 1 = 9,223,372,036,854,775,807 and the minimum value is -(2⁶³ – 1) – 1 = -9,223,372,036,854,775,808.

To take home, the maximum and minimum values for integers in programming languages are determined by the amount of memory that is allocated for storing them and the type of integer that is being used. These values are important because they determine the range of values that an integer variable can store, and they can affect the precision and accuracy of calculations that involve integers.

Python Maximum Integer Value

To obtain the maximum value of the integer data type, use the sys.maxsize.

import sys # Get the max integer value max_int = sys.maxsize print(f"The maximum integer value is {max_int}") Python Minimum Integer Value

To obtain the minimum value of the integer data type, use the negative sys.maxsize value and subtract 1 from it to account for 0 being in the positive value range.

import sys # Get the min integer value min_int = -sys.maxsize - 1 print(f"The minimum integer value is {min_int}") Python 3+ ‘int’ Type Has No Limits!

As of Python 3, the int type is unbound. This means there’s no limit to how big a number you can represent using the int type.

Back in Python versions earlier than 3.0, the int type was bound to be between [-2⁶³, 2⁶³ – 1]. If you wanted to use a number larger or smaller than what is in the range, you’d have to use the long data type. As a matter of fact, a conversion from int to long takes place automatically.

As an example, let’s try printing some large numbers in Python 2 where the int type was still bounded:

print(9223372036854775807) print(9223372036854775808)

Output:

9223372036854775807 9223372036854775808L

Notice the ‘L’ at the end of the second number. Because 9223372036854775808 is bigger than the maximum int value, it automatically became a long which Python denotes by adding ‘L’ to the end.

But in Python 3, the int type is unbounded. Essentially, what was long in Python 2 is now int in Python 3+. Besides, the ‘L’ letter is no longer added to the end of big integers!

Let’s repeat the previous example in Python 3:

print(9223372036854775807) print(9223372036854775808)

Output:

9223372036854775807 9223372036854775808

Even though there’s no limit to how big an integer can be in Python, the sys.maxsize gives you the upper bound for practical lists or strings. The maximum value works as a sentinel value in algorithms, so even though it’s not a hard limit in Python integers, it indicates the maximum word size used to represent integers behind the scenes.

If this makes no sense, let’s see what happens if you try to use an integer larger than sys.maxsize to access a list element:

l = [1,2,3,4,5,6] value = l[10000000000000000000000000000000000]

Output:

Traceback (most recent call last): IndexError: cannot fit 'int' into an index-sized integer

The error says that the integer index you’re using to access the list elements is too big to be an index. This happens because of the limitations of your operating system. A Python index must still be an integer bounded by the 32-bit or 64-bit limits.

So even though the int is unbounded in Python, the underlying operating system still uses either 32 or 64 bits to represent numbers.

Thanks for reading. Happy coding!

Python String %S — What Does It Mean? (With Examples)

Python string with %s is an old string formatting technique.

The %s is placed into a string and it acts as a placeholder for another string variable.

For example:

name = "John" print("Hello, %s" % name)

Output:

Hello, John

However, as more modern string formatting techniques have been added to Python, you rarely see this in use. And you should not use it either!

But let’s have a quick look at how string formatting works using the % operator. Then let’s take a look at the more modern approaches you can use.

Python String Formatting with Percent (%) Operator

Python supports multiple ways to format strings. One of which is the % operator approach. This string formatting originates from C programming. It is one of the original built-in string formatting mechanisms in Python.

To format strings using this approach, place a % operator followed by a character that describes the type of the variable into a string.

For example, to embed a string into another:

name = "John" print("Hello, %s" % name)

Output:

Hello, John Formatting Different Types with % in Python

%s is not the only formatting option when it comes to formatting strings with the % operator in Python.

Here is a full list of all the possible string formatting placeholders using % in Python:

# %c — a placeholder for single character char = "A" sentence = "The first letter in alphabetics is %c" % char # %s — a string placeholder name = "John" sentence = "My name is %s" % name # %i, %d — Placeholders for signed decimal integers number = 10 sentence = "Number %i is my favorite number" % number # %u — Placeholder for an unsigned decimal integer s_int = -10 u_int = -10 + (1 << 32) sentence = "This is an example of unsigned integer: %u" % u_int # %o — a placeholder for an octal integer num = 15 sentence = "Number %i is %o as an octal number" % (num, num) # %x — a placeholder for a hexadecimal integer (in lowercase characters) num = 255 sentence = "Number %i is %x in hexadecimal" % (num, num) # %X - a placeholder for a hexadecimal integer (in uppercase characters) num = 255 sentence = "Number %i is %X in hexadecimal" % (num, num) # %e - a placeholder for exponential notation with lowercase 'e' num = 1324314234 sentence = "Number %i is %e in exponential notation" % (num, num) # %E - a placeholder for exponential notation with lowercase 'E' num = 1324314234 sentence = "Number %i is %E in exponential notation" % (num, num) # %f - a placeholder for price = 5.99 sentence = "The price is %f" % price # %g - a placeholder that does the same as %f and %e above num = 140014653546 sentence = "Number %i is %g in exponential notation" % (num, num) price = 11.99 sentence = "The price is %g" % price # %G - a placeholder that does the same as %f and %E above num = 999834234 sentence = "Number %i is %G in exponential notation" % (num, num) price = 2.39 sentence = "The price is %G" % price A Modern Way to Format Python Strings—Avoid % in Python

Instead of using the old-school approach % to format strings, it is recommended to use one of the two more modern approaches.

Format() Method in Python

As of Python 3.0, it’s been possible to format strings using the format() method.

For example:

age = 50 sentence = "My age is {}".format(age) print(sentence)

Output:

My age is 50

This is already a way more elegant approach to formatting strings in Python than using the % approach.

But as of Python 3.6, there is an even better alternative called F-strings.

F-strings in Python

An even more elegant string formatting approach was introduced in Python 3.6. This is called the F-strings approach.

Instead of having to call format() or use confusing % signs, you can use an f in front of a string and embed the variables in a really intuitive way.

For example:

age = 50 sentence = f"My age is {age}" print(sentence)

Output:

My age is 50 Conclusion

Python string %s means string formatting where a string variable is placed inside another string.

Thanks for reading.

Happy coding!

Working And Examples Of Numpy Axis Function In Python

Introduction to NumPy axis

Web development, programming languages, Software testing & others

Syntax:

NumPy.function(arrayname, axis = 0/1)

Where NumPy.function is any function on which the axis function must be applied, arrayname is the name of the array on which the NumPy.function must be performed along the axis specified by axis function whose value can be either 0 or 1.

Working of axis function in NumPy

The directions along the rows and columns in a two-dimensional array are called axes in NumPy.

The direction along the rows is axis 0 and is the first axis that runs down the rows in multi-dimensional arrays.

The direction along the columns is axis 1 and is the second axis which runs across the columns in multi-dimensional arrays.

The axes in NumPy are numbered, beginning from zero.

One should always be alert on what parameters are passed to the axis function and how they impact the function on which they are used, and the axis function in NumPy can be used on several functions.

Examples

Different examples are mentioned below:

Example #1

Python program to demonstrate NumPy axis function to create an array using array function and find the sum of the elements of the array along the axis = 0 and along the axis = 1:

#we are importing the package NumPy as num import numpy as num #creating a two dimensional array using array function and storing it in a avariable called array1 array1 = num.array([[1,2,3],[4,5,6]]) #displaying the elements of newly created array print("The elements of the newly created array are:") print(array1) #using axis function on the newly created array along with sum function to find the sum of the elements of the array along the axis = 0 arraysum = num.sum(array1, axis = 0) print("n") #displaying the sum of the elements of the array along the axis = 0 print("The sum of the elements of the newly created array along the axis = 0 are:") print(arraysum) print("n") #using axis function on the newly created array along with sum function to find the sum of the elements of the array along the axis = 1 arraysum1 = num.sum(array1, axis = 1) #displaying the sum of the elements of the array along the axis = 1 print("The sum of the elements of the newly created array along the axis = 1 are:") print(arraysum1)

Output:

In the above program, the package NumPy is imported as num to be able to make use of array function, sum function, and axis function. Then a two-dimensional array is created using the array function and stored in a variable called array1. Then the elements of the array array1 are displayed. Then sum function is used on the array array1 to find the sum of the elements of the array along axis = 0, and the result is displayed as the output on the screen; then again sum function is used on the array array2 to find the sun of the elements of the array along axis = 1 and the result is displayed as the output on the screen. The output is shown in the snapshot above.

Example #2

Python program to demonstrate NumPy axis function to create an array using array function and find the sum of the elements of the array along the axis = 0 and along the axis = 1:

#we are importing the package NumPy as num import numpy as num #creating a two dimensional array using array function and storing it in a avariable called array1 array1 = num.array([[5,4,3],[2,1,0]]) #displaying the elements of newly created array print("The elements of the newly created array are:") print(array1) #using axis function on the newly created array along with sum function to find the sum of the elements of the array along the axis = 0 arraysum = num.sum(array1, axis = 0) print("n") #displaying the sum of the elements of the array along the axis = 0 print("The sum of the elements of the newly created array along the axis = 0 are:") print(arraysum) print("n") #using axis function on the newly created array along with sum function to find the sum of the elements of the array along the axis = 1 arraysum1 = num.sum(array1, axis = 1) #displaying the sum of the elements of the array along the axis = 1 print("The sum of the elements of the newly created array along the axis = 1 are:") print(arraysum1)

Output:

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.