6주차: 정규표현식, Pandas 문자열, XML, JSON

import re
 
for s in ["a", "before", "dude"]:
    print(s, bool(re.search(r"[abc]", s)))
# → a True        ← "a"가 있음
# → before True   ← "b"가 있음
# → dude False    ← a, b, c 중 아무것도 없음

for s in ["aab", "a0b", "abc"]:
    print(s, bool(re.match(r"a.b", s)))
# → aab True    ← 가운데 "a"가 . 과 매치
# → a0b True    ← 가운데 "0"이 . 과 매치
# → abc False   ← "a"와 "b" 사이에 문자가 없음

line = "X-DSPAM-Confidence: 0.8475"
 
re.findall(r"^X\S*: [0-9.]+", line)     # → ['X-DSPAM-Confidence: 0.8475']   괄호 없음: 매치 전체
re.findall(r"^X\S*: ([0-9.]+)", line)   # → ['0.8475']                       괄호 안만

import re
 
with open("mbox-short.txt", encoding="utf-8") as hand:
    for line in hand:
        line = line.rstrip()
        if re.search(r"^From:.+@", line):
            print(line)
# → From: stephen.marquard@uct.ac.za
# → From: louis@media.berkeley.edu
# → ... (27줄)

"\b"    # 파이썬이 백스페이스 문자로 바꿔 버림 → 정규식의 단어 경계가 아님
r"\b"   # 역슬래시와 b 두 글자 그대로 → 정규식이 단어 경계로 해석

m = re.match(r"[a-z]+", "python")     # 축약형: 한 번만 쓸 때
 
p = re.compile(r"[a-z]+")             # 컴파일형: 여러 번 쓸 때
m = p.match("python")

p = re.compile(r"[a-z]+")
 
p.match("python")      # → <re.Match object; span=(0, 6), match='python'>
p.match("3 python")    # → None   ← 첫 글자 "3"이 [a-z]가 아님
p.search("python")     # → <re.Match object; span=(0, 6), match='python'>
p.search("3 python")   # → <re.Match object; span=(2, 8), match='python'>   ← 전체를 훑어 찾음

p.findall("life is too short")    # → ['life', 'is', 'too', 'short']
 
result = p.finditer("life is too short")
result                            # → <callable_iterator object at 0x...>
for r in result:
    print(r.group())              # → life / is / too / short

m = p.match("python")
m.group(), m.start(), m.end(), m.span()   # → ('python', 0, 6, (0, 6))
 
m = p.search("3 python")
m.group(), m.start(), m.end(), m.span()   # → ('python', 2, 8, (2, 8))

text = "3 Hello Python3 World 2026!"
m = re.compile(r"[a-zA-Z]+").search(text)
m.group(), m.start(), m.end()             # → ('Hello', 2, 7)

import pandas as pd
 
boston_url = "https://andybek.com/pandas-marathon"
boston = pd.read_csv(boston_url)
boston.info()
# → RangeIndex: 1000 entries, 0 to 999
# → Name, Age, M/F, City, State, Country, Official Time, Overall, Gender, Years Ran

boston.City.str.upper()        # KERINGET, PORTLAND, ...
boston.City.str.lower()        # keringet, portland, ...
boston.City.str.capitalize()   # 첫 글자만 대문자: Machida-City → Machida-city
boston.City.str.swapcase()     # 대소문자 뒤집기: Keringet → kERINGET
 
boston.Name.iloc[0:2].str.strip()   # 앞뒤 공백 제거 → 'Kirui, Geoffrey', 'Rupp, Galen'

boston.Name.str.split(", ")[0]               # → [' Kirui', 'Geoffrey ']   0번 행의 리스트
boston.Name.str.split(", ").str.get(1)       # → 'Geoffrey ', 'Galen   ', ...   각 리스트의 1번 원소
boston.Name.str.split(", ").str.get(0)       # → 'Kirui', 'Rupp', ...
 
boston["First Name"] = boston.Name.str.split(", ").str.get(1)
boston["Last Name"]  = boston.Name.str.split(", ").str.get(0)
 
boston["M/F"].str.cat(boston.Age.astype(str), sep="_")   # → 'M_24', 'M_30', ...

boston.Country.str.slice(0, 2, 1)               # 'KEN' → 'KE'
boston.Country.str.slice(start=-2)              # 'KEN' → 'EN'   뒤에서 두 글자
boston.Country.str.match("ITA")                 # 처음부터 ITA인지 True/False
boston[boston.Country.str.match("ITA")]         # 이탈리아 선수 행만
wills = boston.Name.str.contains("Will")        # 이름 어딘가에 Will이 있는지

