Data Types in Python: A complete Tutorial

Welcome to one of the most exciting parts of your Python journey – understanding data types! Think of data types as the different "flavors" of data Python can work with. Just like we use different containers for water, snacks, or books in real life, Python uses different data types to store and manage different kinds of information. Whether you're storing a person's name, counting the number of steps in your fitness tracker, checking if the light is on or off, or collecting a list of favorite movies – Python needs to know what kind of data it is dealing with to use it properly. In this tutorial, we're going to explore Python’s core data types: integers, floats, strings, booleans, and NoneType. We'll also get a sneak peek at collections like lists, tuples, sets, and dictionaries. To make this fun and interactive, you’ll not only learn the definitions but also play with real-life examples, short quizzes, and hands-on exercises that will make these concepts click. By the end of this section, you'll be confidently identifying and using Python's basic data types like a pro!

Python Basic Data Types

In Python, data types define the kind of value a variable can hold. Since Python is a dynamically-typed language, you don’t need to explicitly declare the type of variable; it automatically detects the data type based on the value assigned. Python supports several built-in data types that fall into different categories such as numeric, text, boolean, sequence, and mapping types. These types help Python manage memory efficiently and allow you to perform operations suitable for the data. Understanding these basic data types is crucial for mastering Python as they form the foundation of data processing, control flow, and manipulation in any Python program.

Integer Numbers

In Python, an integer represents a whole number — positive, negative, or zero — without a decimal point. They are one of the most commonly used data types, especially when counting, indexing, or looping. For example, if you are keeping track of a user's age or the number of items in a shopping cart, you would use integers.

>>> type(42)
<class 'int'>

In the following sections, you’ll learn the basics of how to create and work with integer numbers in Python.

>>> 50
50

>>> -12
-12

>>> 0
0

>>> 987654321987654321987654321987654321 + 1
987654321987654321987654321987654322

>>> 1_000_000
1000000

>>> 0b11
3

>>> 0o11
9

>>> 0x11
17

>>> type(0x11)
<class 'int'>

Integer Methods

In Python, integers (int) are objects, and they support a few useful methods. While not as many as lists or strings, these methods can help perform operations or conversions involving integer values.

(42).as_integer_ratio()  # Correct
42.as_integer_ratio()    # SyntaxError

signal = 0b11010110
set_bits = signal.bit_count()

if set_bits % 2 == 0:
    print("Even parity")
else:
    print("Odd parity")

int(x=0, base=10)

# Convert float to integer
print(int(10.5))       # Output: 10

# Convert string to integer
print(int("100"))      # Output: 100

# Convert binary to decimal
print(int("0b1010", 2)) # Output: 10

x = 3.14
y = 0.0
z = -15.75
scientific = 1.5e2  # Equivalent to 1.5 × 10^2 = 150.0

pi = 3.141_592_653_589

print(0.1 + 0.2)  # Output: 0.30000000000000004

abs((0.1 + 0.2) - 0.3) < 1e-9  # True

x = 0.75
print(x.as_integer_ratio())  # Output: (3, 4)

print(5.0.is_integer())    # True
print(5.1.is_integer())    # False

print(0.625.hex())  # '0x1.4p-1'
print(float.fromhex('0x1.4p-1'))  # 0.625

float(5)        # 5.0
float("3.14")   # 3.14
float("2.5e2")  # 250.0

price_input = input("Enter the product price: ")
price = float(price_input)
print("Total with tax:", price * 1.18)

Complex Numbers in Python

Python has built-in support for complex numbers, which are numbers with both a real part and an imaginary part. A complex number looks like this:

a + bj where:

• a is the real part (a float or integer)
• b is the imaginary part (a float or integer)
• j is used to indicate the imaginary part (just like i in mathematics)

# Example of a complex number
z = 4 + 5j
print(z)  # Output: (4+5j)

These are very useful in mathematics, physics, and engineering fields, especially when dealing with wave functions, electrical signals, etc.

# Another example
z1 = 3 + 2j
z2 = 1 - 7j
sum_result = z1 + z2
print("Sum:", sum_result)  # Output: (4-5j)

Complex Number Literals

A complex number literal is any value in the form of a + bj or a - bj. Python will automatically understand it as a complex number.

You can create them directly in the code:

# Complex literals
x = 2 + 3j
y = -1 - 4j
print(type(x))  # Output: <class 'complex'>

You can also perform operations like:

z1 = 3 + 4j
z2 = 1 + 2j
print(z1 + z2)  # Output: (4+6j)
print(z1 * z2)  # Output: (-5+10j)

Complex Number Methods

Python provides some useful methods and attributes to work with complex numbers:

• z.real - Returns the real part
• z.imag - Returns the imaginary part
• z.conjugate() - Returns the complex conjugate

z = 5 + 6j

print("Real part:", z.real)          # Output: 5.0
print("Imaginary part:", z.imag)    # Output: 6.0
print("Conjugate:", z.conjugate())  # Output: (5-6j)

This is particularly helpful in mathematical computations involving complex numbers.

The Built-in complex() Function

Python also provides a built-in function complex() to create complex numbers.

# Syntax:
# complex(real, imaginary)

a = complex(3, 4)
b = complex(2)  # Equivalent to 2 + 0j
c = complex(imag=5)  # Equivalent to 0 + 5j

print(a)  # Output: (3+4j)
print(b)  # Output: (2+0j)
print(c)  # Output: 5j

