실제 서비스 형태로 확장하기 위해서 이번 작업에서는 앱 개발에 필요한 핵심 인프라(라우팅/데이터/스타일)를 먼저 붙여서 “뼈대”를 만들었다.

• 라우팅: 페이지 단위 구조(리스트/상세/설정 등)로 확장 가능해야 함
• 서버 상태 관리: API 요청/캐싱/로딩/재요청 정책을 표준화하고 싶음
• 스타일링: 템플릿 기본 CSS 대신 Tailwind 기반으로 빠르게 UI를 잡고 싶음

이번 작업 목표

• React Router로 기본 라우팅 구조 구성
• TanStack React Query로 API 호출 표준(캐싱/리패치 정책) 구성
• Tailwind CSS v4로 전역 스타일 엔트리 정리
• Vite 템플릿 보일러플레이트(기본 로고/기본 CSS) 제거
• LiveReserveList 페이지용 플레이스홀더 화면 추가

변경 사항 한눈에 보기

1) Tailwind CSS v4 적용

1-1. Vite 설정에 Tailwind 플러그인 추가

vite.config.ts에 @tailwindcss/vite 플러그인을 추가했다.

    import { defineConfig } from "vite";
    import react from "@vitejs/plugin-react";
    import tailwindcss from "@tailwindcss/vite";

    export default defineConfig({
        plugins: [
            react({
                babel: {
                    plugins: [["babel-plugin-react-compiler"]],
                },
            }),
            tailwindcss(),
        ],
    });

1-2. 전역 CSS를 Tailwind 엔트리로 정리

기존 Vite 템플릿 기본 CSS를 제거하고 src/index.css를 아래처럼 단순화했다.

    @import "tailwindcss";

이제부터 컴포넌트에서 className="bg-red-50" 같은 Tailwind 유틸 클래스를 바로 쓸 수 있다.

2) TanStack React Query 세팅

2-1. QueryClient를 파일로 분리

src/libs/queryClient.ts를 만들고 QueryClient 인스턴스를 분리했다.

    import { QueryClient } from "@tanstack/react-query";

    const queryClient = new QueryClient();

    export default queryClient;

2-2. 앱 루트에 Provider 연결

src/main.tsx에서 앱 전체를 QueryClientProvider로 감쌌다.

    import { StrictMode } from "react";
    import { createRoot } from "react-dom/client";
    import "./index.css";
    import { RouterProvider } from "react-router";
    import { QueryClientProvider } from "@tanstack/react-query";

    import router from "./routes";
    import queryClient from "./libs/queryClient";

    createRoot(document.getElementById("root")!).render(
        <StrictMode>
            <QueryClientProvider client={queryClient}>
                <RouterProvider router={router} />
            </QueryClientProvider>
        </StrictMode>,
    );

이렇게 해두면 이후 어떤 페이지/컴포넌트에서도 useQuery, useMutation을 바로 사용할 수 있다.

3) React Router 기본 라우팅 구성

src/routes.tsx를 새로 만들고, createBrowserRouter로 라우트를 정의했다.

    import { createBrowserRouter } from "react-router";
    import App from "./App";
    import LiveReserveList from "./liveReserveList";

    const router = createBrowserRouter([
        {
            path: "/",
            element: <App />,
        },        
        {
            path: "liveReserveList",
            element: <LiveReserveList />,
        },
    ]);

    export default router;

현재는 최소 단위로 아래 3개만 잡아두고, 앞으로 페이지가 늘어날 수 있게 구조를 열어뒀다.

• / → App
• /liveReserveList → LiveReserveList

4) LiveReserveList 플레이스홀더 추가

라우팅만 먼저 연결해두고, 화면 개발은 다음 단계에서 진행하기 위해 간단한 플레이스홀더를 만들었다.

    export default function LiveReserveList() {
        return <div>LiveReserveList</div>;
    }

5) 템플릿 보일러플레이트 제거 + App 화면 정리

템플릿에 기본으로 들어있던 아래 파일을 제거했다.

• src/App.css
• src/assets/react.svg

그리고 App.tsx는 “템플릿 데모 화면” 대신 아래 두 가지를 확인하는 용도로 바꿨다.

• NavLink로 라우팅 동작 확인
• useQuery로 API 호출 방식/옵션 테스트

    import { useQuery } from "@tanstack/react-query";
    import { NavLink, useNavigation } from "react-router";

    function App() {
        const navigation = useNavigation();

        useQuery({
            queryKey: ["hi"],
            queryFn: async () => {
                const response = await fetch(
                    "https://www.mallprolive.co.kr/api/1.0/minishop/info",
                    {
                        method: "post",
                        headers: {
                            "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
                        },
                        body: "dealerID=test01",
                    },
                );

                const jsonData = await response.json();
                console.log(jsonData);
            },
            staleTime: 60_000,
            refetchOnMount: false,
            refetchOnWindowFocus: false,
            refetchOnReconnect: false,
        });

        return (
            <>
                <div className="bg-red-50">테스트1</div>
                <NavLink to="about">테스트2</NavLink>
            </>
        );
    }

    export default App;

마무리

이번 작업으로 “페이지 구조(라우팅) + 서버 상태 관리(React Query) + 스타일링(Tailwind)”의 기본 세팅을 끝냈다. 이제부터는 LiveReserveList 같은 실제 페이지 개발을 빠르게 진행할 수 있는 상태가 됐다.

목적: 팀 프론트엔드 프로젝트를 시작할 때 각 기술의 역할/개념/필수 용어/설정 포인트/실무 주의사항을 한 문서로 정리했다.
범위: 아래 7개 스택의 “기본적으로 알아야 하는 내용”을 가능한 한 빠짐없이 포함했다.

0. 한 줄 역할 맵

• Vite: 개발 서버/빌드(번들링, HMR)
• React 19: UI 컴포넌트 기반 렌더링(상태 기반)
• TypeScript: 타입 안정성(협업/리팩토링 안전)
• Tailwind CSS v4: 유틸리티 퍼스트 스타일링(빠른 UI/일관성)
• React Router: URL 기반 화면 구성(레이아웃/중첩 라우트)
• TanStack Query: 서버 데이터 패칭/캐싱/동기화 표준
• React Compiler: 렌더 최적화 자동화(자동 memoization 방향)

1) Vite

1-1. Vite가 뭔가

• 프론트엔드 빌드 도구(Dev Server + Bundler).
• 개발 중에는 ESM(ECMAScript Modules) 기반으로 빠르게 로딩하고,
• 빌드 시에는 Rollup 기반 번들링을 수행한다.

1-2. 왜 쓰나

• 개발 서버가 매우 빠름: 필요한 모듈만 즉시 서빙(필요할 때만 변환).
• HMR(Hot Module Replacement)이 빠르고 안정적.
• React/TS/Tailwind 플러그인 생태계가 좋고 설정이 단순한 편.

1-3. 개발/빌드 동작 방식 (핵심)

개발(Dev)

• 브라우저가 import 하는 모듈을 Vite dev server가 그때그때 변환해서 제공.
• 전체 번들링을 매번 하지 않으니 시작/수정 반영이 빠름.

프로덕션 빌드(Build)

• Rollup으로 번들 파일 생성, 코드 스플리팅(청크 분리), 트리쉐이킹 적용.
• 보통 dist/에 산출물 생성(설정에 따라 변경 가능).

1-4. 프로젝트에서 꼭 아는 설정 포인트

• vite.config.ts에서 플러그인/빌드 옵션/별칭(alias)/프록시(proxy) 등을 설정한다.
• 팀 프로젝트에서 특히 자주 만지는 것:
  • base: 서브 디렉토리 배포 시 정적 리소스 경로 대응
  • server.proxy: 로컬에서 API 프록시(CORS 회피)
  • resolve.alias: @/ 별칭 통일

예시(개념용):

    import { defineConfig } from "vite";
    import react from "@vitejs/plugin-react";

    export default defineConfig({
        base: "/",
        plugins: [react()],
        resolve: {
            alias: {
                "@": "/src",
            },
        },
        server: {
            proxy: {
                "/api": {
                    target: "https://example.com",
                    changeOrigin: true,
                },
            },
        },
    });

1-5. 환경변수 기본

• Vite는 import.meta.env를 사용한다.
• 클라이언트에서 접근 가능한 변수는 기본적으로 VITE_ prefix가 필요하다.
  • 예: VITE_API_BASE_URL, VITE_APP_BASENAME

1-6. 흔한 실수

• base 미설정으로 운영에서 CSS/JS 404
• SPA 라우팅인데 서버에서 index.html 리라이트 설정이 없어 새로고침 404
• .env 수정 후 dev 서버 재시작 안 해서 환경변수 반영 안 됨

2) React 19

2-1. React가 뭔가

• UI를 컴포넌트 단위로 구성하는 라이브러리.
• 상태(state)가 바뀌면 UI를 다시 그린다는 선언적(Declarative) 모델.

2-2. 핵심 개념

컴포넌트

• 함수 컴포넌트가 기본.
• props로 입력을 받고 JSX를 반환한다.

