Summary  
This chapter explains how to use None to represent missing values and implement safe default and absence checks, and how to handle raw binary data with bytes and bytearray, including explicit encoding and decoding between text and bytes.  

General domain of usage  
File I/O

Real programs handle missing values and binary data. Use **`None`** to mark "no value", and **`bytes`/`bytearray`** for raw binary content. Know when each is appropriate and how to convert safely between text and bytes.

## None for "No Value"

`None` is a single object meaning "nothing here".

Watch this video for a clear explanation of how to use None for missing values and bytes or bytearray for binary data in Python. You'll see practical examples of when to use each, how to convert between text and bytes, and common mistakes to avoid. This visual overview will reinforce key concepts and help you confidently handle both missing and binary data in your own Python programs.

result = None
email = None
print(result is None)  # True
print(email is None)   # True

if result is None:
    print("No result yet")

Use `is None` instead of truthiness checks, since `0` and `""` are also falsey.

value = 0
print(not value)        # True
print(value is None)    # False

### Defaults and Fallbacks

`None` is used as a clear marker that a value is intentionally missing. It lets you distinguish between "no value provided" and valid values like `0` or `""`, making defaults and fallbacks safer and more predictable.

x = None
print(x or "unknown")         # 'unknown'
print("unknown" if x is None else x)

x = 0
print(x or "unknown")         # 'unknown'
print("unknown" if x is None else x)  # 0

### Functions and Parameters

This example shows how a function uses a parameter set to `None` as a signal that no tag was provided. It allows the function to assign a safe default while still letting the caller override it when needed.

def add_tag(text, tag=None):
    if tag is None:
        tag = "general"
    return f"[{tag}] {text}"

print(add_tag("hello"))           # [general] hello
print(add_tag("hello", "news"))   # [news] hello

## Binary Data

`str` holds text, `bytes` and `bytearray` hold raw byte values.

b1 = b"hello"
b2 = bytes([72, 105])
buf = bytearray(b"abc")
buf[0] = 65

## Encoding and Decoding

Encoding converts text into bytes so it can be stored or transferred reliably, while decoding restores those bytes back into readable text. Using a defined encoding like UTF-8 ensures characters are preserved correctly.

text = "café"
data = text.encode("utf-8")
back = data.decode("utf-8")

## Mixing Text and Bytes

Text (`str`) and bytes (`bytes`) can't be combined directly because they represent different data types. To mix them safely, you must convert the text into bytes first using an explicit encoding.


try:
    b"ID:" + "123"
except TypeError as e:
    print(e)

ok = b"ID:" + "123".encode("utf-8")

## Length Differences

Some characters take one text element but multiple bytes, so their length in `str` and in encoded form can differ. This happens because encodings like UTF-8 may use more than one byte to represent a single character.


ch = "é"
len(ch)            # 1
len(ch.encode())   # 2

## Files

Binary files must be opened in `"rb"` mode so their raw bytes are read exactly as stored. This prevents Python from trying to interpret the data as text.

```python
# with open("example.png", "rb") as f:
#     blob = f.read()
```

Which check correctly detects a missing value?

Få en solid forståelse av Pythons grunnleggende datatyper og lær hvordan du arbeider effektivt med dem. Utforsk tall, boolske verdier og strenger gjennom praktiske øvelser og eksempler. Bygg selvtillit i å utføre grunnleggende operasjoner og utvikle de nødvendige ferdighetene for å skrive ryddig og effektiv Python-kode.

Oppdag det grunnleggende om numeriske datatyper i Python og lær hvordan du arbeider med heltall og flyttall. Få oversikt over grunnleggende aritmetiske operasjoner, utforsk begrepet uforanderlighet, og få praktisk erfaring med Pythons innebygde funksjoner og verktøy for effektiv håndtering av tall i virkelige situasjoner.

Få en tydelig forståelse av den boolske datatypen, en spesialisert undergruppe av numeriske data som representerer sannhetsverdier. Selv om det kan virke utfordrende i starten, er det avgjørende å beherske boolske verdier for å skrive logiske og effektive programmer. Denne delen hjelper deg å anvende boolsk logikk trygt i programmeringsscenarier fra virkeligheten.

Strenger lar deg arbeide med tekst i Python, fra å vise meldinger til å behandle brukerinput. Du vil utforske hvordan du kan opprette, endre og manipulere strenger på en effektiv måte. Forståelse av strenger er avgjørende for å skrive interaktive programmer og formidle informasjon tydelig gjennom koden din.

Lær hvordan du håndterer datatyper effektivt for å sikre nøyaktighet og konsistens i programmene dine. Konverter verdier til riktig type, rens tekst før sammenligning, og skill mellom numeriske operasjoner og tekstformatering. Du vil også oppdage hvordan du bevisst håndterer manglende data og behandler lesbar tekst annerledes enn rå input, for å oppnå pålitelige, konsistente og lettleste resultater.

None og Binære Data

None og Binære Data