boston.Name[boston.Name.str.contains(r"[wW]ill", regex=True)]
# → Vanos, William / Guzick, William F / ... / Williamson, David / ... (15명)
 
boston.Name[boston.Name.str.contains(r",\s[wW]ill$", regex=True)]
# → Cunha, Will / Swenson, Will / Vargas, Will / Rivera, Will   (이름이 정확히 Will)
 
boston["Official Time"].str.replace(
    r"(\d+):(\d+):(\d+)",
    r"\1 hours, \2 minutes, and \3 seconds",
    regex=True,
)
# → '2 hours, 09 minutes, and 37 seconds', ...

<person>
  <name>Chuck</name>
  <phone type="intl">
    +1 734 303 4456
  </phone>
  <email hide="yes" />
</person>

import xml.etree.ElementTree as ET
 
tree = ET.parse("country_data.xml")   # 파일에서 읽기
root = tree.getroot()                 # 뿌리 요소 <data>
 
root.tag        # → 'data'
root.attrib     # → {}            <data>에는 속성이 없음
 
for child in root:
    print(child.tag, child.attrib)
# → country {'name': 'Liechtenstein'}
# → country {'name': 'Singapore'}
# → country {'name': 'Panama'}
 
root[0][1].text   # → '2008'   0번 country의 1번 자식 <year>

for neighbor in root.iter("neighbor"):     # 깊이에 상관없이 모든 <neighbor>
    print(neighbor.attrib)
# → {'name': 'Austria', 'direction': 'E'} ... (5개)
 
for country in root.findall("country"):    # 바로 아래 자식 중 <country>
    rank = country.find("rank").text       # 첫 번째 <rank>의 텍스트
    name = country.get("name")             # 속성 name의 값
    print(name, rank)
# → Liechtenstein 1 / Singapore 4 / Panama 68

for rank in root.iter("rank"):
    new_rank = int(rank.text) + 1
    rank.text = str(new_rank)        # 텍스트 바꾸기 (문자열로 넣어야 함)
    rank.set("updated", "yes")       # 속성 추가
tree.write("output.xml")
 
for country in root.findall("country"):
    rank = int(country.find("rank").text)
    if rank > 50:
        root.remove(country)         # 순위가 50보다 낮은 나라 삭제
tree.write("output2.xml")

root = ET.fromstring(xml_data)
rows = []
for country in root.findall("country"):
    rows.append({
        "name": country.get("name"),
        "rank": int(country.findtext("rank")),
        "year": int(country.findtext("year")),
        "gdppc": int(country.findtext("gdppc")),
        "neighbors": [n.get("name") for n in country.findall("neighbor")],
    })
 
df = pd.DataFrame(rows)
#             name  rank  year   gdppc               neighbors
# 0  Liechtenstein     1  2008  141100  [Austria, Switzerland]
# 1      Singapore     4  2011   59900              [Malaysia]
# 2         Panama    68  2011   13600  [Costa Rica, Colombia]

a = ET.Element("a")            # 뿌리 요소
b = ET.SubElement(a, "b")      # a의 자식
c = ET.SubElement(a, "c")      # a의 자식
d = ET.SubElement(c, "d")      # c의 자식
ET.dump(a)
# → <a><b /><c><d /></c></a>

{"name": "Bob",
 "languages": ["English", "Fench"]
}

import json
 
person = '{"name": "Bob", "languages": ["English", "Fench"]}'   # JSON 문자열
person_dict = json.loads(person)       # 문자열 → 파이썬 dict
person_dict                            # → {'name': 'Bob', 'languages': ['English', 'Fench']}
person_dict["languages"]               # → ['English', 'Fench']
 
with open("person.json") as f:
    data = json.load(f)                # 파일 → 파이썬 dict
 
person_json = json.dumps({"name": "Bob", "age": 12, "children": None})
person_json                            # → '{"name": "Bob", "age": 12, "children": null}'

person_string = '{"name": "Bob", "languages": "English", "numbers": [2, 1.6, null]}'
person_dict = json.loads(person_string)
print(json.dumps(person_dict, indent=4, sort_keys=True))
# {
#     "languages": "English",
#     "name": "Bob",
#     "numbers": [
#         2,
#         1.6,
#         null
#     ]
# }