3. Composite Types

Alert

이 글은 Claude Code의 도움을 받아 작성되었습니다

TL;DR

• Go 배열은 크기가 타입의 일부이므로 실무에서는 슬라이스를 사용
• 슬라이스는 Python list와 유사하지만 append 시 반드시 재할당 필요
• 맵은 Python dict와 거의 동일하나 nil 맵에 쓰기하면 panic 발생
• 구조체는 Python dataclass와 비슷한 역할을 하는 Go의 복합 타입

1. 배열 — 거의 안 쓰지만 알아야 하는 이유

Go의 배열은 C/C++처럼 고정 크기를 가진다. 중요한 점은 크기 자체가 타입의 일부라는 것이다.

var a [3]int  // [3]int 타입
var b [4]int  // [4]int 타입 — a와 다른 타입

[3]int와 [4]int는 서로 다른 타입이기 때문에 대입도, 비교도 안 된다. Python에서 리스트 길이가 타입에 영향을 주지 않는 것과 대조적이다.

a = b  // 컴파일 에러: cannot use b (type [4]int) as type [3]int

배열은 언제 쓰는가

• 실무에서 배열을 직접 쓸 일은 거의 없다
• 슬라이스의 내부 구조를 이해하기 위한 배경 지식 정도로 알아두면 된다
• SHA-256 해시값처럼 크기가 고정된 데이터를 다룰 때 가끔 등장한다

---

2. 슬라이스 — Python list의 Go 버전

슬라이스는 Go에서 가장 많이 쓰는 컬렉션 타입이다. Python의 list와 역할이 같다.

2.1 선언과 초기화

// 리터럴로 선언
var nums = []int{10, 20, 30}
 
// 짧은 선언
names := []string{"alice", "bob"}

Python과 비교하면 이렇다.

# Python
nums = [10, 20, 30]
names = ["alice", "bob"]

// Go
nums := []int{10, 20, 30}
names := []string{"alice", "bob"}

2.2 nil 슬라이스

선언만 하고 초기화하지 않으면 nil 슬라이스가 된다.

var x []int
fmt.Println(x == nil)  // true
fmt.Println(len(x))    // 0

Python의 빈 리스트 []와 다르다. Python에서 []는 유효한 빈 리스트지만, Go의 nil 슬라이스는 아직 메모리가 할당되지 않은 상태다. 다만 len, append 등은 nil 슬라이스에서도 정상 동작한다.

# Python
x = []       # 빈 리스트, None이 아님
x is None    # False

// Go
var x []int  // nil 슬라이스
x == nil     // true
x = append(x, 1)  // 정상 동작

2.3 append — 반드시 재할당

append는 원본 슬라이스를 수정하지 않고 새 슬라이스를 반환한다. 반드시 결과를 재할당해야 한다.

x := []int{1, 2, 3}
x = append(x, 4)          // 반드시 x에 다시 대입
x = append(x, 5, 6, 7)    // 여러 값 동시 추가

Python의 extend에 해당하는 패턴은 ... 연산자를 쓴다.

# Python
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)

// Go
a := []int{1, 2, 3}
b := []int{4, 5, 6}
a = append(a, b...)  // b를 풀어서 append

append를 재할당하지 않으면?

append(x, 10)처럼 결과를 버리면 컴파일러가 에러를 낸다. Python의 list.append()는 원본을 직접 수정(in-place)하므로 반환값을 쓸 필요가 없지만, Go는 다르다.

2.4 슬라이싱 — 부분 추출과 저장 공간 공유

슬라이스에서 일부를 잘라내는 문법은 Python과 거의 같다.

x := []int{10, 20, 30, 40, 50}
y := x[1:3]    // [20, 30] — 인덱스 1부터 3 미만
z := x[:2]     // [10, 20]
w := x[2:]     // [30, 40, 50]

# Python — 동일한 문법
x = [10, 20, 30, 40, 50]
y = x[1:3]    # [20, 30]

하지만 동작 방식이 근본적으로 다르다. Python은 새 리스트를 만들고, Go는 원본 배열을 공유한다.

x := []int{10, 20, 30, 40, 50}
y := x[1:3]    // [20, 30]
y[0] = 999
 
fmt.Println(x) // [10, 999, 30, 40, 50] — 원본도 바뀜!
fmt.Println(y) // [999, 30]

# Python — 원본에 영향 없음
x = [10, 20, 30, 40, 50]
y = x[1:3]
y[0] = 999
print(x)  # [10, 20, 30, 40, 50] — 원본 그대로

Go에서 슬라이싱은 복사가 아니라 같은 내부 배열을 가리키는 뷰(view) 를 만든다. 그래서 한쪽을 수정하면 다른 쪽에도 영향이 간다.

더 위험한 경우는 슬라이싱한 뒤 append를 할 때다. 용량이 남아있으면 원본 데이터를 덮어쓸 수 있다.

x := []int{10, 20, 30, 40, 50}
y := x[:2]     // [10, 20], cap(y) = 5 — 원본의 용량을 그대로 가져감
 