상태(state)

• useState 등으로 관리.
• state가 바뀌면 해당 컴포넌트가 리렌더링된다.

렌더링/리렌더

• 리렌더는 “DOM을 다 갈아엎는다”가 아니라, 변경점을 계산해 DOM에 반영한다.
• 다만 컴포넌트 함수 자체는 다시 실행되므로 렌더 안에서 만드는 객체/함수는 매번 새로 만들어질 수 있다(성능 포인트).

이펙트(effect)

• useEffect는 렌더 결과가 화면에 반영된 뒤 실행된다.
• 데이터 요청/구독/DOM 핸들링 같은 “렌더 외부 작업”에 사용한다.

2-3. 실무에서 자주 나오는 포인트

• 서버에서 오는 데이터는 useState에 복사해서 들고 있기보다 React Query로 관리하는 편이 안전하다(싱크 이슈 감소).
• 상태 업데이트에서 이전 값을 기반으로 할 때는 함수형 업데이트를 사용한다.

    setCount((prev) => prev + 1);

2-4. 흔한 실수

• useEffect 의존성 배열을 잘못 잡아서 무한 루프
• 렌더 중에 무거운 계산/정렬/필터를 매번 수행(메모/컴파일러/구조 개선 고려)

3) TypeScript

3-1. TypeScript가 뭔가

• JavaScript에 정적 타입 시스템을 추가한 언어(컴파일하면 JS).
• 런타임이 아니라 개발/빌드 시점에 타입 에러를 잡는다.

3-2. 왜 쓰나

• 협업/유지보수에서:
  • API 데이터 형태 변경을 컴파일 에러로 감지
  • 컴포넌트 props 계약 명확화
  • 리팩토링 안전성 증가

3-3. 기본 타입 개념 (필수)

• 타입 추론(type inference)
• 타입 선언(type annotation)
• 유니온/인터섹션: A | B, A & B
• 제네릭(generics): 타입을 매개변수로 받는 패턴(React Query, 공용 컴포넌트)
• 타입 vs 인터페이스
  • 복잡한 타입 연산/유니온: type 선호
  • 객체 확장/선언 병합: interface 고려

3-4. React에서 자주 쓰는 TS 패턴

Props 타입

    type ButtonProps = {
        label: string;
        onClick: () => void;
        disabled?: boolean;
    };

    export function Button(props: ButtonProps) {
        return (
            <button disabled={props.disabled} onClick={props.onClick}>
                {props.label}
            </button>
        );
    }

이벤트 타입

    function onChange(e: React.ChangeEvent<HTMLInputElement>) {
        console.log(e.target.value);
    }

API 응답 타입

    type User = {
        id: string;
        name: string;
    };

    async function fetchUser(): Promise<User> {
        const res = await fetch("/api/user");
        if (!res.ok) throw new Error("Failed");
        return (await res.json()) as User;
    }

3-5. 흔한 실수/팁

• any 남발 금지(가능하면 unknown + 타입가드)
• API 응답을 무조건 as Type로 단언하면 런타임 오류를 놓칠 수 있음(필요 시 검증 레이어 고려)

4) Tailwind CSS v4 (@tailwindcss/vite)

4-1. Tailwind가 뭔가

• 유틸리티 클래스를 조합해 UI를 만드는 유틸리티-퍼스트 CSS 프레임워크.
• 예: bg-black text-white px-4 py-2 rounded

4-2. 왜 쓰나

• 스타일링 속도가 빠르고, 컴포넌트와 스타일이 가까워 유지보수가 쉬운 경우가 많다.
• 반응형/상태(hover/focus)/다크모드 패턴을 빠르게 적용 가능.
• 팀에서 규칙을 잡으면 UI 통일이 쉬움.

4-3. v4에서 알아둘 포인트

• 프로젝트 구성에 따라 다르지만, src/index.css에 아래처럼 단순하게 시작하는 형태가 많다.

    @import "tailwindcss";

• Vite 통합은 @tailwindcss/vite 플러그인을 통해 이뤄진다.

4-4. 핵심 사용 규칙

반응형

    <div className="p-4 md:p-8 lg:p-12">...</div>

상태

    <button className="bg-black text-white hover:opacity-80 disabled:opacity-40">
        Save
    </button>

다크모드

    <div className="bg-white text-black dark:bg-neutral-900 dark:text-white">
        ...
    </div>

4-5. 흔한 실수/팁

• className이 너무 길어짐 → 공용 UI로 추출하거나 cn() 유틸로 조건부 결합
• 디자인 토큰(간격/라운드/텍스트 크기)을 정하지 않으면 화면마다 제각각이 되기 쉬움

5) React Router (createBrowserRouter)

5-1. React Router가 뭔가

• SPA에서 URL에 따라 컴포넌트를 렌더링하는 라우팅 라이브러리.
• createBrowserRouter는 라우트 트리를 객체로 선언하고 RouterProvider로 주입한다.

5-2. 기본 구성 예시

    import { createBrowserRouter } from "react-router-dom";
    import App from "./App";

    export const router = createBrowserRouter([
        { path: "/", element: <App /> },
        { path: "/about", element: <div>안녕~</div> },
    ]);

    import { RouterProvider } from "react-router-dom";
    import { router } from "./routes";

    export function Root() {
        return <RouterProvider router={router} />;
    }

5-3. 기본적으로 알아야 할 개념

• Route: path와 element로 매핑
• Nested Routes(중첩 라우트): 레이아웃 공유 시 사용, <Outlet />로 자식 렌더
• Loader/Action(데이터 라우터 기능): 라우트 레벨 데이터 처리(팀 정책에 따라 사용 여부 결정)

6) @tanstack/react-query (TanStack Query)

6-1. React Query가 뭔가

• React에서 “서버 상태(server state)”를 관리하기 위한 라이브러리.
• 패칭(fetch), 캐싱(cache), 동기화(sync), 재시도(retry), 백그라운드 갱신을 표준화한다.

6-2. 왜 필요한가

React 기본 state로 서버 데이터를 관리하면:

• 로딩/에러/성공 상태를 매번 수동 구현
• 캐싱/중복요청 방지/재시도/갱신 전략을 직접 구현
• 여러 화면에서 같은 데이터를 쓸 때 동기화가 어렵다

React Query는 이걸 규칙으로 해결한다.

6-3. 가장 중요한 개념들(필수)

• Query: 읽기 요청(조회)
• Mutation: 쓰기 요청(생성/수정/삭제)
• Query Key: 캐시 식별자(배열 형태 권장)
• staleTime / gcTime(cacheTime): 신선도/캐시 유지 시간
• refetch 옵션: mount/focus/reconnect 시 재요청 제어

6-4. 기본 사용 패턴

QueryClientProvider

    import { QueryClient, QueryClientProvider } from "@tanstack/react-query";

    const queryClient = new QueryClient();

    export function Root() {
        return (
            <QueryClientProvider client={queryClient}>
                {/* router 등 */}
            </QueryClientProvider>
        );
    }

useQuery

    import { useQuery } from "@tanstack/react-query";

    type User = { id: string; name: string };

    async function fetchUsers(): Promise<User[]> {
        const res = await fetch("/api/users");
        if (!res.ok) throw new Error("Failed to fetch users");
        return (await res.json()) as User[];
    }

    export function Users() {
        const { data, isLoading, error } = useQuery({
            queryKey: ["users"],
            queryFn: fetchUsers,
            staleTime: 60_000,
        });

        if (isLoading) return <div>Loading...</div>;
        if (error) return <div>Error</div>;

        return (
            <ul>
                {data?.map((u) => (
                    <li key={u.id}>{u.name}</li>
                ))}
            </ul>
        );
    }

useMutation + invalidate

    import { useMutation, useQueryClient } from "@tanstack/react-query";

    async function createUser(name: string) {
        const res = await fetch("/api/users", {
            method: "POST",
            headers: { "Content-Type": "application/json" },
            body: JSON.stringify({ name }),
        });
        if (!res.ok) throw new Error("Failed to create user");
        return res.json();
    }

    export function CreateUser() {
        const qc = useQueryClient();

        const mutation = useMutation({
            mutationFn: createUser,
            onSuccess: async () => {
                await qc.invalidateQueries({ queryKey: ["users"] });
            },
        });

        return <button onClick={() => mutation.mutate("Kim")}>Add</button>;
    }

6-5. 실무에서 꼭 정해야 하는 규칙

• queryKey 네이밍/구조(예: ["liveReserve", "list", params])
• 에러 처리 UX(토스트/페이지/재시도)
• 공통 fetch 래퍼(인증/에러 파싱/상태 코드 처리)

7) React Compiler (babel-plugin-react-compiler)

7-1. React Compiler가 뭔가

• React 코드를 분석해 자동 memoization 최적화를 적용하려는 컴파일러.
• 목표: 개발자가 useMemo, useCallback, React.memo를 “언제 붙일지” 덜 고민해도 되게.

7-2. 핵심 아이디어(쉽게)

