Python Literals: Brilliant Fundamentals to Master in 2024

Python literals are nothing but the notation for constant values of some in-built data types. As per google, in computer programming language, a literal is a notation for representing a fixed value in source code.

String Python Literals

• Following are valid string literals:
  ‘Mumbai’
  “Delhi”
  “Your’s faithfully”
  ‘He is “very” good’
  ”’He is “very” good”’
  a=’good\
  morning’
  ‘Good\nMorning\nWorld’

Formatting String Literals

• Formatting needs to prefix string with ‘f’ or ‘F’.
• It may contain replacement fields or expression delimited by curly brackets { }
• Formatting is evaluated at run time.
• In formatting, escape sequences are decoded.
• Double curly braces {{ or }} are replaces with single curly brace.
• Conversions are introduced with exclamation point ‘!’
• Format specifiers are introduced with colon ‘:’
• Triple quoted strings cannot contain comments.
• Replacement expression is evaluated in the context where the formatted string literals appears in order from left to right.
• On the result, ‘!s’ calls str(), ‘!r’ calls repr() and ‘!a’ calls asci()

Examples of String Literal Formatting:

city = "Mumbai"
message = f"He is living in {city}"
print(message)

Output:
'He is living in Mumbai'

value = 123.456789
width = 10
precision = 3
formatted_value = f"The value is {value:{width}.{precision}}"
print(formatted_value)

Output:
'The value is 1.23e+02'

value = 123.456789
width = 10
precision = 4
formatted_value = f"The value is {value:{width}.{precision}}"
print(formatted_value)

Output:
'The value is 123.5'

from datetime import date
bd = date(year=1972, month=10, day=4)
formatted_bd = f"Date of birth is {bd:%B %d, %Y}"
print(formatted_bd)

Output:
'Date of birth is October 04,1972'

a=22/7
print(a)

Output:
3.142857142857143

a = 12.3456  # Define 'a' with a value
formatted_a = '{:0.2f}'.format(a)
print(formatted_a)

Output: 
12.35

a = 3.14159265  # Define 'a' with the value of Pi
formatted_string = 'Value of Pi is {:0.2f}'.format(a)
print(formatted_string)

Output: Value of Pi is 3.14

a = 3.14159265  # Define 'a' with the value of Pi
formatted_string = f'Value of Pi is {a:0.2f}'
print(formatted_string)

Output:'Value of Pi is 3.14'

Numeric Python Literals

• Numeric literals are of three types:
  1) Integer literals
  2) Floating point literals
  3) Imaginary literals
• Note that there are no complex literals in Python.
• Numeric literals do not include sign.

1) Integer Literals

• This includes decimal, binary, octal and hexadecimal numbers.
• Decimal includes digits 0 to 9.
• Octal includes digits 0 to 7.
• Hexadecimal includes digits 0 to 9 and alphabets a…f and A…F
• There is no limit for the length of integer literals.
• We can use underscore(_) in number to increase readability and for grouping digits but are ignored in value.(not allowed in version 3.6)
• Leading zeros in non-zero decimal number are not allowed.

Examples of Integer Python Literals:

print(12345)

Output: 12345

print(12_568)

Output: 12568

print(0x123)

Output:291

print(0o50)

Output: 40

print(0b1011001)

Output: 89

2) Floating Point Literal

• Base of floating point numbers is always 10.
• Like in integer literals, underscore(_) is also allowed in floating point literal for grouping digits. (not allowed in version 3.6).

Example of Floating Point Python Literals:

print(123.456)

Output: 123.456

print(12_34.56_78)

Output:1234.5678

print(1_234.56_78)

Output: 1234.5678

print(0.00001)

Output: 1e-05

print(0.002)

Output: 0.002

print(1.23e3)

Output:1230.0

print(1.23e-3)

Output: 0.00123

print(0e0)

Output:0.0

print(100)

Output: 100.0

print(77e05)

Output:7700000.0

3) Imaginary Literal

• Imaginary literals are used to represent imaginary part of complex number.
• An imaginary literals is a complex number with real part 0.0
• Imaginary literals may be any of integer literal or floating point literal with character j or J.
• There must not be any white space between number and character j or J.

Example of Imaginary Python Literals:

print(1.23j)

Output: 1.23j

print(5J)

Output: 5j

print(0.02j)

Output: 0.02j

print(.01j)

Output:0.01j

print(1.23e3j)

Output: 1230j

print(1_234.12_34J)

Output:1234.1234j

print(123.111e-4j)

Output: 0.0123111j

Boolean Literal

• In Python, there are two boolean literals: true and false.
• These literals represent the values 1 and 0, respectively.
• In the below example, ‘a’ is true because it is equal to 1, while ‘b’ is false.

Example of Boolean Python Literals:

a=(1==True)
b=(1==False)
c=True+3

print("a is", a)
print("b is", b)
print("c:",c)

Output:
a is True
b is False
c:4