Engineering

Programming Fundamentals

Python's Distinctive Features: Pythonic Idioms That Actually Matter

Apr 26, 2020 ·

Why “Pythonic” Code Isn’t Just Style

“Write Pythonic code” is advice you’ll hear constantly, but it’s not about aesthetics. Pythonic patterns are faster, safer, and more readable — not just to humans but to other Python programmers who need to maintain your code. For engineers coming from C, Java, or JavaScript, certain Python idioms feel strange at first but quickly become second nature once you understand the underlying model.

This post covers the language features that are genuinely distinctive to Python: the idioms you’d use daily in real engineering work, and why they exist.

Core Concepts: What Makes Python Distinctive

Python’s design philosophy (The Zen of Python, import this) centers on readability and one obvious way to do things. Several language features flow directly from this:

Everything is an object — including integers, functions, and classes
Duck typing — type is determined by behavior, not declaration
EAFP over LBYL — try it and handle failure rather than check first
Rich built-ins — enumerate, zip, map, filter, sorted, any, all
Unpacking everywhere — assignment, function arguments, loop variables

How It Works: Deep Dive

Input / Output

# Input always returns a string
name = input("Enter name: ")
age = int(input("Enter age: "))   # explicit cast required

# print() variations
print("a", "b", "c")              # a b c  (space-separated)
print("a", "b", "c", sep="-")     # a-b-c
print("a", "b", end="")           # no newline
print("a", "b", file=sys.stderr)  # to stderr

File I/O

# Always use context manager — guaranteed close on exception
with open("file.txt", "r") as f:
    content = f.read()           # entire file as string
    lines = f.readlines()        # list of lines (with \n)
    line = f.readline()          # one line at a time

# Memory-efficient iteration over large files
with open("large.log", "r") as f:
    for line in f:               # iterates line by line without loading all
        process(line.strip())

# Write modes
with open("out.txt", "w") as f:    # write (creates or overwrites)
    f.write("hello\n")
with open("out.txt", "a") as f:    # append
    f.write("more\n")

# Binary mode
with open("image.png", "rb") as f:
    data = f.read()

# Command-line arguments
import sys
args = sys.argv[1:]   # sys.argv[0] is the script name
for arg in args:
    print(arg)

Unpacking

Unpacking is one of Python’s most powerful features. Use it aggressively:

# Basic unpacking
first, second, third = [1, 2, 3]
x, y = (3, 4)

# Star unpacking — "rest" collects remaining
first, *rest = [1, 2, 3, 4, 5]
# first = 1, rest = [2, 3, 4, 5]

*beginning, last = [1, 2, 3, 4, 5]
# beginning = [1, 2, 3, 4], last = 5

first, *middle, last = [1, 2, 3, 4, 5]
# first = 1, middle = [2, 3, 4], last = 5

# Swap
a, b = b, a

# Nested unpacking
(a, b), c = (1, 2), 3

# In for loops
pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
for number, letter in pairs:
    print(number, letter)

# Function argument unpacking
def point(x, y):
    print(x, y)

coords = [3, 4]
point(*coords)            # 3 4

config = {'x': 1, 'y': 2}
point(**config)           # 1 2

# Merging dicts (Python 3.5+)
merged = {**dict1, **dict2}

Enumerate: Index + Value Without a Counter

fruits = ['apple', 'banana', 'cherry']

# BAD — manual counter
i = 0
for fruit in fruits:
    print(i, fruit)
    i += 1

# GOOD — enumerate
for i, fruit in enumerate(fruits):
    print(i, fruit)

# With custom start
for i, fruit in enumerate(fruits, start=1):
    print(f"{i}. {fruit}")

Comparison Chaining

Python allows chaining comparison operators naturally:

x = 5

# These all work as expected
result = 1 < x < 10       # True  (between 1 and 10)
result = 10 > x >= 5      # True
result = 1 < x < 10 < 20  # True  (chained)

# Equivalent to: (1 < x) and (x < 10)
# Advantage: x is evaluated only once

Infinity and Special Numeric Values

import math

pos_inf = float('inf')
neg_inf = float('-inf')
not_a_num = float('nan')

# Comparisons
print(999_999_999 < float('inf'))  # True — underscore as thousands separator
print(float('-inf') < -999_999_999)  # True

# math module equivalents
print(math.isinf(float('inf')))   # True
print(math.isnan(float('nan')))   # True

