How Do You Print a Number in Python?

AvatarByBarbara Hernandez Python

Printing a number in Python is one of the fundamental skills every programmer learns when starting out with this versatile language. Whether you’re a complete beginner or brushing up on your coding basics, understanding how to display numbers on the screen is essential for debugging, data presentation, and creating interactive programs. Python’s simplicity and readability make it especially approachable for those eager to see immediate results from their code.

In Python, outputting numbers might seem straightforward, but there are several nuances and methods that can enhance how you present numerical data. From printing integers and floating-point numbers to formatting output for clarity and precision, the ways you can display numbers are both powerful and flexible. This foundational knowledge paves the way for more complex programming tasks, including data analysis, user input handling, and dynamic content generation.

As you dive deeper, you’ll discover how Python’s print functionality integrates seamlessly with other language features to make your programs more informative and user-friendly. Whether you’re writing simple scripts or developing larger applications, mastering the art of printing numbers effectively is a stepping stone toward becoming a confident Python programmer.

Using the print() Function for Numbers

In Python, the primary method to display numbers is the built-in `print()` function. This function converts the number into its string representation and outputs it to the console or terminal. The simplest usage involves passing the number directly as an argument:

“`python
print(42)
print(3.14159)
“`

This will display:

“`
42
3.14159
“`

The `print()` function can handle various numeric types, including integers, floating-point numbers, and complex numbers. When printing multiple values, separate them with commas, and Python inserts spaces between the outputs by default:

“`python
print(10, 20, 30)
“`

Output:

“`
10 20 30
“`

Formatting Numbers with print()

To control how numbers appear, Python offers several formatting techniques:

  • Using f-strings (Python 3.6+): Embed expressions inside string literals with `{}` braces.
  • Using the `format()` method: Format numbers with placeholders.
  • Using the `%` operator: An older style for string formatting.

Each method allows specifying precision, padding, and alignment.

Formatting Numbers Using f-Strings

F-strings provide a concise and readable way to format numbers. You embed the number inside curly braces `{}` prefixed by `f` before the string.

Examples:

“`python
pi = 3.1415926535
print(f”Pi rounded to 2 decimals: {pi:.2f}”)
print(f”Integer with leading zeros: {42:05d}”)
“`

Output:

“`
Pi rounded to 2 decimals: 3.14
Integer with leading zeros: 00042
“`

Key formatting options include:

  • `.nf` – floating-point number rounded to `n` decimals.
  • `0nd` – integer padded with zeros to width `n`.
  • Alignment options: `<` (left), `>` (right), `^` (center).

Using the format() Method to Print Numbers

The `format()` method offers similar formatting features and is compatible with earlier Python versions before 3.6. You use placeholders `{}` in the string and call `.format()` with the values.

Example:

“`python
number = 123.4567
print(“Formatted number: {:.3f}”.format(number))
print(“Padded number: {:08d}”.format(42))
“`

Output:

“`
Formatted number: 123.457
Padded number: 00000042
“`

Common format specifiers

Specifier Description Example Output
`d` Decimal integer `{:d}` `42`
`f` Floating-point number `{:.2f}` `3.14`
`e` Exponential notation `{:.2e}` `1.23e+02`
`b` Binary representation `{:b}` `101010`
`x` Hexadecimal (lowercase) `{:x}` `2a`
`X` Hexadecimal (uppercase) `{:X}` `2A`
`%` Percentage `{:.1%}` `12.3%`

Controlling Output with Multiple Arguments

The `print()` function accepts multiple arguments, separating them with commas. By default, it inserts a space between each argument but you can customize this behavior with the `sep` parameter. Likewise, the end character can be changed with the `end` parameter.

Example:

“`python
a = 10
b = 20
print(a, b, sep=’ – ‘, end=’.\n’)
“`

Output:

“`
10 – 20.
“`

  • `sep`: String inserted between values.
  • `end`: String appended after the last value (default is newline `\n`).

Printing Numbers in Different Bases

Python allows you to print numbers in binary, octal, and hexadecimal formats using built-in functions or format specifiers.

  • bin(): Converts an integer to a binary string.
  • oct(): Converts an integer to octal.
  • hex(): Converts an integer to hexadecimal.

Examples:

“`python
num = 255
print(bin(num)) Output: 0b11111111
print(oct(num)) Output: 0o377
print(hex(num)) Output: 0xff
“`

Alternatively, use format specifiers:

“`python
print(f”Binary: {num:b}”)
print(f”Octal: {num:o}”)
print(f”Hexadecimal: {num:x}”)
“`

Output:

“`
Binary: 11111111
Octal: 377
Hexadecimal: ff
“`

Printing Complex Numbers

Complex numbers in Python have real and imaginary parts and can be printed directly using `print()`:

“`python
c = 3 + 4j
print(c)
“`

Output:

“`
(3+4j)
“`

To format complex numbers with precision, access their `.real` and `.imag` attributes and format them separately:

“`python
print(f”Real part: {c.real:.2f}, Imaginary part: {c.imag:.2f}”)
“`

Output:

“`
Real part: 3.00, Imaginary part: 4.00
“`

Printing Large Numbers with Underscores

Python allows underscores in numeric literals for readability, which do not affect printing:

“`python
large_number = 1_000_000_000
print(large_number)
“`

Output:

“`
1000000000
“`

When printing, the underscores are removed, and the number displays as a continuous digit sequence.

Printing Numbers Using the print() Function

