# 딕셔너리 생성 방법
empty = {}                                    # 빈 딕셔너리
person = {'name': 'John', 'age': 30}          # 기본적인 딕셔너리
scores = dict(math=90, english=85)            # dict() 함수로 생성
mixed = {
    'str': 'hello',                           # 문자열 값
    'list': [1, 2, 3],                        # 리스트 값
    'tuple': (4, 5, 6)                        # 튜플 값
}

# 딕셔너리 수정
person = {'name': 'John', 'age': 30}
person['age'] = 31                    # 값 수정
person['city'] = 'Seoul'              # 새로운 쌍 추가

# 딕셔너리 삭제
del person['age']                     # 특정 키-값 쌍 삭제
person.clear()                        # 모든 항목 삭제

person = {
    'name': 'John',
    'age': 30,
    'city': 'Seoul'
}

# 키 목록 얻기
keys = person.keys()                  # dict_keys 객체 반환
key_list = list(person.keys())        # 리스트로 변환

# 값 목록 얻기
values = person.values()              # dict_values 객체 반환
value_list = list(person.values())    # 리스트로 변환

# 키-값 쌍 얻기
items = person.items()                # dict_items 객체 반환
item_list = list(person.items())      # 리스트로 변환

# 키로 값 얻기
age = person.get('age')               # 키가 있으면 값 반환
age = person.get('height', 0)         # 키가 없으면 기본값 반환

# 키 존재 여부 확인
'name' in person                      # True
'email' in person                     # False

# 항목 추가/수정
person.update({'email': '[email protected]', 'age': 31})  # 여러 항목 한번에 추가/수정

# 항목 제거
removed_value = person.pop('age')     # 키에 해당하는 항목 제거 후 값 반환
random_item = person.popitem()        # 마지막 항목 제거 후 (키, 값) 튜플 반환

# 딕셔너리 복사
person_copy = person.copy()           # 얕은 복사

# 중첩 딕셔너리
users = {
    'user1': {
        'name': 'John',
        'age': 30,
        'scores': {'math': 90, 'english': 85}
    },
    'user2': {
        'name': 'Jane',
        'age': 25,
        'scores': {'math': 95, 'english': 90}
    }
}

# 딕셔너리 순회
for key in users:
    print(key, users[key])

for key, value in users.items():
    print(key, value)

# 딕셔너리 병합
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
merged = {**dict1, **dict2}          # Python 3.5+

# Python 3.9 이상에서 지원하는 간단한 병합 연산자
# merged = dict1 | dict2              # Python 3.9+