# Useful for initializing min/max
max_value = float('-inf')
for x in data:
    if x > max_value:
        max_value = x

# Better: use built-in
max_value = max(data)

Slicing: The Full Syntax

[start:stop:step] — all three are optional, all support negative indices:

a = [1, 2, 3, 4, 5]

a[1:3]      # [2, 3]           — index 1, 2 (not 3)
a[:3]       # [1, 2, 3]        — from start to index 3 (exclusive)
a[2:]       # [3, 4, 5]        — from index 2 to end
a[:]        # [1, 2, 3, 4, 5]  — full copy
a[-1]       # 5                — last element
a[-2:]      # [4, 5]           — last two elements
a[:-1]      # [1, 2, 3, 4]     — everything except last
a[::-1]     # [5, 4, 3, 2, 1]  — reversed
a[::2]      # [1, 3, 5]        — every other element
a[::-2]     # [5, 3, 1]        — every other element, reversed

Works on strings and tuples too:

s = "hello world"
print(s[:5])        # "hello"
print(s[::-1])      # "dlrow olleh"
print(s[6:])        # "world"

List Comprehensions vs Generators: Know When to Use Which

# List comprehension — evaluates immediately, stores all results in memory
squares_list = [x**2 for x in range(1000000)]  # 8MB+ in memory

# Generator expression — lazy, computes one at a time
squares_gen = (x**2 for x in range(1000000))   # almost no memory

# Use generators when:
# 1. You only need to iterate once
# 2. The dataset is large
# 3. You're passing to sum(), max(), any(), all()

total = sum(x**2 for x in range(1000000))  # no intermediate list
any_negative = any(x < 0 for x in data)    # stops at first negative
all_valid = all(validate(x) for x in data) # stops at first invalid

# Use lists when:
# 1. You need to iterate multiple times
# 2. You need len(), indexing, or slicing
# 3. The dataset fits comfortably in memory

any() and all()

# any() — True if at least one element is truthy (short-circuits)
has_admin = any(user.is_admin for user in users)
has_errors = any(line.startswith("ERROR") for line in logs)

# all() — True if all elements are truthy (short-circuits)
all_valid = all(validate(item) for item in data)
all_positive = all(x > 0 for x in numbers)

# Practical: input validation
required_fields = ['name', 'email', 'password']
form_complete = all(field in form_data for field in required_fields)

sorted() and Custom Keys

data = [{'name': 'Charlie', 'score': 85},
        {'name': 'Alice', 'score': 92},
        {'name': 'Bob', 'score': 78}]

# Sort by score (descending)
by_score = sorted(data, key=lambda x: x['score'], reverse=True)

# Sort by multiple criteria
by_name_then_score = sorted(data, key=lambda x: (x['name'], -x['score']))

# Python's sort is stable — equal elements maintain relative order

Practical Application: Real Patterns

Reading a Config File

config = {}
with open("config.txt") as f:
    for line in f:
        line = line.strip()
        if not line or line.startswith('#'):  # skip empty and comments
            continue
        key, _, value = line.partition('=')
        config[key.strip()] = value.strip()

Processing Structured Data

# Transpose a matrix using zip and unpacking
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = list(map(list, zip(*matrix)))
# [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

# Flatten a list of lists
from itertools import chain
nested = [[1, 2], [3, 4], [5, 6]]
flat = list(chain.from_iterable(nested))
# [1, 2, 3, 4, 5, 6]

# Group items by attribute
from itertools import groupby
events = sorted(events, key=lambda e: e['date'])  # must sort first
for date, group in groupby(events, key=lambda e: e['date']):
    print(date, list(group))

Argument Handling for Scripts

import argparse

parser = argparse.ArgumentParser(description='Process some files.')
parser.add_argument('files', nargs='+', help='Input files')
parser.add_argument('-o', '--output', default='out.txt')
parser.add_argument('-v', '--verbose', action='store_true')

args = parser.parse_args()
# args.files, args.output, args.verbose

Gotchas: What Experts Know

`is` vs `==` and the None Pattern

# ALWAYS use 'is' for None comparison
x = None
if x is None:       # correct — checks identity
    pass
if x == None:       # works, but misleading — could be overridden by __eq__
    pass

# This is why 'is None' matters:
class Tricky:
    def __eq__(self, other):
        return True  # lies — claims to equal everything

t = Tricky()
print(t == None)    # True — wrong!
print(t is None)    # False — correct

The Pitfall of `print()` as a Debug Tool