This is helpful when you're dealing with dynamically calculated real or imaginary parts in variables.

real_part = float(input("Enter real part: "))
imag_part = float(input("Enter imaginary part: "))
z = complex(real_part, imag_part)
print("Complex Number:", z)

Strings and Characters

In Python, a string is a sequence of characters enclosed within single quotes (') or double quotes ("). Strings are used to store text, such as names, messages, commands, or any textual data.

name = 'Ankit'
greeting = "Hello, world!"
print(name)
print(greeting)

Python treats both single and double quotes the same. You can even use triple quotes (''' or """) for multiline strings.

multiline = '''This is
a multiline
string'''
print(multiline)

Each string is an object of the str class and supports many useful methods for manipulation, analysis, and formatting.

Regular String Literals

Regular string literals are created using quotes. These strings can include letters, digits, symbols, and even whitespace characters.

text1 = 'Python'
text2 = "Learning is fun!"
print(text1 + " - " + text2)

Regular strings can span one line or use escape sequences (like \n, \t) to control formatting. These strings are mutable in terms of variable content, but the actual string value is immutable.

Escape Sequences in Strings

Escape sequences allow you to include special characters inside strings by prefixing them with a backslash (\).

• \n - Newline
• \t - Tab
• \\ - Backslash
• \' - Single quote
• \" - Double quote

quote = "He said, \"Python is awesome!\""
path = "C:\\Users\\Ankit\\Documents"
print(quote)
print(path)

These escape characters help you avoid syntax issues and display output correctly.

Raw String Literals

A raw string tells Python to ignore escape sequences and treat backslashes as literal characters. You create it by prefixing the string with r or R.

path = r"C:\Users\Ankit\Documents\NewFolder"
print(path)  # Output: C:\Users\Ankit\Documents\NewFolder

Raw strings are especially useful for regular expressions, file paths, and any time you want to avoid accidental escape sequences.

F-String Literals (Formatted Strings)

F-strings (available from Python 3.6+) allow you to embed expressions directly inside string literals using curly braces {}. You prefix the string with f.

name = "Ankit"
age = 25
greeting = f"My name is {name} and I am {age} years old."
print(greeting)

F-strings are clean, readable, and support any Python expression inside the {} block.

print(f"5 + 3 = {5 + 3}")

They are faster and preferred over older formatting techniques like % or str.format().

String Methods

Python strings support a wide range of built-in methods to modify and analyze text.

• .lower() – Converts to lowercase
• .upper() – Converts to uppercase
• .strip() – Removes leading/trailing whitespace
• .replace() – Replaces a substring
• .split() – Splits string by delimiter
• .join() – Joins elements into a string
• .find() – Finds index of substring

text = "  Hello, Python!  "
print(text.strip())          # "Hello, Python!"
print(text.lower())          # "  hello, python!  "
print(text.replace("Python", "World"))  # "  Hello, World!  "

Common Sequence Operations on Strings

Since strings are sequences, you can use operations like indexing, slicing, iteration, length, etc.

text = "Python"

# Indexing
print(text[0])     # P
print(text[-1])    # n

# Slicing
print(text[1:4])   # yth

# Length
print(len(text))   # 6

# Iteration
for char in text:
    print(char)

Strings are immutable, meaning you can’t change a character directly (you must create a new string).

The Built-in str() and repr() Functions

The str() function converts a value to a user-friendly string, while repr() gives a string that’s more for developers (often with quotes and escape characters).

num = 100
text = str(num)
debug = repr("Hello\nWorld")

print(text)   # 100
print(debug)  # 'Hello\nWorld'

Use str() when you want readable output (for end users), and repr() when you want accurate, debug-friendly output (for developers).

b1 = b"Hello"
b2 = b'Python Bytes'

# Create empty bytes
b = bytes()
print(b)  # Output: b''

# Create from integer
b = bytes(4)
print(b)  # Output: b'\x00\x00\x00\x00'

# Create from list of integers (0–255)
b = bytes([65, 66, 67])
print(b)  # Output: b'ABC'

ba = bytearray([65, 66, 67])
print(ba)  # Output: bytearray(b'ABC')

# Modify
ba[0] = 68
print(ba)  # Output: bytearray(b'DBC')

b = b'Hello World'
print(b.hex())            # Output: 48656c6c6f20576f726c64
print(b.decode())         # Output: Hello World
print(b.startswith(b'He')) # Output: True
print(b.find(b'o'))       # Output: 4

x = True
y = False

print(type(x))  # Output: <class 'bool'>

print(True + True)   # Output: 2
print(False + True)  # Output: 1

print(bool(10))        # True
print(bool(0))         # False
print(bool("Ankit"))   # True
print(bool(""))        # False
print(bool([]))        # False
print(bool([1, 2]))    # True

Conclusion

Mastering Python’s basic data types is a foundational step in your programming journey. From simple integers to complex strings and bytes, understanding these types allows you to write better, more effective, and more efficient Python code. Once you are comfortable with these data types, you'll find it easier to debug, build logic, and manipulate data in your projects.

Frequently Asked Questions - Python Data Types

num1 = 5      # int
num2 = 5.5    # float

z = 3 + 4j

x = 10
print(type(x))  # Output: <class 'int'>

a = 5
b = 10
print(a < b)  # True

b = bytes([65, 66, 67])
ba = bytearray([65, 66, 67])

x = "100"
print(int(x))  # Output: 100

x = 10       # int
x = "Ankit"  # now it's str