y = append(y, 999)
fmt.Println(x) // [10, 20, 999, 40, 50] — x[2]가 덮어써짐!
fmt.Println(y) // [10, 20, 999]

이 문제를 방지하는 방법이 두 가지 있다.

방법 1: 완전한 슬라이스 표현식 (3-index slice)

세 번째 인덱스로 용량을 제한할 수 있다. x[start:end:cap] 형태다.

x := []int{10, 20, 30, 40, 50}
y := x[:2:2]   // [10, 20], cap(y) = 2 — 용량을 길이와 같게 제한
 
y = append(y, 999)  // 용량 초과 → 새 배열 할당
fmt.Println(x)      // [10, 20, 30, 40, 50] — 원본 안전
fmt.Println(y)      // [10, 20, 999]

세 번째 값이 용량의 끝 위치를 지정한다. x[:2:2]는 “길이 2, 용량도 2”가 되어 append 시 반드시 새 배열이 할당된다.

방법 2: copy 함수

아예 데이터를 복사해서 독립적인 슬라이스를 만든다. Python의 슬라이싱(x[1:3])이 하는 것과 결과적으로 같다.

x := []int{10, 20, 30, 40, 50}
y := make([]int, 2)   // 길이 2짜리 슬라이스를 미리 만든다 (make는 2.6에서 자세히)
copy(y, x[1:3])       // x[1:3]의 내용을 y에 복사
 
y[0] = 999
fmt.Println(x)     // [10, 20, 30, 40, 50] — 원본 안전
fmt.Println(y)     // [999, 30]

copy(dst, src)는 두 슬라이스 중 짧은 쪽의 길이만큼만 복사한다. 그래서 대상(dst)에는 미리 길이가 확보된 슬라이스가 필요하고, 여기서 make를 쓴다. 반환값은 실제로 복사된 원소 수다.

슬라이싱 시 주의

• Go의 슬라이싱은 복사가 아니라 뷰를 만드는 것이다
• 원본과 분리하고 싶으면 copy를 쓰거나, 3-index slice(x[:2:2])로 용량을 제한해야 한다
• Python 개발자는 슬라이싱이 항상 복사인 것에 익숙하므로, Go에서 이 차이를 놓치기 쉽다

2.5 len과 cap

슬라이스에는 길이(length)와 용량(capacity) 두 가지 속성이 있다.

x := []int{1, 2, 3}
fmt.Println(len(x))  // 3 — 현재 원소 개수
fmt.Println(cap(x))  // 3 — 내부 배열의 전체 크기
 
x = append(x, 4)
fmt.Println(len(x))  // 4
fmt.Println(cap(x))  // 6 — 용량이 부족해서 2배로 확장됨

• len: 현재 들어있는 원소 수
• cap: 재할당 없이 담을 수 있는 최대 원소 수

용량이 부족하면 Go 런타임이 더 큰 배열을 새로 할당하고 기존 데이터를 복사한다. 확장 규칙은 대략 다음과 같다. (Go 1.14 기준)

• 현재 용량이 1024 미만이면 2배로 확장
• 1024 이상이면 약 25%씩 확장

Python의 list도 내부적으로 비슷한 동적 배열 구조를 쓴다. 다만 Python에서는 개발자가 capacity를 직접 관리할 일이 없다.

2.6 make — 용량을 미리 지정

크기를 미리 알고 있으면 make로 슬라이스를 생성하면 불필요한 재할당을 줄일 수 있다.

// 길이 5, 용량 5 (기본값으로 cap == len)
a := make([]int, 5)
// a = [0, 0, 0, 0, 0]
 
// 길이 5, 용량 10
b := make([]int, 5, 10)
// b = [0, 0, 0, 0, 0], cap(b) = 10

길이 0, 용량만 지정하는 패턴

크기를 예상할 수 있지만 처음에는 비어있어야 할 때 자주 쓴다.

result := make([]int, 0, 100)
for _, v := range data {
    result = append(result, v*2)
}

2.7 언제 뭘 쓰는가

상황	권장 방식	예시
비어있을 수도 있는 경우	nil 슬라이스	var data []int
초기값이 있는 경우	리터럴	nums := []int{1, 2, 3}
크기를 예상할 수 있는 경우	make	make([]int, 0, n)

// JSON 응답 등에서 값이 없을 수도 있으면 nil 슬라이스
var data []int
 
// 고정된 초기값이 있으면 리터럴
defaults := []string{"en", "ko", "ja"}
 
// 루프 결과를 모을 때 크기를 미리 잡으면 성능 이득
result := make([]int, 0, len(input))

---

3. 맵 — Python dict와 거의 같다

Go의 map은 Python의 dict와 기능이 거의 동일하다. 키-값 쌍을 저장하는 해시 테이블 기반 자료구조다.

3.1 선언과 초기화

// 리터럴
m := map[string]int{
    "alice": 90,
    "bob":   85,
}
 
// make로 빈 맵 생성
scores := make(map[string]int)

# Python
m = {"alice": 90, "bob": 85}
scores = {}