• 컴포넌트는 렌더 때마다 함수가 실행되므로:
  • 렌더 안에서 만든 객체/배열/함수는 매번 새 참조가 생길 수 있고
  • props로 내려가면 자식 리렌더가 늘어날 수 있다
• 컴파일러는 “이 값은 변하지 않는다”를 분석해 참조를 안정적으로 재사용하도록 변환한다(가능한 경우).

7-3. 프로젝트에서 어떻게 적용되나

• Vite의 React 플러그인(Babel 단계)에 babel-plugin-react-compiler로 포함된다.
• 개발자는 별도 코드를 추가하지 않아도 빌드 단계에서 최적화 코드가 생성된다.

7-4. 장점

• 수동 최적화(useMemo/useCallback)로 인한 복잡도를 줄일 수 있음
• 컴포넌트가 많아질수록 불필요한 리렌더를 줄일 가능성

7-5. 주의할 점(실무)

• 컴파일러는 “분석”을 하므로:
  • 일부 코드 패턴에서 제약/예상치 못한 동작이 있을 수 있음
  • 빌드/디버깅 경험에 영향이 있을 수 있음
• “무조건 빨라진다”는 보장은 없음
  → 렌더 구조/데이터량/리스트 크기 같은 근본 병목이 더 중요함

부록 A) 이 스택으로 일할 때 기본 운영 원칙

• 서버 데이터는 React Query로: 로딩/에러/캐싱/동기화를 표준화
• 라우팅 경로는 상수화: 문자열 하드코딩 최소화
• Tailwind 토큰 규칙: 간격/라운드/텍스트 기본값만이라도 팀 합의
• Vite base/basename: 서브패스 배포 가능성 있으면 초기에 확정(운영 이슈 예방)
• 타입은 억지로 엄격하게가 아니라 “핵심 경계(API/Props)”부터 잡기

부록 B) 체크리스트(도입/온보딩용)

• bun install / bun run dev 동작 확인
• 라우팅 새로고침(직접 URL 진입) 시 404 여부 확인(서버 리라이트)
• 환경변수 VITE_ prefix 확인 + dev 서버 재시작
• React Query 전역 Provider 주입 + queryKey 규칙 문서화
• Tailwind 적용 확인 + 다크모드 정책(선택) 합의
• 배포 경로(base/basename) 운영 환경과 일치 확인

📘 개념 설명

• input()은 문자열을 입력받는다.
• 공백으로 구분된 여러 값을 받을 땐 .split()을 사용한다.
• 문자열을 숫자로 연산하려면 반드시 int() 또는 float()로 형 변환이 필요하다.
• 문자열 결합 시 +를 사용할 수 있지만, 숫자는 반드시 str()로 변환해야 한다.

🔹 기본 예시

a, b = map(int, input().split())
print(f"{a} + {b} = {a + b}")

📝 연습문제

다음 코드를 실행했을 때의 출력 결과를 작성하시오. (입력값은 2 3이다.)

print("파이썬 입출력에 대한 문제입니다.")
num1, num2 = input().split()
num1 = int(num1)
num2 = int(num2)
print(num1, num2)
print(f"{num1} + {num2} = {num1 + num2}")

✅ 해설

1. input() → "2 3"
2. .split() → ['2', '3']
3. int() 변환 → num1=2, num2=3
4. 출력 흐름:

   파이썬 입출력에 대한 문제입니다.
   2 3
   2 + 3 = 5

✨ 2장. 자료형과 type() 함수

📘 개념 설명

• type()은 객체의 자료형을 반환한다.
• int, float, str, tuple, set, dict 등이 주요 자료형이다.
• isinstance(x, int)는 좀 더 권장되는 방식이다.

🔹 예시

type(100)      # <class 'int'>
type('100')    # <class 'str'>
type(100.0)    # <class 'float'>

📝 연습문제

def func(value):
    if type(value) == type(100):
        return 100
    elif type(value) == type(""):
        return len(value)
    else:
        return 20

a = '100.0'
b = 100.0
c = (100, 200)
print(func(a) + func(b) + func(c))

✅ 해설

• 출력 결과:

  45

✨ 3장. 문자열 슬라이싱

📘 개념 설명

• 문자열은 불변 객체(immutable) 이며, 인덱스로 접근 가능하다.
• 문자열[start:end] → start부터 end-1까지
• 부분 문자열을 잘라 결합할 수 있다.

🔹 예시

a = "REMEMBER NOVEMBER"
print(a[:3])      # REM
print(a[12:16])   # EMBE

📝 연습문제

a = "REMEMBER NOVEMBER"
b = a[:3] + a[12:16]
c = "R AND %s" % "STR"
print(b + c)

✅ 해설

• a[:3] → "REM"

• a[12:16] → "EMBE"

• c → "R AND STR"

• b + c → "REMEMBE" + "R AND STR" = REMEMBER AND STR

• 출력:

  REMEMBER AND STR

✨ 4장. 리스트와 슬라이싱

📘 개념 설명

• 리스트는 가변 객체(mutable) 로 수정 가능하다.
• 인덱스: 0부터 시작.
• lst[::2] → 짝수 인덱스, lst[1::2] → 홀수 인덱스.

🔹 예시

lst = [1,2,3,4,5,6]
print(lst[::2])  # [1,3,5]
print(lst[1::2]) # [2,4,6]

📝 연습문제