# 기본 형식
squares = {x: x**2 for x in range(6)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 조건식 추가
even_squares = {x: x**2 for x in range(6) if x % 2 == 0}
# {0: 0, 2: 4, 4: 16}

# 키-값 변환
original = {'a': 1, 'b': 2, 'c': 3}
swapped = {v: k for k, v in original.items()}
# {1: 'a', 2: 'b', 3: 'c'}

# 중첩 루프 사용
matrix = {(i, j): i*j for i in range(3) for j in range(3)}
# {(0, 0): 0, (0, 1): 0, (0, 2): 0, (1, 0): 0, (1, 1): 1, (1, 2): 2, (2, 0): 0, (2, 1): 2, (2, 2): 4}

# if-else 사용
status = {x: 'even' if x % 2 == 0 else 'odd' for x in range(6)}
# {0: 'even', 1: 'odd', 2: 'even', 3: 'odd', 4: 'even', 5: 'odd'}

# 문자열 처리
word = "hello"
char_count = {char: word.count(char) for char in word}
# {'h': 1, 'e': 1, 'l': 2, 'o': 1}

from types import MappingProxyType

original = {'a': 1, 'b': 2}
read_only = MappingProxyType(original)

# 읽기는 가능
print(read_only['a'])  # 1

# 수정 시도는 오류 발생
try:
    read_only['c'] = 3
except TypeError as e:
    print(e)  # 'mappingproxy' object does not support item assignment

# 원본 수정 시 읽기 전용 뷰에도 반영됨
original['a'] = 100
print(read_only['a'])  # 100

from collections import defaultdict

# 기본값으로 정수 0 사용
int_dict = defaultdict(int)
print(int_dict['non_existent_key'])  # 0

# 기본값으로 리스트 사용
list_dict = defaultdict(list)
list_dict['fruits'].append('apple')
list_dict['fruits'].append('banana')
print(list_dict['fruits'])  # ['apple', 'banana']

# 기본값으로 사용할 함수 정의
def default_factory():
    return 'default value'

custom_dict = defaultdict(default_factory)
print(custom_dict['key'])  # 'default value'

# 단어 빈도수 세기
text = "hello world hello python world python"
word_count = defaultdict(int)
for word in text.split():
    word_count[word] += 1
print(dict(word_count))  # {'hello': 2, 'world': 2, 'python': 2}

from collections import Counter

# 문자열에서 문자 빈도 세기
char_count = Counter("hello world")
print(char_count)  # Counter({'l': 3, 'o': 2, ' ': 1, 'h': 1, 'e': 1, 'w': 1, 'r': 1, 'd': 1})

# 리스트에서 요소 빈도 세기
fruit_basket = ['apple', 'orange', 'apple', 'banana', 'orange', 'apple']
fruit_count = Counter(fruit_basket)
print(fruit_count)  # Counter({'apple': 3, 'orange': 2, 'banana': 1})

# 가장 흔한 요소 찾기
print(fruit_count.most_common(2))  # [('apple', 3), ('orange', 2)]

# 산술 연산
counter1 = Counter(['a', 'b', 'c', 'a'])
counter2 = Counter(['a', 'd', 'e'])
print(counter1 + counter2)  # Counter({'a': 3, 'b': 1, 'c': 1, 'd': 1, 'e': 1})
print(counter1 - counter2)  # Counter({'b': 1, 'c': 1, 'a': 1})

from collections import OrderedDict

# 순서가 있는 딕셔너리 생성
ordered = OrderedDict([('a', 1), ('b', 2), ('c', 3)])

# 항목 이동
ordered.move_to_end('a')
print(ordered)  # OrderedDict([('b', 2), ('c', 3), ('a', 1)])

# 마지막 항목 제거
last_item = ordered.popitem()
print(last_item)  # ('a', 1)

# 순서 비교
od1 = OrderedDict([('a', 1), ('b', 2)])
od2 = OrderedDict([('b', 2), ('a', 1)])
print(od1 == od2)  # False - 순서가 다름

# 일반 딕셔너리에서는 순서가 중요하지 않음
d1 = {'a': 1, 'b': 2}
d2 = {'b': 2, 'a': 1}
print(d1 == d2)  # True - 순서가 달라도 같음

import copy

# 얕은 복사
original = {'name': 'John', 'hobbies': ['reading', 'swimming']}
shallow_copy = original.copy()  # 또는 dict(original)

# 내부 가변 객체는 참조 공유
shallow_copy['hobbies'].append('running')
print(original['hobbies'])  # ['reading', 'swimming', 'running'] - 원본도 변경됨

# 깊은 복사
original = {'name': 'John', 'hobbies': ['reading', 'swimming']}
deep_copy = copy.deepcopy(original)

# 내부 가변 객체도 복사
deep_copy['hobbies'].append('running')
print(original['hobbies'])  # ['reading', 'swimming'] - 원본은 변경되지 않음
print(deep_copy['hobbies'])  # ['reading', 'swimming', 'running']

import time
import timeit

# 딕셔너리 vs 리스트 검색 성능 비교
def dict_lookup(dictionary, key):
    return dictionary.get(key)

def list_lookup(item_list, key):
    for k, v in item_list:
        if k == key:
            return v
    return None

# 데이터 준비
size = 10000
dict_data = {str(i): i for i in range(size)}
list_data = [(str(i), i) for i in range(size)]

# 검색 시간 측정
dict_time = timeit.timeit(
    lambda: dict_lookup(dict_data, str(size-1)),
    number=10000
)
list_time = timeit.timeit(
    lambda: list_lookup(list_data, str(size-1)),
    number=10000
)

print(f"딕셔너리 검색 시간: {dict_time:.6f}초")
print(f"리스트 검색 시간: {list_time:.6f}초")
print(f"딕셔너리가 약 {list_time/dict_time:.1f}배 빠름")

def get_user_data(user_id, cache={}):
    if user_id in cache:
        print(f"캐시에서 사용자 {user_id} 정보 가져오기")
        return cache[user_id]
    
    print(f"데이터베이스에서 사용자 {user_id} 정보 가져오기")
    # 여기서는 실제 DB 조회 대신 시뮬레이션
    data = {'id': user_id, 'name': f'User {user_id}', 'age': 20 + (user_id % 10)}
    cache[user_id] = data
    return data

# 첫 번째 호출은 "데이터베이스"에서 가져옴
print(get_user_data(1))
# 두 번째 호출은 캐시에서 가져옴
print(get_user_data(1))

# 인접 리스트로 그래프 표현
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

# 깊이 우선 탐색(DFS)
def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start, end=' ')
    
    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)
    
    return visited

print("DFS 탐색 결과:", end=' ')
dfs(graph, 'A')  # A B D E F C

def word_frequency(text):
    # 문자 단위로 분리하고 소문자로 변환
    words = text.lower().split()
    # 단어 빈도수 계산
    frequency = {}
    for word in words:
        # 구두점 제거
        word = word.strip('.,!?;:()[]{}""\'')
        if word:
            frequency[word] = frequency.get(word, 0) + 1
    return frequency

text = "Python is amazing. Python is a great programming language."
print(word_frequency(text))
# {'python': 2, 'is': 2, 'amazing.': 1, 'a': 1, 'great': 1, 'programming': 1, 'language.': 1}