3.2 읽기와 쓰기

m["charlie"] = 78    // 쓰기
score := m["alice"]  // 읽기 — 90

없는 키를 읽으면 Python은 KeyError를 발생시키지만, Go는 해당 값 타입의 zero value를 반환한다.

score := m["unknown"]  // 0 (int의 zero value)

이 동작 때문에 키가 존재하는지 확인하려면 comma ok 관용구를 사용한다.

3.3 comma ok 관용구

v, ok := m["key"]
if !ok {
    fmt.Println("key가 없음")
}

Python에서는 두 가지 방법이 있다.

# Python — 방법 1: get
v = m.get("key")  # 없으면 None
 
# Python — 방법 2: in 연산자
if "key" in m:
    v = m["key"]

Go의 comma ok 패턴은 Python의 dict.get()과 in 검사를 하나로 합친 형태라고 보면 된다.

3.4 삭제

// Go
delete(m, "bob")

# Python
del m["bob"]

Go의 delete는 없는 키를 삭제해도 panic이 발생하지 않는다. Python의 del은 없는 키면 KeyError가 발생한다.

3.5 nil 맵 주의

var m map[string]int  // nil 맵
fmt.Println(m["key"]) // 0 — 읽기는 된다
m["key"] = 1          // panic: assignment to entry in nil map

nil 맵에 쓰기하면 panic

nil 맵은 읽기는 가능하지만 쓰기를 시도하면 런타임 panic이 발생한다. 반드시 make(map[string]int) 또는 리터럴 map[string]int{}로 초기화한 뒤 사용해야 한다.

---

4. 구조체 맛보기

Go의 구조체(struct)는 Python의 dataclass와 비슷한 역할을 한다. 여러 필드를 하나의 타입으로 묶는다.

4.1 Python dataclass와 비교

# Python
from dataclasses import dataclass
 
@dataclass
class User:
    name: str
    age: int

// Go
type User struct {
    Name string
    Age  int
}

4.2 선언과 사용

// var 선언 — 모든 필드가 zero value
var u User
fmt.Println(u.Name)  // "" (빈 문자열)
fmt.Println(u.Age)   // 0
 
// 리터럴 선언
u2 := User{
    Name: "alice",
    Age:  30,
}

Python에서는 기본값을 지정하지 않으면 반드시 인자를 넘겨야 하지만, Go의 구조체는 선언만 하면 모든 필드가 zero value로 초기화된다.

4.3 익명 구조체

일회성으로 데이터를 묶고 싶을 때 타입 이름 없이 구조체를 만들 수 있다.

person := struct {
    Name string
    Age  int
}{
    Name: "bob",
    Age:  25,
}

JSON 변환이나 테스트 코드에서 간단한 데이터를 임시로 담을 때 유용하다.

4.4 구조체 비교와 변환

비교

구조체는 모든 필드가 비교 가능한 타입(숫자, 문자열, bool 등)으로만 이루어져 있으면 ==로 직접 비교할 수 있다. 같은 타입이고 모든 필드 값이 같으면 true다.

type Point struct {
    X int
    Y int
}
 
a := Point{1, 2}
b := Point{1, 2}
c := Point{3, 4}
 
fmt.Println(a == b)  // true — 모든 필드가 같음
fmt.Println(a == c)  // false

단, 슬라이스나 맵 같은 비교 불가능한 필드가 들어있으면 ==를 쓸 수 없고 컴파일 에러가 난다. 이 경우는 reflect.DeepEqual 같은 별도 방법을 써야 한다.

Python에서는 @dataclass가 __eq__를 자동 생성해서 필드 값으로 비교해준다. Go의 구조체 ==도 결과적으로 비슷하지만, 언어 차원에서 기본 제공된다는 점이 다르다.

# Python — dataclass는 값 비교를 자동 지원
a = Point(1, 2)
b = Point(1, 2)
print(a == b)  # True

변환

타입이 다른 두 구조체는 서로 비교할 수 없다. 하지만 필드의 이름, 순서, 타입이 모두 같다면 명시적 타입 변환은 가능하다.

type Point struct {
    X int
    Y int
}
 
type Coord struct {
    X int
    Y int
}
 
p := Point{1, 2}
// fmt.Println(p == Coord{1, 2})  // 컴파일 에러: 타입이 다름
 
c := Coord(p)   // OK — 필드 이름/순서/타입이 같아서 변환 가능
fmt.Println(c)  // {1 2}

필드 구성이 하나라도 다르면(이름, 순서, 타입 중 하나라도) 변환이 안 된다.

type Named struct {
    X int
    Y int
    Label string  // 필드가 하나 더 있음
}
 
// c := Named(p)  // 컴파일 에러: 필드 구성이 다름

비교 vs 변환 정리

• 비교(==) : 같은 타입끼리만 가능, 모든 필드 값이 같으면 true
• 변환 : 타입이 달라도 필드의 이름/순서/타입이 완전히 같으면 명시적 변환 가능
• 슬라이스·맵 필드가 있으면 == 비교 불가 (reflect.DeepEqual 사용)