REFERENCEpython

python Documentation

📖 INDEX

# print

# arithmetic-operators

# assignment-operators

# comparison-operators

# logical-operators

# identity-operators

# membership-operators

# keyword-arguments-kwargs

# default-parameter-value

# class-methods-classmethod

# static-methods-staticmethod

# dunder-methods

# try-block

# except-block

# else-block-exceptions

# list-comprehensions

# dictionary-comprehensions

# set-comprehensions

# iterators

# property-decorator-property

# context-managers-contextmanager

LOADING ENGINE...

NoneType

AI & DATA SCIENCE // nonetype

NoneType is the type of Python's single null-like value, None, used to represent 'no value' or 'nothing here'.

Syntax

x = None
if x is None:
    ...
def f():
    pass  # implicitly returns None

Deep Dive Course

None is the sole instance of NoneType — there's only ever one None object in a running Python program, which is exactly why `is None` (identity comparison) is preferred over `== None` (equality comparison) when checking for it. Functions that don't explicitly return anything implicitly return None, and it's commonly used as a default placeholder value for optional arguments.

1Understanding NoneType

None is the sole instance of NoneType — there's only ever one None object in a running Python program, which is exactly why is None (identity comparison) is preferred over == None (equality comparison) when checking for it. Functions that don't explicitly return anything implicitly return None, and it's commonly used as a default placeholder value for optional arguments.

💡

Never use a mutable object, like an empty list, as a default argument value; use None as the default and create the mutable object inside the function body instead, since default argument values are evaluated only once, at function definition time, and shared across all calls.

editor.html

def find_user(user_id, users):
    for u in users:
        if u["id"] == user_id:
            return u
    return None

result = find_user(99, [{"id": 1}])
print(result is None)

localhost:3000

2Practical Example

Here is a real-world application of NoneType showing how it is used in production Python code.

editor.html

def add_item(item, bucket=None):
    if bucket is None:
        bucket = []
    bucket.append(item)
    return bucket

print(add_item("a"))
print(add_item("b"))

localhost:3000

3Best Practices

Follow these guidelines when working with NoneType:

1. Use is None / is not None instead of == for checking None, since it's both faster and can't be fooled by a custom __eq__

2. Use None as the default value for optional mutable arguments, creating the real object inside the function body

3. Check function return values for None explicitly when a function's docs say it might return 'nothing found'

⚠️

Tip: Never use a mutable object, like an empty list, as a default argument value; use None as the default and create the mutable object inside the function body instead, since default argument values are evaluated only once, at function definition time, and shared across all calls.

editor.html

def find_user(user_id, users):
    for u in users:
        if u["id"] == user_id:
            return u
    return None

result = find_user(99, [{"id": 1}])
print(result is None)

localhost:3000

Examples

Example 01Basic Usage

def find_user(user_id, users):
    for u in users:
        if u["id"] == user_id:
            return u
    return None

result = find_user(99, [{"id": 1}])
print(result is None)

Example 02Advanced Example

def add_item(item, bucket=None):
    if bucket is None:
        bucket = []
    bucket.append(item)
    return bucket

print(add_item("a"))
print(add_item("b"))

Best Practices

Use is None / is not None instead of == for checking None, since it's both faster and can't be fooled by a custom __eq__
Use None as the default value for optional mutable arguments, creating the real object inside the function body
Check function return values for None explicitly when a function's docs say it might return 'nothing found'

Interview Question

Why is using a mutable default argument, like an empty list, considered a classic Python bug?▼

Hint: Think about when default argument values are actually evaluated.

Default argument values are evaluated exactly once, when the function is defined, not each time it's called — so a mutable default like an empty list is the same object shared across every call that doesn't override it. Mutating it in one call, like appending to it, leaves those changes visible the next time the function is called with the default. Using None as the default and creating a fresh mutable object inside the function body avoids this shared-state bug entirely.

Exercises

MediumPractice using NoneType in a real scenario.

View Solution

def find_user(user_id, users):
    for u in users:
        if u["id"] == user_id:
            return u
    return None

result = find_user(99, [{"id": 1}])
print(result is None)

Frequently Asked Questions

Why is using a mutable default argument, like an empty list, considered a classic Python bug?▼

Related Functions

default-parameter-valueis operatorNone