# print() is fine for quick checks, but use logging for real code
import logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

logger.debug("Processing item: %s", item)   # lazy evaluation — no f-string cost if DEBUG is off
logger.info("Completed: %d items", count)
logger.error("Failed: %s", error)

Integer Division Behavior (Python 3 vs 2)

# Python 3 — always true division
print(3 / 4)    # 0.75
print(7 / 2)    # 3.5

# Floor division (rounds toward negative infinity)
print(3 // 4)   # 0
print(-7 // 2)  # -4  (not -3 — rounds DOWN, not toward zero)
print(7 // -2)  # -4

# Modulo follows the same sign convention
print(-7 % 2)   # 1  (not -1)

Sorting Stability and Key Functions

# sorted() and list.sort() are stable — equal keys maintain original order
# Use key= instead of cmp= (cmp was removed in Python 3)

# DON'T use lambda x: (x.last, x.first) with - for reverse on strings
# DO use reverse=True for simple descending, or negate numeric keys
sorted(data, key=lambda x: (-x.priority, x.name))  # desc priority, asc name

Quick Reference

# Unpacking
first, *rest = iterable
a, b = b, a                   # swap
for k, v in d.items(): ...    # dict unpacking
merged = {**d1, **d2}         # merge dicts

# File I/O
with open(path) as f:
    for line in f: ...         # memory-efficient line iteration

# Slicing
s[start:stop:step]
s[::-1]                        # reverse
s[::2]                         # every other

# Built-ins
enumerate(lst, start=0)        # index + value
zip(lst1, lst2)                # parallel iteration
sorted(lst, key=fn, reverse=True)
any(pred(x) for x in it)      # at least one
all(pred(x) for x in it)      # all
sum(x for x in it)            # sum with generator

# Comparison chaining
1 < x < 10                    # equivalent to (1 < x) and (x < 10)

# Generator vs list
(expr for x in it)            # generator — lazy, low memory
[expr for x in it]            # list — eager, full memory

“Pythonic”한 코드가 단순한 스타일이 아닌 이유

“Pythonic한 코드를 작성하라”는 말을 자주 듣지만, 이건 미적인 문제가 아니다. Pythonic 패턴은 더 빠르고, 더 안전하고, 더 읽기 쉽다. C, Java, JavaScript에서 온 엔지니어에게는 처음에 이상하게 느껴지지만, 내부 모델을 이해하면 금방 자연스러워진다.

핵심 개념: Python을 독특하게 만드는 것

Python의 설계 철학은 가독성과 “당연한 한 가지 방법”에 집중한다. 여러 언어 특성이 여기에서 나온다:

모든 것이 객체 — 정수, 함수, 클래스 포함
덕 타이핑 — 타입은 선언이 아닌 동작으로 결정됨
EAFP — 먼저 확인하기보다 시도하고 실패를 처리
풍부한 내장 함수 — enumerate, zip, sorted, any, all
언패킹 — 할당, 함수 인수, 루프 변수 어디서든

작동 원리: 깊이 들어가기

입출력

# input()은 항상 문자열을 반환함
name = input("이름 입력: ")
age = int(input("나이 입력: "))   # 명시적 형변환 필요

# print() 다양한 활용
print("a", "b", "c", sep="-")     # a-b-c
print("a", "b", end="")           # 개행 없음
print("a", "b", file=sys.stderr)  # stderr로 출력

파일 입출력

# 항상 컨텍스트 관리자 사용 — 예외 시에도 닫힘 보장
with open("file.txt", "r") as f:
    content = f.read()            # 전체를 문자열로
    lines = f.readlines()         # 줄의 리스트
    line = f.readline()           # 한 줄씩

# 대용량 파일에 메모리 효율적 반복
with open("large.log", "r") as f:
    for line in f:                # 전체를 로드하지 않고 줄별 반복
        process(line.strip())

# 쓰기 모드
with open("out.txt", "w") as f:    # 쓰기 (생성 또는 덮어쓰기)
    f.write("hello\n")
with open("out.txt", "a") as f:    # 이어쓰기
    f.write("more\n")

# 커맨드라인 인수
import sys
args = sys.argv[1:]   # sys.argv[0]은 스크립트 이름
for arg in args:
    print(arg)

언패킹

언패킹은 Python에서 가장 강력한 기능 중 하나다:

# 기본 언패킹
first, second, third = [1, 2, 3]

# 스타 언패킹
first, *rest = [1, 2, 3, 4, 5]
# first = 1, rest = [2, 3, 4, 5]

*beginning, last = [1, 2, 3, 4, 5]
# beginning = [1, 2, 3, 4], last = 5

# swap
a, b = b, a

# for 루프에서
pairs = [(1, 'a'), (2, 'b')]
for number, letter in pairs:
    print(number, letter)

# 함수 인수 언패킹
def point(x, y):
    print(x, y)

coords = [3, 4]
point(*coords)            # 3 4

config = {'x': 1, 'y': 2}
point(**config)           # 1 2

# 딕셔너리 병합 (Python 3.5+)
merged = {**dict1, **dict2}

Enumerate: 카운터 없는 인덱스 + 값

fruits = ['apple', 'banana', 'cherry']

# 나쁨 — 수동 카운터
i = 0
for fruit in fruits:
    print(i, fruit)
    i += 1

# 좋음 — enumerate
for i, fruit in enumerate(fruits, start=1):
    print(f"{i}. {fruit}")

비교 연산자 체인

x = 5
result = 1 < x < 10       # True — (1 < x) and (x < 10)과 동일
result = 10 > x >= 5      # True

슬라이싱: 전체 문법

[start:stop:step] — 셋 다 선택적이고, 모두 음수 인덱스 지원:

a = [1, 2, 3, 4, 5]

a[1:3]      # [2, 3]           — 인덱스 1, 2
a[:3]       # [1, 2, 3]        — 시작부터 인덱스 3 (미포함)
a[-1]       # 5                — 마지막 원소
a[-2:]      # [4, 5]           — 마지막 두 원소
a[::-1]     # [5, 4, 3, 2, 1]  — 역순
a[::2]      # [1, 3, 5]        — 하나 걸러

문자열과 튜플에도 동작:

s = "hello world"
print(s[:5])        # "hello"
print(s[::-1])      # "dlrow olleh"

리스트 컴프리헨션 vs 생성자

# 리스트 컴프리헨션 — 즉시 평가, 전체 결과 메모리에 저장
squares_list = [x**2 for x in range(1000000)]  # 8MB+ 메모리

# 생성자 표현식 — 지연 평가, 한 번에 하나씩
squares_gen = (x**2 for x in range(1000000))   # 메모리 거의 없음

# 생성자를 사용해야 할 때:
total = sum(x**2 for x in range(1000000))  # 중간 리스트 없음
any_negative = any(x < 0 for x in data)    # 첫 음수에서 멈춤
all_valid = all(validate(x) for x in data) # 첫 무효값에서 멈춤

any()와 all()

# any() — 하나라도 참이면 True (단락 평가)
has_admin = any(user.is_admin for user in users)

# all() — 모두 참이면 True (단락 평가)
all_valid = all(validate(item) for item in data)

# 실용 예시: 입력 검증
required_fields = ['name', 'email', 'password']
form_complete = all(field in form_data for field in required_fields)

전문가가 아는 함정들

`is` vs `==`와 None 패턴

# None 비교에는 항상 'is' 사용
x = None
if x is None:       # 올바름 — 동일성 확인
    pass
if x == None:       # 동작하지만 __eq__ 재정의로 오류 가능
    pass

정수 나눗셈 동작 (Python 3)

print(3 / 4)    # 0.75 — 진짜 나눗셈
print(3 // 4)   # 0   — 나머지 버림
print(-7 // 2)  # -4  — 음수 무한대 방향으로 버림 (0 방향이 아님!)
print(-7 % 2)   # 1   (음수 아님)

빠른 참조

# 언패킹
first, *rest = iterable
a, b = b, a                   # swap
merged = {**d1, **d2}         # 딕셔너리 병합

# 파일 입출력
with open(path) as f:
    for line in f: ...         # 메모리 효율적 반복

# 슬라이싱
s[start:stop:step]
s[::-1]                        # 역순
s[::2]                         # 하나 걸러

# 내장 함수
enumerate(lst, start=0)        # 인덱스 + 값
zip(lst1, lst2)                # 병렬 반복
sorted(lst, key=fn, reverse=True)
any(pred(x) for x in it)      # 하나라도 참
all(pred(x) for x in it)      # 모두 참

# 비교 체인
1 < x < 10                    # (1 < x) and (x < 10)과 동일

# 생성자 vs 리스트
(expr for x in it)            # 생성자 — 지연, 저메모리
[expr for x in it]            # 리스트 — 즉시, 전체 메모리