def func(lst):
    for i in range(len(lst)//2):
        lst[i], lst[-i-1] = lst[-i-1], lst[i]

lst = [1,2,3,4,5,6]
func(lst)
print(sum(lst[::2]) - sum(lst[1::2]))

✅ 해설

• 리스트 뒤집기 후: [6,5,4,3,2,1]

• 짝수 인덱스 합: 6 + 4 + 2 = 12

• 홀수 인덱스 합: 5 + 3 + 1 = 9

• 결과: 12 - 9 = 3

• 출력:

  3

✨ 5장. 딕셔너리 내포와 집합(Set)

📘 개념 설명

• dict는 {key: value} 형태.
• 집합(set)은 중복이 없고, 순서가 없다.
• & 연산자는 교집합을 구한다.

  dst = {i: i*2 for i in [1,2,3]}  # {1:2, 2:4, 3:6}
  s = set(dst.values())             # {2,4,6}

📝 연습문제

lst = [1,2,3]
dst = {i: i*2 for i in lst}
s = set(dst.values())
dst[2] = 7
s.add(99)
print(len(s & set(dst.values())))

✅ 해설

• dst = {1:2, 2:7, 3:6}

• s = {2,4,6,99}

• 교집합 {2,6} → 길이 2

• 출력:

  2

✨ 6장. 함수의 기본값 인자

📘 개념 설명

• 함수 정의 시 인자에 기본값을 줄 수 있다.
• 호출 시 값을 생략하면 기본값이 사용된다.

🔹 예시

def add(a, b=10):
    return a + b

📝 연습문제

def exam(num1, num2=2):
    print('a=', num1, 'b=', num2)
exam(20)

✅ 해설

• num1 = 20, num2는 기본값 2 사용

• 출력:

  a= 20 b= 2

✨ 7장. 람다(lambda)와 map()

📘 개념 설명

• lambda는 간단한 익명 함수 정의 방법이다.
• map()은 리스트 요소 전체에 함수를 적용한다.

🔹 예시

nums = [1,2,3]
print(list(map(lambda x: x+10, nums)))  # [11,12,13]

📝 연습문제

TestList = [1,2,3,4,5]
TestList = list(map(lambda num : num + 100, TestList))
print(TestList)

✅ 해설

• 각 요소에 100을 더함 → [101,102,103,104,105]

✨ 8장. 중첩 리스트(for문 2중 순회)

📘 개념 설명

• 리스트 안의 리스트를 순회할 때는 이중 for문을 사용한다.

📝 연습문제

lol = [[1,2,3],[4,5],[6,7,8,9]]
print(lol[0])
print(lol[2][1])
for sub in lol:
    for item in sub:
        print(item, end = '')
    print()

✅ 해설

1. lol[0] → [1, 2, 3]
2. lol[2][1] → 7
3. 반복문 출력:

   123
   45
   6789

✨ 9장. 부분 문자열 탐색

📘 개념 설명

• 문자열에서 특정 패턴이 등장하는 횟수를 구할 때, 슬라이싱으로 부분 문자열을 비교하는 기법이 자주 쓰인다.

📝 연습문제

def fnCalculation(x,y):
    result = 0
    for i in range(len(x)):
        temp = x[i:i+len(y)]
        if temp == y:
            result += 1
    return result

a = "abdcabcabca"
p1 = "ab"
p2 = "ca"
print(f"ab{fnCalculation(a,p1)}ca{fnCalculation(a,p2)}")

✅ 해설

• "ab" 3회

• "ca" 3회 → "ab3ca3"

• 출력:

  ab3ca3

✨ 10장. 트리 구조와 재귀

📘 개념 설명

• 재귀함수를 이용해 트리 탐색을 구현할 수 있다.
• 이진 트리의 부모 인덱스 = (i-1)//2

📝 연습문제

class Node:
    def __init__(self, value):
        self.value = value
        self.children = []

def tree(li):
    nodes = [Node(i) for i in li]
    for i in range(1, len(li)):
        nodes[(i - 1) // 2].children.append(nodes[i])
    return nodes[0]

def calc(node, level=0):
    if node is None:
        return 0
    return (node.value if level % 2 == 1 else 0) + sum(calc(n, level + 1) for n in node.children)

li = [3,5,8,12,15,18,21]
root = tree(li)
print(calc(root))

✅ 해설

• 트리 구조:

        3
      /   \
     5     8
   /  \   / \
  12  15 18 21

• 홀수 레벨: 5 + 8 = 13

• 출력:

  13

lst = [1, 2, 3]
dst = {i: i * 2 for i in lst}
s = set(dst.values())
lst[0] = 99
dst[2] = 7
s.add(99)
print(len(s & set(dst.values())))

🎯 출제 의도

• 딕셔너리 내포(Dictionary Comprehension) 문법 이해
• set(집합) 자료형의 특징과 연산자(&) 이해
• 객체 간 참조 변경과 자료 구조 간 독립성 확인
• len() 과 교집합 결과의 길이 계산

📘 개념 정리

1. 딕셔너리 내포 (Dictionary Comprehension)

dst = {i: i * 2 for i in lst}

• lst = [1, 2, 3]
• 각 i에 대해 key=i, value=i*2

➡ 결과:

dst = {1: 2, 2: 4, 3: 6}

2. 집합 생성

s = set(dst.values())

• 딕셔너리의 value들 {2, 4, 6}을 set으로 변환 ➡ s = {2, 4, 6}

3. 리스트 변경

lst[0] = 99

• 리스트 첫 번째 값이 바뀌어도, 이미 생성된 dst는 리스트와 연결되지 않음 (깊은 복사 X) ➡ dst는 여전히 {1: 2, 2: 4, 3: 6} 유지됨.

4. 딕셔너리 값 변경

dst[2] = 7

➡ dst는 {1: 2, 2: 7, 3: 6} ➡ dst.values() = [2, 7, 6]

5. 집합에 값 추가

s.add(99)

➡ s = {2, 4, 6, 99}

6. 교집합 연산

s & set(dst.values())

• s = {2, 4, 6, 99}
• set(dst.values()) = {2, 7, 6}
• 교집합(&) → {2, 6}

7. 길이 계산

len({2, 6}) = 2

✅ 최종 출력 결과

2

💡 정리

이 문제에서 꼭 알아야 할 개념:

class Node:
    def __init__(self, value):
        self.value = value
        self.children = []

def tree(li):
    nodes = [Node(i) for i in li]
    for i in range(1, len(li)):
        nodes[(i - 1) // 2].children.append(nodes[i])
    return nodes[0]

def calc(node, level=0):
    if node is None:
        return 0
    return (node.value if level % 2 == 1 else 0) + sum(calc(n, level + 1) for n in node.children)

li = [3, 5, 8, 12, 15, 18, 21]

root = tree(li)

print(calc(root))

🎯 출제 의도

• 리스트로 이진 트리 구조를 구성하는 방식 이해
• (i - 1) // 2 로 부모-자식 관계 계산 원리 파악
• 재귀함수와 level(깊이) 활용 구조 이해
• 짝수/홀수 레벨 조건 처리 (level % 2 == 1) 확인

📘 개념 정리

1. 트리 구조 생성

for i in range(1, len(li)):
    nodes[(i - 1) // 2].children.append(nodes[i])

• (i - 1) // 2는 이진 트리의 부모 인덱스 계산 공식이다.
• 예:

➡ 트리 구조를 그리면 아래와 같다:

          3(level 0)
       /           \
     5(level 1)    8(level 1)
   /     \        /     \
12(2)   15(2)  18(2)   21(2)

2. calc(node, level) 함수 분석

return (node.value if level % 2 == 1 else 0) + sum(calc(n, level + 1) for n in node.children)

• 홀수 레벨(level % 2 == 1)이면 해당 노드의 value를 더함
• 자식 노드가 있다면 재귀적으로 다음 레벨(level+1) 탐색
• 최종적으로 모든 노드를 돌며 홀수 레벨 노드들의 합을 계산

📝 풀이 과정

따라서 최종 합은

13

✅ 최종 출력 결과

13

💡 정리

이 문제에서 꼭 알아야 할 개념:

• 이진 트리 부모 인덱스 계산식: (i - 1) // 2
• 홀수 레벨(level % 2 == 1) 노드만 더함
• 재귀 구조: sum(calc(n, level + 1) for n in node.children) 로 하위 노드 전체 탐색
• 트리 깊이별 구조 시각화로 로직을 쉽게 이해할 수 있음.

def func(lst):
    for i in range(len(lst)//2):
        lst[i], lst[-i-1] = lst[-i-1], lst[i]

lst = [1, 2, 3, 4, 5, 6]
func(lst)
print(sum(lst[::2]) - sum(lst[1::2]))

🎯 출제 의도

• 리스트 인덱스 음수 처리(-i-1) 개념 이해
• 리스트의 절반 교환 구조(역순) 파악
• 슬라이싱 lst[::2], lst[1::2] 의미와 합계 비교

📘 개념 정리

1. 리스트 교환 구조

for i in range(len(lst)//2):
    lst[i], lst[-i-1] = lst[-i-1], lst[i]

• len(lst) // 2 → 리스트 길이의 절반만 반복 (대칭 교환)
• lst[i] ↔ lst[-i-1] → 맨 앞과 맨 뒤부터 차례로 자리 바꿈

2. 초기 리스트 상태

lst = [1, 2, 3, 4, 5, 6]

• 길이 = 6 → len(lst)//2 = 3 → i = 0, 1, 2 일 때만 반복

📝 풀이 과정

✅ 최종 리스트:

[6, 5, 4, 3, 2, 1]

• 슬라이싱 분석

  • lst[::2] → 짝수 인덱스(0,2,4)

    [6, 4, 2]
    sum = 12

  • lst[1::2] → 홀수 인덱스(1,3,5)

    [5, 3, 1]
    sum = 9

🧮 최종 계산

sum(lst[::2]) - sum(lst[1::2])
= 12 - 9
= 3

✅ 최종 출력 결과

3

💡 정리

이 문제에서 꼭 알아야 할 개념:

• 음수 인덱스(-i-1) 는 뒤에서부터 접근한다.
  • lst[-1] → 마지막 원소
  • lst[-i-1] → 뒤에서 (i+1)번째 원소
• 리스트 길이의 절반만 교환하면 전체가 뒤집힌다.
• 슬라이싱
  • lst[::2] → 0,2,4,… (짝수 인덱스)
  • lst[1::2] → 1,3,5,… (홀수 인덱스)
• 합계 차이 계산: 짝수 인덱스 합 - 홀수 인덱스 합

def fnCalculation(x, y):
    result = 0
    for i in range(len(x)):
        temp = x[i:i+len(y)]
        if temp == y:
            result += 1
    return result

a = "abdcabcabca"
p1 = "ab"
p2 = "ca"

out = f"ab{fnCalculation(a, p1)}ca{fnCalculation(a, p2)}"
print(out)

🎯 출제 의도

• 문자열 슬라이싱(x[i:i+len(y)]) 의 범위 동작 이해
• 부분 문자열(substring) 탐색 로직 파악
• 포매팅 f-string 의 활용법 (f"문자열{값}")
• for문 + if 조건문 을 이용한 카운트 알고리즘 이해

📘 개념 정리

1. 함수 fnCalculation(x, y)의 역할

def fnCalculation(x, y):
    result = 0
    for i in range(len(x)):
        temp = x[i:i+len(y)]
        if temp == y:
            result += 1
    return result

• 문자열 x 안에서, 부분 문자열 y가 몇 번 등장하는지 세는 함수
• x[i:i+len(y)] 로 슬라이싱하여 길이 len(y)인 부분 문자열을 순서대로 비교
• 일치할 때마다 result 값 1 증가

2. 변수 값 확인

a = "abdcabcabca"
p1 = "ab"
p2 = "ca"

📝 풀이 과정

1. fnCalculation(a, p1) → "ab" 찾기

✅ "ab"는 총 3회 등장

2. fnCalculation(a, p2) → "ca" 찾기

✅ "ca"도 총 3회 등장

3. 최종 문자열 조합

   out = f"ab{fnCalculation(a, p1)}ca{fnCalculation(a, p2)}"

• fnCalculation(a, p1) → 3
• fnCalculation(a, p2) → 3 ➡ "ab" + "3" + "ca" + "3" → "ab3ca3"

✅ 최종 출력 결과

ab3ca3

💡 정리

이 문제에서 꼭 알아야 할 개념:

• 슬라이싱 규칙 a[i:i+len(y)] → 인덱스 i부터 len(y) 길이만큼의 부분 문자열 추출
• 문자열 비교 if temp == y: → 부분 문자열이 같을 때만 카운트
• for문 범위 range(len(x)) 으로 모든 시작 인덱스 순회
• f-string f"ab{값}ca{값}" 형태로 문자열과 변수 결합 가능
• 문자열 "ab3ca3"은 p1, p2 각각 3회 등장 결과를 반영한 것이다.

a = ["Seoul", "Kyeonggi", "Incheon", "Daejun", "Daegu", "Pusan"]
str = "S"

for i in a:
    str = str + i[1]

print(str)

🎯 출제 의도

• 리스트 요소 접근과 반복문(for) 의 기본 구조 이해
• 문자열의 인덱싱(i[1]) 개념 확인
• 문자열 덧셈(연결) 동작 파악

📘 개념 정리

1. 리스트 구조.

a = ["Seoul", "Kyeonggi", "Incheon", "Daejun", "Daegu", "Pusan"]

2. 문자열 누적 구조

str = "S"
for i in a:
    str = str + i[1]

• 반복문이 돌 때마다, 각 도시 이름의 두 번째 글자(i[1]) 를 이어붙임.
• str 변수에 누적되어 문자열이 점점 길어짐.

📝 풀이 과정

✅ 최종 출력 결과

Seynaau

💡 정리

이 문제에서 꼭 알아야 할 개념:

• 리스트 순회
  • for i in a: → 리스트의 각 요소를 차례로 가져옴.
• 문자열 인덱싱
  • i[1] → 두 번째 문자(인덱스는 0부터 시작).
• 문자열 덧셈(+)
  • 문자열은 연결(concatenation) 가능.
  • str = str + i[1] → 누적 문자열 생성.
• 문자열은 불변(immutable) 이지만, 덧셈 시 새 문자열이 계속 만들어진다.

print("파이썬 입출력에 대한 문제입니다.")

num1, num2 = input()._____()
num1 = int(num1)
num2 = int(num2)
print(num1, num2)

num3 = num1 + num2
print(num1 + " + "  + num2 + " = " + num3)

🎯 출제 의도

• input() 함수로 여러 값을 한 줄에 입력받는 방법 이해
• 문자열 분리 함수(split())의 사용법
• int()를 이용한 정수 변환
• 문자열 결합 시 형 변환 필요성 이해

📘 개념 정리

1. input() 함수

• 기본적으로 문자열 전체를 한 줄로 입력받는다.
• 예:

  input() → '2 3'

2. 문자열 분리(split())

• input().split() → 입력받은 문자열을 공백 기준으로 나누어 리스트로 반환한다. 예시:

  num1, num2 = input().split()

3. 형 변환(int())

• 입력값은 문자열이므로, 정수 연산을 위해 int()로 변환해야 한다.

  num1 = int(num1)
  num2 = int(num2)

  → num1 = 2, num2 = 3

📝 풀이 과정

✅ 정답

split

💡 정리

이 문제에서 꼭 알아야 할 개념:

• split()은 문자열을 공백 기준으로 나눈다.
• 입력값은 기본적으로 문자열(str) 이므로, 숫자 연산을 위해 int() 변환이 필요하다.
• 문자열 결합 시에는 모든 항목을 str()로 변환해야 오류가 발생하지 않는다.

a = "engineer information processing"
b = a[:3]
c = a[4:6]
d = a[28:]
e = b + c + d
print(e)

🎯 출제 의도

• 문자열 슬라이싱(slice) 문법을 정확히 이해하는가
• 문자열 인덱스의 0부터 시작 규칙을 아는가
• 끝 인덱스는 포함되지 않는다는 점을 구분할 수 있는가

📘 개념 정리

1. 문자열 인덱스 구조

• 문자열 a = "engineer information processing" 각 문자의 인덱스는 다음과 같다 👇

2. 슬라이싱 구문 분석

b = a[:3]

• 인덱스 0~2까지 → "eng"

c = a[4:6]

• 인덱스 4~5까지 → a[4]='n', a[5]='e' → "ne"

d = a[28:]

• 인덱스 28부터 문자열 끝까지 → a[28]='n', a[29]='g' → "ng"

3. 문자열 결합

e = b + c + d

• "eng" + "ne" + "ng" → "engneng"

📝 풀이 과정

✅ 최종 출력 결과

engneng

💡 정리

이 문제에서 꼭 알아야 할 개념:

• 슬라이싱 구문
  • a[start:end] → start 인덱스 포함, end 인덱스 직전까지
• 인덱스는 0부터 시작
• 끝 인덱스 생략(a[28:]) 시, 문자열의 끝까지 반환
• 문자열 덧셈(+)은 단순 연결(concatenation)

a = {'한국', '중국', '일본'}
a.add('베트남')
a.add('중국')
a.remove('일본')
a.update({'홍콩', '한국', '태국'})
print(a)

🎯 출제 의도

• 파이썬 set(집합) 자료형의 특징 이해
• add(), remove(), update() 메서드의 동작 원리 확인
• 중복 데이터 처리 방식과 출력 순서 비보장 개념 확인

📘 개념 정리

1. 집합(set)의 기본 특징

• 중복을 허용하지 않는다.
• 순서가 없다 (즉, 인덱스로 접근 불가).
• 집합 내 동일한 요소를 여러 번 추가해도 한 번만 저장된다.

  a = {'한국', '중국', '일본'}

  ➡ a에는 "한국", "중국", "일본" 3개의 원소가 들어 있음.

2. 요소 추가: add()

a.add('베트남')
a.add('중국')

• '베트남'은 새로 추가됨.
• '중국'은 이미 존재하므로 중복으로 인한 변화 없음.

3. 요소 삭제: remove()

a.remove('일본')

• '일본' 원소가 제거됨.
• remove()는 존재하지 않는 원소를 삭제하면 KeyError가 발생하지만, 여기서는 '일본'이 존재하므로 정상 작동.

4. 여러 요소 추가: update()

a.update(['홍콩', '한국', '태국'])

• 리스트([])에 포함된 원소들을 집합에 한꺼번에 추가함.
• '한국'은 이미 존재하므로 중복으로 인해 추가되지 않음.

📝 풀이 과정

• 최종적으로 a에는 5개의 원소가 존재한다. ('일본'은 제거, '중국'은 중복 제외)
• set은 순서가 없기 때문에, 출력 순서는 달라질 수 있다.

✅ 최종 출력 결과

{'한국', '중국', '베트남', '홍콩', '태국'}

💡 정리

이 문제에서 꼭 알아야 할 개념:

• set은 중복을 허용하지 않는다.
• add() → 한 개 원소 추가
• update() → 여러 개 원소 한꺼번에 추가
• remove() → 해당 원소를 삭제 (없으면 오류)
• 출력 순서는 일정하지 않다. (비정렬 구조)

TestList = [1, 2, 3, 4, 5]
TestList = list(map(lambda num: num + 100, TestList))

print(TestList)

🎯 출제 의도

• map() 함수와 람다 함수(lambda) 의 활용 이해
• 리스트 각 원소를 변환하여 새로운 리스트로 반환하는 흐름 파악
• 함수형 프로그래밍 요소(map, lambda) 의 동작 구조 이해

📘 개념 정리

1. lambda 익명 함수

lambda num: num + 100

• 이름이 없는 간단한 함수
• 입력값 num을 받아서 num + 100을 반환한다.
• 즉, 리스트의 각 요소에 100을 더하는 함수 역할을 함.

2. map() 함수

map(lambda num: num + 100, TestList)

• 첫 번째 인자: 적용할 함수 (lambda num: num + 100)
• 두 번째 인자: 반복 가능한 객체 (TestList)
• 결과: 각 원소에 함수를 적용한 map 객체가 반환됨. → 리스트로 바꾸려면 list()로 감싸야 함.

📝 풀이 과정

✅ 최종 출력 결과

[101, 102, 103, 104, 105]

💡 정리

이 문제에서 꼭 알아야 할 개념:

• lambda 함수는 한 줄짜리 익명 함수로, 간단한 연산에 자주 사용된다.
• map(function, iterable)은 iterable의 모든 요소에 함수를 적용한다.
• map 객체는 바로 출력되지 않으므로 list()로 변환해야 리스트 형태로 보인다.
• 각 원소에 100을 더했기 때문에 최종 리스트는 [101, 102, 103, 104, 105].

a = "REMEMBER NOVEMBER"
b = a[:3] + a[12:16]
c = "R AND %s" % "STR"
print(b + c)

🎯 출제 의도

• 문자열 슬라이싱(slice) 문법 이해
• 문자열 포맷팅(%s)의 사용법 확인
• 문자열 덧셈(연결) 동작 원리 파악

📘 개념 정리

1. 문자열 슬라이싱

문자열 a = "REMEMBER NOVEMBER" 인덱스를 기준으로 나누면 👇

• a[:3] → 0~2 인덱스까지 "REM"
• a[12:16] → 12~15 인덱스까지 "EMBE"

따라서

b = "REM" + "EMBE"   # "REMEMBE"

2. 문자열 포맷팅

c = "R AND %s" % "STR"

• %s → 문자열을 삽입하는 포맷 기호
• "R AND %s"에 "STR"을 넣으면 → "R AND STR"

즉,

c = "R AND STR"

3. 문자열 결합

print(b + c)

• "REMEMBE" + "R AND STR" → "REMEMBER AND STR"

📝 풀이 과정

4. 여러 요소 추가: update()

a.update(['홍콩', '한국', '태국'])

• 리스트([])에 포함된 원소들을 집합에 한꺼번에 추가함.
• '한국'은 이미 존재하므로 중복으로 인해 추가되지 않음.

✅ 최종 출력 결과

REMEMBER AND STR

💡 정리

이 문제에서 꼭 알아야 할 개념:

• 슬라이싱 a[start:end]
  • start 인덱스 포함, end 인덱스 직전까지
  • a[:3] → "REM" a[12:16] → "EMBE"
• 문자열 포맷팅 "문자열 %s" % 값 은 %s 위치에 문자열을 삽입한다.
• 문자열 간 + 연산은 단순 연결(concatenation) 이다.
• 최종 결과: "REMEMBER AND STR"

def exam(num1, num2=2):
    print('a=', num1, 'b=', num2)

exam(20)

🎯 출제 의도

• 함수 매개변수 기본값(default parameter) 개념 이해
• 함수 호출 시 인자(argument) 개수에 따른 동작 방식 확인
• 출력 결과의 형식과 변수 대응 관계 파악

📘 개념 정리

1. 함수 정의부

def exam(num1, num2=2):

• num1 : 필수 매개변수
• num2=2 : 기본값이 2로 지정된 선택적 매개변수

즉, exam() 호출 시

• 첫 번째 인자 → num1
• 두 번째 인자 생략 시 → num2는 자동으로 2 사용

2. 함수 호출

exam(20)

• 인자를 하나만 전달했으므로
  • num1 = 20
  • num2는 생략되어 기본값 2 사용

3. print() 실행

print('a=', num1, 'b=', num2)

→ 실제 출력:

a= 20 b= 2

📝 풀이 과정

✅ 최종 출력 결과

a= 20 b= 2

💡 정리

이 문제에서 꼭 알아야 할 개념:

• 기본 매개변수(default argument) → 함수 정의 시 num2=2처럼 미리 기본값을 지정할 수 있다.
• 인자를 하나만 전달하면, 두 번째 매개변수는 기본값 사용
• 함수 호출 시, 매개변수 개수가 일치하지 않아도 기본값 덕분에 오류 발생 X
• 출력 시 'a=', 'b='는 문자열 그대로 출력되고, 뒤의 값과 쉼표로 구분됨.

a, b = 100, 200
print(a == b)

🎯 출제 의도

• 파이썬의 비교 연산자(==) 동작 원리를 이해한다.
• 두 변수의 값 비교 결과로 반환되는 논리값(boolean) 출력 확인.

📘 개념 정리

1. 변수 선언 및 초기화

a, b = 100, 200

• 다중 대입문 (tuple unpacking 방식)
• 왼쪽 변수 a, b에 각각 오른쪽의 100, 200이 순서대로 할당된다. → a = 100, b = 200

2. 비교 연산자 ==

• == : 값이 같은지 비교하는 연산자
• 결과는 True(참) 또는 False(거짓) 중 하나로 반환된다.

a == b

➡ 100 == 200 → 두 값이 다르므로 False

📝 풀이 과정

✅ 최종 출력 결과

False

💡 정리

이 문제에서 꼭 알아야 할 개념:

• a, b = 100, 200 은 동시에 여러 변수에 값을 할당하는 문법이다.
• == 는 두 값의 동일성을 비교한다.
• 비교 결과는 항상 True 또는 False 형태의 bool 타입이다.
• 100 == 200 은 같지 않으므로 결과는 False.

a = 100
result = 0
for i in range(1, 3):
    result = a >> i
    result = result + 1
print(result)

🎯 출제 의도

• 파이썬의 비트 연산자(shift) 개념 이해
• >> (오른쪽 시프트) 연산의 동작 원리 파악
• for문의 반복 범위(range(1,3))와 마지막 값 추적
• 변수의 재할당 및 최종값 흐름 분석

📘 개념 정리

1. 비트 시프트 연산자 >>

• a >> n : a의 이진수를 오른쪽으로 n비트 이동 → 즉, 2ⁿ으로 나눈 정수 몫과 같음

예를 들어,

a = 100
a >> 1 → 50  (100 ÷ 2¹)
a >> 2 → 25  (100 ÷ 2²)

2. for문 범위

for i in range(1, 3):

• range(1,3) → [1, 2]
• 즉, i = 1 → i = 2 두 번 반복한다.

📝 풀이 과정

최종 반복이 끝난 뒤 result는 26.

✅ 최종 출력 결과

26

💡 정리

이 문제에서 꼭 알아야 할 개념:

• a >> n 은 a를 2ⁿ으로 나눈 몫과 동일하다. (즉, 100 >> 2 → 100 ÷ 4 = 25)
• range(1,3) 은 1부터 2까지 반복된다.
• result는 반복마다 덮어써지므로 마지막 반복 결과가 출력된다.
• 최종 출력값은 26.

class good:
    li = ["seoul", "kyeonggi", "inchon", "daejeon", "daegu", "pusan"]

g = good()
str01 = ''
for i in g.li:
    str01 = str01 + i[0]

print(str01)

🎯 출제 의도

• 클래스 내부의 리스트(class 변수) 접근 방법 이해
• 문자열 인덱싱을 이용한 문자 추출
• for문을 이용한 누적 문자열 생성 로직 이해

📘 개념 정리

1. 클래스 변수

class good:
    li = ["seoul", "kyeonggi", "inchon", "daejeon", "daegu", "pusan"]

• li는 클래스 변수로, good 클래스의 모든 인스턴스가 공유한다.
• 객체를 생성하지 않아도 good.li로 접근 가능하다.
• g = good()으로 인스턴스를 생성하면 g.li로도 접근 가능하다.

2. for문 순회

for i in g.li:
    str01 = str01 + i[0]

• g.li는 ["seoul", "kyeonggi", "inchon", "daejeon", "daegu", "pusan"]
• for i in g.li: → 각 지역명을 순서대로 가져옴
• i[0] → 각 문자열의 첫 글자 추출
• str01에 하나씩 이어붙임 (+= 또는 + 사용)

📝 풀이 과정

✅ 최종 출력 결과

skiddp

💡 정리

이 문제에서 꼭 알아야 할 개념:

• 클래스 변수는 모든 인스턴스가 공유하며, 클래스명.변수 또는 인스턴스명.변수로 접근 가능하다.
• 문자열 인덱싱 i[0]은 첫 번째 문자를 의미한다.
• 문자열은 불변 객체(immutable)이므로, 누적 연결 시 새 문자열이 생성된다.
• for문을 이용한 문자열 누적 패턴은 문자열 처리 문제에서 자주 등장한다.

lol = [[1,2,3],[4,5],[6,7,8,9]]
print(lol[0])
print(lol[2][1])

for sub in lol:
    for item in sub:
        print(item, end = '')
    print()

🎯 출제 의도

• 파이썬 리스트(List)와 중첩 리스트(2차원 리스트) 구조 이해
• 중첩 for문을 이용한 리스트 순회 로직 파악
• 인덱싱과 end 인자의 동작 확인 (print()의 기본 줄바꿈 제어)

📘 개념 정리

1. 이중 리스트의 구조

lol = [[1,2,3], [4,5], [6,7,8,9]]

• 이 리스트는 3개의 하위 리스트로 구성되어 있다.

2. 인덱싱 출력

print(lol[0])

→ 첫 번째 하위 리스트 출력 → [1, 2, 3]

print(lol[2][1])

→ 세 번째 리스트(lol[2] = [6,7,8,9])의 두 번째 값(7) 출력

3. 중첩 for문 순회

for sub in lol:          # sub = [1,2,3] → [4,5] → [6,7,8,9]
    for item in sub:     # 각 하위 리스트의 원소 하나씩
        print(item, end = '')
    print()

• end='' → 줄바꿈 없이 연속으로 출력
• print() → 한 하위 리스트가 끝날 때 줄바꿈

📝 풀이 과정

✅ 최종 출력 결과

[1, 2, 3]
7
123
45
6789

💡 정리

이 문제에서 꼭 알아야 할 개념:

• 이중 리스트는 리스트 안에 리스트가 포함된 구조이다.
• lol[i][j] 형태로 접근하면 i번째 리스트의 j번째 요소를 가리킨다.
• end='' → print 시 줄바꿈을 하지 않음
• 중첩 for문은 행렬, 표, 중첩 리스트 탐색에서 자주 사용됨
• 각 sub는 리스트 한 줄을 의미하고, item은 그 내부의 원소를 의미한다.

a = {'일본', '중국', '한국'}
a.add('베트남')
a.add('중국')
a.remove('일본')
a.update(['홍콩', '한국', '태국'])
print(a)

🎯 출제 의도

• 파이썬 set(집합) 자료형의 특징 이해
• add(), remove(), update() 메서드의 동작 원리 확인
• 중복 데이터 처리 방식과 출력 순서 비보장 개념 확인

📘 개념 정리

1. 집합(set)의 기본 특징

• 중복을 허용하지 않는다.
• 순서가 없다 (즉, 인덱스로 접근 불가).
• 집합 내 동일한 요소를 여러 번 추가해도 한 번만 저장된다.

  a = {'일본', '중국', '한국'}

  ➡ a에는 "일본", "중국", "한국" 3개의 원소가 들어 있음.

2. 요소 추가: add()

a.add('베트남')
a.add('중국')

• '베트남'은 새로 추가됨.
• '중국'은 이미 존재하므로 중복으로 인한 변화 없음.

3. 요소 삭제: remove()

a.remove('일본')

• '일본' 원소가 제거됨.
• remove()는 존재하지 않는 원소를 삭제하면 KeyError가 발생하지만, 여기서는 '일본'이 존재하므로 정상 작동.

4. 여러 요소 추가: update()

a.update(['홍콩', '한국', '태국'])

• 리스트([])에 포함된 원소들을 집합에 한꺼번에 추가함.
• '한국'은 이미 존재하므로 중복으로 인해 추가되지 않음.

📝 풀이 과정

• 최종적으로 a에는 5개의 원소가 존재한다. ('일본'은 제거, '중국'은 중복 제외)
• set은 순서가 없기 때문에, 출력 순서는 달라질 수 있다.

✅ 최종 출력 결과

{'중국', '한국', '베트남', '홍콩', '태국'}

💡 정리

이 문제에서 꼭 알아야 할 개념:

• set은 중복을 허용하지 않는다.
• add() → 한 개 원소 추가
• update() → 여러 개 원소 한꺼번에 추가
• remove() → 해당 원소를 삭제 (없으면 오류)
• 출력 순서는 일정하지 않다. (비정렬 구조)

📘 개념 설명

• 자바에서 클래스는 객체를 생성하기 위한 설계도, 객체는 이 설계도로 만들어진 실체(Instance)이다.

class Car {
    String name;
    int speed;
    void run() { System.out.println(name + "이 달립니다!"); }
}

public class Main {
    public static void main(String[] args){
        Car c = new Car();
        c.name = "소나타";
        c.run();
    }
}

출력:

소나타이 달립니다!

• class : 객체의 속성(필드)과 동작(메서드)을 정의.
• new : 객체를 메모리에 생성.
• this : 현재 객체 자신을 가리킴.
• 생성자는 클래스 이름과 같고 반환형이 없다.

📝 연습문제

class A {
    int x;
    A(int x){ this.x = x; }
}

public class Main {
    public static void main(String[] args){
        A obj1 = new A(5);
        A obj2 = obj1;
        obj2.x = 10;
        System.out.println(obj1.x);
    }
}

✅ 해설

• obj1과 obj2는 같은 객체를 참조한다.
• obj2.x = 10은 obj1.x에도 반영된다.

정답:

10

✨ 2장. 상속(Inheritance)과 오버라이딩(Overriding)

📘 개념 설명

• 자바의 상속은 기존 클래스의 기능을 확장(extends) 하는 개념이다. 부모의 멤버를 자식이 물려받아 재사용할 수 있다.

class Parent {
    void show() { System.out.println("Parent"); }
}

class Child extends Parent {
    void show() { System.out.println("Child"); }
}

public class Main {
    public static void main(String[] args){
        Parent p = new Child();
        p.show();
    }
}

출력:

Child

• 오버라이딩: 상속받은 메서드를 같은 이름, 매개변수, 반환형으로 재정의
• 동적 바인딩: 실행 시점에 실제 객체 타입(Child) 기준으로 메서드 결정

📝 연습문제

class Parent {
    int x = 100;
    int getX() { return x; }
}

class Child extends Parent {
    int x = 4000;
    int getX() { return x * 2; }
}

public class Main {
    public static void main(String[] args){
        Parent p = new Child();
        System.out.println(p.getX());
    }
}

✅ 해설

• getX()는 오버라이딩 → 객체 타입(Child) 기준 호출
• x는 필드 숨김 → 참조 타입(Parent) 기준 사용되지 않음

정답:

8000

✨ 3장. static(정적 멤버)과 Singleton 패턴

📘 개념 설명

• static은 클래스 단위로 공유되는 영역이다. 모든 인스턴스가 같은 값을 본다.

class Counter {
    static int count = 0;
    Counter() { count++; }
}

public class Main {
    public static void main(String[] args){
        new Counter();
        new Counter();
        System.out.println(Counter.count);
    }
}

출력:

2

📝 연습문제

class Connection {
    private static Connection _inst = null;
    private int count = 0;

    static Connection get() {
        if(_inst == null)
            _inst = new Connection();
        return _inst;
    }

    void count(){ count++; }
    int getCount(){ return count; }
}

public class Main {
    public static void main(String[] args){
        Connection c1 = Connection.get();
        c1.count();
        Connection c2 = Connection.get();
        c2.count();
        System.out.println(c1.getCount());
    }
}

✅ 해설

• static은 클래스 단위로 단 하나만 존재한다.
• Connection.get()은 항상 동일 객체 반환.
• count가 누적되어 2가 된다.

정답:

2

✨ 4장. 추상 클래스 & 인터페이스

📘 개념 설명

• abstract 클래스는 상속을 위한 틀
• 인터페이스(interface)는 모든 메서드가 추상(abstract)

abstract class Vehicle {
    abstract String getName(String val);
    void start(){ System.out.println("출발!"); }
}

class Car extends Vehicle {
    String getName(String val){ return "Car name : " + val; }
}

📝 연습문제

abstract class Vehicle {
    private String name;
    abstract String getName(String val);
    public String getName() { return "vehicle name:" + name; }
    public void setName(String val){ name = val; }
}

class Car extends Vehicle {
    public Car(String val){ setName(val); }
    public String getName(String val){ return "Car name : " + val; }
}

public class Main {
    public static void main(String[] args){
        Vehicle obj = new Car("Spark");
        System.out.println(obj.getName());
    }
}

✅ 해설

• obj.getName()은 매개변수 없는 오버로딩 메서드 호출
• name 필드는 "Spark"로 설정되어 있다.

정답:

vehicle name:Spark

✨ 5장. 예외 처리(Exception Handling)

📘 개념 설명

try {
    int x = 5 / 0;
} catch (ArithmeticException e) {
    System.out.println("0으로 나눌 수 없습니다");
} finally {
    System.out.println("항상 실행");
}

📝 연습문제

public class Main {
    public static void main(String[] args){
        int a = 5, b = 0;
        try {
            System.out.print(a / b);
        } catch (ArithmeticException e) {
            System.out.print("출력1");
        } finally {
            System.out.print("출력2");
        }
    }
}

✅ 해설

• 5 / 0 → ArithmeticException 발생
• catch로 "출력1" 출력, finally는 항상 실행

정답:

출력1출력2

✨ 6장. 배열(Array)과 참조(Reference)

📘 개념 설명

• 배열은 참조형 객체이다.
• 배열 원소로 객체를 저장하면, 각 칸에는 객체 주소값이 저장된다.

  int[] arr = {1, 2, 3};
  String[] s = {"A", "B"};

📝 연습문제

public class Main {
    public static void change(String[] data, String s){
        data[0] = s;
        s = "Z";
    }

    public static void main(String[] args){
        String data[] = {"A"};
        String s = "B";
        change(data, s);
        System.out.println(data[0] + s);
    }
}

✅ 해설

• 배열(data)은 참조형이라 원소 변경이 반영됨.
• 문자열(s)은 값 복사이므로 지역 변경은 영향 없음.

정답:

BB

✨ 7장. 람다(Lambda)와 함수형 인터페이스

📘 개념 설명

interface F { int apply(int x) throws Exception; }

public class Main {
    static int run(F f){
        try { return f.apply(3); }
        catch(Exception e){ return 7; }
    }
}

• 람다는 함수형 인터페이스(메서드 1개)에서 사용 가능하며, 익명 함수처럼 작성된다.

📝 연습문제

public class Main {
    static interface F { int apply(int x) throws Exception; }
    static int run(F f){
        try { return f.apply(3); }
        catch(Exception e){ return 7; }
    }
    public static void main(String[] args){
        F f = (x) -> {
            if(x > 2) throw new Exception();
            return x * 2;
        };
        System.out.println(run(f) + run((int n) -> n + 9));
    }
}

✅ 해설

• run(f) → 예외 발생 → 7
• run((n)->n+9) → 3+9=12
• 최종 7+12=19

정답:

19

✨ 8장. 문자열(String) 비교

📘 개념 설명

📝 연습문제

String str1 = "Programming";
String str2 = "Programming";
String str3 = new String("Programming");

System.out.println(str1==str2);
System.out.println(str1==str3);
System.out.println(str1.equals(str3));

✅ 해설

• str1 == str2 → true (리터럴 동일 참조)
• str1 == str3 → false (new로 별도 객체)
• .equals() → true (내용 동일)

정답:

true
false
true

✨ 9장. 재귀(Recursion)

📘 개념 설명

• 재귀는 메서드가 자기 자신을 호출하는 구조이다. 항상 종료 조건을 포함해야 한다.

📝 연습문제

static int func(int[] a, int st, int end) {
    if (st >= end) return 0;
    int mid = (st + end) / 2;
    return a[mid] + Math.max(func(a, st, mid), func(a, mid + 1, end));
}

public static void main(String[] args){
    int[] data = {3,5,8,12,17};
    System.out.println(func(data,0,data.length-1));
}

✅ 해설

• 중앙값 8 + 오른쪽의 최대 합 12 → 20

정답:

20

✨ 10장. 오버로딩(Overloading)과 오버라이딩(Overriding) 심화

📘 개념 설명

오버로딩(Overloading) : 같은 이름, 다른 매개변수로 여러 메서드를 정의하는 것 → 컴파일 시점에 결정됨 (정적 바인딩)

오버라이딩(Overriding) : 상속 관계에서 부모 메서드를 재정의하는 것 → 실행 시점에 결정됨 (동적 바인딩)

class Parent {
    void show(){ System.out.println("Parent"); }
}

class Child extends Parent {
    void show(){ System.out.println("Child"); }
}

📝 연습문제

public class Main {
    public static class Parent {
        public int x(int i){ return i + 2; }
        public static String id(){ return "P"; }
    }

    public static class Child extends Parent {
        public int x(int i){ return i + 3; }
        public String x(String s){ return s + "R"; }
        public static String id(){ return "C"; }
    }

    public static void main(String[] args){
        Parent ref = new Child();
        System.out.println(ref.x(2) + ref.id());
    }
}

✅ 해설

• x(2) → 동적 바인딩으로 Child.x(int) 호출 → 5
• id() → 정적 메서드, 참조 타입 기준 → Parent.id() = “P”

정답:

5P

✨ 11장. static 변수와 메모리 공유 구조

📘 개념 설명

static은 클래스 전체에서 공유되는 변수이다. 인스턴스와 무관하게 하나만 존재한다.

class Counter {
    static int count = 0;
    Counter(){ count++; }
}

모든 객체가 하나의 count를 공유한다.

📝 연습문제

class Connection {
    private static Connection inst = null;
    private int count = 0;

    static Connection get(){
        if(inst == null) inst = new Connection();
        return inst;
    }

    void count(){ count++; }
    int getCount(){ return count; }
}

public class Main {
    public static void main(String[] args){
        Connection c1 = Connection.get();
        c1.count();
        Connection c2 = Connection.get();
        c2.count();
        Connection c3 = Connection.get();
        c3.count();
        System.out.println(c1.getCount());
    }
}

✅ 해설

• 모든 호출은 동일 객체를 참조
• count() 총 3회 실행 → count = 3

정답:

3

✨ 12장. 추상 클래스(abstract)와 다형성

📘 개념 설명

추상 클래스:

• 공통 구조를 정의하고 구체적 구현은 자식이 담당
• abstract 메서드는 몸체가 없음

📝 연습문제

abstract class Vehicle {
    String name;
    abstract String getName(String val);
    public String getName(){ return "Vehicle name: " + name; }
}

class Car extends Vehicle {
    public Car(String val){ name = val; }
    public String getName(String val){ return "Car name: " + val; }
}

public class Main {
    public static void main(String[] args){
        Vehicle obj = new Car("Spark");
        System.out.println(obj.getName());
    }
}

✅ 해설

• 호출된 메서드는 매개변수 없는 버전
• "Vehicle name: Spark"

정답:

Vehicle name: Spark

✨ 13장. 예외 처리(Exception Handling)

📘 개념 설명

• try ~ catch ~ finally 구조

try {
   int x = 10 / 0;
} catch (ArithmeticException e) {
   System.out.println("0으로 나눌 수 없습니다");
} finally {
   System.out.println("항상 실행");
}

📝 연습문제

public class Main {
    public static void main(String[] args){
        int a = 5, b = 0;
        try {
            System.out.println(a/b);
        } catch(ArithmeticException e) {
            System.out.print("출력1");
        } finally {
            System.out.print("출력5");
        }
    }
}

✅ 해설

• a/b → 0으로 나눔 → ArithmeticException 발생
• catch 실행 → "출력1"
• finally 항상 실행 → "출력5"

정답:

출력1출력5

✨ 14장. 문자열(String) 비교

📘 개념 설명

• == : 참조 주소 비교
• .equals() : 문자열 내용 비교

📝 연습문제

String str1 = "Programming"; String str2 = "Programming"; String str3 = new String("Programming");

System.out.println(str1 == str2); System.out.println(str1 == str3); System.out.println(str1.equals(str3));

✅ 해설

• 리터럴은 String Pool 공유 → str1 == str2 → true
• new로 만든 객체는 별도 → str1 == str3 → false
• 내용은 동일 → .equals() → true

정답:

true
false
true

✨ 15장. 배열 참조(Reference)와 스왑

📘 개념 설명

• 배열은 참조형이므로, 스왑 시 주소가 교환된다.

📝 연습문제

public class Main {
    static class BO {
        public int v;
        public BO(int v){ this.v = v; }
    }
    public static void main(String[] args){
        BO a = new BO(1);
        BO b = new BO(2);
        BO c = new BO(3);
        BO[] arr = {a,b,c};
        BO t = arr[0];
        arr[0] = arr[2];
        arr[2] = t;
        arr[1].v = arr[0].v;
        System.out.println(a.v + "a" + b.v + "b" + c.v);
    }
}

✅ 해설

• arr = {c,b,a}
• b.v = c.v → 3
• 최종 a=1, b=3, c=3

정답:

1a3b3

✨ 16장. 재귀 함수(Recursion)와 분할정복

📘 개념 설명

• 재귀 함수는 자기 자신을 호출하며, 분할 → 정복 → 합침 패턴을 갖는다.

📝 연습문제

int func(int[] a, int st, int end){
    if(st >= end) return 0;
    int mid = (st + end) / 2;
    return a[mid] + Math.max(func(a, st, mid), func(a, mid+1, end));
}

배열 {3,5,8,12,17} 입력 시

✅ 해설

• 중심값 8 + 오른쪽 최대 12 → 20

정답:

20

✨ 17장. 람다(Lambda)와 함수형 인터페이스

📘 개념 설명

• 람다는 익명 함수로, 인터페이스의 단 하나의 메서드를 구현할 때 사용.

  @FunctionalInterface
  interface F { int apply(int x) throws Exception; }

📝 연습문제

F f = (x) -> {
    if(x > 2) throw new Exception();
    return x * 2;
};
System.out.print(run(f) + run((int n) -> n + 9));

✅ 해설

• 첫 run은 예외 → 7
• 두 번째 run → 12
• 합 → 19

정답:

19

✨ 18장. 예외 + throws / throw 심화

📘 개념 설명

• throws : 메서드가 예외를 호출자에게 던짐
• throw : 예외를 실제 발생시킴

📝 연습문제

public class ExceptionHandling {
    public static void main(String[] args){
        int sum = 0;
        try {
            func();
        } catch (NullPointerException e) {
            sum += 1;
        } catch (Exception e) {
            sum += 10;
        } finally {
            sum += 100;
        }
        System.out.print(sum);
    }

    static void func() throws Exception {
        throw new NullPointerException();
    }
}

✅ 해설

• func() → NullPointerException 발생 → 첫 번째 catch 실행 → +1
• finally는 항상 실행 → +100
• 총합 101

정답:

101

✨ 19장. 제네릭(Generics)과 오버로딩 선택

📘 개념 설명

• 오버로딩 시 가장 정확히 일치하는 타입의 메서드가 우선된다.

📝 연습문제

class Main {
  public static class Collection<T>{
    T value;
    Collection(T t){ value = t; }

    void print(){
       new Printer().print(value);
    }

    class Printer {
      void print(Integer a){ System.out.print("A" + a); }
      void print(Object a){ System.out.print("B" + a); }
      void print(Number a){ System.out.print("C" + a); }
    }
  }

  public static void main(String[] args){
      new Collection<>(0).print();
  }
}

✅ 해설

• T = Integer
• 가장 구체적인 print(Integer) 선택 → "A0"

정답:

A0

✨ 20장. 다형성과 메서드 호출 순서

📘 개념 설명

• 자바의 다형성은 상속 + 오버라이딩 + 참조형 변환으로 이루어진다.
• 부모 타입 변수로 자식 객체를 참조할 수 있고, 호출되는 메서드는 객체의 실제 타입 기준으로 결정된다.

📝 연습문제

public class Main {
    public static void main(String[] args){
        new Child();
        System.out.println(Parent.total);
    }
}

class Parent {
    static int total = 0;
    int v = 1;
    Parent(){
        total += (++v);
        show();
    }
    public void show(){ total += total; }
}

class Child extends Parent {
    int v = 10;
    Child(){
        v += 2;
        total += v++;
        show();
    }
    public void show(){ total += total * 2; }
}

✅ 해설

• 부모 생성자 → total=2, show()(자식 버전 호출) → 6
• 자식 생성자 → v=10→12, total+=12→18, show()(자식) → 18+36=54

정답:

54