In Python, the print() function is the primary method for displaying output, including numbers. It can handle various numeric types such as integers, floats, and complex numbers effortlessly. The most straightforward way to print a number is to pass it directly to the print() function.

number = 42
print(number)

This will output:

42

Python automatically converts the number to its string representation before printing. This behavior applies to all numeric types:

Numeric Type Example Output
Integer print(123) 123
Float print(3.14159) 3.14159
Complex print(2+3j) (2+3j)

Formatting Numbers for Output

To control the appearance of numbers when printed, Python offers several formatting approaches. This is especially useful for floats where precision and alignment matter.

  • Using f-strings (formatted string literals): Introduced in Python 3.6, f-strings allow inline expressions and formatting specifications.
pi = 3.141592653589793
print(f"Pi rounded to 2 decimals: {pi:.2f}")

This outputs:

Pi rounded to 2 decimals: 3.14
  • Using the format() method: This method provides similar formatting capabilities compatible with earlier Python versions.
number = 7.856
print("Rounded number: {:.1f}".format(number))

Output:

Rounded number: 7.9
  • Old-style % formatting: Though less preferred today, it is still widely used in legacy code.
value = 123.456
print("Value: %.2f" % value)

Output:

Value: 123.46

Printing Numbers with Multiple Values and Separators

The print() function can accept multiple arguments, which it separates by default with a space. This is useful when printing multiple numbers or combining numbers with text.

a = 10
b = 20
print("Values are:", a, b)

Output:

Values are: 10 20

You can customize the separator between printed values using the sep parameter:

print(a, b, sep=", ")

Output:

10, 20

Similarly, the end parameter controls what is printed after all arguments. By default, it is a newline character:

print(a, end="; ")
print(b)

Output:

10; 20

Printing Numbers in Different Bases

Python allows printing numbers in various numeral systems, such as binary, octal, and hexadecimal. This is helpful for applications involving low-level data representation or debugging.

  • Binary: Use the bin() function or format specifier 'b'.
  • Octal: Use the oct() function or format specifier 'o'.
  • Hexadecimal: Use the hex() function or format specifier 'x' (lowercase) or 'X' (uppercase).
Number Function Output Format Specifier Example Output
42 bin(42) 0b101010 format(42, 'b') 101010
42 oct(42) 0o52 format(42, 'o') 52Expert Perspectives on Printing Numbers in Python

Dr. Elena Martinez (Senior Python Developer, TechCode Solutions). Understanding how to print a number in Python is fundamental for beginners. Using the built-in print() function allows seamless output of numeric values, and it supports various formatting options to display numbers precisely as needed.

Jason Lee (Software Engineer and Python Educator, CodeCraft Academy). When printing numbers in Python, it is crucial to recognize the difference between integers, floats, and formatted strings. Leveraging f-strings or the format() method enhances readability and control over the output, especially in complex applications.

Priya Nair (Data Scientist and Python Trainer, Data Insights Lab). Printing numbers effectively in Python is not only about displaying values but also about ensuring clarity in data representation. Utilizing Python’s print function with appropriate formatting techniques can significantly improve the interpretability of numerical data in reports and analyses.

Frequently Asked Questions (FAQs)

How do I print a number in Python?
Use the built-in `print()` function with the number as an argument, for example, `print(123)`.

Can I print multiple numbers in one statement?
Yes, separate numbers by commas inside the `print()` function, like `print(1, 2, 3)`, which outputs them separated by spaces.

How do I print a number along with text in Python?
Combine text and numbers by separating them with commas in `print()`, for example, `print("Number:", 5)`, or use formatted strings like `print(f"Number: {5}")`.

What is the difference between printing integers and floats?
Both are printed using `print()`, but floats display decimal points (e.g., `print(3.14)`), while integers do not (e.g., `print(3)`).

How can I format a number before printing it?
Use string formatting methods such as f-strings (`print(f"{number:.2f}")` for two decimal places) or the `format()` function to control number presentation.

Is it possible to print numbers without a newline at the end?
Yes, use the `end` parameter in `print()`, for example, `print(10, end=" ")` prints the number without moving to a new line.
Printing a number in Python is a fundamental task that can be accomplished easily using the built-in `print()` function. Whether dealing with integers, floating-point numbers, or complex numbers, Python’s `print()` function provides a straightforward way to display numeric values to the console. Understanding how to convert numbers to strings when necessary, and formatting output for readability, are essential skills for effective Python programming.

Key takeaways include the versatility of the `print()` function, which can handle multiple data types and expressions simultaneously. Additionally, Python offers advanced formatting options such as f-strings and the `format()` method, enabling developers to control the appearance of numeric output precisely. Mastery of these techniques enhances code clarity and user interaction, especially in applications requiring formatted numerical data.

In summary, printing numbers in Python is both simple and powerful. By leveraging the core `print()` function along with Python’s formatting capabilities, programmers can efficiently present numerical information in a clear and professional manner. This foundational knowledge supports broader programming tasks and contributes to writing clean, readable, and maintainable code.

Author Profile

Avatar
Barbara Hernandez
Barbara Hernandez is the brain behind A Girl Among Geeks a coding blog born from stubborn bugs, midnight learning, and a refusal to quit. With zero formal training and a browser full of error messages, she taught herself everything from loops to Linux. Her mission? Make tech less intimidating, one real answer at a time.

Barbara writes for the self-taught, the stuck, and the silently frustrated offering code clarity without the condescension. What started as her personal survival guide is now a go-to space for learners who just want to understand what the docs forgot to mention.

© 2025 A Girl Among Geeks