절차지향 vs 객체지향

절차지향 프로그래밍

• 함수 중심의 프로그래밍
• 데이터와 기능이 분리
• 프로그램 = 함수들의 집합

객체지향 프로그래밍

• 클래스(설계도)를 사용
• 데이터와 기능이 하나로 묶임
• 객체 간 메시지 전달 방식
• 재사용성 향상 (정보은닉, 상속, 다형성, 캡슐화)

객체의 구성요소

• 상태(state): 객체의 속성 → 멤버 변수
• 동작(behavior): 객체가 취할 수 있는 동작 → 멤버 함수

2. 클래스 작성 문법

기본 구조

class 클래스명 {
접근지정자:
    멤버변수;
    멤버함수();
};

접근 지정자

3. 핵심 문법 예제

예제 1: 기본 클래스 작성

#include <iostream>
#include <string>
using namespace std;

class Circle {
public:
    int radius;
    string color;

    double calcArea() {
        return 3.14159 * radius * radius;
    }
};

int main() {
    Circle obj;
    obj.radius = 100;
    obj.color = "blue";
    cout << "원의 면적은 " << obj.calcArea() << "입니다." << endl;
    return 0;
}

예제 2: 여러 객체 생성

int main() {
    Circle pizza1, pizza2;

    pizza1.radius = 100;
    pizza1.color = "yellow";
    cout << "피자1의 면적=" << pizza1.calcArea() << "\n";

    pizza2.radius = 200;
    pizza2.color = "white";
    cout << "피자2의 면적=" << pizza2.calcArea() << "\n";

    return 0;
}

중요: 각 객체의 멤버 변수 값은 독립적으로 관리됨!

예제 3: 함수 오버로딩

class PrintData {
public:
    void print(int i) { cout << i << endl; }
    void print(double f) { cout << f << endl; }
    void print(string s = "No Data!") { cout << s << endl; }
};

int main() {
    PrintData obj;
    obj.print(1);           // int 버전 호출
    obj.print(3.14);        // double 버전 호출
    obj.print("C++14");     // string 버전 호출
    obj.print();            // 기본값 사용
    return 0;
}

4. 클래스 선언과 정의 분리

car.h (헤더 파일)

#include <iostream>
#include <string>
using namespace std;

class Car {
    int speed;
    int gear;
    string color;
public:
    int getSpeed();
    void setSpeed(int s);
};

car.cpp (구현 파일)

#include "car.h"

int Car::getSpeed() {
    return speed;
}

void Car::setSpeed(int s) {
    speed = s;
}

main.cpp (사용 파일)

#include "car.h"

int main() {
    Car myCar;
    myCar.setSpeed(80);
    cout << "현재 속도는 " << myCar.getSpeed() << endl;
    return 0;
}

분리의 장점

✅ 컴파일 시간 단축: 헤더가 변경되지 않으면 재컴파일 불필요

✅ 정보 은닉: 구현 세부사항을 .cpp에 숨김

✅ 코드 재사용: .h와 .cpp만 공유하면 됨

5. 이름 공간 (namespace)

// 방법 1: 매번 std:: 사용
std::cout << "Hello" << std::endl;

// 방법 2: using namespace std 선언
using namespace std;
cout << "Hello" << endl;

// 방법 3: 특정 항목만 사용
using std::cout;
using std::endl;

목적: 식별자의 충돌 방지, 논리적 그룹화

6. 객체지향 4대 개념

마 턱걸이합격도 합격이다 아닙니까

하하하

공부시간 기록 (저는 공부시간을 기록하는 오랜 습관이 있습니다) 공부시간 4:01 + 6:04 = 총 "10시간 5분" (다른 것들은 무시해주십쇼)

사용교재: 학교에서 강의와 함께 제공해준 교재를 활용했습니다. 내돈내산이 아닌 책 후기를 올리게 되다니 감개무량하네요

공부법(위의 책 기준입니다)

1. 강의를 듣는다(1.25~1.5배속)

저는 아래 강의들을 활용했습니다. (댓글창에 일주일의 용사들이 많더군요) 12과목은 두 번 정도 들었고 3과목도 두 번 들었습니다. 이해 안 가는 부분은 반복해서 들으면 도움이 되더군요 이 강의도 활용했습니다.(12과목 위주로 봤는데 딕션이 좋으시고 귀에 쏙쏙 들어오더군요)

2. 책의 개념부분을 푼다.

앞에 개념 부분을 한두 번 읽고 바로 아래 있는 문제를 풉니다. 문제를 풀면서 개념을 익히는 방식이라고 할 수 있겠습니다. 틀린 문제는 해설을 보면서 왜 틀렸는지 확인하고 해설을 손으로 적어가면서 이해해줍니다. (눈으로만 읽으면 공부가 안됩니다. 쓰세요!)

3. 단원별 개념문제들을 풀어줍니다.

보통 개념 - 해당 부분 기출문제(한두개) - 개념 - 단원 종합문제 이런 식으로 구성되어 있는데, 모른다고 다시 개념부분으로 회귀하는 등의 흐름을 끊는 행동을 하지 않고 쭉 풀어나갔습니다. 이렇게 3과목까지 풀어줍니다. 중간에 쉬는시간을 가질 경우 여기서 끊는 걸 권장드립니다. (개념-개념문제-단원별문제-쉬기-다음단원)

4. 헷갈리는 부분 확인 후 기출을 벅벅 푼다

저는 기출을 4세트정도 풀었는데 처음 푼 것 빼고 다 과락권이었습니다...(1, 2과목은 여유로운데 3과목에서 다 깎아먹어서) 개의치 않고 벅벅 풉니다. 채점 후 틀린 문제 오답을 열심히 합니다. 고등학교 시절 모의고사 오답했던 기억을 떠올려 오답을 해줍니다.

5. 시험을 봅니다.

6. 잊습니다.

7. 합격! 합격! 합격!

짧은 시간이었지만 효율적으로 준비한 덕분에 합격할 수 있었던 것 같습니다 ^^ 여러분도 충분히 하실 수 있어요 파이팅!

핵심 개념

• 함수: 특정 작업을 수행하는 코드 블록
• 함수 선언: 함수의 이름, 매개변수, 반환형을 미리 정의
• 함수 호출: 정의된 함수를 실행하는 과정

핵심 문법

// 함수 선언 (함수 원형)
반환타입 함수명(매개변수);

// 함수 정의
반환타입 함수명(매개변수) {
    // 함수 본체
    return 값;
}

// 함수 호출
결과 = 함수명(인수);

예제 코드

#include <iostream>
using namespace std;

// 함수 원형 선언
int max(int x, int y);

int main() {
    int result = max(10, 20);  // 함수 호출
    cout << "최댓값: " << result << endl;
    return 0;
}

// 함수 정의
int max(int x, int y) {
    if (x > y)
        return x;
    else
        return y;
}

2️⃣ 인수 전달 방법

핵심 개념

1. 값으로 호출 (Call-by-Value)
   • 인수의 값이 매개변수로 복사됨
   • 원본 값은 변경되지 않음
2. 참조로 호출 (Call-by-Reference)
   • 인수의 주소가 전달됨
   • 원본 값이 직접 변경됨

핵심 문법

// 값으로 전달
void func1(int x) {
    x = 100;  // 원본 변경 안됨
}

// 참조로 전달
void func2(int& x) {
    x = 100;  // 원본 변경됨
}

예제 코드 - swap 함수

#include <iostream>
using namespace std;

void swap(int& x, int& y) {
    int temp = x;
    x = y;
    y = temp;
}

int main() {
    int a = 100, b = 200;
    cout << "교환 전: a=" << a << ", b=" << b << endl;
    swap(a, b);
    cout << "교환 후: a=" << a << ", b=" << b << endl;
    return 0;
}

3️⃣ 중복 함수 (Function Overloading)

핵심 개념

• 동일한 이름의 함수를 매개변수 타입이나 개수를 다르게 하여 여러 개 정의
• 컴파일러가 호출 시 적절한 함수를 자동 선택

예제 코드

#include <iostream>
using namespace std;

int square(int i) {
    cout << "정수 제곱 함수 호출" << endl;
    return i * i;
}

double square(double i) {
    cout << "실수 제곱 함수 호출" << endl;
    return i * i;
}

void print(int i) { cout << "정수: " << i << endl; }
void print(double f) { cout << "실수: " << f << endl; }
void print(char c) { cout << "문자: " << c << endl; }

4️⃣ 디폴트 매개변수

핵심 개념

• 함수 호출 시 인수가 전달되지 않으면 기본값을 사용
• 마지막 매개변수부터 디폴트 값을 설정해야 함

핵심 문법

반환타입 함수명(타입 변수1, 타입 변수2 = 기본값, 타입 변수3 = 기본값);

예제 코드

#include <iostream>
using namespace std;

void display(char c = '*', int n = 10) {
    for (int i = 0; i < n; i++)
        cout << c;
    cout << endl;
}

int sum(int x, int y, int z = 0, int w = 0) {
    return x + y + z + w;
}

int main() {
    display();           // 모든 기본값 사용
    display('#');        // c='#', n=10(기본값)
    display('#', 5);     // 모든 값 지정

    cout << sum(10, 20) << endl;        // 30
    cout << sum(10, 20, 30) << endl;    // 60
    cout << sum(10, 20, 30, 40) << endl; // 100
    return 0;
}

5️⃣ 인라인 함수

핵심 개념

• inline 키워드를 사용하여 함수 호출 오버헤드를 줄임
• 컴파일러가 함수 코드를 호출 위치에 직접 삽입
• 간단하고 자주 호출되는 함수에 적합

예제 코드

inline double square(double i) {
    return i * i;
}

inline int max(int a, int b) {
    return (a > b) ? a : b;
}

6️⃣ string 클래스

핵심 개념

• C++에서 문자열을 다루기 위한 클래스
• <string> 헤더 파일 포함 필요
• 동적 크기 조정, 다양한 멤버 함수 제공

핵심 문법

#include <string>
using namespace std;

string s;                    // 빈 문자열 생성
string s = "Hello";          // 초기화
string s{"Hello"};           // 보편적 초기화

주요 연산자와 함수

// 문자열 연산
string s1 = "Hello";
string s2 = "World";
string s3 = s1 + " " + s2;   // 문자열 결합
s3 += "!";                   // 문자열 추가

// 문자열 비교
if (s1 == s2) { }            // 동등 비교
if (s1 > s2) { }             // 사전식 비교

// 주요 멤버 함수
s.length()                   // 문자열 길이
s.find("text")              // 부분 문자열 찾기
s[i]                        // i번째 문자 접근
getline(cin, s)             // 공백 포함 문자열 입력

예제 코드

#include <iostream>
#include <string>
using namespace std;

int main() {
    string name, address;

    cout << "이름을 입력하세요: ";
    cin >> name;
    cin.ignore();  // 버퍼 정리

    cout << "주소를 입력하세요: ";
    getline(cin, address);

    cout << address << "의 " << name << "씨 안녕하세요!" << endl;

    // 문자열 검색
    string text = "When in Rome, do as the Romans.";
    int pos = text.find("Rome");
    cout << "Rome의 위치: " << pos << endl;

    return 0;
}

🔥 예상 문제 및 실전 대비

📝 예상 문제 1: 함수 기본 (★★☆)

// 다음 코드의 출력 결과를 예측하시오
#include <iostream>
using namespace std;

int calculate(int a, int b = 5) {
    return a * b;
}

int main() {
    cout << calculate(3) << endl;
    cout << calculate(3, 2) << endl;
    return 0;
}

정답: 15, 6

해설: 첫 번째 호출에서는 b의 기본값 5가 사용되어 3×5=15, 두 번째 호출에서는 b=2가 전달되어 3×2=6

📝 예상 문제 2: 참조 전달 (★★★)

// 다음 코드를 완성하여 두 변수의 값을 교환하는 함수를 작성하시오
#include <iostream>
using namespace std;

void swap(_______ a, _______ b) {
    _______________________
    _______________________
    _______________________
}

int main() {
    int x = 10, y = 20;
    cout << "교환 전: x=" << x << ", y=" << y << endl;
    swap(x, y);
    cout << "교환 후: x=" << x << ", y=" << y << endl;
    return 0;
}

정답:

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

📝 예상 문제 3: 중복 함수 (★★★)

// 다음과 같이 동작하는 중복 함수 print를 작성하시오
// print(100) → "정수: 100"
// print(3.14) → "실수: 3.14"
// print('A') → "문자: A"

#include <iostream>
using namespace std;

// 여기에 중복 함수들을 작성하시오
_________________________________
_________________________________
_________________________________

int main() {
    print(100);
    print(3.14);
    print('A');
    return 0;
}

정답:

void print(int i) {
    cout << "정수: " << i << endl;
}

void print(double f) {
    cout << "실수: " << f << endl;
}

void print(char c) {
    cout << "문자: " << c << endl;
}

📝 예상 문제 4: string 클래스 활용 (★★★)

// 사용자로부터 문자열을 입력받아 특정 문자의 개수를 세는 프로그램을 완성하시오
#include <iostream>
#include <string>
using namespace std;

int main() {
    string text;
    char target;
    int count = 0;

    cout << "문자열을 입력하세요: ";
    getline(cin, text);
    cout << "찾을 문자를 입력하세요: ";
    cin >> target;

    // 여기에 문자 개수를 세는 코드를 작성하시오
    _________________________________
    _________________________________
    _________________________________

    cout << "'" << target << "' 문자의 개수: " << count << endl;
    return 0;
}

정답:

for (int i = 0; i < text.length(); i++) {
    if (text[i] == target) {
        count++;
    }
}

또는:

for (char c : text) {
    if (c == target) {
        count++;
    }
}

📝 예상 문제 5: 해밍 거리 (★★★★)

// 두 DNA 문자열의 해밍 거리를 구하는 프로그램을 작성하시오
// 해밍 거리: 같은 위치에서 다른 문자의 개수

#include <iostream>
#include <string>
using namespace std;

int hammingDistance(string s1, string s2) {
    // 여기에 해밍 거리를 계산하는 코드를 작성하시오
    _________________________________
    _________________________________
    _________________________________
}

int main() {
    string dna1, dna2;
    cout << "DNA1: ";
    cin >> dna1;
    cout << "DNA2: ";
    cin >> dna2;

    if (dna1.length() != dna2.length()) {
        cout << "오류: 길이가 다릅니다." << endl;
    } else {
        int distance = hammingDistance(dna1, dna2);
        cout << "해밍 거리: " << distance << endl;
    }
    return 0;
}

정답:

int hammingDistance(string s1, string s2) {
    int count = 0;
    for (int i = 0; i < s1.length(); i++) {
        if (s1[i] != s2[i]) {
            count++;
        }
    }
    return count;
}

🎯 실전 대비 핵심 포인트

✅ 함수 관련 체크포인트

1. 함수 원형 선언을 main() 함수 앞에 작성했는가?
2. 참조 전달이 필요한 경우 & 연산자를 사용했는가?
3. 중복 함수에서 매개변수 타입이 다른가?
4. 디폴트 매개변수를 오른쪽부터 설정했는가?

✅ string 관련 체크포인트

1. #include <string> 헤더를 포함했는가?
2. 공백 포함 입력에는 getline()을 사용했는가?
3. cin 후 getline() 사용 시 cin.ignore()를 호출했는가?
4. 문자열 길이는 length() 또는 size() 함수로 구했는가?

⚠️ 주의사항

• 함수에서 지역변수는 함수 종료 시 소멸됨
• 참조 전달 시 원본이 변경되므로 주의 필요
• string 객체는 동적으로 크기가 변함
• 배열 인덱스는 0부터 시작함

📖 추가 연습 문제

연습문제 1

팩토리얼을 계산하는 함수를 작성하고, 중복 함수로 int와 long long 타입을 모두 처리하도록 하시오.

연습문제 2

문자열에서 모든 공백을 제거하는 함수를 작성하시오.

연습문제 3

두 문자열이 애너그램(같은 글자로 구성되었지만 순서가 다른 단어)인지 판별하는 함수를 작성하시오.

시퀀스가 있기 때문에 루프가 가능함

stream manipulator boolalpha

1. 관계연산자와 논리연산자

핵심 개념

• 관계연산자: ==, !=, <, >, <=, >=
• 논리연산자: &&(AND), ||(OR), !(NOT)
• bool 타입: true/false 값을 저장

중요 문법

#include <iostream>
using namespace std;

int main() {
    bool b = (1 == 2);  // false
    cout << boolalpha;  // bool 값을 true/false로 출력
    cout << b << endl;  // false 출력
    return 0;
}

2. if-else 문

핵심 구조

if (조건) {
    // 조건이 참일 때 실행
} else {
    // 조건이 거짓일 때 실행
}

실전 예제

// 두 수 중 큰 값 찾기
int x, y;
cin >> x >> y;
if (x > y)
    cout << "x가 y보다 큽니다." << endl;
else
    cout << "y가 x보다 큽니다." << endl;

3. 중첩 if-else 문

핵심 구조

if (조건1) {
    // 조건1이 참
} else if (조건2) {
    // 조건1은 거짓, 조건2는 참
} else {
    // 모든 조건이 거짓
}

실전 예제 - 나이별 구분

int age;
cin >> age;
if (age <= 12)
    cout << "어린이입니다." << endl;
else if (age <= 19)
    cout << "청소년입니다." << endl;
else
    cout << "성인입니다." << endl;

4. switch 문

핵심 구조

switch (변수) {
    case 값1:
        문장1;
        break;
    case 값2:
        문장2;
        break;
    default:
        기본문장;
        break;
}

주의사항

• break 문 필수: break가 없으면 다음 case로 넘어감
• 정수형/문자형만 가능: 실수형은 사용 불가

5. 반복문

5.1 while 문

int n = 10;
while (n > 0) {
    cout << n << " ";
    n--;
}

5.2 do-while 문

string str;
do {
    cout << "문자열을 입력하시오: ";
    getline(cin, str);
    cout << "사용자의 입력: " << str << endl;
} while (str != "종료");

5.3 for 문

// 1부터 10까지 합계
int sum = 0;
for (int i = 1; i <= 10; i++) {
    sum += i;
}
cout << "합계: " << sum << endl;

차이점 정리

• while: 조건을 먼저 확인 (0번 실행 가능)
• do-while: 최소 1번은 실행
• for: 초기값, 조건, 증감식이 명확할 때 사용

6. break와 continue

break 문

for (int i = 1; i < 10; i++) {
    cout << i << " ";
    if (i == 4)
        break;  // 루프 종료
}
// 출력: 1 2 3 4

continue 문

for (int i = 1; i <= 5; i++) {
    if (i == 3)
        continue;  // 3일 때 건너뛰기
    cout << i << " ";
}
// 출력: 1 2 4 5

7. 배열

7.1 배열 선언과 초기화

// 선언
int scores[10];

// 초기화
int sales[5] = {100, 200, 300, 400, 500};
int sales[] = {100, 200, 300};  // 크기 자동 결정

// 보편적 초기화 (C++11)
int scores[]{10, 20, 30};

7.2 범위 기반 for 루프

int list[] = {1, 2, 3, 4, 5};

// 읽기만
for (int i : list) {
    cout << i << " ";
}

// 수정 가능
for (int& i : list) {
    i = i * 2;  // 값 변경
}

// 자동 타입 추론
for (auto& i : list) {
    cout << i << " ";
}

8. 2차원 배열

8.1 선언과 초기화

// 선언
int s[3][5];

// 초기화
int table[3][5] = {
    {1, 2, 3, 4, 5},
    {2, 4, 6, 8, 10},
    {3, 6, 9, 12, 15}
};

8.2 접근 방법

// 이중 반복문으로 접근
for (int r = 0; r < 3; r++) {
    for (int c = 0; c < 5; c++) {
        cout << table[r][c] << " ";
    }
    cout << endl;
}

9. 예상 문제 및 해답

🔥 예상문제 1: 조건문 (난이도: ★★☆)

문제: 사용자로부터 점수를 입력받아 학점을 출력하는 프로그램을 작성하시오.

• 90점 이상: A
• 80점 이상: B
• 70점 이상: C
• 60점 이상: D
• 60점 미만: F

해답:

#include <iostream>
using namespace std;

int main() {
    int score;
    cout << "점수를 입력하세요: ";
    cin >> score;

    if (score >= 90)
        cout << "학점: A" << endl;
    else if (score >= 80)
        cout << "학점: B" << endl;
    else if (score >= 70)
        cout << "학점: C" << endl;
    else if (score >= 60)
        cout << "학점: D" << endl;
    else
        cout << "학점: F" << endl;

    return 0;
}

🔥 예상문제 2: 반복문 (난이도: ★★☆)

문제: 1부터 n까지의 수 중에서 홀수만의 합을 구하는 프로그램을 작성하시오.

해답:

#include <iostream>
using namespace std;

int main() {
    int n, sum = 0;
    cout << "n을 입력하세요: ";
    cin >> n;

    for (int i = 1; i <= n; i++) {
        if (i % 2 == 1) {  // 홀수일 때
            sum += i;
        }
    }

    cout << "1부터 " << n << "까지 홀수의 합: " << sum << endl;
    return 0;
}

🔥 예상문제 3: 배열 (난이도: ★★★)

문제: 10개의 정수를 배열에 저장하고, 배열에서 최댓값과 최솟값을 찾아 출력하는 프로그램을 작성하시오.

해답:

#include <iostream>
using namespace std;

int main() {
    int numbers[10];

    // 배열에 값 입력
    cout << "10개의 정수를 입력하세요: ";
    for (int i = 0; i < 10; i++) {
        cin >> numbers[i];
    }

    // 최댓값과 최솟값 찾기
    int max = numbers[0];
    int min = numbers[0];

    for (int i = 1; i < 10; i++) {
        if (numbers[i] > max)
            max = numbers[i];
        if (numbers[i] < min)
            min = numbers[i];
    }

    cout << "최댓값: " << max << endl;
    cout << "최솟값: " << min << endl;

    return 0;
}

🔥 예상문제 4: 2차원 배열 (난이도: ★★★)

문제: 3×3 행렬의 각 행의 합을 구하는 프로그램을 작성하시오.

해답:

#include <iostream>
using namespace std;

int main() {
    int matrix[3][3];

    // 행렬 입력
    cout << "3x3 행렬을 입력하세요:" << endl;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            cin >> matrix[i][j];
        }
    }

    // 각 행의 합 계산
    for (int i = 0; i < 3; i++) {
        int rowSum = 0;
        for (int j = 0; j < 3; j++) {
            rowSum += matrix[i][j];
        }
        cout << "행 " << (i+1) << "의 합: " << rowSum << endl;
    }

    return 0;
}

🔥 예상문제 5: 종합 문제 (난이도: ★★★)

문제: 학생 5명의 3과목 점수를 2차원 배열에 저장하고, 각 학생의 평균과 전체 평균을 구하는 프로그램을 작성하시오.

해답:

#include <iostream>
using namespace std;

int main() {
    int scores[5][3];  // 5명의 학생, 3과목

    // 점수 입력
    for (int i = 0; i < 5; i++) {
        cout << "학생 " << (i+1) << "의 3과목 점수를 입력하세요: ";
        for (int j = 0; j < 3; j++) {
            cin >> scores[i][j];
        }
    }

    int totalSum = 0;

    // 각 학생의 평균 계산
    for (int i = 0; i < 5; i++) {
        int studentSum = 0;
        for (int j = 0; j < 3; j++) {
            studentSum += scores[i][j];
        }
        totalSum += studentSum;
        double average = studentSum / 3.0;
        cout << "학생 " << (i+1) << "의 평균: " << average << endl;
    }

    // 전체 평균
    double totalAverage = totalSum / 15.0;  // 5명 × 3과목 = 15
    cout << "전체 평균: " << totalAverage << endl;

    return 0;
}

📝 시험 대비 체크리스트

꼭 암기해야 할 것들

• if-else 문의 기본 구조
• for 문의 3가지 구성요소 (초기화; 조건; 증감)
• 배열 선언과 초기화 문법
• 2차원 배열 접근 방법
• break와 continue의 차이점
• 범위 기반 for 루프 문법

자주 나오는 실수들

1. 세미콜론 빠뜨리기: if문 뒤에 세미콜론 사용 금지
2. 배열 인덱스: 0부터 시작, 크기-1까지
3. break 누락: switch문에서 break 빠뜨리기
4. 초기화 안함: 변수 사용 전 반드시 초기화
5. 참조자 사용: 배열 요소 수정할 때 int& 사용 int&은 참조를 의미, 이미 존재하는 변수나 객체에 대한 별명 역할

시험장에서 주의사항

• 문제를 정확히 읽고 요구사항 파악
• 변수명과 출력 형식 정확히 따르기
• 컴파일 에러가 나지 않도록 문법 확인
• 논리 오류가 없는지 간단한 값으로 검증

🎯 최종 점검 문제

문제: 다음 코드의 출력 결과를 예측하시오.

#include <iostream>
using namespace std;

int main() {
    int arr[] = {1, 2, 3, 4, 5};

    for (int i = 0; i < 5; i++) {
        if (i % 2 == 0)
            continue;
        cout << arr[i] << " ";
    }

    cout << endl;

    for (auto& x : arr) {
        x *= 2;
    }

    for (int x : arr) {
        cout << x << " ";
    }

    return 0;
}

정답:

2 4
2 4 6 8 10

해설:

• 첫 번째 루프: i가 짝수일 때 continue하므로 홀수 인덱스(1, 3)의 값인 2, 4 출력
• 두 번째 루프: 모든 배열 요소를 2배로 변경
• 세 번째 루프: 변경된 배열 전체 출력

핵심 개념

• 개발자: Bjarne Stroustrup (비야네 스트로스트룹, 덴마크)
• 개발 시기: 1980년대 초, AT&T 벨연구소
• 발전 과정: C with Classes → C++
• 표준화: ANSI와 ISO에 의해 공동 개발 (1997년 공식 표준)

C++의 주요 특징

1. 클래스(class): 객체의 속성과 동작 정의
2. 상속(inheritance): 코드 재사용
3. 연산자 중복(operator overloading): 동일 연산자로 새로운 연산 정의
4. 함수 중복(function overloading): 매개변수가 다른 동일명 함수
5. new와 delete: 동적 메모리 할당/해제
6. 제네릭(generics): 자료형에 상관없이 재사용

설계 철학

• 엄격한 타입 검사, 효율적
• 범용 언어, 이식성
• 다양한 프로그래밍 스타일 지원 (절차지향, 객체지향, 일반화)
• C와의 최대 호환성

💻 2. 기본 프로그램 구조

표준 프로그램 템플릿

#include <iostream>
using namespace std;

int main()
{
    // 프로그램 내용
    return 0;
}

핵심 구성 요소

• #include <iostream>: 입출력 스트림 헤더 포함
• using namespace std;: std 네임스페이스 사용 선언
• int main(): 프로그램의 시작점
• return 0;: 정상 종료 신호

주석(Comment)

// 한 줄 주석
/*
   여러 줄 주석
   블록 주석
*/

• 단축키: Ctrl+K, Ctrl+C (주석), Ctrl+K, Ctrl+U (주석 해제)

🔢 3. 변수와 자료형/이건알아

기본 자료형

정수형

int age = 25;           // 4바이트
short height = 170;     // 2바이트
long population = 50000000L; // 4바이트 이상

실수형

float pi = 3.14f;       // 4바이트
double precision = 3.141592653; // 8바이트

논리형

bool isStudent = true;  // 1바이트
bool isWorking = false;

문자형

char grade = 'A';       // 1바이트

문자열

#include <string>
string name = "홍길동";
string greeting = "Hello" + " " + "World!";//걍 한번에 띄어쓰기있이 붙여써도됨 왜 이따구로햇는지모르겟네?
string number_str = to_string(123); // 숫자를 문자열로 변환

기호상수

const double PI = 3.141592;
const int MAX_SIZE = 100;

auto 키워드 (자동 타입 추론)

auto number = 42;        // int로 추론
auto price = 99.99;      // double로 추론
auto name = "김철수";     // const char*로 추론

📥📤 4. 입력과 출력

🔹 연산자 해석

• << : 삽입 연산자 (insertion operator)

  👉 cout << "어쩌구";

  = "어쩌구"라는 데이터를 출력 스트림에 집어넣는다 → 화면에 표시됨.

• >> : 추출 연산자 (extraction operator)

  👉 cin >> 변수명;

  = 입력 스트림에서 데이터를 꺼내서 변수에 저장한다.

🔹 비유

• cout << : "데이터를 파이프(스트림)에 흘려보낸다 → 밖(모니터)로 간다"
• cin >> : "파이프(스트림)에서 데이터를 꺼낸다 → 내 변수로 가져온다"

출력 (cout)

cout << "문자열 출력";
cout << 변수명;
cout << "값: " << 변수 << endl;

입력 (cin)

int age;
cin >> age;

string name;
cin >> name;  // 공백 전까지만 입력받음

// 여러 값 한번에 입력
int a, b;
cin >> a >> b;

실용 예제

#include <iostream>
#include <string>
using namespace std;

int main() {
    string name;
    int age;

    cout << "이름을 입력하세요: ";
    cin >> name;
    cout << "나이를 입력하세요: ";
    cin >> age;

    cout << name << "님의 나이는 " << age << "세입니다." << endl;
    return 0;
}

🔢 5. 연산자와 수식

산술 연산자

int a = 10, b = 3;
cout << a + b;  // 13 (덧셈)
cout << a - b;  // 7  (뺄셈)
cout << a * b;  // 30 (곱셈)
cout << a / b;  // 3  (나눗셈 - 정수)
cout << a % b;  // 1  (나머지)

비교 연산자

'bool'은 컴퓨터 프로그래밍에서 참(true)과 거짓(false)이라는 두 가지 값만 저장하는 논리 자료형(boolean type)을 의미하며, 영국 수학자 조지 불(George Boole)의 이름에서 유래했습니다. 이 자료형은 조건문이나 반복문에서 특정 상태를 참 또는 거짓으로 판단하여 제어하는 데 사용됩니다.

int x = 5, y = 3;
bool result1 = (x > y);   // true
bool result2 = (x == y);  // false
bool result3 = (x != y);  // true

🎲 6. 난수 생성

전통적인 방법

#include <ctime>
#include <cstdlib>

srand(time(NULL));        // 시드값 초기화
int dice = (rand() % 6) + 1;  // 1~6 사이 난수

📝 예상 문제 및 풀이

📌 문제 1: 기본 개념 (객관식)

C++의 개발자와 개발 장소는?

1. Dennis Ritchie, AT&T 벨연구소
2. Bjarne Stroustrup, AT&T 벨연구소
3. James Gosling, Sun Microsystems
4. Anders Hejlsberg, Microsoft

정답: 2번

📌 문제 2: 프로그램 구조 (단답형)

다음 빈칸을 채우시오.

_______ <iostream>
_______ namespace std;

int _______()
{
    cout << "Hello World!" << _______;
    _______ 0;
}

정답:

#include <iostream>
using namespace std;

int main()
{
    cout << "Hello World!" << endl;
    return 0;
}

📌 문제 3: 변수와 자료형 (서술형)

다음 변수 선언에서 잘못된 부분을 찾고 올바르게 수정하시오.

int 2number = 100;
char name = "홍길동";
bool isTrue = 1;
const PI = 3.14;

정답:

int number2 = 100;        // 변수명은 숫자로 시작할 수 없음
string name = "홍길동";    // 문자열은 string 타입 사용
bool isTrue = true;       // bool은 true/false 사용 권장
const double PI = 3.14;   // const는 타입 명시 필요

📌 문제 4: 입출력 프로그래밍 (실습형)

사용자로부터 두 정수를 입력받아 사칙연산 결과를 모두 출력하는 프로그램을 작성하시오.

정답:

#include <iostream>
using namespace std;

int main() {
    int a, b;
    cout << "두 정수를 입력하세요: ";
    cin >> a >> b;

    cout << a << " + " << b << " = " << a + b << endl;
    cout << a << " - " << b << " = " << a - b << endl;
    cout << a << " * " << b << " = " << a * b << endl;
    cout << a << " / " << b << " = " << a / b << endl;
    cout << a << " % " << b << " = " << a % b << endl;

    return 0;
}

📌 문제 5: 실전 응용 (복합형)

다음 조건을 만족하는 프로그램을 작성하시오:

• 사용자로부터 반지름을 입력받는다
• 원의 넓이와 둘레를 계산한다
• 결과를 소수점 둘째자리까지 출력한다

정답:

#include <iostream>
#include <iomanip>
using namespace std;

int main() {
    const double PI = 3.141592;
    double radius;

    cout << "원의 반지름을 입력하세요: ";
    cin >> radius;

    double area = PI * radius * radius;
    double circumference = 2 * PI * radius;

    cout << fixed << setprecision(2);
    cout << "원의 넓이: " << area << endl;
    cout << "원의 둘레: " << circumference << endl;

    return 0;
}

📌 문제 6: 오류 찾기 (디버깅)

다음 프로그램의 오류를 찾아 수정하시오.

#include iostream
using namespace std

int main()
{
    int age
    cout << "나이를 입력하세요: "
    cin >> age
    cout << "당신의 나이는 " << age << "세입니다." << endl
    return 0
}

정답 (수정된 코드):

#include <iostream>     // < > 누락
using namespace std;    // 세미콜론 누락

int main()
{
    int age;            // 세미콜론 누락
    cout << "나이를 입력하세요: ";  // 세미콜론 누락
    cin >> age;         // 세미콜론 누락
    cout << "당신의 나이는 " << age << "세입니다." << endl;  // 세미콜론 누락
    return 0;           // 세미콜론 누락
}

1.1 클래스(Class)와 객체(Object)

• 클래스: 객체를 만들기 위한 템플릿/설계도
• 객체: 클래스의 인스턴스, 실제로 메모리에 할당된 실체

# 기본 클래스 정의 예시
class Rectangle:
    def __init__(self, side=0):  # 생성자 메서드
        self.side = side  # 인스턴스 변수

    def getArea(self):  # 인스턴스 메서드
        return self.side * self.side

# 객체 생성
myRect = Rectangle(5)
print(myRect.getArea())  # 25

1.2 클래스 변수와 인스턴스 변수

• 클래스 변수: 클래스 내부에서 선언되며 모든 객체가 공유하는 변수
• 인스턴스 변수: self.변수명으로 선언되며 각 객체마다 별도로 생성되는 변수

class Television:
    serialNumber = 0  # 클래스 변수

    def __init__(self):
        Television.serialNumber += 1  # 클래스 변수 접근
        self.number = Television.serialNumber  # 인스턴스 변수

a = Television()
b = Television()
c = Television()

print(a.serialNumber)  # 3 (모든 객체가 공유)
print(a.number)  # 1 (객체별 고유값)
print(b.number)  # 2
print(c.number)  # 3

1.3 특수 메서드(Special Methods)

• __init__: 생성자 메서드
• __eq__: 두 객체의 동등성 비교 (== 연산자)
• __lt__: 크기 비교 (< 연산자)
• __add__, __sub__ 등: 산술 연산자 오버로딩

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def __eq__(self, other):
        return self.radius == other.radius

    def __lt__(self, other):
        return self.radius < other.radius

c1 = Circle(10)
c2 = Circle(100)

print(c1 == c2)  # False
print(c1 < c2)   # True

1.4 벡터 연산 예제

class Vector2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector2D(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Vector2D(self.x - other.x, self.y - other.y)

    def __str__(self):
        return '(%d, %d)' % (self.x, self.y)

u = Vector2D(0, 1)
v = Vector2D(1, 1)
result = u + v
print(result)  # (1, 2)

2. GUI 프로그래밍 핵심 개념

2.1 tkinter 기본 구조

from tkinter import *

window = Tk()  # 윈도우 생성
# 위젯 배치
window.mainloop()  # 이벤트 루프 시작

2.2 주요 위젯

2.3 위젯 배치 관리자

• pack(): 상대적 위치로 배치 (TOP, BOTTOM, LEFT, RIGHT)
• grid(): 격자 형태로 배치 (row, column)
• place(): 절대 위치로 배치 (x, y)

# pack() 예시
label = Label(window, text="Hello")
label.pack(side=LEFT)

# grid() 예시
label1 = Label(window, text="이름")
label1.grid(row=0, column=0)
entry1 = Entry(window)
entry1.grid(row=0, column=1)

2.4 이벤트 처리

def callback():
    button["text"] = "버튼이 클릭되었음!"

button = Button(window, text="클릭", command=callback)

2.5 계산기 예제 (코어 로직)

from tkinter import *

def click(key):
    if key == '=':  # '=' 버튼이면 수식을 계산하여 결과를 표시
        try:
            result = eval(entry.get())
            entry.delete(0, END)  # 0번째 위치부터 끝까지 삭제
            entry.insert(END, str(result))
        except:
            entry.insert(END, "오류!")
    elif key == 'C':
        entry.delete(0, END)
    else:
        entry.insert(END, key)

window = Tk()
window.title("계산기")

buttons = ['7', '8', '9', '+', 'C',
           '4', '5', '6', '-', ' ',
           '1', '2', '3', '*', ' ',
           '0', '.', '=', '/', ' ']

# 반복문으로 버튼을 생성한다.
i = 0
for b in buttons:
    b = Button(window, text=b, width=5, relief='ridge', command=lambda x=b: click(x))
    b.grid(row=i//5+1, column=i%5)
    i += 1

# 엔트리 위젯은 5개의 셀을 병합한 너비로 맨 위에 배치된다.
entry = Entry(window, width=33, bg="yellow")
entry.grid(row=0, column=0, columnspan=5)

window.mainloop()

3. 예상 문제 및 풀이

파이썬 기말고사 대비 예상 문제 및 풀이

객체지향 프로그래밍

문제 1: 클래스와 객체 기초

다음 코드의 실행 결과는 무엇인가?

class Counter:
    count = 0

    def __init__(self):
        Counter.count += 1
        self.id = Counter.count

    def get_id(self):
        return self.id

a = Counter()
b = Counter()
print(a.count, b.count)
print(a.id, b.id)

풀이:

2 2
1 2

클래스 변수 count는 모든 객체가 공유하므로 두 객체 모두 2가 출력됩니다. 인스턴스 변수 id는 각 객체마다 다른 값을 가지므로 a는 1, b는 2가 출력됩니다.

문제 2: 특수 메서드

다음 코드를 실행했을 때 에러가 발생하지 않도록 __lt__ 메서드를 구현하시오.

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    # 여기에 __lt__ 메서드를 구현하세요

students = [Student("Kim", 85), Student("Lee", 92), Student("Park", 78)]
sorted_students = sorted(students)
for student in sorted_students:
    print(f"{student.name}: {student.score}")

풀이:

def __lt__(self, other):
    return self.score < other.score

문제 3: 벡터 연산

2차원 벡터를 나타내는 Vector2D 클래스에 곱셈 연산(*)을 지원하도록 __mul__ 메서드를 구현하시오. 벡터와 스칼라 값의 곱셈을 지원해야 합니다.

class Vector2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    # 여기에 __mul__ 메서드를 구현하세요

v = Vector2D(3, 4)
result = v * 2
print(result)  # 출력: (6, 8)

풀이:

def __mul__(self, scalar):
    return Vector2D(self.x * scalar, self.y * scalar)

GUI 프로그래밍

문제 4: 버튼 이벤트 처리

다음 코드에서 버튼을 클릭할 때마다 카운터가 증가하도록 increase_counter 함수를 구현하시오.

from tkinter import *

def increase_counter():
    # 여기에 코드를 구현하세요

window = Tk()
counter = 0
label = Label(window, text="카운터: 0")
label.pack()

button = Button(window, text="증가", command=increase_counter)
button.pack()

window.mainloop()

풀이:

def increase_counter():
    global counter
    counter += 1
    label.config(text=f"카운터: {counter}")

문제 5: Entry 위젯 활용

다음 조건을 만족하는 간단한 온도 변환기(섭씨→화씨) GUI 프로그램의 convert 함수를 완성하시오.

from tkinter import *

def convert():
    # 여기에 코드를 구현하세요

window = Tk()
window.title("온도 변환기")

Label(window, text="섭씨(°C):").grid(row=0, column=0)
celsius_entry = Entry(window)
celsius_entry.grid(row=0, column=1)

Label(window, text="화씨(°F):").grid(row=1, column=0)
fahrenheit_label = Label(window, text="")
fahrenheit_label.grid(row=1, column=1)

Button(window, text="변환", command=convert).grid(row=2, column=1)

window.mainloop()

풀이:

def convert():
    try:
        celsius = float(celsius_entry.get())
        fahrenheit = (celsius * 9/5) + 32
        fahrenheit_label.config(text=f"{fahrenheit:.2f}")
    except ValueError:
        fahrenheit_label.config(text="오류: 숫자를 입력하세요")

문제 6: 산수 퀴즈 프로그램

다음 산수 퀴즈 프로그램에서 check_answer 함수를 완성하여, 사용자의 답을 확인하고 결과를 표시하시오.

from tkinter import *
import random

def generate_question():
    global a, b, operation
    a = random.randint(1, 10)
    b = random.randint(1, 10)
    operation = random.choice(['+', '-', '*'])
    question_label.config(text=f"{a} {operation} {b} = ?")
    answer_entry.delete(0, END)
    result_label.config(text="")

def check_answer():
    # 여기에 코드를 구현하세요

window = Tk()
window.title("산수 퀴즈")

a, b, operation = 0, 0, '+'

question_label = Label(window, font=('Arial', 14))
question_label.pack(pady=10)

answer_entry = Entry(window)
answer_entry.pack(pady=5)

Button(window, text="확인", command=check_answer).pack(pady=5)
Button(window, text="새 문제", command=generate_question).pack(pady=5)

result_label = Label(window, font=('Arial', 12))
result_label.pack(pady=10)

generate_question()
window.mainloop()

풀이:

def check_answer():
    try:
        user_answer = int(answer_entry.get())
        if operation == '+':
            correct_answer = a + b
        elif operation == '-':
            correct_answer = a - b
        else:  # '*'
            correct_answer = a * b

        if user_answer == correct_answer:
            result_label.config(text="정답입니다!", fg="green")
        else:
            result_label.config(text=f"오답입니다. 정답은 {correct_answer}입니다.", fg="red")
    except ValueError:
        result_label.config(text="숫자를 입력하세요", fg="red")

파이썬 객체지향 프로그래밍 & GUI 기말고사 대비 요약 정리

객체지향 프로그래밍

1. 객체와 클래스의 기본 개념

• 클래스(Class): 객체를 생성하기 위한 템플릿/설계도
• 객체(Object): 클래스의 인스턴스(실체)
• 속성(Attribute): 객체의 특성을 나타내는 변수
• 메서드(Method): 객체가 수행할 수 있는 동작/함수

# 기본 클래스 구조
class ClassName:
    # 생성자 메서드
    def __init__(self, parameter1, parameter2):
        self.attribute1 = parameter1  # 인스턴스 변수
        self.attribute2 = parameter2

    # 일반 메서드
    def method1(self):
        # 메서드 내용
        pass

2. 변수 유형

class Television:
    serialNumber = 0  # 클래스 변수

    def __init__(self):
        Television.serialNumber += 1
        self.number = Television.serialNumber  # 인스턴스 변수

    def display(self):
        count = 1  # 지역 변수
        print(f"TV #{self.number}, 총 TV 개수: {Television.serialNumber}")

3. 특수 메서드(Magic Methods)

class Vector2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __add__(self, other):
        return Vector2D(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Vector2D(self.x - other.x, self.y - other.y)

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

4. 객체와 함수의 관계

class Rectangle:
    def __init__(self, side=0):
        self.side = side

    def getArea(self):
        return self.side * self.side

# 객체를 함수에 전달
def printAreas(r, n):
    while n >= 1:
        print(f"n = {n}, r.side = {r.side}, r.getArea() = {r.getArea()}")
        r.side = r.side + 1
        n = n - 1

# 함수 호출
myRect = Rectangle()
count = 5
printAreas(myRect, count)
print(f"함수 탈출 후 myRect.side = {myRect.side}")  # 5

GUI 프로그래밍 (tkinter)

1. tkinter 기본 구조

from tkinter import *

window = Tk()  # 윈도우 생성
window.title("제목")  # 윈도우 제목 설정

# 위젯 배치 코드

window.mainloop()  # 이벤트 루프 시작

2. 주요 위젯

3. 배치 관리자

pack() 옵션

• side: TOP(기본값), BOTTOM, LEFT, RIGHT
• fill: X, Y, BOTH, NONE
• expand: 0(기본값) 또는 1
• padx, pady: 여백

grid() 옵션

• row, column: 배치할 행과 열 (0부터 시작)
• rowspan, columnspan: 병합할 행/열 수
• padx, pady: 여백

4. 이벤트 처리

# 방법 1: command 옵션 사용
def button_clicked():
    label.config(text="버튼이 클릭되었습니다!")

button = Button(window, text="클릭", command=button_clicked)

# 방법 2: bind() 메서드 사용
def key_pressed(event):
    print(f"키가 눌렸습니다: {event.char}")

entry.bind("<Key>", key_pressed)

5. 위젯 속성 변경

# 생성 시 설정
label = Label(window, text="원래 텍스트", fg="blue", bg="yellow")

# 나중에 변경
label["text"] = "변경된 텍스트"  # 딕셔너리 형태로 접근
label.config(text="새로운 텍스트", fg="red")  # config() 메서드 사용

6. 계산기 응용 프로그램

from tkinter import *

def click(key):
    if key == '=':  # 계산 실행
        try:
            result = eval(entry.get())
            entry.delete(0, END)
            entry.insert(END, str(result))
        except:
            entry.insert(END, "오류!")
    elif key == 'C':  # 입력 내용 지우기
        entry.delete(0, END)
    else:  # 다른 키는 화면에 추가
        entry.insert(END, key)

window = Tk()
window.title("계산기")

# 계산 결과 표시창
entry = Entry(window, width=33, bg="yellow")
entry.grid(row=0, column=0, columnspan=5)

# 버튼 배열 정의
buttons = ['7', '8', '9', '+', 'C',
           '4', '5', '6', '-', ' ',
           '1', '2', '3', '*', ' ',
           '0', '.', '=', '/', ' ']

# 버튼 생성 및 배치
i = 0
for b in buttons:
    button = Button(window, text=b, width=5, relief='ridge',
                   command=lambda x=b: click(x))
    button.grid(row=i//5+1, column=i%5)
    i += 1

자주 실수하는 부분과 주요 포인트

객체지향 프로그래밍

1. self 매개변수 누락: 모든 인스턴스 메서드의 첫 매개변수는 반드시 self
2. 클래스 변수와 인스턴스 변수 혼동: 용도에 맞게 사용
3. 특수 메서드 구현 시 매개변수 개수/이름 확인: __add__(self, other)

GUI 프로그래밍

1. mainloop() 호출 누락: 이벤트 루프 시작을 위해 필수
2. 위젯 생성과 배치 분리: button = Button(...); button.pack() 또는 Button(...).pack()
3. 전역 변수 사용 시 global 키워드 필요: 함수 내에서 전역 변수 변경 시
4. 람다 함수 사용 시 매개변수 전달 주의: command=lambda x=value: function(x)
5. 이벤트 처리 함수에서 이벤트 객체(event) 처리: bind 사용 시 필요

예상 문제 및 풀이

파이썬 기말고사 대비 예상 문제 및 풀이

객체지향 프로그래밍

문제 1: 클래스와 객체 기초

다음 코드의 실행 결과는 무엇인가?

class Counter:
    count = 0

    def __init__(self):
        Counter.count += 1
        self.id = Counter.count

    def get_id(self):
        return self.id

a = Counter()
b = Counter()
print(a.count, b.count)
print(a.id, b.id)

풀이:

2 2
1 2

클래스 변수 count는 모든 객체가 공유하므로 두 객체 모두 2가 출력됩니다. 인스턴스 변수 id는 각 객체마다 다른 값을 가지므로 a는 1, b는 2가 출력됩니다.

문제 2: 특수 메서드

다음 코드를 실행했을 때 에러가 발생하지 않도록 __lt__ 메서드를 구현하시오.

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    # 여기에 __lt__ 메서드를 구현하세요

students = [Student("Kim", 85), Student("Lee", 92), Student("Park", 78)]
sorted_students = sorted(students)
for student in sorted_students:
    print(f"{student.name}: {student.score}")

풀이:

def __lt__(self, other):
    return self.score < other.score

문제 3: 벡터 연산

2차원 벡터를 나타내는 Vector2D 클래스에 곱셈 연산(*)을 지원하도록 __mul__ 메서드를 구현하시오. 벡터와 스칼라 값의 곱셈을 지원해야 합니다.

class Vector2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    # 여기에 __mul__ 메서드를 구현하세요

v = Vector2D(3, 4)
result = v * 2
print(result)  # 출력: (6, 8)

풀이:

def __mul__(self, scalar):
    return Vector2D(self.x * scalar, self.y * scalar)

GUI 프로그래밍

문제 4: 버튼 이벤트 처리

다음 코드에서 버튼을 클릭할 때마다 카운터가 증가하도록 increase_counter 함수를 구현하시오.

from tkinter import *

def increase_counter():
    # 여기에 코드를 구현하세요

window = Tk()
counter = 0
label = Label(window, text="카운터: 0")
label.pack()

button = Button(window, text="증가", command=increase_counter)
button.pack()

window.mainloop()

풀이:

def increase_counter():
    global counter
    counter += 1
    label.config(text=f"카운터: {counter}")

문제 5: Entry 위젯 활용

다음 조건을 만족하는 간단한 온도 변환기(섭씨→화씨) GUI 프로그램의 convert 함수를 완성하시오.

from tkinter import *

def convert():
    # 여기에 코드를 구현하세요

window = Tk()
window.title("온도 변환기")

Label(window, text="섭씨(°C):").grid(row=0, column=0)
celsius_entry = Entry(window)
celsius_entry.grid(row=0, column=1)

Label(window, text="화씨(°F):").grid(row=1, column=0)
fahrenheit_label = Label(window, text="")
fahrenheit_label.grid(row=1, column=1)

Button(window, text="변환", command=convert).grid(row=2, column=1)

window.mainloop()

풀이:

def convert():
    try:
        celsius = float(celsius_entry.get())
        fahrenheit = (celsius * 9/5) + 32
        fahrenheit_label.config(text=f"{fahrenheit:.2f}")
    except ValueError:
        fahrenheit_label.config(text="오류: 숫자를 입력하세요")

문제 6: 산수 퀴즈 프로그램

다음 산수 퀴즈 프로그램에서 check_answer 함수를 완성하여, 사용자의 답을 확인하고 결과를 표시하시오.

from tkinter import *
import random

def generate_question():
    global a, b, operation
    a = random.randint(1, 10)
    b = random.randint(1, 10)
    operation = random.choice(['+', '-', '*'])
    question_label.config(text=f"{a} {operation} {b} = ?")
    answer_entry.delete(0, END)
    result_label.config(text="")

def check_answer():
    # 여기에 코드를 구현하세요

window = Tk()
window.title("산수 퀴즈")

a, b, operation = 0, 0, '+'

question_label = Label(window, font=('Arial', 14))
question_label.pack(pady=10)

answer_entry = Entry(window)
answer_entry.pack(pady=5)

Button(window, text="확인", command=check_answer).pack(pady=5)
Button(window, text="새 문제", command=generate_question).pack(pady=5)

result_label = Label(window, font=('Arial', 12))
result_label.pack(pady=10)

generate_question()
window.mainloop()

풀이:

def check_answer():
    try:
        user_answer = int(answer_entry.get())
        if operation == '+':
            correct_answer = a + b
        elif operation == '-':
            correct_answer = a - b
        else:  # '*'
            correct_answer = a * b

        if user_answer == correct_answer:
            result_label.config(text="정답입니다!", fg="green")
        else:
            result_label.config(text=f"오답입니다. 정답은 {correct_answer}입니다.", fg="red")
    except ValueError:
        result_label.config(text="숫자를 입력하세요", fg="red")

1.1 클래스와 객체

• 클래스(Class): 객체를 생성하기 위한 템플릿 또는 청사진
• 객체(Object): 클래스의 인스턴스, 실제 메모리에 할당된 실체
• 인스턴스 변수: 각 객체마다 개별적으로 가지는 변수
• 메소드: 클래스 내에 정의된 함수

python
class Counter:
    def __init__(self):
        self.count = 0

    def reset(self):
        self.count = 0

    def increment(self):
        self.count += 1

    def get(self):
        return self.count

# 객체 생성 및 사용
a = Counter()
print(a.count)# 0
a.increment()
print(a.count)# 1
print(a.get())# 1

1.2 생성자 (__init__)

• 객체가 생성될 때 자동으로 호출되는 특별한 메소드
• 객체를 초기 상태로 설정하는 역할
• 첫 번째 매개변수는 항상 self

python
class Television:
    def __init__(self, channel, volume, on):
        self.channel = channel
        self.volume = volume
        self.on = on

    def show(self):
        print(self.channel, self.volume, self.on)

    def setChannel(self, channel):
        self.channel = channel

    def getChannel(self):
        return self.channel

# 객체 생성 및 메소드 호출
t = Television(9, 10, True)
t.show()# 9 10 True
t.setChannel(11)
t.show()# 11 10 True

1.3 기본값 매개변수

• 생성자나 메소드의 매개변수에 기본값 설정 가능

python
class Student:
    def __init__(self, name=None, age=0):
        self.name = name
        self.age = age

ob1 = Student("Hong", 20)
print("object 1 상태 :", ob1.name, ob1.age)# object 1 상태 : Hong 20
ob2 = Student()
print("object 2 상태 :", ob2.name, ob2.age)# object 2 상태 : None 0

2. 정보 은닉과 캡슐화

2.1 비공개 인스턴스 변수 (Private Variables)

• 변수명 앞에 이중 밑줄(__)을 붙여 정의
• 클래스 외부에서 직접 접근 불가
• 클래스 내부에서만 접근 가능

python
class Student:
    def __init__(self, name=None, age=0):
        self.__name = name# 비공개 인스턴스 변수
        self.__age = age# 비공개 인스턴스 변수

obj = Student("Hong", 20)
# print(obj.__age)    # 오류 발생: AttributeError

2.2 접근자(Getter)와 설정자(Setter) 메소드

• 비공개 인스턴스 변수에 안전하게 접근하고 수정하기 위한 메소드
• 값의 유효성 검사 등 로직 추가 가능

python
class Student:
    def __init__(self, name=None, age=0):
        self.__name = name
        self.__age = age

    def getAge(self):
        return self.__age

    def getName(self):
        return self.__name

    def setAge(self, age):
        self.__age = age

    def setName(self, name):
        self.__name = name

obj = Student("Hong", 20)
print(obj.getName())# Hong
obj.setAge(30)
print(obj.getAge())# 30

2.3 명명 규칙에 의한 비공개 변수 접근 (네임 맹글링)

• 실제로는 _클래스명__변수명 형태로 변환됨
• 이를 통해 비공개 변수에도 접근 가능 (하지만 권장되지 않음)

python
obj = Student("Hong", 20)
print(obj._Student__age)# 20
print(obj._Student__name)# Hong

3. 객체의 문자열 표현 (__str__ 메소드)

• 객체를 문자열로 표현할 때 사용되는 특별 메소드
• print(객체) 호출 시 자동으로 사용됨

python
class Cat:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def __str__(self):
        return '(%s, %d)' % (self.__name, self.__age)

cream = Cat('Cream', 15)
print(cream)# (Cream, 15)

4. 실제 응용 예제

4.1 원(Circle) 클래스

python
import math

class Circle:
    def __init__(self, radius=1.0):
        self.__radius = radius

    def setRadius(self, r):
        self.__radius = r

    def getRadius(self):
        return self.__radius

    def calcArea(self):
        area = math.pi * self.__radius * self.__radius
        return area

    def calcCircum(self):
        circumference = 2.0 * math.pi * self.__radius
        return circumference

c1 = Circle(10)
print("원의 반지름=", c1.getRadius())
print("원의 넓이=", c1.calcArea())
print("원의 둘레=", c1.calcCircum())

4.2 은행 계좌(BankAccount) 클래스

python
class BankAccount:
    def __init__(self):
        self.__balance = 0
        print("처음 잔액 :", self.__balance, "\n")

    def withdraw(self, amount):
        self.__balance -= amount
        print("통장에", amount, "원 출금되었음")
        return self.__balance

    def deposit(self, amount):
        self.__balance += amount
        print("통장에서", amount, "원 입금되었음")
        return self.__balance

a = BankAccount()
print("현재 잔액 :", a.deposit(100000), "원\n")
print("현재 잔액 :", a.withdraw(10000), "원\n")

4.3 상자(Box) 클래스 - 부피 계산

python
class Box:
    def __init__(self, length=0, width=0, height=0):
        self.__width = width
        self.__length = length
        self.__height = height

    def setLength(self, length):
        self.__length = length

    def setWidth(self, width):
        self.__width = width

    def setHeight(self, height):
        self.__height = height

    def getVolume(self):
        return self.__width * self.__length * self.__height

    def __str__(self):
        return '(%d, %d, %d)' % (self.__length, self.__width, self.__height)

box = Box(10, 4, 5)
print(box)# (10, 4, 5)
print('상자의 부피는', box.getVolume())# 상자의 부피는 200

4.4 자동차(Car) 클래스

python
class Car:
    def __init__(self, speed=0, gear=1, color="white"):
        self.__speed = speed
        self.__gear = gear
        self.__color = color

    def setSpeed(self, speed):
        self.__speed = speed

    def setGear(self, gear):
        self.__gear = gear

    def setColor(self, color):
        self.__color = color

    def __str__(self):
        return '(%d, %d, %s)' % (self.__speed, self.__gear, self.__color)

myCar = Car()
print(myCar)# (0, 1, white)
myCar.setGear(3)
myCar.setSpeed(100)
print(myCar)# (100, 3, white)

4.5 객체를 함수로 전달하기

python
class Rectangle:
    def __init__(self, side=0):
        self.side = side

    def getArea(self):
        return self.side * self.side

# 사각형 객체와 반복횟수를 매개변수로 받는 함수
def printAreas(r, n):
    while n >= 1:
        print("n =", n, "이고", "r.side =", r.side, "r.getArea() =", r.getArea())
        r.side = r.side + 1
        n = n - 1

myRect = Rectangle()
count = 5
printAreas(myRect, count)
print("\n함수 탈출 후 myRect.side =", myRect.side)# 5

5. 기말고사 예상 문제

문제 1: 기본 클래스 작성

문제: 다음 조건을 만족하는 Person 클래스를 작성하시오.

• 인스턴스 변수: __name(이름), __age(나이)

• 생성자: 이름과 나이를 매개변수로 받아 초기화

• 접근자 메소드: getName(), getAge()

• 설정자 메소드: setName(), setAge()

• __str__ 메소드: "(이름, 나이)" 형태로 반환

• person 클래스 풀이

  class Person:

    def __init__(self, name=None, age=0):
        self.__name = name
        self.__age = age
  
    def getName(self):
        return self.__name
  
    def getAge(self):
        return self.__age
  
    def setName(self, name):
        self.__name = name
  
    def setAge(self, age):
        self.__age = age
  
    def __str__(self):
        return '(%s, %d)' % (self.__name, self.__age)

  # 테스트 코드

  person1 = Person("Kim", 25) print(person1)

  # (Kim, 25)

  print(person1.getName())

  # Kim

  print(person1.getAge())

  # 25

  person1.setName("Park") person1.setAge(30) print(person1)

  # (Park, 30)

파이썬 객체지향 프로그래밍 기말고사 대비 예상 문제

제공해주신 객체지향 방법론 학습 자료를 바탕으로 기말고사 대비용 예상 문제를 준비했습니다. 다양한 유형의 문제로 구성했으며, 객체지향 프로그래밍의 핵심 개념을 테스트할 수 있도록 했습니다.

객관식 문제 (각 5점)

1. 파이썬에서 객체의 인스턴스 변수를 클래스 외부로부터 보호하기 위해 사용하는 명명법은?
   • a) _variable
   • b) __variable
   • c) variable_
   • d) variable
2. 파이썬 클래스의 생성자 메소드 이름은?
   • a) construct
   • b) new
   • c) init
   • d) create
3. 객체의 현재 상태를 문자열로 요약해주는 메소드는?
   • a) str
   • b) print
   • c) toString()
   • d) repr
4. 파이썬에서 클래스 외부에서 __name과 같은 비공개(private) 변수에 접근하는 올바른 방법은?
   • a) object.__name
   • b) object._name
   • c) object._ClassName__name
   • d) object.getName()
5. 클래스 내부에서 인스턴스 변수를 참조할 때 사용하는 키워드는?
   • a) this
   • b) self
   • c) instance
   • d) me

단답형 문제 (각 5점)

1. 객체지향 프로그래밍에서 인스턴스 변수에 대한 접근을 제어하는 메소드 중, 값을 반환하는 메소드를 무엇이라고 하는가?
2. 객체지향 프로그래밍에서 인스턴스 변수에 대한 접근을 제어하는 메소드 중, 값을 설정하는 메소드를 무엇이라고 하는가?
3. 파이썬에서 클래스의 인스턴스를 생성할 때 자동으로 호출되는 메소드는?
4. 파이썬에서 비공개(private) 인스턴스 변수를 정의할 때 변수명 앞에 붙이는 기호는?
5. 객체의 상태를 보호하고 외부에서 직접 접근하지 못하게 하는 객체지향 개념을 무엇이라고 하는가?

코드 분석 문제 (각 10점)

1. 다음 코드의 실행 결과를 예측하시오.

python
class Student:
    def __init__(self, name=None, age=0):
        self.__name = name
        self.__age = age

    def getName(self):
        return self.__name

    def getAge(self):
        return self.__age

    def setName(self, name):
        self.__name = name

    def setAge(self, age):
        self.__age = age

obj = Student("Kim", 20)
print(obj.getName())
obj.setAge(21)
print(obj.getAge())

1. 다음 코드의 실행 결과를 예측하시오.

python
class Box:
    def __init__(self, length=0, width=0, height=0):
        self.__length = length
        self.__width = width
        self.__height = height

    def getVolume(self):
        return self.__length * self.__width * self.__height

    def __str__(self):
        return '(%d, %d, %d)' % (self.__length, self.__width, self.__height)

box = Box(5, 3, 2)
print(box)
print("부피:", box.getVolume())

1. 다음 코드의 오류를 찾고 수정하시오.

python
class Circle:
    def __init__(self, radius=1.0):
        self.__radius = radius

    def calcArea(self):
        area = 3.14 * self.__radius * self.__radius
        return area

c = Circle(5)
print("반지름:", c.__radius)
print("원의 넓이:", c.calcArea())

코드 작성 문제 (각 15점)

1. 직원(Employee) 클래스를 정의하시오. 이 클래스는 다음을 포함해야 합니다:
   • 이름(name), 직위(position), 급여(salary)를 인스턴스 변수로 가짐
   • 인스턴스 변수는 모두 비공개로 설정
   • 각 변수에 대한 접근자와 설정자 메소드 구현
   • str 메소드를 구현하여 직원 정보를 문자열로 반환
   • 급여를 인상하는 raiseSalary(percent) 메소드 구현 (percent는 인상 비율)
2. 주식(Stock) 클래스를 정의하시오. 이 클래스는 다음을 포함해야 합니다:
   • 종목명(symbol), 현재가(price), 보유수량(shares)을 인스턴스 변수로 가짐
   • 인스턴스 변수는 모두 비공개로 설정
   • 각 변수에 대한 접근자와 설정자 메소드 구현
   • 총 가치를 계산하는 getTotalValue() 메소드 구현
   • 주식을 구매하는 buy(amount) 메소드와 판매하는 sell(amount) 메소드 구현
3. 도서관 도서(LibraryBook) 클래스를 정의하시오. 이 클래스는 다음을 포함해야 합니다:
   • 제목(title), 저자(author), 대출상태(borrowed) 인스턴스 변수
   • 인스턴스 변수는 모두 비공개로 설정
   • 각 변수에 대한 접근자와 설정자 메소드 구현
   • 도서를 대출하는 borrowBook() 메소드와 반납하는 returnBook() 메소드 구현
   • str 메소드를 구현하여 도서 정보와 대출 상태를 문자열로 반환

응용 문제 (20점)

1. 은행 시스템을 구현하기 위한 클래스를 설계하시오. 다음 요구사항을 만족해야 합니다:
   • 계좌(Account) 클래스는 계좌번호(accountNumber), 소유자명(ownerName), 잔액(balance)을 인스턴스 변수로 가짐
   • 모든 인스턴스 변수는 비공개로 설정하고 적절한 접근자와 설정자 메소드 구현
   • 입금(deposit), 출금(withdraw) 메소드 구현
   • 출금 시 잔액이 부족하면 오류 메시지 출력
   • str 메소드를 구현하여 계좌 정보를 문자열로 반환
   • 계좌 클래스를 활용하여 입금, 출금, 계좌 정보 조회 기능을 테스트하는 코드 작성

핵심 개념

• 2차원 리스트를 활용한 게임 보드 표현
• 반복문과 조건문을 활용한 게임 로직 구현
• 랜덤 함수를 활용한 컴퓨터 플레이어 구현
• 승리 조건 확인 로직

주요 코드 구조

python
# 게임 초기화
me = input("Tic-Tac_Toe게임입니다. 원하는 기호를 O, X 중에서 선택하시오 : ")
if me == "X":
    com = "O"
else:
    com = "X"
board = [[' ' for x in range(5)] for y in range(5)]# 5x5 게임 보드 생성
result = ""
import random

# 게임 루프
while True:
# 현재 보드 상태 출력
    for r in range(5):
        print(" "+board[r][0]+"| "+board[r][1]+"| "+board[r][2]+"| "+board[r][3]+"| "+board[r][4])
        if (r!=4):
            print("---|---|---|---|---")

# 게임 종료 확인
    if result == "win_me":
        print("당신이 컴퓨터를 이겼습니다.")
        break
    elif result == "win_com":
        print("컴퓨터가 당신을 이겼습니다.")
        break

# 사용자 입력 받기
    x = int(input("(0 ~ 4)사이의 x좌표를 입력하시오:"))
    y = int(input("(0 ~ 4)사이의 y좌표를 입력하시오:"))

# 입력 위치 확인
    if board[x][y] != ' ':
        print("잘못된 위치입니다.")
        continue
    else:
        board[x][y] = me

# 컴퓨터 차례
    while True:
        a = random.randrange(0, 5)# 0 이상 5 미만의 랜덤 숫자
        b = random.randrange(0, 5)# 0 이상 5 미만의 랜덤 숫자
        if board[a][b] == ' ':
            board[a][b] = com
            break

# 승리 조건 확인 (수직, 수평, 대각선)# 수직 패턴 확인
    ver0 = []
    ver1 = []
    ver2 = []
    ver3 = []
    ver4 = []
    for i in range(5):
        ver0.append(board[i][0])
    for i in range(5):
        ver1.append(board[i][1])
    for i in range(5):
        ver2.append(board[i][2])
    for i in range(5):
        ver3.append(board[i][3])
    for i in range(5):
        ver4.append(board[i][4])

# 수평 패턴 확인
    hori0 = []
    hori1 = []
    hori2 = []
    hori3 = []
    hori4 = []
    for i in range(5):
        hori0.append(board[0][i])
    for i in range(5):
        hori1.append(board[1][i])
    for i in range(5):
        hori2.append(board[2][i])
    for i in range(5):
        hori3.append(board[3][i])
    for i in range(5):
        hori4.append(board[4][i])

# 대각선 패턴 확인
    dia0 = []
    dia1 = []
    for i in range(5):
        dia0.append(board[i][i])
    for i in range(5):
        dia1.append(board[i][4-i])

# 승리 조건 검사
    w_m = [me, me, me, me, me]# 사용자 승리 패턴
    w_c = [com, com, com, com, com]# 컴퓨터 승리 패턴

    if ((ver0 == w_m) or (ver1 == w_m) or (ver2 == w_m) or (ver3 == w_m) or (ver4 == w_m) or
        (hori0 == w_m) or (hori1 == w_m) or (hori2 == w_m) or (hori3 == w_m) or (hori4 == w_m) or
        (dia0 == w_m) or (dia1 == w_m)):
        result = "win_me"
    elif ((ver0 == w_c) or (ver1 == w_c) or (ver2 == w_c) or (ver3 == w_c) or (ver4 == w_c) or
          (hori0 == w_c) or (hori1 == w_c) or (hori2 == w_c) or (hori3 == w_c) or (hori4 == w_c) or
          (dia0 == w_c) or (dia1 == w_c)):
        result = "win_com"

2. 객체 지향 프로그래밍

핵심 개념

• 객체(Object): 상태(인스턴스 변수)와 동작(메소드)을 가진 요소
• 클래스(Class): 객체의 설계도
• 인스턴스(Instance): 클래스로부터 만들어진 객체
• 인스턴스 변수: 객체의 상태를 나타내는 변수(self.변수명)
• 메소드(Method): 객체의 동작을 정의하는 함수
• 캡슐화(Encapsulation): 데이터와 알고리즘을 하나로 묶는 것

클래스 구조

class 클래스이름:
    def 메소드1(self, 매개변수들):
# 메소드 내용
        self.인스턴스변수 = 값

    def 메소드2(self, 매개변수들):
# 메소드 내용

객체 생성 및 사용

객체변수 = 클래스이름()# 객체 생성
객체변수.메소드()# 메소드 호출

Counter 클래스 예제

python
class Counter:
    def reset(self):
        self.count = 0

    def increment(self):
        self.count += 1

    def get(self):
        return self.count

# 사용 예시
a = Counter()
a.reset()
a.increment()
print("카운터 a의 값은", a.get())# 카운터 a의 값은 1
print("카운터 a의 값은", a.count)# 카운터 a의 값은 1# 두 개의 독립적인 객체 생성
b = Counter()
a.reset()
b.reset()
a.increment()
print("카운터 a의 값은", a.get())# 카운터 a의 값은 1
print("카운터 b의 값은", b.get())# 카운터 b의 값은 0

객체 지향 프로그래밍의 장점

1. 생산성 향상: 잘 설계된 클래스 재사용
2. 자연적인 모델링: 일상 개념을 프로그래밍으로 표현
3. 유지보수 용이성: 수정 및 기능 추가가 쉬움
4. 캡슐화: 데이터와 함수를 하나로 묶어 관리

기말고사 예상 문제

객관식 문제

1. 파이썬에서 객체는 다음 중 무엇으로 구성되는가? a) 함수와 변수 b) 인스턴스 변수와 메소드 c) 클래스와 상속 d) 속성과 프로퍼티
2. 다음 중 객체지향 프로그래밍의 장점이 아닌 것은? a) 생산성 향상 b) 자연적인 모델링 c) 유지보수의 용이성 d) 메모리 사용량 감소
3. 파이썬에서 클래스의 메소드를 정의할 때 첫 번째 매개변수로 주로 사용되는 것은? a) cls b) self c) this d) method
4. 객체지향 프로그래밍에서 데이터와 알고리즘을 하나로 묶고 공용 인터페이스만 제공하고 구현 세부 사항을 감추는 것을 무엇이라고 하는가? a) 추상화 b) 다형성 c) 캡슐화 d) 상속
5. Tic-Tac-Toe 게임 프로그래밍에서 게임판(board)을 초기화하는 코드로 올바른 것은? a) board = [' ' for x in range(5)] b) board = [[' ' for x in range(5)]] c) board = [[' ' for x in range(5)] for y in range(5)] d) board = [for x in range(5) for y in range(5)]

단답형 문제

1. 객체지향 프로그래밍에서 클래스로부터 만들어지는 각각의 객체를 무엇이라고 하는가?
2. 파이썬에서 인스턴스 변수를 생성하려면 메소드 안에서 어떤 키워드를 변수 앞에 붙여야 하는가?
3. Tic-Tac-Toe 게임에서 컴퓨터가 랜덤한 위치에 표시를 하기 위해 사용하는 파이썬 모듈은 무엇인가?
4. 객체지향 프로그래밍에서 기존 클래스의 기능을 확장하여 새로운 클래스를 만드는 기법을 무엇이라고 하는가?
5. Tic-Tac-Toe 게임에서 승리 조건을 확인하기 위해 사용되는 패턴의 세 가지 종류는 무엇인가?

코드 분석 문제

1. 다음 코드의 실행 결과는 무엇인가?

python
class Counter:
    def reset(self):
        self.count = 0
    def increment(self):
        self.count += 1
    def get(self):
        return self.count

a = Counter()
a.reset()
a.increment()
a.increment()
print("카운터 a의 값은", a.get())

1. 다음 Tic-Tac-Toe 게임 코드에서 빈칸에 들어갈 올바른 코드는?

python
# 대각선 패턴 win append
dia0 = []
dia1 = []
for i in range(5):
    dia0.append(board[i][i])
for i in range(5):
    _________________# 이 부분에 들어갈 코드는?

코드 작성 문제

1. 아래 Counter 클래스를 완성하되, 다음 요구사항을 만족시키시오:
   • reset() 메소드: count를 0으로 초기화
   • increment() 메소드: count를 1 증가
   • decrement() 메소드: count를 1 감소 (단, 0보다 작아지지 않도록)
   • get() 메소드: 현재 count 값 반환

python
class Counter:
# 코드를 작성하시오

1. Tic-Tac-Toe 게임에서 사용자의 입력을 받아 보드에 표시하는 코드를 작성하시오. 이미 표시된 위치에는 중복해서 표시할 수 없어야 합니다.
2. 객체지향 프로그래밍 개념을 이용하여 간단한 TV 클래스를 설계하고 구현하시오. TV 클래스는 다음 속성과 메소드를 가져야 합니다:
   • 속성: 채널번호, 볼륨, 전원상태
   • 메소드: 켜기, 끄기, 채널 변경하기, 볼륨 변경하기

서술형 문제

1. 객체지향 프로그래밍의 주요 특징과 장점을 세 가지 이상 설명하시오.
2. Tic-Tac-Toe 게임에서 승리 조건을 확인하는 방법에 대해 설명하고, 코드로 구현하는 방법을 서술하시오.
3. 파이썬에서 "모든 것이 객체"라는 말이 의미하는 바를 설명하고, 예시를 들어 서술하시오.

종합 문제

1. 객체지향 방법론을 활용하여 Tic-Tac-Toe 게임을 클래스로 구현하는 방법을 설명하고, 주요 메소드와 속성을 설계하시오.
2. 다음과 같은 Counter 클래스를 상속받아 새로운 기능을 추가한 AdvancedCounter 클래스를 작성하시오. AdvancedCounter 클래스는 기존 기능에 추가로 reset_to(n) 메소드로 특정 값으로 초기화 기능과 현재까지의 increment 호출 횟수를 저장하는 기능을 가져야 합니다.

python
class Counter:
    def reset(self):
        self.count = 0
    def increment(self):
        self.count += 1
    def get(self):
        return self.count

class AdvancedCounter(Counter):
# 코드를 작성하시오

1.1 정규표현식 기본 개념

• 정의: 특정한 규칙을 가진 문자열의 집합을 표현하는 형식 언어
• 용도: 문자열 검색, 치환, 필터링 등에 사용
• 파이썬 모듈: re 모듈 사용 (파이썬 기본 라이브러리)

1.2 메타 문자

다음 문자들은 특별한 의미를 가진 메타 문자입니다:

. ^ $ * + ? { } [ ] \ | ( )

주요 메타 문자 의미:

• [ ] - 문자 클래스: 괄호 안의 문자 중 하나와 매치
  • [abc]: a, b, c 중 하나와 매치
  • [a-z]: a부터 z까지 소문자 알파벳과 매치
  • [0-9]: 숫자와 매치
  • [^0-9]: 숫자가 아닌 문자와 매치 (^ 은 부정)

1. 단축 표현:
   • \d: 숫자와 매치 (= [0-9])
   • \D: 숫자가 아닌 것과 매치 (= [^0-9])
   • \s: 공백 문자와 매치 (= [ \t\n\r\f\v])
   • \S: 공백이 아닌 문자와 매치
   • \w: 문자+숫자와 매치 (= [a-zA-Z0-9_])
   • \W: 문자+숫자가 아닌 것과 매치
2. . (Dot): 줄바꿈(\n)을 제외한 모든 문자와 매치
   • a.b: a와 b 사이에 어떤 문자든 한 개 있는 패턴
3. 반복 관련 메타 문자:
   • : 0번 이상 반복 (= {0,})
   • +: 1번 이상 반복 (= {1,})
   • ?: 0번 또는 1번 (= {0,1})
   • {m}: 정확히 m번 반복
   • {m,n}: m번 이상 n번 이하 반복

1.3 정규표현식 사용 방법

1. re.compile(): 정규표현식 패턴 컴파일

    import re
    p = re.compile('[a-z]+')  # 소문자 알파벳 1개 이상
   

2. 주요 메서드:

   • match(): 문자열의 처음부터 매치 검사
   • search(): 문자열 전체에서 첫 번째 매치 검사
   • findall(): 모든 매치를 리스트로 반환
   • finditer(): 모든 매치를 반복 가능한 객체로 반환

3. 매치 객체 메서드:

   • group(): 매치된 문자열 반환
   • start(): 매치 시작 위치 반환
   • end(): 매치 끝 위치 반환
   • span(): (시작, 끝) 튜플 반환

2. 딕셔너리(Dictionary)와 튜플(Tuple)

2.1 딕셔너리(Dictionary)

• 정의: 키(key)와 값(value)의 쌍으로 이루어진 자료구조
• 특징:
  • 키는 중복될 수 없음
  • 키를 통해 값에 빠르게 접근 가능
  • 순서가 없음 (Python 3.7부터는 삽입 순서 유지)

딕셔너리 활용 예:

# 단어 카운팅
word_count = {}
for word in words:
    if word not in word_count:
        word_count[word] = 1
    else:
        word_count[word] += 1

2.2 튜플(Tuple)

• 정의: 순서가 있는 변경 불가능한(immutable) 자료구조
• 특징:
  • 한번 생성하면 변경할 수 없음
  • 인덱싱, 슬라이싱 가능
  • 여러 값을 패킹/언패킹하여 동시에 다룰 수 있음

튜플 활용 예:

# 함수에서 여러 값 반환
def calculate_circle(r):
    area = math.pi * r * r
    circumference = 2 * math.pi * r
    return (area, circumference)

# 언패킹
(a, c) = calculate_circle(10)

예상문제 및 풀이

1. 정규표현식 (Regular Expressions) 문제

문제 1: 기본 개념

다음 정규표현식이 매치하는 패턴을 설명하세요.

1. [a-zA-Z0-9]+
2. \d{3}-\d{3}-\d{4}
3. [^0-9]
4. a.b
5. ca{2,5}t

답안:

1. 알파벳 대소문자와 숫자가 1개 이상 반복되는 패턴
2. 000-000-0000 형식의 전화번호 패턴
3. 숫자가 아닌 모든 문자 중 1개
4. a와 b 사이에 어떤 문자든 한 개 있는 패턴(예: aab, a0b)
5. c 다음에 a가 2~5회 반복된 후 t가 오는 패턴(caat, caaat, caaaat, caaaaat)

문제 2: re 모듈 메서드

다음 코드의 실행 결과를 예측하세요.

import re

text = "Python is fun. python is easy. PYTHON is powerful."
pattern = re.compile('[Pp]ython')

# (a) match 메서드 결과
result1 = pattern.match(text)
print(result1)

# (b) search 메서드 결과
result2 = pattern.search(text)
print(result2)

# (c) findall 메서드 결과
result3 = pattern.findall(text)
print(result3)

답안:

# (a) match 메서드 결과
<re.Match object; span=(0, 6), match='Python'>

# (b) search 메서드 결과
<re.Match object; span=(0, 6), match='Python'>

# (c) findall 메서드 결과
['Python', 'python']

문제 3: 이메일 주소 검증

다음 이메일 주소가 올바른 형식인지 검증하는 정규표현식 패턴을 작성하세요. 이메일 형식: 사용자이름@도메인.최상위도메인

import re

def validate_email(email):
    pattern = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')
    if pattern.match(email):
        return True
    else:
        return False

# 테스트
emails = ["user@example.com", "invalid-email", "another.user@sub.domain.co.kr", "no@domain"]
for email in emails:
    print(f"{email}: {validate_email(email)}")

실행 결과:

user@example.com: True
invalid-email: False
another.user@sub.domain.co.kr: True
no@domain: False

문제 4: 로그 파일 분석

다음 로그 파일에서 에러 코드가 포함된 라인만 추출하는 프로그램을 작성하세요. 에러 코드 형식: ERROR-숫자4자리

import re

def extract_errors(log_file):
    error_pattern = re.compile(r'ERROR-\d{4}')
    errors = []

    with open(log_file, 'r') as f:
        for line in f:
            if error_pattern.search(line):
                errors.append(line.strip())

    return errors

# 예시 로그 파일 생성 (실제 시험에서는 주어질 수 있음)
sample_log = """
2023-05-14 12:30:45 INFO: System started
2023-05-14 12:35:22 ERROR-1033: Invalid argument
2023-05-14 12:40:11 WARNING: Low memory
2023-05-14 12:45:30 ERROR-2045: Connection failed
2023-05-14 12:50:15 INFO: Process completed
"""

with open('sample.log', 'w') as f:
    f.write(sample_log)

# 에러 라인 추출
errors = extract_errors('sample.log')
for error in errors:
    print(error)

실행 결과:

2023-05-14 12:35:22 ERROR-1033: Invalid argument
2023-05-14 12:45:30 ERROR-2045: Connection failed

2. 딕셔너리와 튜플 문제

문제 5: 단어 빈도수 계산

텍스트 파일에서 각 단어의 빈도수를 계산하여 출력하는 프로그램을 작성하세요.

def count_words(filename):
    word_count = {}

    try:
        with open(filename, 'r') as file:
            for line in file:
                words = line.strip().split()
                for word in words:
                    if word not in word_count:
                        word_count[word] = 1
                    else:
                        word_count[word] += 1

        return word_count
    except FileNotFoundError:
        print(f"파일 '{filename}'을 찾을 수 없습니다.")
        return {}

# 테스트용 파일 생성
sample_text = """
Well begun is half done.
Good morning
Birds of a feather flock together.
Well begun is half done.
Birds of a feather flock together.
Well begun is half done.
"""

with open('word_count.txt', 'w') as f:
    f.write(sample_text)

# 단어 빈도수 계산
result = count_words('word_count.txt')
print(result)

실행 결과:

{'Well': 3, 'begun': 3, 'is': 3, 'half': 3, 'done.': 3, 'Good': 1, 'morning': 1, 'Birds': 2, 'of': 2, 'a': 2, 'feather': 2, 'flock': 2, 'together.': 2}

문제 6: 축약어 변환기

축약어를 원래 단어로 변환하는 프로그램을 작성하세요.

def expand_abbreviations(message):
    abbreviations = {
        "B4": "Before",
        "TX": "Thanks",
        "BBL": "Be Back Later",
        "BCNU": "Be Seeing You",
        "HAND": "Have A Nice Day"
    }

    words = message.split()
    result = ""

    for word in words:
        if word in abbreviations:
            result += abbreviations[word] + " "
        else:
            result += word + " "

    return result.strip()

# 테스트
message = "TX Mr. Park! HAND"
expanded = expand_abbreviations(message)
print(f"입력: {message}")
print(f"출력: {expanded}")

실행 결과:

입력: TX Mr. Park! HAND
출력: Thanks Mr. Park! Have A Nice Day

문제 7: 원의 계산 함수

반지름을 입력받아 원의 넓이와 둘레를 계산하여 튜플로 반환하는 함수를 작성하세요.

import math

def calculate_circle(radius):
    area = math.pi * radius ** 2
    circumference = 2 * math.pi * radius
    return (area, circumference)

# 테스트
radius = 10
area, circumference = calculate_circle(radius)
print(f"반지름이 {radius}인 원의:")
print(f"- 넓이: {area}")
print(f"- 둘레: {circumference}")

실행 결과:

반지름이 10인 원의:
- 넓이: 314.1592653589793
- 둘레: 62.83185307179586

문제 8: 학생 정보 관리

학생 정보를 관리하는 프로그램을 작성하세요. 각 학생은 (이름, 나이, 전공) 튜플로 저장되며, 학생 목록을 딕셔너리로 관리하세요. 학번(키)으로 학생 정보를 조회하는 기능을 구현하세요.

def add_student(students, student_id, name, age, major):
    students[student_id] = (name, age, major)
    return students

def get_student(students, student_id):
    if student_id in students:
        return students[student_id]
    else:
        return None

def print_student_info(student):
    if student:
        name, age, major = student
        print(f"이름: {name}")
        print(f"나이: {age}")
        print(f"전공: {major}")
    else:
        print("학생 정보가 없습니다.")

# 테스트
students = {}
students = add_student(students, "2023001", "홍길동", 20, "컴퓨터과학")
students = add_student(students, "2023002", "김철수", 19, "수학")
students = add_student(students, "2023003", "이영희", 21, "물리학")

print("전체 학생 목록:")
for student_id, info in students.items():
    print(f"{student_id}: {info[0]}")

print("\n학번 2023002 학생 정보:")
student = get_student(students, "2023002")
print_student_info(student)

print("\n학번 2023004 학생 정보:")
student = get_student(students, "2023004")
print_student_info(student)

실행 결과:

전체 학생 목록:
2023001: 홍길동
2023002: 김철수
2023003: 이영희

학번 2023002 학생 정보:
이름: 김철수
나이: 19
전공: 수학

학번 2023004 학생 정보:
학생 정보가 없습니다.

3. 종합 문제

문제 9: 전화번호부 관리

정규표현식을 사용하여 전화번호 형식을 검증하고, 딕셔너리를 사용하여 전화번호부를 관리하는 프로그램을 작성하세요.

import re

class PhoneBook:
    def __init__(self):
        self.contacts = {}
        # 전화번호 형식: 000-000-0000 또는 (000) 000-0000
        self.phone_pattern = re.compile(r'^\(\d{3}\)\s\d{3}-\d{4}$|^\d{3}-\d{3}-\d{4}$')

    def add_contact(self, name, phone_number):
        if not self.is_valid_phone(phone_number):
            print(f"유효하지 않은 전화번호 형식입니다: {phone_number}")
            return False

        self.contacts[name] = phone_number
        print(f"{name} 연락처가 추가되었습니다.")
        return True

    def is_valid_phone(self, phone_number):
        return bool(self.phone_pattern.match(phone_number))

    def find_contact(self, name):
        if name in self.contacts:
            return self.contacts[name]
        else:
            return None

    def list_contacts(self):
        if not self.contacts:
            print("전화번호부가 비어있습니다.")
        else:
            print("연락처 목록:")
            for name, phone in self.contacts.items():
                print(f"{name}: {phone}")

# 테스트
phone_book = PhoneBook()
phone_book.add_contact("홍길동", "010-123-4567")  # 잘못된 형식
phone_book.add_contact("홍길동", "010-1234-5678")  # 잘못된 형식
phone_book.add_contact("홍길동", "010-123-4567")  # 잘못된 형식
phone_book.add_contact("홍길동", "123-456-7890")  # 올바른 형식
phone_book.add_contact("김철수", "(123) 456-7890")  # 올바른 형식
phone_book.add_contact("이영희", "987-654-3210")  # 올바른 형식

print("\n홍길동의 연락처:", phone_book.find_contact("홍길동"))
print("박지성의 연락처:", phone_book.find_contact("박지성"))

print("\n전체 연락처 목록:")
phone_book.list_contacts()

실행 결과:

유효하지 않은 전화번호 형식입니다: 010-123-4567
유효하지 않은 전화번호 형식입니다: 010-1234-5678
유효하지 않은 전화번호 형식입니다: 010-123-4567
홍길동 연락처가 추가되었습니다.
김철수 연락처가 추가되었습니다.
이영희 연락처가 추가되었습니다.

홍길동의 연락처: 123-456-7890
박지성의 연락처: None

전체 연락처 목록:
연락처 목록:
홍길동: 123-456-7890
김철수: (123) 456-7890
이영희: 987-654-3210

문제 10: 이메일 주소 추출 및 통계

주어진 텍스트에서 모든 이메일 주소를 추출하고, 도메인별 이메일 개수를 계산하는 프로그램을 작성하세요.

import re

def extract_emails(text):
    email_pattern = re.compile(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}')
    return email_pattern.findall(text)

def count_domains(emails):
    domain_counts = {}

    for email in emails:
        # @ 이후의 도메인 부분 추출
        domain = email.split('@')[1]

        if domain not in domain_counts:
            domain_counts[domain] = 1
        else:
            domain_counts[domain] += 1

    return domain_counts

# 테스트용 텍스트
sample_text = """
Contact us at support@example.com for help.
Send your resume to jobs@company.co.kr if you're interested.
For technical questions: tech@support.example.com or admin@example.com.
Marketing team: marketing@company.co.kr, sales@company.co.kr.
"""

# 이메일 추출
emails = extract_emails(sample_text)
print("추출된 이메일 주소:")
for email in emails:
    print(email)

# 도메인별 통계
domain_stats = count_domains(emails)
print("\n도메인별 이메일 개수:")
for domain, count in domain_stats.items():
    print(f"{domain}: {count}개")

실행 결과:

추출된 이메일 주소:
support@example.com
jobs@company.co.kr
tech@support.example.com
admin@example.com
marketing@company.co.kr
sales@company.co.kr

도메인별 이메일 개수:
example.com: 2개
company.co.kr: 3개
support.example.com: 1개

1.1 개념 정리

2차원 리스트란?

• 리스트 안에 리스트가 포함된 형태의 자료구조
• 행렬(matrix), 표(table) 등의 데이터를 표현할 때 사용
• 행(row)과 열(column)을 이용하여 데이터에 접근

2차원 리스트 생성 방법

1. 직접 정의

s = [
    [1, 2, 3, 4, 5],
    [6, 7, 8, 9, 10],
    [11, 12, 13, 14, 15]
]

1. 동적 생성 (반복문 활용)

rows = 3
cols = 5
s = []
for row in range(rows):
    s += [[0] * cols]  # 중요: [0] * cols는 0으로 채워진 cols 길이의 1차원 리스트

1. 리스트 내포(List Comprehension) 활용

rows = 6
cols = 6
table = [[0] * cols for i in range(rows)]

1.2 2차원 리스트 접근 방법

인덱싱을 통한 접근

s = [
    [1, 2, 3, 4, 5],
    [6, 7, 8, 9, 10],
    [11, 12, 13, 14, 15]
]
print(s[0])     # 첫 번째 행 전체: [1, 2, 3, 4, 5]
print(s[1][2])  # 두 번째 행, 세 번째 열: 8

반복문을 이용한 2차원 리스트 순회

rows = len(s)        # 행의 개수
cols = len(s[0])     # 열의 개수

for r in range(rows):
    for c in range(cols):
        print(s[r][c], end=" ")
    print()  # 한 행이 끝나면 줄바꿈

1.3 다양한 형식의 데이터를 저장한 다차원 리스트

list = [["Seoul", 10], ["Paris", 12], ["London", 50]]
# 리스트 안에 문자열과 숫자를 함께 저장할 수 있음

# 문자열에 대한 인덱싱도 가능
print(list[0][0][0])  # "Seoul"의 첫 번째 글자: 'S'

# 더 복잡한 다차원 리스트
list = ["atom", ["bold", ["crew", ["date", "easy", 45]]]]

2. 딕셔너리 (Dictionary)

2.1 개념 정리

딕셔너리란?

• 키(key)와 값(value)의 쌍으로 이루어진 자료구조
• 순서가 없고, 키를 통해 값에 접근
• 키는 중복될 수 없고, 값은 중복될 수 있음

딕셔너리 생성 방법

1. 중괄호를 이용한 직접 정의

contacts = {'Kim': '01012345678', 'Park': '01012345679', 'Lee': '01012345680'}

1. dict() 함수 활용

dic = dict()
dic['kim'] = 23
dic[20001] = 22  # 키는 문자열뿐만 아니라 정수형도 가능

2.2 딕셔너리 조작 방법

get(key, default value) ⇒ key의 value를 리턴함(키가 없으면 디폴트 밸류 출력)

데이터 검색

contacts = {'Kim': '01012345678', 'Park': '01012345679', 'Lee': '01012345680'}
print(contacts['Kim'])                 # '01012345678' (키가 없으면 오류)
print(contacts.get('Kim'))             # '01012345678'
print(contacts.get('Choi'))            # None (키가 없어도 오류 없음)
print(contacts.get('Choi', "없음"))     # '없음' (키가 없을 때 기본값 설정)

키 존재 여부 확인

if "Kim" in contacts:
    print("키가 딕셔너리에 있음")

데이터 추가/수정

contacts['Choi'] = '01056781234'  # 새 항목 추가
contacts['Kim'] = '01099998888'   # 기존 항목 수정

데이터 삭제

phone = contacts.pop("Kim")  # 'Kim' 항목을 삭제하고 값을 반환

2.3 딕셔너리 순회 방법

items() 메소드 활용(for i 도 가능): key, value 함께 출력함

scores = {'Korean': 80, 'Math': 90, 'English': 80}
for item in scores.items():
    print(item)  # ('Korean', 80), ('Math', 90), ('English', 80)

keys() 메소드 활용

for key in scores.keys():
    print(key)  # 'Korean', 'Math', 'English'

values() 메소드 활용

for value in scores.values():
    print(value)  # 80, 90, 80

3. 예상 문제 및 풀이

문제 1: 주사위 합계 테이블 만들기

두 개의 주사위를 굴렸을 때 나오는 숫자의 합을 6x6 크기의 2차원 리스트로 만드는 프로그램을 작성하세요.

풀이:

# 6x6 크기의 2차원 리스트 생성
rows = 6
cols = 6
table = [[0] * cols for i in range(rows)]

# 각 칸에 주사위 합계 저장
for row in range(rows):
    for col in range(cols):
        table[row][col] = (row+1) + (col+1)

# 결과 출력
print(" ||", end=" ")
for c in range(1, 7):
    print("%3d" % (c), end=" ")
print()
print("="*40)

for r in range(6):
    print(r+1, "|| ", end="")
    for c in range(6):
        print("%3d" % table[r][c], end=" ")
    print()

문제 2: 학생 성적 관리 프로그램

학생의 이름과 성적을 딕셔너리로 관리하고, 평균 점수를 계산하는 프로그램을 작성하세요.

풀이:

# 학생 성적 딕셔너리 생성
students = {
    '김철수': {'국어': 90, '영어': 85, '수학': 95},
    '이영희': {'국어': 78, '영어': 88, '수학': 92},
    '박민수': {'국어': 92, '영어': 96, '수학': 98}
}

# 각 학생의 평균 점수 계산 및 출력
for name, scores in students.items():
    total = sum(scores.values())
    average = total / len(scores)
    print(f"{name}의 평균 점수: {average:.2f}")

# 과목별 평균 점수 계산
subjects = ['국어', '영어', '수학']
for subject in subjects:
    total = 0
    for student in students.values():
        total += student[subject]
    average = total / len(students)
    print(f"{subject} 과목 평균: {average:.2f}")

문제 3: 영한 사전 확장하기

영단어를 키로, 한글 설명을 값으로 하는 영한 사전을 만들고, 단어 추가, 삭제, 검색 기능을 구현하세요.

풀이:

def create_dictionary():
    english_dict = {
        'one': '하나',
        'two': '둘',
        'three': '셋',
        'four': '넷',
        'five': '다섯'
    }
    return english_dict

def add_word(dictionary):
    eng = input("추가할 영단어를 입력하세요: ")
    kor = input("단어의 뜻을 입력하세요: ")
    dictionary[eng] = kor
    print(f"'{eng}: {kor}'가 사전에 추가되었습니다.")

def delete_word(dictionary):
    eng = input("삭제할 영단어를 입력하세요: ")
    if eng in dictionary:
        meaning = dictionary.pop(eng)
        print(f"'{eng}: {meaning}'가 사전에서 삭제되었습니다.")
    else:
        print(f"'{eng}'는 사전에 없습니다.")

def search_word(dictionary):
    eng = input("검색할 영단어를 입력하세요: ")
    meaning = dictionary.get(eng, "사전에 등록된 정보가 없음")
    print(f"{eng}: {meaning}")

def print_all(dictionary):
    print("\n--- 영한 사전 전체 단어 ---")
    for eng, kor in dictionary.items():
        print(f"{eng}: {kor}")

def main():
    dictionary = create_dictionary()

    while True:
        print("\n=== 영한 사전 프로그램 ===")
        print("1. 단어 검색")
        print("2. 단어 추가")
        print("3. 단어 삭제")
        print("4. 전체 단어 출력")
        print("5. 종료")

        choice = input("메뉴를 선택하세요: ")

        if choice == '1':
            search_word(dictionary)
        elif choice == '2':
            add_word(dictionary)
        elif choice == '3':
            delete_word(dictionary)
        elif choice == '4':
            print_all(dictionary)
        elif choice == '5':
            print("프로그램을 종료합니다.")
            break
        else:
            print("잘못된 메뉴입니다. 다시 선택해주세요.")

if __name__ == "__main__":
    main()

문제 4: 도시별 인구 데이터 분석

도시 이름과 인구수를 저장한 2차원 리스트를 만들고, 인구가 많은 순서대로 정렬하여 출력하는 프로그램을 작성하세요.

풀이:

# 도시별 인구 데이터 (도시명, 인구수(만 명))
cities = [
    ["Seoul", 980],
    ["Busan", 340],
    ["Incheon", 290],
    ["Daegu", 240],
    ["Daejeon", 150],
    ["Gwangju", 145],
    ["Ulsan", 115],
    ["Suwon", 120]
]

# 인구수(두 번째 요소)를 기준으로 내림차순 정렬
cities.sort(key=lambda x: x[1], reverse=True)

# 결과 출력
print("=== 인구가 많은 순서 ===")
print("순위\t도시명\t인구수(만 명)")
for i, city in enumerate(cities, 1):
    print(f"{i}\t{city[0]}\t{city[1]}")

# 인구수 평균 계산
total_population = sum(city[1] for city in cities)
average = total_population / len(cities)
print(f"\n도시 평균 인구: {average:.2f}만 명")

# 평균보다 인구가 많은 도시 찾기
print("\n평균보다 인구가 많은 도시:")
for city in cities:
    if city[1] > average:
        print(f"{city[0]}: {city[1]}만 명")

파이썬 기말고사 대비 실전 문제

다차원 리스트 문제

문제 1: 행렬 덧셈

두 개의 2차원 리스트(행렬)를 입력받아 같은 위치의 원소를 더한 새로운 행렬을 반환하는 함수를 작성하세요.

예시:
matrix_A = [[1, 2, 3], [4, 5, 6]]
matrix_B = [[7, 8, 9], [10, 11, 12]]

결과: [[8, 10, 12], [14, 16, 18]]

문제 2: 성적표 만들기

학생들의 이름과 각 과목(국어, 영어, 수학) 점수를 입력받아 성적표를 출력하는 프로그램을 작성하세요. 각 학생별 총점과 평균, 그리고 과목별 평균도 함께 출력하세요.

예시 입력:
students = [
    ["김철수", 85, 90, 95],
    ["이영희", 90, 85, 80],
    ["박민수", 75, 80, 85]
]

예시 출력:
이름    국어  영어  수학  총점  평균
김철수  85   90   95   270   90.0
이영희  90   85   80   255   85.0
박민수  75   80   85   240   80.0
과목평균 83.3 85.0 86.7

문제 3: 행렬 회전

N x N 크기의 2차원 리스트(행렬)를 시계 방향으로 90도 회전시키는 함수를 작성하세요.

예시:
원본 행렬:
1 2 3
4 5 6
7 8 9

90도 회전 후:
7 4 1
8 5 2
9 6 3

딕셔너리 문제

문제 4: 단어 빈도수 계산

주어진 문장에서 각 단어의 등장 횟수를 계산하여 딕셔너리로 반환하는 함수를 작성하세요. 대소문자는 구분하지 않고, 특수문자는 제외합니다.

예시:
sentence = "Python is easy to learn. Python is popular and Python is powerful."

결과: {'python': 3, 'is': 3, 'easy': 1, 'to': 1, 'learn': 1, 'popular': 1, 'and': 1, 'powerful': 1}

문제 5: 투표 결과 집계

선거에서 투표한 결과를 리스트로 받아, 각 후보자별 득표수를 딕셔너리로 반환하고, 가장 많은 표를 받은 후보자를 출력하는 프로그램을 작성하세요.

예시:
votes = ["김후보", "이후보", "김후보", "박후보", "이후보", "김후보", "최후보", "김후보", "이후보", "박후보"]

결과:
투표 결과: {'김후보': 4, '이후보': 3, '박후보': 2, '최후보': 1}
당선인: 김후보 (4표)

문제 6: 학생 성적 관리

학생들의 성적을 관리하는 프로그램을 작성하세요. 다음 기능을 구현하세요:

1. 학생 추가: 이름과 성적(국어, 영어, 수학)을 입력받아 딕셔너리에 저장
2. 학생 검색: 이름으로 학생을 검색하여 성적 정보 출력
3. 전체 학생 출력: 모든 학생의 이름과 성적, 평균 출력
4. 평균 순위로 정렬하여 출력

복합 문제

문제 7: 도서 관리 시스템

도서관에서 사용할 도서 관리 시스템을 구현하세요. 다음 기능을 포함해야 합니다:

1. 도서 등록: 제목, 저자, 출판년도, 장르 정보를 딕셔너리로 저장
2. 도서 검색: 제목 또는 저자로 도서 검색
3. 도서 대출/반납 처리: 대출 상태를 관리하고 대출 중인 도서 목록 확인
4. 장르별 도서 목록 출력: 특정 장르의 모든 도서를 출력

문제 8: 주간 일정 관리

요일별 일정을 관리하는 프로그램을 작성하세요. 2차원 리스트와 딕셔너리를 활용하여 다음 기능을 구현하세요:

1. 일정 추가: 요일, 시간, 일정 내용을 입력받아 저장
2. 일정 삭제: 요일과 시간을 입력받아 해당 일정 삭제
3. 요일별 일정 출력: 특정 요일의 모든 일정을 시간순으로 출력
4. 주간 요약: 전체 주간 일정을 표 형식으로 출력

답안 작성 제출 양식

문제 풀이 시, 다음 형식으로 답안을 작성하세요:

1. 문제 이해: 문제가 요구하는 사항을 자신의 말로 간략히 설명
2. 알고리즘/접근법: 문제 해결을 위한 접근 방식 설명
3. 코드 구현: 파이썬 코드 작성
4. 결과 확인: 예시 입력값으로 실행한 결과
5. 코드 설명: 주요 부분에 대한 간략한 설명

리스트는 파이썬에서 여러 항목을 순서대로 저장하는 시퀀스 자료형입니다. 대괄호 []로 표현하며, 다양한 데이터 타입을 함께 저장할 수 있습니다.

리스트 생성 및 접근:

# 리스트 생성
heroes = ["스파이더맨", "헐크", "아이언맨"]

# 리스트 요소 접근
first_hero = heroes[0]  # "스파이더맨"

2. 리스트의 주요 연산과 함수

기본 연산자 및 함수

예제 코드:

marvel_heroes = ["스파이더맨", "헐크", "아이언맨"]
dc_heroes = ["슈퍼맨", "배트맨", "원더우먼"]

# 리스트 연결
heroes = marvel_heroes + dc_heroes
print(heroes)  # ['스파이더맨', '헐크', '아이언맨', '슈퍼맨', '배트맨', '원더우먼']

# 리스트 반복
values = [1, 2, 3] * 3
print(values)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

# 리스트 길이
print(len(heroes))  # 6

# 포함 여부 확인
if "배트맨" in heroes:
    print("배트맨은 영웅입니다.")  # 출력됨

# 최소/최대/합계
numbers = [11, 2, 13, 4, 5]
print(min(numbers))  # 2
print(max(numbers))  # 13
print(sum(numbers))  # 35

3. 리스트 메소드

예제 코드:

# 항목 추가
shopping_list = []
shopping_list.append("두부")
shopping_list.append("양배추")
print(shopping_list)  # ['두부', '양배추']

# 특정 위치에 항목 삽입
a = [1, 2, 3]
a.insert(0, 4)  # 0번 위치에 4 삽입
print(a)  # [4, 1, 2, 3]

# 항목 삭제
heroes = ["스파이더맨", "슈퍼맨", "헐크", "아이언맨", "배트맨", "조커"]
heroes.remove("조커")
print(heroes)  # ['스파이더맨', '슈퍼맨', '헐크', '아이언맨', '배트맨']

# pop으로 항목 삭제 및 반환
hero = heroes.pop(1)  # '슈퍼맨'
print(hero)  # '슈퍼맨'
print(heroes)  # ['스파이더맨', '헐크', '아이언맨', '배트맨']

# 항목 위치 확인
index = heroes.index("헐크")
print(index)  # 1

# 정렬
numbers = [3, 2, 1, 5, 4]
numbers.sort()  # 원본 리스트 변경
print(numbers)  # [1, 2, 3, 4, 5]

# 내림차순 정렬
numbers.sort(reverse=True)
print(numbers)  # [5, 4, 3, 2, 1]

# sorted() 함수 (원본 리스트 유지하며 정렬된 새 리스트 반환)
a = [3, 2, 1, 5, 4]
b = sorted(a)
print(b)  # [1, 2, 3, 4, 5]
print(a)  # [3, 2, 1, 5, 4] - 원본 유지

4. 리스트 복사

얕은 복사(Shallow copy)

scores = [10, 20, 30, 40, 50]
values = scores  # 얕은 복사 - 동일한 객체를 참조
print(id(scores))  # 메모리 주소
print(id(values))  # scores와 동일한 메모리 주소

# 하나의 리스트를 변경하면 다른 리스트도 변경됨
scores[0] = 99
print(values)  # [99, 20, 30, 40, 50]

깊은 복사(Deep copy)

import copy
a = [1, 2, 3, 4]
b = copy.deepcopy(a)  # 깊은 복사 - 새로운 객체 생성

# 메모리 주소 다름
print(id(a))  # 첫 번째 메모리 주소
print(id(b))  # 두 번째 메모리 주소

# 한 리스트 변경해도 다른 리스트는 영향 없음
a.append(500)
print(a)  # [1, 2, 3, 4, 500]
print(b)  # [1, 2, 3, 4]

5. 리스트 컴프리헨션(List Comprehension), 함축!!

리스트 컴프리헨션은 리스트를 간결하게 생성하는 방법입니다.

기본 구문:

[표현식 for 항목 in 반복가능객체 if 조건문]

예제 코드:

# 기본 리스트 컴프리헨션
squares = [x**2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 기존 리스트 변환
list1 = [3, 4, 5]
list2 = [x*2 for x in list1]
print(list2)  # [6, 8, 10]

# 조건문 사용
even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)  # [0, 2, 4, 6, 8]

# 다중 반복문
pythagorean_triples = [(x, y, z) for x in range(1, 21)
                       for y in range(x, 21)
                       for z in range(y, 21)
                       if x**2 + y**2 == z**2]
print(pythagorean_triples)  # [(3, 4, 5), (5, 12, 13), (6, 8, 10), (8, 15, 17), (9, 12, 15)]

6. 함수에서의 리스트 전달

파이썬에서 리스트를 함수에 전달하면 참조 방식으로 전달됩니다. 즉, 함수 내에서 리스트를 변경하면 원본 리스트도 변경됩니다.

def modify_list(lst):
    lst[0] = 99

values = [0, 1, 2, 3, 4]
print("함수 호출 전:", values)  # [0, 1, 2, 3, 4]
modify_list(values)
print("함수 호출 후:", values)  # [99, 1, 2, 3, 4]

7. 실전 예제 프로그램

예제 1: 성적 처리 프로그램

STUDENTS = 5
scores = []
scoreSum = 0

# 성적 입력 받기
for i in range(STUDENTS):
    value = int(input("성적을 입력하시오: "))
    scores.append(value)
    scoreSum += value

# 평균 계산
scoreAvg = scoreSum / len(scores)

# 80점 이상 학생 수 계산
highScoreStudents = 0
for score in scores:
    if score >= 80:
        highScoreStudents += 1

# 결과 출력
print("성적 평균은", scoreAvg, "입니다.")
print("80점 이상 성적을 받은 학생은", highScoreStudents, "명입니다.")

예제 2: 연락처 관리 프로그램

menu = 0
friends = []

while menu != 9:
    print("--------------------")
    print("1. 친구 리스트 출력")
    print("2. 친구 추가")
    print("3. 친구 삭제")
    print("4. 이름 변경")
    print("9. 종료")

    menu = int(input("메뉴를 선택하시오: "))

    if menu == 1:
        print(friends)
    elif menu == 2:
        name = input("이름을 입력하시오: ")
        friends.append(name)
    elif menu == 3:
        del_name = input("삭제하고 싶은 이름을 입력하시오: ")
        if del_name in friends:
            friends.remove(del_name)
        else:
            print("이름이 발견되지 않았음")
    elif menu == 4:
        old_name = input("변경하고 싶은 이름을 입력하시오: ")
        if old_name in friends:
            index = friends.index(old_name)
            new_name = input("새로운 이름을 입력하시오: ")
            friends[index] = new_name
        else:
            print("이름이 발견되지 않았음")

8. 중간고사 예상 문제 및 풀이

파이썬 리스트 중간고사 예상 문제 및 풀이

객관식 문제

문제 1

다음 중 리스트 a = [1, 2, 3, 4, 5]를 복제하여 새로운 리스트 b를 만들고 싶을 때, 독립적인 복사본(깊은 복사)을 만드는 올바른 방법은?

a) b = a b) b = a[:] c) b = copy.deepcopy(a) d) b = list(a)

정답: c) b = copy.deepcopy(a)

해설:

• b = a는 새로운 리스트를 만드는 것이 아니라 같은 객체를 참조(얕은 복사)합니다.
• b = a[:]와 b = list(a)는 1차원 리스트의 경우 독립적인 복사본을 만들지만, 중첩 리스트의 경우 내부 리스트는 여전히 같은 객체를 참조합니다.
• copy.deepcopy(a)는 중첩 리스트를 포함한 모든 구조를 완전히 독립적으로 복사합니다.

문제 2

다음 코드의 실행 결과는?

values = [1, 2, 3]
values.append([4, 5])
print(len(values))

a) 3 b) 4 c) 5 d) 오류 발생

정답: b) 4

해설: values.append([4, 5])는 리스트 [4, 5]를 하나의 요소로 values 리스트에 추가합니다. 따라서 values는 [1, 2, 3, [4, 5]]가 되고, 길이는 4가 됩니다.

문제 3

다음 코드의 실행 결과는?

numbers = [1, 2, 3, 4, 5]
print(numbers[1:-1])

a) [1, 2, 3, 4] b) [2, 3, 4] c) [2, 3, 4, 5] d) [1, 2, 3]

정답: b) [2, 3, 4]

해설: numbers[1:-1]은 인덱스 1부터 마지막 인덱스(-1) 바로 전까지의 요소를 반환합니다. 인덱스 1은 2, 인덱스 -1은 5이므로, 2부터 5 직전까지인 [2, 3, 4]가 출력됩니다.

문제 4

다음 중 리스트 메소드가 아닌 것은?

a) append() b) insert() c) add() d) remove()

정답: c) add()

해설: 파이썬 리스트에는 add() 메소드가 존재하지 않습니다. 요소를 추가하는 메소드는 append()(끝에 추가), insert()(지정된 위치에 추가), extend()(반복 가능한 객체의 요소를 추가)입니다.

문제 5

다음 코드의 출력은?

a = [3, 2, 1, 5, 4]
b = a.sort()
print(b)

a) [1, 2, 3, 4, 5] b) [3, 2, 1, 5, 4] c) None d) 오류 발생

정답: c) None

해설: sort() 메소드는 원본 리스트를 제자리에서 정렬하고 아무것도 반환하지 않습니다(None 반환). 따라서 b에는 None이 할당되고, 이것이 출력됩니다. 정렬된 리스트를 반환받으려면 sorted() 함수를 사용해야 합니다.

서술형 및 코딩 문제

문제 6

다음 조건을 만족하는 리스트 컴프리헨션을 작성하세요:

1. 1부터 50까지의 정수 중
2. 3의 배수이면서
3. 5의 배수가 아닌 수

정답:

result = [x for x in range(1, 51) if x % 3 == 0 and x % 5 != 0]

문제 7

다음 코드가 출력하는 결과를 쓰세요:

heroes = ["아이언맨", "토르", "헐크", "스파이더맨"]
heroes.pop(1)
heroes.insert(0, "블랙위도우")
heroes.append("캡틴아메리카")
print(heroes)

정답: ['블랙위도우', '아이언맨', '헐크', '스파이더맨', '캡틴아메리카']

해설:

1. 초기 heroes = ["아이언맨", "토르", "헐크", "스파이더맨"]
2. heroes.pop(1)로 인덱스 1의 "토르" 제거 → ["아이언맨", "헐크", "스파이더맨"]
3. heroes.insert(0, "블랙위도우")로 인덱스 0에 "블랙위도우" 삽입 → ["블랙위도우", "아이언맨", "헐크", "스파이더맨"]
4. heroes.append("캡틴아메리카")로 끝에 "캡틴아메리카" 추가 → ["블랙위도우", "아이언맨", "헐크", "스파이더맨", "캡틴아메리카"]

문제 8

다음 코드의 출력을 예측하세요:

def modify_scores(scores):
    scores.append(100)
    scores = [50, 60, 70]
    scores.append(80)
    return scores

my_scores = [85, 90, 95]
new_scores = modify_scores(my_scores)
print(my_scores)
print(new_scores)

정답:

[85, 90, 95, 100]
[50, 60, 70, 80]

해설:

1. my_scores가 modify_scores 함수에 전달됩니다.
2. 함수 내에서 scores.append(100)로 my_scores에 100 추가 → my_scores = [85, 90, 95, 100]
3. scores = [50, 60, 70]으로 scores 변수에 새 리스트 할당. 하지만 이것은 my_scores에 영향을 주지 않습니다.
4. scores.append(80)으로 새 리스트에 80 추가 → scores = [50, 60, 70, 80]
5. 함수는 scores 리스트를 반환하므로 new_scores = [50, 60, 70, 80]
6. my_scores에는 첫 번째 append 작업만 영향을 주었으므로 [85, 90, 95, 100]이 됩니다.

문제 9

다음 리스트에서 중복된 요소를 제거하여 유일한 값만 가진 새 리스트를 반환하는 함수를 작성하세요. 원본 리스트 순서를 유지해야 합니다. (힌트: 이미 확인한 요소를 기록하는 새 리스트를 사용하세요)

def remove_duplicates(input_list):
    # 코드 작성
    pass

정답:

def remove_duplicates(input_list):
    result = []
    for item in input_list:
        if item not in result:
            result.append(item)
    return result

또는 리스트 컴프리헨션 사용:

def remove_duplicates(input_list):
    seen = set()
    return [x for x in input_list if not (x in seen or seen.add(x))]

문제 10

피보나치 수열의 처음 20개 항을 계산하여 리스트에 저장하는 코드를 작성하세요. 피보나치 수열은 0, 1로 시작하고, 다음 항은 이전 두 항의 합으로 구성됩니다.

정답:

fibonacci = [0, 1]
for i in range(2, 20):
    fibonacci.append(fibonacci[i-1] + fibonacci[i-2])
print(fibonacci)

또는 리스트 컴프리헨션 사용 (조금 더 복잡):

fibonacci = [0, 1]
[fibonacci.append(fibonacci[-1] + fibonacci[-2]) for _ in range(18)]
print(fibonacci)

문제 11

리스트의 모든 가능한 두 요소의 조합과 그 합을 계산하는 프로그램을 작성하세요. 출력은 튜플 리스트 [(a, b, a+b), ...] 형태여야 합니다.

입력: [1, 2, 3, 4] 출력: [(1, 2, 3), (1, 3, 4), (1, 4, 5), (2, 3, 5), (2, 4, 6), (3, 4, 7)]

정답:

def all_combinations(numbers):
    result = []
    for i in range(len(numbers)):
        for j in range(i+1, len(numbers)):
            result.append((numbers[i], numbers[j], numbers[i] + numbers[j]))
    return result

print(all_combinations([1, 2, 3, 4]))

또는 리스트 컴프리헨션 사용:

def all_combinations(numbers):
    return [(numbers[i], numbers[j], numbers[i] + numbers[j])
            for i in range(len(numbers))
            for j in range(i+1, len(numbers))]

print(all_combinations([1, 2, 3, 4]))

문제 12

다음과 같은 학생 성적 리스트가 있습니다: scores = [78, 65, 89, 93, 87, 45, 92] 평균보다 높은 점수만 출력하는 코드를 작성하세요.

정답:

scores = [78, 65, 89, 93, 87, 45, 92]
average = sum(scores) / len(scores)
above_average = [score for score in scores if score > average]
print(f"평균: {average}")
print(f"평균보다 높은 점수: {above_average}")

9. 중간고사 실전 대비 TIP

리스트 관련 주요 개념 정리

• 리스트 기본 연산: +, , in, not in 등의 사용법 숙지
• 리스트 주요 메소드: append(), insert(), remove(), pop(), index(), sort() 등의 기능과 사용법 숙지
• 리스트 슬라이싱: 인덱싱과 슬라이싱 문법 확실히 이해
• 리스트 복사 방식: 얕은 복사와 깊은 복사의 차이점 명확히 이해
• 리스트 컴프리헨션: 기본 구조와 응용 방법 연습

실전 대비 전략

1. 개념 이해하기: 각 리스트 메소드와 함수의 역할, 반환값을 분명히 이해하세요.
2. 손으로 코드 실행해보기: 복잡한 리스트 조작이 있는 코드는 손으로 한 줄씩 실행해보며 결과를 예측해보세요.
3. 문제 풀이 시간 배분하기: 쉬운 문제를 먼저 풀고 어려운 문제에 시간을 투자하세요.
4. 코드 트레이싱 연습하기: 주어진 코드가 어떤 결과를 내는지 단계별로 예측하는 연습을 하세요.
5. 리스트 컴프리헨션 활용하기: 간결하고 가독성 높은 코드 작성을 위해 리스트 컴프리헨션을 적절히 활용하세요.

자주 나오는 실수

• 인덱스 오류: 리스트 범위를 벗어나는 인덱스 접근
• 얕은 복사와 깊은 복사 혼동: 의도와 다른 복사 방식 사용
• 메소드의 반환값 무시: sort()와 sorted()의 차이 혼동
• 리스트 변경 시 참조 문제: 함수에서 리스트를 변경할 때 발생하는 문제 인지 부족

핵심 정의

• 문자열(string)은 문자들의 순서 있는 집합
• 문자들이 끈으로 묶여 있는 형태로 이해 가능
• 파이썬에서 문자열은 따옴표(' 또는 ")로 둘러싸여 표현

중요성

• 컴퓨터는 숫자 중심이지만, 인간은 문자열을 통해 정보 표현
• 문자열 처리는 프로그래밍에서 매우 중요한 부분

2. 문자열 생성과 기본 표현

문자열 선언 방법

greeting = "Merry Christmas!"  # 큰따옴표 사용
greeting = 'Happy Holiday!'    # 작은따옴표 사용

여러 줄 문자열

greeting = '''지난 한해 저에게 보여주신 보살핌과 사랑에
깊은 감사를 드립니다.
새해에도 하시고자 하는 일
모두 성취하시기를 바랍니다.'''

따옴표 처리

# 큰따옴표 안에 작은따옴표 사용
message = "철수가 '안녕'이라고 말했습니다."

# 작은따옴표 안에 큰따옴표 사용
message = '철수가 "안녕"이라고 말했습니다.'

# 이스케이프 문자 사용
message = "\"Yes,\" he said."  # 큰따옴표 출력
message = 'doesn\'t'           # 작은따옴표 출력

3. 문자열 연산

문자열 연결 (+)

"Py" + "thon"    # 'Python'
'Harry ' + 'Potter'  # 'Harry Potter'

# 변수 사용
first_name = "길동"
last_name = "홍"
name = last_name + first_name  # '홍길동'

문자열과 숫자 연결

# 숫자를 문자열로 변환 후 연결
print("student" + str(26))  # 'student26'

# 문자열을 숫자로 변환
price = int("3000")  # 3000 (정수)
height = float("290.54")  # 290.54 (실수)

문자열 반복 (*)

line = "=" * 50  # 50개의 등호(=) 반복
message = "Congratulations! " * 3  # 'Congratulations! ' 3번 반복

4. 문자열 서식

형식 지정자 (%s)

price = 10000
print("상품의 가격은 %s원입니다." % price)  # 상품의 가격은 10000원입니다.

message = "현재 시간은 %s입니다."
time = "12:00pm"
print(message % time)  # 현재 시간은 12:00pm입니다.

5. 문자열 메소드

탐색 관련 메소드

s = "Love will find a way."
"Love" in s      # True
"love" in s      # False - 대소문자 구분
"Love" not in s  # False

문자 유형 확인 메소드

num = '111'
baeg = 'hundred'
hanguel = '한글'
space = ' '

num.isdigit()     # True - 숫자인지 확인
baeg.isalpha()    # True - 알파벳(문자)인지 확인
hanguel.isalpha() # True - 문자인지 확인
space.isspace()   # True - 공백인지 확인

분리와 결합 메소드

# split() - 문자열을 구분자로 분리하여 **리스트로** 반환
"Life is too short".split()  # ['Life', 'is', 'too', 'short']
"a:b:c:d".split(':')         # ['a', 'b', 'c', 'd']

공백 제거 메소드

s = ' Python '
s.lstrip()  # 'Python ' - 왼쪽 공백 제거
s.rstrip()  # ' Python' - 오른쪽 공백 제거
s.strip()   # 'Python' - 양쪽 공백 제거

대소문자 변환 메소드

'python'.upper()  # 'PYTHON' - 대문자로 변환
'PYTHON'.lower()  # 'python' - 소문자로 변환

문자 코드 변환

ord("A")  # 65 - 문자를 ASCII 코드 값으로 변환
chr(65)   # 'A' - ASCII 코드 값을 문자로 변환

문자열 치환

text = '123,456,789,999'
text.replace(",", "")    # '123456789999' - 모든 콤마 제거
text.replace(",", "", 1) # '123456,789,999' - 첫 번째 콤마만 제거

6. 문자열 인덱싱과 슬라이싱

인덱싱

word = 'Python'
word[0]   # 'P' - 첫 번째 문자
word[5]   # 'n' - 여섯 번째 문자
word[-1]  # 'n' - 마지막 문자 (음수 인덱스)

슬라이싱

word = 'Python'
word[0:2]  # 'Py' - 0부터 1까지
word[2:5]  # 'tho' - 2부터 4까지

7. 실전 문제 풀이 예제

예제 1: 두문자어(acronym) 만들기

# 여러 단어로 된 문자열에서 각 단어의 첫 글자로 두문자어 만들기
phrase = input("문자열을 입력하시오: ")  # 예: "Programming Language Theory"
acronym = ""
for word in phrase.upper().split():
    acronym += word[0]
print("acronym :", acronym)  # "PLT"

예제 2: 모음 제거하기

s = input('문자열을 입력하시오: ')  # 예: "hello"
vowels = "aeiouAEIOU"
result = ""
for letter in s:
    if letter not in vowels:
        result += letter
print(result)  # "hll"

예제 3: 모음과 자음 개수 세기

original = input('문자열을 입력하시오: ')  # 예: "Python"
word = original.lower()
vowels = 0
consonants = 0

if len(original) > 0 and original.isalpha():
    for char in word:
        if char in 'aeiou':
            vowels += 1
        else:
            consonants += 1

print("모음의 개수", vowels)
print("자음의 개수", consonants)

예제 4: 문자 유형별 개수 세기

statement = input("문자열을 입력하시오: ")  # 예: "Hello 123"
alphas = 0
digits = 0
spaces = 0

for c in statement:
    if c.isalpha():
        alphas += 1
    if c.isdigit():
        digits += 1
    if c.isspace():
        spaces += 1

print("알파벳 개수=", alphas)
print("숫자 개수=", digits)
print("공백 개수=", spaces)

예제 5: 특수문자 제거 (계좌번호 처리)

account = input('계좌번호를 입력하시오: ')  # 예: "312-02-1234567"
processed = ""

for c in account:
    if c != "-":
        processed += c

print(processed)  # "312021234567"

예제 6: 회문(palindrome) 검사

def check_pal(s):
    low = 0
    high = len(s) - 1

    while True:
        if low > high:
            return True
        a = s[low]
        b = s[high]
        if a != b:
            return False
        low += 1
        high -= 1

s = input("문자열을 입력하시오: ")  # 예: "mom" 또는 "level"
s = s.replace(" ", "")  # 공백 제거
if check_pal(s):
    print("회문입니다.")
else:
    print("회문이 아닙니다.")

8. 중간고사 예상 문제 및 풀이

문제 1: 문자열 조작 기본

주어진 문자열의 모든 공백을 제거하고, 대문자로 변환한 후 출력하는 프로그램을 작성하시오.

# 답안
text = input("문자열을 입력하세요: ")  # 예: "Hello World Python"
result = text.replace(" ", "").upper()
print(result)  # "HELLOWORLDPYTHON"

문제 2: 이메일 주소 분석

사용자로부터 이메일 주소를 입력받아 사용자 이름과 도메인을 분리하여 출력하는 프로그램을 작성하시오.

# 답안
email = input("이메일 주소를 입력하세요: ")  # 예: "user@example.com"
username, domain = email.split('@')
print("사용자 이름:", username)
print("도메인:", domain)

문제 3: 비밀번호 유효성 검사

사용자로부터 비밀번호를 입력받아 다음 조건을 모두 만족하는지 검사하는 프로그램을 작성하시오.

• 최소 8자 이상
• 최소 하나의 숫자 포함
• 최소 하나의 대문자 포함

# 답안
password = input("비밀번호를 입력하세요: ")

length_valid = len(password) >= 8
digit_valid = False
upper_valid = False

for char in password:
    if char.isdigit():
        digit_valid = True
    if char.isupper():
        upper_valid = True

if length_valid and digit_valid and upper_valid:
    print("유효한 비밀번호입니다.")
else:
    print("유효하지 않은 비밀번호입니다.")
    if not length_valid:
        print("- 비밀번호는 최소 8자 이상이어야 합니다.")
    if not digit_valid:
        print("- 최소 하나의 숫자를 포함해야 합니다.")
    if not upper_valid:
        print("- 최소 하나의 대문자를 포함해야 합니다.")

문제 4: 문자열 통계

사용자로부터 문장을 입력받아 단어 수, 문자 수(공백 제외), 평균 단어 길이를 계산하는 프로그램을 작성하시오.

# 답안
sentence = input("문장을 입력하세요: ")  # 예: "Python is a great programming language"

words = sentence.split()
word_count = len(words)
char_count = len(sentence.replace(" ", ""))
average_word_length = char_count / word_count if word_count > 0 else 0

print("단어 수:", word_count)
print("문자 수(공백 제외):", char_count)
print("평균 단어 길이:", round(average_word_length, 2))

문제 5: 문자열 암호화

사용자로부터 문자열을 입력받아 각 문자의 ASCII 코드값에 5를 더한 후, 해당 ASCII 코드값에 해당하는 문자로 변환하여 암호화하는 프로그램을 작성하시오.

# 답안
text = input("암호화할 문자열을 입력하세요: ")  # 예: "abc"
encrypted = ""

for char in text:
    encrypted += chr(ord(char) + 5)

print("암호화된 문자열:", encrypted)  # "fgh"

9. 실전 대비 팁

1. 핵심 메소드 암기하기
   • upper(), lower(), strip(), split(), replace() 등의 메소드 사용법을 숙지
2. 인덱싱과 슬라이싱 연습하기
   • 양수/음수 인덱스 모두 능숙하게 사용할 수 있어야 함
   • 다양한 슬라이싱 범위에 대한 결과 예측 연습
3. 자주 나오는 문제 유형 연습
   • 회문 검사, 문자 개수 세기, 특정 문자 제거 등
4. 문자열 포맷팅 방법 숙지
   • %s 형식 지정자 사용법 이해
5. 문자열 처리 알고리즘 이해하기
   • 반복문과 조건문을 활용한 문자열 처리 패턴 연습

확인 문제를 통해 개념 이해도를 체크해보세요!

10. 확인 문제

1. 다음 중 문자열에서 모든 공백을 제거하는 코드로 올바른 것은?

   • A. text.replace(" ")
   • B. text.strip()
   • C. text.replace(" ", "")
   • D. text.remove(" ")

2. 파이썬에서 문자열의 첫 번째 문자를 가리키는 인덱스는?

   • A. 1
   • B. 0
   • C. -1
   • D. None

3. 다음 코드의 실행 결과는?

    s = "Python Programming"
    print(s[7:])
   

   • A. "Python"
   • B. "Programming"
   • C. "Py"
   • D. "thon Programming"

4. 다음 중 문자열이 숫자로만 이루어져 있는지 확인하는 메소드는?

   • A. isalpha()
   • B. isnumeric()
   • C. isdigit()
   • D. isnum()

5. 문자열 "Hello"를 3번 반복하는 코드는?

   • A. "Hello".repeat(3)
   • B. "Hello" * 3
   • C. "Hello" + "Hello" + "Hello"
   • D. "Hello".multiply(3)

답안: 1-C, 2-B, 3-B, 4-C, 5-B

1.1 Anaconda 개발 환경

• Anaconda는 패키지 관리를 단순화하기 위한 파이썬 오픈 소스 배포판
• 패키지 관리 기능을 제공하여 라이브러리 설치 및 관리 용이

1.2 모듈과 __name__ 변수

• 모듈: 함수, 변수, 클래스 등을 모아놓은 파이썬 파일
• __name__ 변수: 현재 실행 중인 모듈의 이름을 저장하는 특수 변수
  • 직접 실행 시: __main__
  • 다른 모듈에서 임포트 시: 모듈 이름

1.3 객체 속성과 메소드 탐색

• dir() 함수: 객체가 가진 변수와 메소드를 보여주는 내장 함수
• 문자열 객체의 메소드 예: upper(), lower(), split() 등

1.4 모듈 임포트 방식

1. import 모듈명: 전체 모듈을 가져옴
2. from 모듈명 import 함수/변수: 특정 함수나 변수만 가져옴
3. import 모듈명 as 별칭: 별칭을 사용하여 모듈 임포트

2. 코드 예제 분석

예제 1: 기본 객체 탐색

a = "hi, python"
print(a)
print(dir())  # 현재 네임스페이스의 변수/함수 목록
print("="*30)
print(dir(a))  # 문자열 객체의 메소드 목록
print(a.upper())  # 대문자 변환

예제 2: __name__ 변수 활용

def greetings(name):
    print('Hello,', name)

if __name__ == '__main__':
    greetings("christina")
    greetings("daniel")
else:
    print(__name__)

예제 3: 나이 계산 함수와 모듈 활용

# test_04.py 모듈
print(" << test_04 모듈 >>")

def age():
    year = int(input("태어난 년도? "))
    age = 2023-year
    return age

if __name__ == '__main__':
    age = age()
    print("나이 : ", age)
else:
    print("test_04 모듈이 임포트되었습니다.")
    print(" test_04모듈 __name__ : ", __name__)
    print(" test_04모듈 age()함수에서 출력한 나이 : ", age())

예제 4: 모듈 임포트 방식 비교

# import 모듈명
import test_04
age = test_04.age()

# from 모듈명 import 함수
from test_04 import age
age = age()

# import 모듈명 as 별칭
import test_04 as t
age = t.age()

3. 예상 문제 및 답안

파이썬 중간고사 예상 문제 및 답안

객관식 문제

Q1. Anaconda의 주요 용도는 무엇인가?

1. 파이썬 코드 컴파일
2. 패키지 관리 및 라이브러리 설치
3. 하드웨어 자원 최적화
4. 웹 어플리케이션 배포

정답: 2

Q2. 다음 중 파이썬 모듈이 직접 실행될 때 __name__ 변수의 값은?

1. "module"
2. "python"
3. "main"
4. 모듈의 파일명

정답: 3

Q3. 다음 코드의 실행 결과로 올바른 것은?

a = "hello world"
print(a.upper())

1. "Hello World"
2. "HELLO WORLD"
3. "hello world"
4. 오류 발생

정답: 2

Q4. 객체의 메소드와 속성을 확인하는 내장 함수는?

1. type()
2. list()
3. dir()
4. help()

정답: 3

Q5. 다른 모듈에서 함수를 가져올 때 사용하는 올바른 문법은?

1. export function from module
2. include module.function
3. from module import function
4. require module.function

정답: 3

단답형 문제

Q6. print(dir()) 명령어는 무엇을 보여주는가?

정답: 현재 네임스페이스에 있는 변수, 함수, 클래스 등의 이름 목록

Q7. 파이썬에서 모듈의 별칭을 지정하는 문법은?

정답: import 모듈명 as 별칭

Q8. 특정 문자열을 대문자로 변환하는 메소드는?

정답: upper()

Q9. 모듈이 다른 모듈에 임포트될 때 __name__ 변수의 값은?

정답: 해당 모듈의 파일명(확장자 제외)

Q10. 다음 코드에서 출력되는 값은?

print("python"*3)

정답: pythonpythonpython

코드 작성 문제

Q11. 두 개의 파이썬 파일을 만들어보세요:

1. 'calculator.py' - 더하기, 빼기, 곱하기, 나누기 함수를 포함하며, 직접 실행 시 간단한 테스트를 수행
2. 'main.py' - calculator 모듈을 임포트하여 사용자 입력으로 계산을 수행

답안 예시:

# calculator.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        return "Error: Division by zero"
    return a / b

if __name__ == '__main__':
    # 테스트 코드
    print("테스트 시작")
    print(f"10 + 5 = {add(10, 5)}")
    print(f"10 - 5 = {subtract(10, 5)}")
    print(f"10 * 5 = {multiply(10, 5)}")
    print(f"10 / 5 = {divide(10, 5)}")
    print(f"10 / 0 = {divide(10, 0)}")
    print("테스트 종료")

# main.py
import calculator

print("간단한 계산기 프로그램")

while True:
    print("\n1: 더하기, 2: 빼기, 3: 곱하기, 4: 나누기, 0: 종료")
    choice = input("선택: ")

    if choice == '0':
        break

    if choice not in ['1', '2', '3', '4']:
        print("잘못된 선택입니다.")
        continue

    a = float(input("첫 번째 숫자: "))
    b = float(input("두 번째 숫자: "))

    if choice == '1':
        print(f"결과: {calculator.add(a, b)}")
    elif choice == '2':
        print(f"결과: {calculator.subtract(a, b)}")
    elif choice == '3':
        print(f"결과: {calculator.multiply(a, b)}")
    else:
        print(f"결과: {calculator.divide(a, b)}")

print("프로그램 종료")

Q12. 다음 코드의 출력 결과를 예측하세요:

def test_function():
    print("함수 실행")
    return 42

if __name__ == '__main__':
    value = test_function()
    print(f"반환값: {value}")

정답:

함수 실행
반환값: 42

Q13. __name__ 변수를 활용하여 직접 실행과 임포트 시 다르게 동작하는 모듈을 작성하세요.

답안 예시:

# my_module.py
def greet(name):
    return f"안녕하세요, {name}님!"

def calculate_age(birth_year):
    current_year = 2023
    return current_year - birth_year

if __name__ == '__main__':
    # 직접 실행 시에만 아래 코드 실행
    print("모듈 테스트 모드")
    test_name = "홍길동"
    test_year = 2000
    print(f"{test_name}에게 인사: {greet(test_name)}")
    print(f"{test_name}의 나이: {calculate_age(test_year)}")
else:
    # 임포트 시에만 아래 코드 실행
    print("my_module이 임포트되었습니다")

실전 문제

Q14. 다음 오류가 발생하는 이유를 설명하고 수정하세요:

import my_functions

result = my_functions.square(5)
print(result)

오류: AttributeError: module 'my_functions' has no attribute 'square'

정답: my_functions 모듈에 square 함수가 정의되어 있지 않습니다. 모듈에 해당 함수를 정의하거나, 올바른 함수 이름을 사용해야 합니다.

수정 예시:

# my_functions.py 파일에 다음 함수 추가
def square(x):
    return x * x

Q15. 다음 코드의 문제점을 찾고 수정하세요:

from math import *

def calculate_area(radius):
    return pi * radius ** 2

if __name__ = '__main__':
    radius = 5
    area = calculate_area(radius)
    print(f"반지름이 {radius}인 원의 면적: {area}")

정답: 두 가지 문제가 있습니다:

1. if __name__ = '__main__': 부분에서 비교 연산자 ==가 아닌 할당 연산자 =를 사용했습니다.
2. from math import *은 네임스페이스 오염을 일으킬 수 있어 권장되지 않습니다.

수정 코드:

from math import pi  # 필요한 함수만 임포트

def calculate_area(radius):
    return pi * radius ** 2

if __name__ == '__main__':  # == 사용
    radius = 5
    area = calculate_area(radius)
    print(f"반지름이 {radius}인 원의 면적: {area}")

4. 실전 대비 추가 팁

모듈 시스템 이해하기

• 모듈은 파이썬 코드를 논리적으로 조직화하는 기본 단위
• 적절한 모듈 구조는 코드 재사용성과 유지보수성을 높임
• __name__ 변수를 활용한 모듈 테스트 코드 패턴은 실무에서 매우 중요

IDE 능숙하게 사용하기

• 코드 자동완성, 디버깅 도구 사용법 숙지
• PyCharm의 단축키 익히기 (예: Alt + Shift + E로 한 줄씩 실행)
• 가상환경 관리와 패키지 설치 방법 익히기

문자열 메소드 숙달하기

• upper(), lower(), strip(), split() 등의 주요 메소드 사용법 익히기
• 문자열 포맷팅 방식 (f-string, format 메소드) 능숙하게 사용하기

모듈 임포트 방식별 장단점 이해하기

• import module
  • 장점: 네임스페이스 충돌 방지
  • 단점: 모듈명을 항상 명시해야 함
• from module import function
  • 장점: 함수 직접 호출 가능
  • 단점: 이름 충돌 가능성
• import module as alias
  • 장점: 긴 모듈명 축약 가능
  • 사용법: 가독성을 고려한 적절한 별칭 사용

1.1 while 반복문

기본 구조:

while 조건:
    # 반복할 코드
    # 조건이 참인 동안 계속 실행됨

주요 특징:

• 조건이 참인 동안 계속 실행
• 무한 루프 방지를 위해 반복 조건이 언젠가는 거짓이 되도록 설계해야 함
• 변수 초기화가 루프 전에 필요함

1.2 for 반복문

기본 구조:

for 변수 in 범위/시퀀스:
    # 반복할 코드

주요 특징:

• range() 함수와 많이 사용됨: range(시작, 끝, 스텝)
• 리스트, 문자열 등 순회 가능한 객체에 대해 반복 수행
• 횟수가 정해진 반복에 적합

1.3 반복문 제어 명령어

• break: 반복문을 완전히 종료
• 센티널 값: 특정 값이 입력되면 반복문을 종료하는 방식
  • continue: 현재 반복을 중단하고 다음 반복으로 이동

1.4 중첩 반복문

기본 구조:

for i in range():
    for j in range():
        # 코드 실행

주요 특징:

• 반복문 안에 또 다른 반복문이 있는 구조
• 행렬, 그리드 작업, 복잡한 패턴 생성에 유용
• 실행 시간이 급격히 증가할 수 있으므로 효율성 고려 필요

2. 주요 예제 분석

2.1 구구단 출력 (while 문)

print("구구단 출력")
print("-"*30)
dan = int(input("몇 단을 출력할까요 ? "))
i = 1
while i <= 9:
    print("%d * %d = %d" %(dan, i, dan*i))
    i = i + 1

핵심 포인트:

• 변수 초기화: i = 1
• 반복 조건: i <= 9
• 변수 증가: i = i + 1

2.2 배수의 합 계산

sum = 0
number = 1
while number <= 100:
    if number % 3 == 0:
        sum = sum + number
    number = number + 1
print("1부터 100사이의 모든 3의 배수의 합은 %d입니다." % sum)

핵심 포인트:

• 누적 합계 변수: sum = 0
• 조건부 누적: if number % 3 == 0
• 범위 지정: while number <= 100

2.3 자리수의 합 계산

number = int(input("자리수의 합을 계산하기 위한 값을 입력하시오 : "))
sum = 0
while number > 0:
    digit = number % 10
    sum = sum + digit
    number = number // 10
print("자리수의 합은 %d입니다." % sum)

핵심 포인트!!!!!!!!!!!!!!!:

• 1의 자리 추출: digit = number % 10
• 자릿수 이동: number = number // 10
• 종료 조건: number > 0 (모든 자릿수 처리 완료)

2.4 센티널을 이용한 성적 평균 계산

n = 0
sum = 0
score = 0
print("종료하려면 음수를 입력하시오")
while score >= 0:
    score = int(input("성적을 입력하시오: "))
    if score > 0:
        sum = sum + score
        n = n + 1
if n > 0:
    average = sum / n
    print("성적의 평균은 %f입니다." % average)

핵심 포인트:

• 센티널 값: 음수 입력 시 종료
• 유효한 데이터만 처리: if score > 0
• 평균 계산 전 분모 검사: if n > 0

2.5 숫자 맞추기 게임

import random
tries = 0
number = random.randint(1, 100)
print("1부터 100사이의 숫자를 맞추시오")
while tries < 10:
    guess = int(input("숫자를 입력하시오: "))
    tries = tries + 1
    if guess < number:
        print("컴퓨터가 생각하는 숫자보다 더 작음!")
    elif guess > number:
        print("컴퓨터가 생각하는 숫자보다 더 큼!")
    else:
        break
if guess == number:
    print("축하합니다.정답입니다.시도횟수=", tries)
else:
    print("정답은 ", number)

핵심 포인트:

• 무작위 수 생성: random.randint(1, 100)
• 시도 횟수 제한: tries < 10
• break 사용: 정답을 맞췄을 때 반복문 탈출

2.6 가위 바위 보 게임

from random import randint
def game(player):
    while True:
        player = input("scissors, rock, paper중에서 하나를 입력하고,게임을 끝내려면 q를 입력하세요: ")
        if player == "q":
            return
        elif player == "scissors":
            playerNum = 0
        elif player == "rock":
            playerNum = 1
        elif player == "paper":
            playerNum = 2
        else:
            continue
        list = ["scissors", "rock", "paper"]
        comNum = randint(0,2)
        print("● user :", player, "● computer :", list[comNum])
        if (playerNum-comNum==0):
            print("user and computer are in the same.")
        elif (playerNum-comNum==-2 or playerNum-comNum==1):
            print("user win !!")
        else:
            print("computer win !!")

player = input("게임을 시작하려면 s를 입력하세요: ")
if player =="s":
    print("게임이 시작되었습니다.")
    game(player)

핵심 포인트:

• continue 사용: 잘못된 입력 시 재입력 요청
• 함수 내부의 무한 루프: while True
• 간단한 승패 결정 로직: playerNum-comNum 값 비교

2.7 중첩 반복문을 이용한 패턴 출력

for y in range(5):
    for x in range(10):
        print("* ", end="")
    print()

핵심 포인트:

• 외부 루프: 행 반복 (y)
• 내부 루프: 열 반복 (x)
• end="" 파라미터로 줄바꿈 제어

2.8 피타고라스 직각삼각형 찾기

for a in range(1, 101, 1):
    for b in range(a, 101, 1):
        for c in range(b, 101, 1):
            if((a*a+b*b)==c*c):
                print(a, b, c)

핵심 포인트:

• 3중 중첩 반복문 사용
• 효율성 향상: b는 a부터, c는 b부터 시작
• 조건 검사: 피타고라스 정리 a²+b²=c²

3. 예상 문제 및 풀이

문제 1: while 루프 기초

문제: 1부터 사용자가 입력한 수까지의 합을 계산하는 프로그램을 작성하시오.

풀이:

n = int(input("숫자를 입력하세요: "))
sum = 0
i = 1 #while은 초깃값 뺴먹지말기!!!!!!

while i <= n:
    sum += i
    i += 1

print(f"1부터 {n}까지의 합은 {sum}입니다.")

문제 2: for 루프와 range 함수

문제: range 함수를 사용하여 10부터 1까지 역순으로 출력하는 프로그램을 작성하시오.

풀이:

for i in range(10, 0, -1):
    print(i, end=" ")
print()  # 줄바꿈

문제 3: break와 continue 활용

문제: 1부터 100까지 숫자 중 7의 배수이거나 3의 배수인 경우만 출력하되, 합이 200을 초과하면 중단하는 프로그램을 작성하시오.

풀이:

sum = 0
for num in range(1, 101):
    if num % 7 == 0 or num % 3 == 0:
        print(num, end=" ")
        sum += num
        if sum > 200:
            print("\n합이 200을 초과했습니다. 현재 합:", sum)
            break
    else:
        continue

문제 4: 자리수 계산

문제:

풀이:

number = int(input("정수를 입력하세요: "))
original = number
count = 0

while number > 0:
    number = number // 10
    count += 1

print(f"{original}은(는) {count}자리 수입니다.")

문제 5: 중첩 반복문 패턴

문제: 다음과 같은 패턴을 출력하는 프로그램을 작성하시오.

*
**
***
****
*****

풀이:

rows = 5
for i in range(1, rows + 1):
    for j in range(i):
        print("*", end="")
    print()

문제 6: 소수 찾기

문제: 2부터 100까지의 모든 소수를 찾아 출력하는 프로그램을 작성하시오.

풀이:

for num in range(2, 101):  # 2부터 100까지의 모든 숫자(num)를 확인
    is_prime = True  # 소수 여부를 저장하는 변수 (기본적으로 True로 설정)

    for i in range(2, int(num**0.5) + 1):  # 2부터 num의 제곱근까지 반복
        if num % i == 0:  # 나누어 떨어지는 수가 있으면
            is_prime = False  # 소수가 아님
            break  # 더 확인할 필요 없으므로 반복문 종료

    if is_prime:  # 소수라면 출력
        print(num, end=" ")  # 한 줄로 출력하기 위해 end=" " 추가3

문제 7: 센티널 값을 활용한 데이터 입력

문제: 사용자로부터 숫자를 입력받아 합계를 계산하되, 0이 입력되면 입력을 중단하고 지금까지의 합계와 평균을 출력하는 프로그램을 작성하시오.

풀이:

sum = 0
count = 0
print("숫자들을 입력하세요 (종료는 0):")

while True:
    num = float(input("숫자: "))
    if num == 0:
        break
    sum += num
    count += 1

if count > 0:
    print(f"합계: {sum}")
    print(f"평균: {sum / count}")
else:
    print("입력된 숫자가 없습니다.")

'''### 문### 문제 7: 센티널 값을 활용한 데이터 입력

**문제:** 사용자로부터 숫자를 입력받아 합계를 계산하되,
0이 입력되면 입력을 중단하고 지금까지의
합계와 평균을 출력하는 프로그램을 작성하시오.'''
sum=0
count=0
# 걍 냅다 print처넣기
'''알고리즘
1. while True처넣기
2. 숫자입력
3. 만약 입력된숫자가 0임: 멈춰씨발!
4. 아님:(계속진행됨): num추가, 카운트 +1
5. 이 다음은 break 당한 경우밖에 없으므로 만약 카운트>0: 합계평균출력
아님: 입력된숫자가없음을어필!)'''
print("숫자들을 입력하세요(종료는 0)")
while True:
    num = float(input("숫자?: "))
    if num == 0:
        break
    sum += num
    count += 1

if count>0:
    print(f"지금까지 입력된 숫자의 합계는: {sum}, 평균은 {sum/count}")
else:
    print("입력된 숫자가 없습니다.")

문제 8: 난수 생성과 반복문

문제: 주사위를 100번 던져서 각 숫자(1~6)가 나온 횟수를 세는 프로그램을 작성하시오.

풀이:

import random

counts = [0, 0, 0, 0, 0, 0]  # 인덱스 0은 사용하지 않음

for i in range(100):
    dice = random.randint(1, 6)
    counts[dice-1] += 1

for i in range(6):
    print(f"숫자 {i+1}: {counts[i]}번")

#내가한거
'''알고리즘
1. 랜덤임포트
2. 카운트리스트 준비
3. 100번굴려
4. 주사위수 = r.randint 지정해둠
5. 카운트[주사위수-1] += 1
개빡세네 시발
내가잘한점: 리스트[숫자] += 1 이거어케생각햇대 ㅎ'''
import random as r

counts = [0, 0, 0, 0, 0, 0]
for i in range(100):
    num = r.randint(1,6)
    counts[num-1] += 1
print(counts[0], counts[1], counts[2], counts[3], counts[4], counts[5])

문제 9: 중첩 루프와 조건문(개잘햇죠?ㅋㅋ)

문제: 구구단 중 짝수 단(2, 4, 6, 8단)만 출력하는 프로그램을 작성하시오.

풀이:

for dan in range(2, 10, 2):
    print(f"\n== {dan}단 ==")
    for i in range(1, 10):
        print(f"{dan} × {i} = {dan * i}")

문제 10: 실전 응용 문제

문제: 사용자로부터 양의 정수 n을 입력받아, 피보나치 수열의 첫 n개 항을 출력하는 프로그램을 작성하시오.

풀이:

n = int(input("출력할 피보나치 수열의 항 개수: "))

a, b = 0, 1 #초깃값지정해두기!! 피보나치수열=1,1,2,3...이딴식으로전개됨
count = 0

while count < n:
    print(a, end=" ") #앞두자리수의합>다음b가되므로 a만출력: ㅇㅋ
    a, b = b, a + b
    count += 1

4. 실전 대비 연습 문제

Python 반복문 실전 대비 연습 문제

기초 연습 문제

문제 1: 팩토리얼 계산

n!을 계산하는 프로그램을 작성하시오. (n은 사용자 입력)

문제 2: 구구단

사용자가 입력한 단 ~ 9단까지 구구단을 출력하는 프로그램을 작성하시오.

문제 3: 약수 찾기

사용자가 입력한 숫자의 모든 약수를 찾아 출력하는 프로그램을 작성하시오.

중급 연습 문제

문제 4: 완전수 찾기

1부터 1000까지의 수 중에서 완전수를 모두 찾아 출력하시오. (완전수는 자기 자신을 제외한 약수의 합이 자기 자신과 같은 수)

#1부터 1000까지의 수 중에서 완전수를 모두 찾아 출력하시오.
#(완전수는 자기 자신을 제외한 약수의 합이 자기 자신과 같은 수) 

for i in range(1,1001):
    sum = 0
    for n in range(1, i):
        if i%n ==0:
            sum += n
        else:
            continue
    if sum == i:
        print(i, end=" ")

문제 5: 암스트롱 수 찾기

100부터 999까지의 암스트롱 수를 모두 찾아 출력하시오. (각 자릿수의 세제곱의 합이 원래 수와 같은 수)

### 문제 5: 암스트롱 수 찾기

#100부터 999까지의 암스트롱 수를 모두 찾아 출력하시오.
#(각 자릿수의 세제곱의 합이 원래 수와 같은 수)
a=0
b=0
c=0
for i in range(100,1000):
    a=i//100 #백의자리수
    b=(i-a*100)//10 #십의자리수
    c=i%10
    if (a**3 + b**3 + c**3 == i):
        print(i)

문제 6: 별 패턴 출력

다음과 같은 패턴을 출력하시오.

    *
   ***
  *****
 *******
*********

for i in range(1,6):
    print(" "*(6-i), "*"*(2*i-1)) 우 하 하

고급 연습 문제

문제 7: 콜라츠 추측

사용자가 입력한 양의 정수 n에 대해 콜라츠 추측을 적용하여 1이 될 때까지의 과정과 단계 수를 출력하시오.

• n이 짝수면 2로 나눔
• n이 홀수면 3을 곱하고 1을 더함
• 위 과정을 n이 1이 될 때까지 반복

### 문제 7: 콜라츠 추측

#사용자가 입력한 양의 정수 n에 대해
#콜라츠 추측을 적용하여 1이 될 때까지의 과정과 단계 수를 출력하시오.

#- n이 짝수면 2로 나눔
#- n이 홀수면 3을 곱하고 1을 더함
#- 위 과정을 n이 1이 될 때까지 반복

num = int(input("정수를 입력하시오: "))
while num != 1:
    if num%2 == 0:
        num //= 2
        print("num//2=", num)
    elif num%2 == 1:
        num = num*3 + 1
        print("num*3-1=",num)

문제 8: 최대공약수와 최소공배수

두 수를 입력받아 최대공약수와 최소공배수를 계산하는 프로그램을 작성하시오.

문제 9: 로또 번호 생성기

1부터 45까지의 숫자 중에서 중복되지 않는 6개의 숫자를 무작위로 선택하여 출력하는 로또 번호 생성기를 작성하시오.

주요 개념

• 시퀀스(문자열, 리스트 등)를 순회할 때 사용
• range() 함수를 활용한 반복
• 다양한 반복 패턴 구현 가능

예제 코드

# 기본 for 반복문 예시
for i in range(5):
    print(i)  # 0, 1, 2, 3, 4 출력

# 문자열 순회
for char in "python":
    print(char)  # p, y, t, h, o, n 각각 출력

# 1부터 10까지의 합 계산
sum = 0
for i in range(1, 11):
    sum += i
print(f"1부터 10까지의 합: {sum}")  # 55

주요 range() 함수 사용법

• range(stop): 0부터 stop-1까지
• range(start, stop): start부터 stop-1까지
• range(start, stop, step): start부터 stop-1까지 step 간격으로

2. While 반복문 (While Loops)

주요 개념

• 조건이 참인 동안 반복 수행
• 반복 횟수를 미리 알 수 없는 경우 유용
• 무한 루프 주의

예제 코드

# 기본 while 반복문
i = 0
while i < 5:
    print(i)
    i += 1  # 0, 1, 2, 3, 4 출력

# 팩토리얼 계산
factorial = 1
n = 10
i = 1
while i <= n:
    factorial *= i
    i += 1
print(f"{n}! = {factorial}")  # 3,628,800

3. 반복문 활용 예시 - Turtle 그래픽

다각형 그리기

import turtle

# 육각형 그리기
polygon = turtle.Turtle()
num_sides = 6
side_length = 70
angle = 360.0 / num_sides

for i in range(num_sides):
    polygon.forward(side_length)
    polygon.right(angle)

Sin 곡선 그리기

import math
import turtle

t = turtle.Turtle()
t.speed('fastest')

for degree in range(360):
    y = math.sin(math.radians(degree))
    scaledX = degree
    scaledY = y * 100
    t.goto(scaledX, scaledY)

4. 중간고사 예상 문제

이론 문제

1. for와 while 반복문의 차이점은 무엇인가?

   • 답

     for 반복문

     • 미리 정해진 시퀀스나 횟수를 반복할 때 사용

     • 반복 횟수를 알고 있는 경우에 적합

     • 주로 리스트, 문자열, range() 등과 함께 사용

     • 반복 횟수가 명확하고 정해진 범위 내에서 반복할 때 효율적

       while 반복문

     • 조건이 참인 동안 계속 반복

     • 반복 횟수를 미리 알 수 없는 경우에 적합

     • 특정 조건이 만족될 때까지 반복

     • 조건 검사를 먼저 수행하고 반복 여부 결정

     • 무한 루프 가능성이 있어 주의 필요

       주요 차이점

     • 반복 제어 방식:

       • for: 정해진 범위나 시퀀스 순회
       • while: 조건 기반 반복

     • 사용 상황:

       • for: 알려진 반복 횟수나 시퀀스 순회
       • while

2. range(5, 10, 2)는 어떤 값을 생성하는가?

   • 답

     정답

     • [5, 7, 9]를 생성

     • 시작값: 5

     • 끝값: 10 이전까지 (10 제외)

     • 증가 간격: 2

       상세 설명

     • 첫 번째 인자 5: 시작값

     • 두 번째 인자 10: 종료값 (이 값은 포함되지 않음)

     • 세 번째 인자 2: 각 단계별 증가값

     • 5부터 시작해서 2씩 증가하며 10 미만까지 생성

3. 반복문에서 break와 continue의 역할은 무엇인가?

   • 답

     break

     • 반복문을 즉시 종료하고 반복문 밖으로 탈출

     • 특정 조건에서 반복을 완전히 중단할 때 사용

     • 반복문의 모든 후속 반복을 건너뜀

       예시

       python
       복사
       for i in range(10):
         if i == 5:
             break  # 5에서 반복문 완전 종료
         print(i)  # 0, 1, 2, 3, 4만 출력
       

       continue

     • 현재 반복의 나머지 코드를 건너뛰고 다음 반복으로 진행

     • 특정 조건에서 해당 반복만 건너뛰고 싶을 때 사용

     • 반복문 자체는 계속 진행

       예시

       python
       복사
       for i in range(10):
         if i % 2 == 0:
             continue  # 짝수일 경우 건너뜀
         print(i)  # 1, 3, 5, 7, 9만 출력
       

       주요 차이점

     • break: 반복문 전체 종료

     • continue: 현재 반복만 건너뛰고 다음 반복 진행

코딩 문제

1. 1부터 100까지의 짝수의 합을 계산하는 프로그램을 작성하시오.
2. 사용자로부터 입력받은 정수의 팩토리얼을 계산하는 프로그램을 작성하시오.
3. Turtle 그래픽을 사용하여 8개의 원을 그리는 프로그램을 작성하시오.

예시 솔루션

# 1. 1부터 100까지 짝수의 합
even_sum = 0
for i in range(2, 101, 2):
    even_sum += i
print(f"짝수의 합: {even_sum}")

# 2. 사용자 입력 팩토리얼 계산
n = int(input("정수를 입력하세요: "))
factorial = 1
for i in range(1, n+1):
    factorial *= i
print(f"{n}! = {factorial}")

# 3. 8개의 원 그리기
import turtle
t = turtle.Turtle()
for i in range(8):
    t.circle(100)
    t.right(360/8)

1.1 함수의 기본 개념

• 함수(Function): 특정 작업을 수행하는 코드 블록
• 장점: 코드 재사용성, 모듈화, 가독성 향상

1.2 함수 정의와 호출

# 함수 정의
def 함수이름(매개변수):
    # 함수 내용
    return 결과값

# 함수 호출
결과 = 함수이름(인자)

1.3 사칙 연산 함수 예제

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

def sub(a, b):
    return a - b

def mul(a, b):
    return a * b

def div(a, b):
    return a / b

# 함수 호출 예제
r1 = mul(a=20, b=30)  # 키워드 인자 사용
r2 = add(a=10, b=r1)
print(r2)  # 출력: 610

1.4 온도 변환기 함수 예제

def printOptions():
    print("'c'섭씨온도에서 화씨온도로 변환")
    print("'f'화씨온도에서 섭씨온도로 변환")
    print("'q'종료")
    print("="*30)

def C2F(c_temp):  # 섭씨 온도를 화씨 온도로 변환
    return 9.0 / 5.0 * c_temp + 32

def F2C(f_temp):  # 화씨 온도를 섭씨 온도로 변환
    return (f_temp - 32.0) * 5.0 / 9.0

# 사용 예시
printOptions()
choice = input("메뉴에서 선택하세요.")
if choice == "c":
    temp = float(input("섭씨온도: "))
    print("화씨온도:", C2F(temp))
elif choice == "f":
    temp = float(input("화씨온도: "))
    print("섭씨온도:", F2C(temp))
elif choice == "q":
    print("종료합니다.")
else:
    print("c, f, q중 하나를 입력하시오.")

2. 함수의 변수 작동 방식

2.1 Call-by-value vs Call-by-reference

Call-by-value (값에 의한 전달)

• 변수의 값을 복사하여 함수에 전달
• 함수 내에서 값을 변경해도 원본 변수에 영향 없음
• 숫자, 문자열과 같은 불변(immutable) 타입에 적용

def modify(n):
    print("함수 내부 n id =", id(n))
    print("함수 내부 n value =", n)
    n = n + 1
    print("함수 n = n +1실행 후 내부 n id =", id(n))
    print("함수 n = n +1실행 후 내부 n value =", n)

k = 10
print("함수 외부 (1) k id =", id(k))
print("함수 외부 (1) k value =", k)
modify(k)
print("함수 외부 (2) k id =", id(k))
print("함수 외부 (2) k value =", k)

Call-by-reference (참조에 의한 전달)

• 변수의 참조(메모리 주소)를 함수에 전달
• 함수 내에서 변경 시 원본 변수도 변경됨
• 리스트와 같은 가변(mutable) 타입에 적용

def modify2(li):
    print("함수 내부 li id =", id(li))
    print("함수 내부 li =", li)
    li += [100, 200]  # 원본 리스트 변경
    print("함수 li += [100, 200]실행 후 내부 li id =", id(li))
    print("함수 li += [100, 200]실행 후 내부 li =", li)

list = [1, 2, 3, 4, 5]
print("함수 호출 전 외부 list id =", id(list))
print("함수 호출 전 외부 list =", list)
modify2(list)
print("함수 호출 후 외부 list id =", id(list))
print("함수 호출 후 외부 list =", list)  # [1, 2, 3, 4, 5, 100, 200]

참고: 객체 재할당은 새로운 객체를 생성하므로 참조가 끊어짐

def modify2(li):
    print("함수 내부 li id =", id(li))
    print("함수 내부 li =", li)
    li = [100, 200]  # 새로운 객체 할당 (원본 변경 안 됨)
    print("함수 li = [100, 200]실행 후 내부 li id =", id(li))
    print("함수 li = [100, 200]실행 후 내부 li =", li)

list = [1, 2, 3, 4, 5]
modify2(list)
print("함수 호출 후 외부 list =", list)  # [1, 2, 3, 4, 5]

2.2 지역 변수와 전역 변수

지역 변수 (Local Variable)

• 함수 내부에서 선언된 변수
• 함수 내부에서만 사용 가능
• 함수 실행이 끝나면 소멸

def sub():
    s = "바나나가 좋음!"  # 지역 변수
    print(s)

sub()
# print(s)  # 오류: 지역 변수는 함수 외부에서 접근 불가

전역 변수 (Global Variable)

• 함수 외부에서 선언된 변수
• 프로그램 전체에서 접근 가능
• 함수 내부에서도 사용 가능 (단, 수정은 global 키워드 필요)

global 키워드: 함수 내에서 전역 변수를 수정할 때 사용

s = "사과가 좋음!"  # 전역 변수

def sub():
    print("함수 내부 :", s)  # 전역 변수 사용 가능

sub()
print("함수 외부 :", s)

def sub():
    global s  # 전역 변수 s를 사용하겠다고 선언//글로벌썻으니까 이거이제 걍 연결됏다고간주 ㄱㄱ
    print("함수 내부 (외부로 부터 전달받음) : s ->", s)
    s = "바나나가 좋음!"  # 전역 변수 값 변경
    print("함수 내부 (내부에서 수정됨) : s ->", s)

s = "사과가 좋음!"
print("함수 외부 (함수 실행 전) : s ->", s)
sub()
print("함수 외부 (함수 실행 후) : s ->", s)  # "바나나가 좋음!" 출력

2.3 람다 함수 (Lambda Function)

• 익명 함수: 이름이 없는 한 줄짜리 함수

  ◦ 여러 개의 argument를 가지고 있으나 return value는 하나만 있어야 함 ◦ 익명함수 내에서는 print()를 호출할 수 없고 간단한 계산만 가능함 ◦ global variables를 참조할 수 없음 ◦ 1개의 라인으로 구성되는 함수임

• lambda 키워드로 생성

• 간단한 계산에 유용

sum = lambda x, y: x + y
print("정수의 합 :", sum(10, 20))  # 정수의 합 : 30
print("정수의 합 :", sum(20, 20))  # 정수의 합 : 40

3. 반복문(Loops) 핵심 개념

3.1 반복문 기본 개념

• 동일한 작업을 여러 번 수행하는 구조
• 컴퓨터는 반복 작업을 실수 없이 빠르게 수행

3.2 for 반복문

기본 구조:

for 변수 in 시퀀스:
    # 반복할 코드

예제:

# 문자열 "환영합니다"를 5번 출력
for x in range(5):
    print("환영합니다.")

# 리스트의 각 요소에 접근
for name in ["철수", "영희", "길동", "유신"]:
    print("안녕! " + name)

3.3 range() 함수

• 특정 범위의 정수 시퀀스를 생성하는 함수
• range(stop): 0부터 stop-1까지의 정수 생성
• range(start, stop): start부터 stop-1까지의 정수 생성
• range(start, stop, step): start부터 stop-1까지 step 간격으로 정수 생성

# 0부터 9까지 출력
for x in range(10):
    print(x, end=" ")  # 0 1 2 3 4 5 6 7 8 9

# 0부터 9까지의 합계 계산
sum = 0
for x in range(10):
    sum = sum + x
print(sum)  # 45

4. 예상 문제 및 풀이

문제 1: 함수 개념 이해하기

다음 코드의 출력 결과는?

def calculate_area(radius):
    result = 3.14 * radius**2
    return result

r = float(input("원의 반지름: "))  # 사용자가 10.0 입력
area = calculate_area(r)
print(area)

• 답:

  314.0

문제 2: 지역 변수와 전역 변수

다음 코드의 출력 결과는?

def sub(x, y):
    global a
    a = 7
    x, y = y, x
    b = 3
    print("함수 내부 a : %d, b : %d, x : %d, y : %d" % (a, b, x, y))

a, b, x, y = 1, 2, 3, 4
sub(x, y)
print("함수 외부 a : %d, b : %d, x : %d, y : %d" % (a, b, x, y))

• 답:

    함수 내부 a : 7, b : 3, x : 4, y : 3
    함수 외부 a : 7, b : 2, x : 3, y : 4

문제 3: Call-by-value와 Call-by-reference

다음 코드의 출력 결과는?

def modify(mylist):
    print("함수 내부에서의 mylist:", mylist)
    mylist = [1, 2, 3, 4]
    print("함수 내부에서의 mylist:", mylist)
    return

mylist = [10, 20, 30, 40]
modify(mylist)
print("함수 외부에서의 mylist:", mylist)

• 답:

    함수 내부에서의 mylist: [10, 20, 30, 40]
    함수 내부에서의 mylist: [1, 2, 3, 4]
    함수 외부에서의 mylist: [10, 20, 30, 40]
  

문제 4: for 반복문과 range 함수

다음 코드를 실행하면 총 몇 번의 반복이 수행되는가?

sum = 0
for i in range(1, 10, 2):
    for j in range(2, 5):
        sum += i * j
print(sum)

• 답:

  5 × 3 = 15번 (i는 1,3,5,7,9의 5개 값, j는 2,3,4의 3개 값)

문제 5: 함수 작성 문제

다음과 같은 기능을 하는 함수를 작성하시오:

1. 사용자로부터 두 개의 정수를 입력받는 함수
2. 입력받은 두 정수 사이의 모든 정수의 합을 계산하는 함수
3. 결과를 출력하는 함수

• 답:

    def get_two_integers():
        num1 = int(input("첫 번째 정수를 입력하세요: "))
        num2 = int(input("두 번째 정수를 입력하세요: "))
        return num1, num2
  
    def calculate_sum_between(a, b):
        # 항상 작은 수부터 큰 수까지 더하기
        if a > b:
            a, b = b, a
        total = 0
        for i in range(a, b + 1):
            total += i
        return total
  
    def print_result(result):
        print("두 정수 사이의 모든 정수의 합:", result)
  
    def main():
        num1, num2 = get_two_integers()
        sum_result = calculate_sum_between(num1, num2)
        print_result(sum_result)
  
    main()
  

1.1 핵심 개념

• 조건문은 특정 조건에 따라 코드 실행을 제어하는 구문
• 파이썬에서는 if, elif, else 키워드를 사용
• 조건의 참/거짓 여부에 따라 실행 흐름이 달라짐

1.2 if-elif-else 구문

if 조건1:
    # 조건1이 참일 때 실행할 코드
elif 조건2:
    # 조건1이 거짓이고 조건2가 참일 때 실행할 코드
else:
    # 모든 조건이 거짓일 때 실행할 코드

1.3 중첩 조건문

if 조건1:
    if 조건2:
        # 조건1과 조건2가 모두 참일 때 실행할 코드
    else:
        # 조건1은 참이지만 조건2가 거짓일 때 실행할 코드
else:
    # 조건1이 거짓일 때 실행할 코드

1.4 논리 연산자

• and: 양쪽 조건이 모두 참일 때만 참
• or: 양쪽 조건 중 하나라도 참이면 참
• not: 조건의 결과를 반대로 바꿈

if 조건1 and 조건2:
    # 조건1과 조건2가 모두 참일 때 실행
if 조건1 or 조건2:
    # 조건1이나 조건2 중 하나라도 참일 때 실행
if not 조건:
    # 조건이 거짓일 때 실행

1.5 예제: 학점 계산기

score = int(input("성적을 입력하시오: "))
if score >= 90:
    print("학점 A")
elif score >= 80:
    print("학점 B")
elif score >= 70:
    print("학점 C")
elif score >= 60:
    print("학점 D")
else:
    print("학점 F")

1.6 예제: 월별 일수 출력

month = int(input("월을 입력하시오: "))
if month == 2:
    print(month, "월의 날수는 28일")
elif month in [4, 6, 9, 11]:
    print(month, "월의 일수는 30일")
elif month in [1, 3, 5, 7, 8, 10, 12]:
    print(month, "월의 일수는 31일")
else:
    print(month, "월은 없습니다.")

1.7 예외 처리

try:
    예외가 발생할 가능성이 있는 코드

except:
    예외가 발생했을 때 실행할 코드
    (필요에 따라 except 절을 추가로 작성)

try:
    # 예외가 발생할 수 있는 코드
    x = int(input('숫자를 입력하세요: '))
    y = 10 / x
    print(y)
except ValueError:
    # 값 오류 발생 시 실행되는 코드
    print('숫자가 아닌 값을 입력했습니다.')
except ZeroDivisionError:
    # 0으로 나누기 시도 시 실행되는 코드
    print('0으로 나눌 수 없습니다.')
except:
    # 다른 모든 예외 발생 시 실행되는 코드
    print('알 수 없는 오류가 발생했습니다.')

2. 함수 (Functions)

2.1 핵심 개념

• 함수: 특정 작업을 수행하는 명령어들의 모음에 이름을 붙인 것
• 함수는 코드의 재사용성을 높이고 가독성을 향상시킴
• 내장 함수와 사용자 정의 함수가 있음

2.2 함수 정의 및 호출

def 함수이름(매개변수1, 매개변수2, ...):
    # 함수 본문
    return 반환값  # 선택적

# 함수 호출
결과변수 = 함수이름(인수1, 인수2, ...)

2.3 매개변수와 인수

• 매개변수(parameter): 함수 정의에서 입력으로 받는 변수
• 인수(argument): 함수 호출 시 전달하는 실제 값

2.4 반환값

• return 문을 사용하여 함수의 결과를 반환
• return 문이 없으면 함수는 None을 반환
• 여러 값을 한 번에 반환할 수 있음

def get_values():
    return 1, 2, 3

a, b, c = get_values()

2.5 기본 인수

• 매개변수에 기본값을 설정할 수 있음
• 함수 호출 시 값을 전달하지 않으면 기본값이 사용됨

def greet(name, msg="안녕하세요"):
    print(name + ", " + msg)

greet("영희")  # 기본 메시지 사용
greet("영희", "오랜만이에요")  # 사용자 지정 메시지 사용

2.6 키워드 인수

• 인수의 순서와 상관없이 매개변수 이름으로 값을 전달

def calculate(x, y, z):
    return x + y + z

result = calculate(y=20, x=10, z=30)  # 순서 상관없이 매개변수 이름으로 전달

2.7 모듈 사용

• 함수, 변수, 클래스 등을 모아놓은 파일
• import 문을 사용하여 모듈을 가져옴

import math
radius = 10
area = math.pi * radius ** 2

# 모듈에서 특정 함수나 변수만 가져오기
from math import pi, sqrt
area = pi * radius ** 2

3. 예상 문제 및 풀이

조건문 관련 문제

문제 1: 조건문 오류 찾기

다음 코드의 오류를 찾아 수정하세요. 이 코드는 학점을 계산하는 프로그램입니다.

score = int(input("성적을 입력하시오: "))
if score >= 90:
    print("학점 A")
elif score >= 60:
    print("학점 D")
elif score >= 70:
    print("학점 C")
elif score >= 80:
    print("학점 B")
else:
    print("학점 F")

• 정답:

  조건문의 순서가 잘못되었습니다. 조건을 큰 값부터 작은 값 순으로 검사해야 합니다.

    score = int(input("성적을 입력하시오: "))
    if score >= 90:
        print("학점 A")
    elif score >= 80:
        print("학점 B")
    elif score >= 70:
        print("학점 C")
    elif score >= 60:
        print("학점 D")
    else:
        print("학점 F")
  

문제 2: 조건문 실행 결과 예측

다음 코드의 실행 결과를 예측하세요.

age = 20
height = 180
if (age >= 10 and height >= 165):
    print("놀이 기구를 탈 수 있습니다.")
else:
    print("놀이 기구를 탈 수 없습니다.")

• 정답:

  "놀이 기구를 탈 수 있습니다."가 출력됩니다. age가 20이고 height가 180이므로 두 조건(age >= 10, height >= 165)을 모두 만족합니다.

문제 3: 예외 처리 코드 작성

사용자로부터 월을 입력받아 해당 월의 일수를 출력하는 프로그램을 작성하세요. 단, 사용자가 숫자가 아닌 값을 입력할 경우 예외 처리를 하고, 1~12 이외의 숫자를 입력할 경우에도 적절한 메시지를 출력하세요.

• 정답:

    try:
        month = int(input("월을 입력하시오: "))
        if month == 2:
            print(month, "월의 날수는 28일")
        elif month in [4, 6, 9, 11]:
            print(month, "월의 일수는 30일")
        elif month in [1, 3, 5, 7, 8, 10, 12]:
            print(month, "월의 일수는 31일")
        else:
            print(month, "월은 없습니다.")
    except ValueError:
        print("입력값이 숫자 타입의 월이 아닙니다.")
        print("월은 3월로 자동 입력됩니다.")
        month = 3
        print(month, "월의 일수는 31일")
  

함수 관련 문제

문제 4: 함수 구현하기

두 숫자 중 큰 수를 반환하는 함수 get_max()를 구현하세요.

• 정답:

    def get_max(x, y):
        if x > y:
            return x
        else:
            return y
  
    # 테스트
    print(get_max(10, 20))  # 20 출력
    print(get_max(30, 15))  # 30 출력
  

문제 5: 함수 오류 찾기

다음 함수에서 오류를 찾아 수정하세요.

def power(x, y):
    result = 1
    result = result * x * y
    return result

print(power(10, 2))

• 정답:

거듭제곱 계산 방식이 잘못되었습니다. x의 y제곱은 x를 y번 곱해야 합니다.

```python
def power(x, y):
    result = x ** y  # 또는 result = pow(x, y)
    return result

print(power(10, 2))  # 100 출력

```

문제 6: 함수와 모듈 사용하기

math 모듈을 사용하여 반지름이 주어졌을 때 구의 부피를 계산하는 함수 sphere_volume()을 작성하세요.

• 정답:

    import math
  
    def sphere_volume(radius):
        volume = (4.0 / 3.0) * math.pi * radius ** 3
        return volume
  
    # 테스트
    radius = float(input("구의 반지름을 입력하시오: "))
    print(sphere_volume(radius))
  

문제 7: 기본 인수 사용하기

이름과 메시지를 인수로 받아 인사말을 출력하는 함수 greet()을 작성하세요. 메시지에는 기본값 "별일없죠?"를 사용하세요.

• 정답:

    def greet(name, msg="별일없죠?"):
        print("안녕 " + name + ", " + msg)
  
    # 테스트
    greet("영희")  # "안녕 영희, 별일없죠?" 출력
    greet("영희", "지금 집에 있니?")  # "안녕 영희, 지금 집에 있니?" 출력
  

4. 실전 대비 종합 문제

문제 1: 종합 조건문 문제

사용자로부터 나이와 키를 입력받아 다음 조건에 따라 적절한 메시지를 출력하는 프로그램을 작성하세요.

• 나이가 12세 이상이고 키가 140cm 이상이면 "모든 놀이기구를 탈 수 있습니다."

• 나이가 10세 이상이고 키가 130cm 이상이면 "대부분의 놀이기구를 탈 수 있습니다."

• 그 외에는 "일부 놀이기구만 탈 수 있습니다."

• 정답:

    try:
        age = int(input("나이를 입력하세요: "))
        height = float(input("키를 입력하세요(cm): "))
  
        if age >= 12 and height >= 140:
            print("모든 놀이기구를 탈 수 있습니다.")
        elif age >= 10 and height >= 130:
            print("대부분의 놀이기구를 탈 수 있습니다.")
        else:
            print("일부 놀이기구만 탈 수 있습니다.")
    except ValueError:
        print("나이와 키는 숫자로 입력해야 합니다.")
  

문제 2: 종합 함수 문제

섭씨 온도와 화씨 온도를 상호 변환하는 두 함수 celsius_to_fahrenheit()와 fahrenheit_to_celsius()를 작성하세요. 사용자로부터 변환하고자 하는 온도와 단위(C 또는 F)를 입력받아 변환 결과를 출력하는 프로그램을 작성하세요.

• 정답:

    def celsius_to_fahrenheit(temp_c):
        temp_f = (9.0 / 5.0) * temp_c + 32.0
        return temp_f
  
    def fahrenheit_to_celsius(temp_f):
        temp_c = (5.0 / 9.0) * (temp_f - 32.0)
        return temp_c
  
    try:
        temp = float(input("온도를 입력하세요: "))
        unit = input("단위를 입력하세요(C 또는 F): ")
  
        if unit.upper() == "C":
            converted = celsius_to_fahrenheit(temp)
            print(f"{temp}°C는 {converted:.2f}°F입니다.")
        elif unit.upper() == "F":
            converted = fahrenheit_to_celsius(temp)
            print(f"{temp}°F는 {converted:.2f}°C입니다.")
        else:
            print("단위는 C 또는 F로 입력해야 합니다.")
    except ValueError:
        print("온도는 숫자로 입력해야 합니다.")
  

문제 3: 예외 처리 응용 문제

사용자로부터 두 개의 정수를 입력받아 나눗셈을 수행하는 프로그램을 작성하세요. 다음 예외를 처리해야 합니다:

• 사용자가 숫자가 아닌 값을 입력할 경우

• 사용자가 두 번째 숫자로 0을 입력할 경우

• 정답:

    try:
        num1 = int(input("첫 번째 정수를 입력하세요: "))
        num2 = int(input("두 번째 정수를 입력하세요: "))
  
        result = num1 / num2
        print(f"{num1} / {num2} = {result}")
  
    except ValueError:
        print("입력값이 정수가 아닙니다. 정수를 입력해주세요.")
    except ZeroDivisionError:
        print("0으로 나눌 수 없습니다. 두 번째 숫자는 0이 아닌 값을 입력해주세요.")
    except:
        print("알 수 없는 오류가 발생했습니다.")
  

문제 4: 함수와 조건문 응용 문제

사용자로부터 세 개의 숫자를 입력받아, 가장 큰 수를 반환하는 함수 find_largest()를 작성하세요. 이 함수를 사용하여 최댓값을 출력하는 프로그램을 작성하세요.

• 정답:

    def find_largest(a, b, c):
        if a >= b and a >= c:
            return a
        elif b >= a and b >= c:
            return b
        else:
            return c
  
    try:
        num1 = float(input("첫 번째 숫자: "))
        num2 = float(input("두 번째 숫자: "))
        num3 = float(input("세 번째 숫자: "))
  
        largest = find_largest(num1, num2, num3)
        print(f"가장 큰 수는 {largest}입니다.")
    except ValueError:
        print("유효한 숫자를 입력해주세요.")
  

문제 5: 모듈 활용 문제

math 모듈을 사용하여 다음 기능을 수행하는 프로그램을 작성하세요:

1. 사용자로부터 원의 반지름을 입력받음
2. 원의 둘레와 면적을 계산하여 출력
3. 반지름을 이용해 구의 표면적과 부피를 계산하여 출력

• 정답:

    import math
  
    def circle_properties(radius):
        circumference = 2 * math.pi * radius
        area = math.pi * radius ** 2
        return circumference, area
  
    def sphere_properties(radius):
        surface_area = 4 * math.pi * radius ** 2
        volume = (4/3) * math.pi * radius ** 3
        return surface_area, volume
  
    try:
        radius = float(input("원의 반지름을 입력하세요: "))
  
        if radius <= 0:
            print("반지름은 양수여야 합니다.")
        else:
            circ, area = circle_properties(radius)
            surf_area, volume = sphere_properties(radius)
  
            print(f"원의 둘레: {circ:.2f}")
            print(f"원의 면적: {area:.2f}")
            print(f"구의 표면적: {surf_area:.2f}")
            print(f"구의 부피: {volume:.2f}")
  
    except ValueError:
        print("유효한 숫자를 입력해주세요.")
  

핵심 개념

1. 파이썬 소개
   • 1991년 귀도 반 로섬이 개발한 대화형 프로그래밍 언어
   • 특징: 생산성이 뛰어남, 문법이 쉬움, 초보자에게 적합, 다양한 플랫폼 지원
2. 파이썬의 장점
   • 문법이 직관적이고 이해하기 쉬움
   • 다양한 환경에서 사용 가능
   • 라이브러리가 풍부함
   • 바로 결과를 확인할 수 있음

II. 변수와 연산자

핵심 개념

1. 변수
   • 정의: 값을 저장하는 공간(메모리)
   • 변수 생성: 변수명 = 값 형태로 할당
   • 변수 작명 규칙:
     • 영문자, 숫자, 언더바(_)로 구성
     • 첫 글자는 숫자 불가
     • 대소문자 구분
     • 중간에 공백 불가
     • 특수문자 불가
   • 낙타체 표기법: 첫 글자는 소문자, 나머지 단어의 첫 글자는 대문자 (예: myNewCar)
2. 상수
   • 변경되지 않는 고정된 값
   • 관례적으로 대문자로 표기 (예: PI = 3.141592)
3. 데이터 타입
   • 정수(int): -2, -1, 0, 1, 2
   • 실수(float): 3.2, 3.14, 0.12
   • 문자열(str): 'Hello World!', "1234"
   • 타입 확인: type() 함수 사용
4. 산술 연산자
   • 덧셈: +
   • 뺄셈: -
   • 곱셈: *
   • 나눗셈(실수형): / (예: 7/4 = 1.75)
   • 나눗셈(정수형): // (예: 7//4 = 1)
   • 나머지: % (예: 7%4 = 3)
   • 거듭제곱: ** (예: 2**3 = 8)
5. 연산자 우선순위
   • 괄호 > 거듭제곱 > 곱셈/나눗셈/나머지 > 덧셈/뺄셈
6. 사용자 입력
   • input() 함수: 문자열 입력
   • 정수 변환: int(input())
   • 실수 변환: float(input())
7. 주석
   • 한 줄 주석: #
   • 여러 줄 주석: ''' 또는 """

III. 조건문

핵심 개념

1. 관계 연산자

   • 동등: ==
   • 같지 않음: !=
   • 크다: >
   • 작다: <
   • 크거나 같다: >=
   • 작거나 같다: <=

2. if 문

   • 기본 구조:

       if 조건:    # 조건이 참일 때 실행할 코드else:    # 조건이 거짓일 때 실행할 코드
     

   • else 부분은 생략 가능

3. 들여쓰기

   • 파이썬에서는 들여쓰기로 코드 블록을 구분
   • 일반적으로 4칸 또는 탭 사용

실습 예제

1. 변수와 연산자

# 변수 사용 예제
width = 10
height = 20
area = width * height
print(area)  # 출력: 200

# 연산자 사용 예제
x = 2.0
y = 3.0 * x**2 + 7.0 * x + 9.0
print(y)  # 출력: 35.0

# 사용자 입력 예제
name = input("What is your name? ")
print("Hello, Mr. ", name)

2. 조건문

# 홀수/짝수 판별
number = int(input("정수를 입력하시오: "))
if (number % 2) == 0:
    print("입력된 정수는 짝수입니다.")
else:
    print("입력된 정수는 홀수입니다.")

# 두 수 중 큰 수 찾기
x = int(input("첫 번째 정수: "))
y = int(input("두 번째 정수: "))
if x > y:
    print("큰 수는", x)
else:
    print("큰 수는", y)

# 할인 금액 계산
sales = int(input("구입 금액을 입력하시오: "))
discount = 0
if sales >= 100000:
    discount = sales * 0.05
print("쇼핑 금액은", sales, "원 입니다.")
print("할인된 금액은", discount, "원 이고,")
print("최종 지불 금액은", sales-discount, "원 입니다.")

예상 문제 및 풀이

객관식 문제

1. 파이썬에서 변수명으로 올바른 것은?

   • a) 1stName

   • b) my-name

   • c) userName

   • d) user@name

   • 답:

     c) userName

2. 다음 중 파이썬의 특징이 아닌 것은?

   • a) 인터프리터 언어이다

   • b) 문법이 복잡하고 이해하기 어렵다

   • c) 다양한 플랫폼에서 사용 가능하다

   • d) 다양한 라이브러리를 제공한다

   • 답:

     b) 문법이 복잡하고 이해하기 어렵다

3. 다음 중 파이썬에서 정수 나눗셈의 결과는?

   • a) 7 / 4 = 1.75

   • b) 7 // 4 = 1

   • c) 7 % 4 = 3

   • d) 7 ** 4 = 2401

   • 답:

     b) 7 // 4 = 1

4. 파이썬에서 주석을 표시하는 방법은?

   • a) // 주석

   • b) /* 주석 */

   • c) # 주석

   • d)

   • 답:

     c) # 주석

5. 파이썬에서 조건문의 올바른 구문은?

   • a) if (condition) { statements }

   • b) if condition: statements

   • c) if condition then statements

   • d) if (condition) statements endif

   • 답:

     b) if condition: statements

주관식 문제

1. 파이썬에서 변수의 타입을 확인하는 함수는?

   답: type()

2. 파이썬에서 사용자로부터 입력을 받는 함수는?

   답: input()

3. 파이썬에서 거듭제곱을 표현하는 연산자는?

   답: **

4. 파이썬에서 들여쓰기의 역할은?

   답: 코드 블록의 구분

5. 파이썬에서 문자열을 정수로 변환하는 함수는?

   답: int()

실습 문제

1. 나이 계산기

   사용자로부터 태어난 연도를 입력받아 현재 나이(2025년 기준)를 계산하는 프로그램을 작성하세요.

    #내 답변
    year = int(input("태어난 연도를 입력하세요.: "))
    age = 2025 - year + 1
    print(age)

    birth_year = int(input("태어난 연도를 입력하세요: "))
    current_year = 2025
    age = current_year - birth_year
    print("당신의 나이는", age, "세입니다.")
   

2. 온도 변환기

   사용자로부터 섭씨 온도를 입력받아 화씨 온도로 변환하는 프로그램을 작성하세요. (화씨 = 섭씨 * 9/5 + 32)

    celsius = float(input("섭씨 온도를 입력하세요: "))
    fahrenheit = celsius * 9/5 + 32
    print("섭씨", celsius, "도는 화씨", fahrenheit, "도입니다.")
   

3. 학점 계산기

   사용자로부터 시험 점수를 입력받아 학점을 출력하는 프로그램을 작성하세요.

   • 90점 이상: A

   • 80점 이상: B

   • 70점 이상: C

   • 60점 이상: D

   • 60점 미만: F

     score = int(input("시험 점수를 입력하세요: "))
     if score >= 90:
       grade = "A"
     elif score >= 80:
       grade = "B"
     elif score >= 70:
       grade = "C"
     elif score >= 60:
       grade = "D"
     else:
       grade = "F"
     print("당신의 학점은", grade, "입니다.")
     

4. 짝수 합 계산기

   사용자로부터 숫자 n을 입력받아 1부터 n까지의 짝수의 합을 계산하는 프로그램을 작성하세요.

    n = int(input("숫자를 입력하세요: "))
    sum_even = 0
    for i in range(2, n+1, 2):
        sum_even += i
    print("1부터", n, "까지의 짝수의 합은", sum_even, "입니다.")
   

5. BMI 계산기

   사용자로부터 키(cm)와 몸무게(kg)를 입력받아 BMI를 계산하고 비만도를 출력하는 프로그램을 작성하세요.

   • BMI = 몸무게(kg) / (키(m) * 키(m))

   • 18.5 미만: 저체중

   • 18.5 이상 23 미만: 정상

   • 23 이상 25 미만: 과체중

   • 25 이상: 비만

     height = float(input("키를 입력하세요(cm): ")) / 100  # cm를 m로 변환
     weight = float(input("몸무게를 입력하세요(kg): "))
     bmi = weight / (height * height)
     print("BMI:", bmi)
     if bmi < 18.5:
       print("저체중")
     elif bmi < 23:
       print("정상")
     elif bmi < 25:
       print("과체중")
     else:
       print("비만")
     

실전 대비 요약 팁

1. 변수와 자료형
   • 변수 생성: 변수명 = 값
   • 자료형: int, float, str
   • 타입 확인: type(변수명)
2. 산술 연산자
   • 기본: +, , , /, //, %
   • 거듭제곱: *
   • 우선순위: 괄호 > 거듭제곱 > 곱셈/나눗셈 > 덧셈/뺄셈
3. 조건문
   • 기본 구조: if 조건: 실행문
   • 관계 연산자: ==, !=, >, <, >=, <=
   • 들여쓰기로 코드 블록 구분
4. 입력과 출력
   • 입력: input("메시지")
   • 형변환: int(), float(), str()
   • 출력: print()
5. 주석
   • 한 줄: #
   • 여러 줄: ''' 또는 """
6. 자주 나오는 실수
   • 들여쓰기 오류: 일관된 들여쓰기 유지
   • 변수명 오류: 변수명 규칙 준수
   • 타입 오류: 적절한 형변환 필요
   • 괄호 오류: 괄호 쌍 맞추기
7. 코드 실행 팁
   • 코드 실행 전 문법 오류 확인
   • 테스트 케이스 활용하여 검증
   • 주석 활용하여 코드 이해도 높이기

• 정의: 서로 다른 데이터형의 변수들을 하나로 묶어서 사용하는 기능
• 목적: 사용자 정의형을 만드는 방법
• 문법:

struct 태그명 {
    데이터형 멤버1;
    데이터형 멤버2;
    ...
};

2. 구조체 정의와 선언

struct content {
    char title[40];
    int price;
    double rate;
};

• 구조체 정의는 함수 밖에서, 소스 파일 시작 부분에 정의
• struct content가 새로운 데이터형이 됨
• 구조체 변수 선언: struct content c1;

3. 구조체 초기화

// 방법 1: 선언과 동시에 초기화
struct content c1 = {"Avengers", 11000, 8.8};

// 방법 2: 부분 초기화 (나머지는 0으로 초기화)
struct content c2 = {"Movie", 5000};

// 방법 3: 구조체 변수 간 초기화
struct content c3 = c1;

4. 구조체 멤버 접근

• 멤버 접근 연산자: . (점 연산자)
• 간접 멤버 접근 연산자: > (화살표 연산자, 포인터용)

c1.price = 10000;        // 점 연산자
ptr->price = 10000;      // 화살표 연산자

5. 구조체 배열

struct content arr[] = {
    {"Movie1", 5000, 7.5},
    {"Movie2", 8000, 8.0},
    {"Movie3", 6000, 6.5}
};

• 배열 원소 접근: arr[i].member

6. 구조체 포인터

struct content* ptr = &c1;
ptr->price = 9000;        // 포인터를 통한 멤버 접근
(*ptr).price = 9000;      // 동일한 표현

• const 포인터: 읽기 전용 접근

7. 함수 매개변수로 구조체 전달

값에 의한 호출 (Call by Value)

void print_content(struct content c);

• 구조체 전체를 복사하여 전달
• 메모리 낭비, 시간 소모 가능

참조에 의한 호출 (Call by Reference) - 권장

void print_content(const struct content* ptr);  // 입력용
void modify_content(struct content* ptr);       // 수정용

8. 중첩 구조체

struct point {
    int x, y;
};
struct line {
    struct point start, end;
};

• 멤버의 멤버 접근: ln.start.x

🎯 예상 문제 및 풀이

【문제 1】 구조체 정의 및 메모리 크기 (10점)

다음 구조체의 메모리 크기를 계산하고, 그 이유를 설명하시오.

struct student {
    char name[20];
    int age;
    double gpa;
};

풀이:

• char name[20]: 20바이트
• int age: 4바이트
• double gpa: 8바이트
• 총 32바이트 (20+4+8)
• 단, 메모리 정렬에 따라 실제 크기는 더 클 수 있음

【문제 2】 구조체 초기화 및 사용 (15점)

다음 코드의 출력 결과를 예측하고, 오류가 있다면 수정하시오.

struct book {
    char title[30];
    int pages;
    double price;
};

int main() {
    struct book b1 = {"C Programming", 500};
    struct book b2;

    b2 = {"Data Structure", 400, 35.5};  // 오류!

    printf("%s %d %.1f\n", b1.title, b1.pages, b1.price);
    return 0;
}

풀이:

• b1 초기화: price는 0.0으로 자동 초기화
• b2 대입문 오류: 선언 후 {}로 직접 대입 불가
• 수정: strcpy(b2.title, "Data Structure"); b2.pages = 400; b2.price = 35.5;
• 출력: C Programming 500 0.0

【문제 3】 구조체 배열 검색 (20점)

학생 정보를 저장하는 구조체 배열에서 특정 학생을 찾는 함수를 작성하시오.

struct student {
    char name[20];
    int id;
    double gpa;
};

// 학번으로 학생을 찾는 함수 (반환: 인덱스, 없으면 -1)
int find_student(const struct student arr[], int size, int target_id);

풀이:

int find_student(const struct student arr[], int size, int target_id) {
    for (int i = 0; i < size; i++) {
        if (arr[i].id == target_id) {
            return i;  // 찾은 학생의 인덱스 반환
        }
    }
    return -1;  // 찾지 못함
}

【문제 4】 구조체 포인터 활용 (15점)

다음 코드의 출력 결과를 예측하시오.

struct point {
    int x, y;
};

int main() {
    struct point p1 = {10, 20};
    struct point* ptr = &p1;

    ptr->x += 5;
    (*ptr).y *= 2;

    printf("%d %d\n", p1.x, p1.y);
    printf("%d %d\n", ptr->x, ptr->y);
    return 0;
}

풀이:

• ptr은 p1을 가리킴
• ptr->x += 5: p1.x = 10 + 5 = 15
• (*ptr).y *= 2: p1.y = 20 * 2 = 40
• 출력: 15 40 (두 번 동일)

【문제 5】 함수 매개변수 전달 방식 (20점)

다음 두 함수의 차이점을 설명하고, 각각 언제 사용해야 하는지 서술하시오.

// 함수 A
void print_book1(struct book b);

// 함수 B
void print_book2(const struct book* b);

풀이:

• 함수 A (값에 의한 호출):
  • 구조체 전체를 복사하여 전달
  • 원본 데이터 안전, 메모리/시간 비효율적
  • 작은 구조체에 적합
• 함수 B (참조에 의한 호출):
  • 구조체 주소만 전달
  • 메모리/시간 효율적, const로 안전성 보장
  • 큰 구조체에 권장

【문제 6】 중첩 구조체 (15점)

다음 구조체에서 사각형의 넓이를 계산하는 함수를 작성하시오.

struct point {
    int x, y;
};

struct rectangle {
    struct point top_left;
    struct point bottom_right;
};

double calc_area(const struct rectangle* rect);

풀이:

double calc_area(const struct rectangle* rect) {
    int width = rect->bottom_right.x - rect->top_left.x;
    int height = rect->top_left.y - rect->bottom_right.y;
    return (double)(width * height);
}

【문제 7】 열거체 활용 (10점)

요일을 나타내는 열거체를 정의하고, 주말인지 평일인지 판단하는 함수를 작성하시오.

풀이:

enum weekday {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
};

int is_weekend(enum weekday day) {
    return (day == SATURDAY || day == SUNDAY);
}

💡 실전 대비 팁

자주 하는 실수들

1. 구조체 사용 시 struct 키워드 누락

    content c1;  // 오류!
    struct content c1;  // 올바름
   

2. 선언 후 {} 직접 대입

    struct book b;
    b = {"Title", 300};  // 오류!
   

3. 구조체 변수 직접 비교

    if (b1 == b2)  // 오류!
    // 멤버별로 비교해야 함
   

4. 배열 멤버 직접 대입

    b1.title = b2.title;  // 오류!
    strcpy(b1.title, b2.title);  // 올바름
   

• 문자: 하나의 문자 ('A', '\n') - 단일 인용부호 사용
• 문자열: 연속된 문자들의 모임 ("hello") - 이중 인용부호 사용
• 널 종료 문자열: 문자열 끝에 널 문자(\0) 저장

2. 문자 배열 선언 및 초기화

char str1[10] = "abc";        // 크기 10, "abc" + 널 문자
char str2[] = "hello";        // 크기 자동 할당 (6개)
char str3[10] = "";           // 모든 원소를 널 문자로 초기화

⚠️ 중요 포인트:

• 배열 크기 = 문자열 길이 + 1 (널 문자 포함)
• 초기화 시 문자열이 배열보다 길면 오류 발생

3. 표준 C 문자열 처리 함수 (<string.h>)

함수	기능	사용법
strlen()	문자열 길이 (널 문자 제외)	int len = strlen(str);
strcpy()	문자열 복사	strcpy(dest, src);
strcmp()	문자열 비교	int result = strcmp(s1, s2);
strcat()	문자열 연결	strcat(dest, src);
strchr()	문자 검색	char* p = strchr(str, 'c');
strstr()	문자열 검색	char* p = strstr(str, "sub");
strtok()	토큰 분리	char* token = strtok(str, "-");

4. 문자열 포인터

char* p = "hello";           // 문자열 리터럴을 가리킴 (읽기 전용)
const char* cp = "world";    // 읽기 전용 포인터 (권장)
char str[] = "test";
char* p2 = str;              // 수정 가능한 문자 배열을 가리킴

5. 2차원 문자 배열 vs 문자열 포인터 배열

// 2차원 문자 배열 (수정 가능)
char books[3][20] = {"book1", "book2", "book3"};

// 문자열 포인터 배열 (읽기 전용)
const char* menu[] = {"File", "Edit", "View"};

🔥 시험 출제 포인트

1. 버퍼 오버런 문제

• strcpy(), strcat() 함수의 안전성 문제
• _CRT_SECURE_NO_WARNINGS 매크로 사용법
• 안전한 함수: strcpy_s(), strcat_s()

2. 문자열 비교

// ❌ 잘못된 방법
if (str1 == str2)  // 주소 비교

// ✅ 올바른 방법
if (strcmp(str1, str2) == 0)  // 내용 비교

3. strtok() 함수 사용법//외워!!!!!!!!!!!

char str[] = "010-123-4567";
char* token = strtok(str, "-");  // 첫 번째 토큰
while (token != NULL) {
    printf("%s\n", token);
    token = strtok(NULL, "-");   // 다음 토큰
}

📝 예상 문제 & 해답

문제 1: 기본 개념 (객관식)

다음 중 올바른 문자 배열 선언은?

1. char str[5] = "hello";
2. char str[6] = "hello";
3. char str[] = "hello";
4. 2번과 3번 모두

정답: 4번

• "hello"는 5글자 + 널 문자 = 6바이트 필요
• 3번은 자동으로 크기 6으로 할당됨

문제 2: 코드 분석 (주관식)

#include <stdio.h>
#include <string.h>

int main(void) {
    char str1[10] = "abc";
    char str2[10] = "xyz";
    char temp[10];

    strcpy(temp, str1);
    strcpy(str1, str2);
    strcpy(str2, temp);

    printf("str1: %s, str2: %s\n", str1, str2);
    return 0;
}

출력 결과는?

정답: str1: xyz, str2: abc

• 두 문자열을 교환하는 코드

문제 3: 문자열 길이 (주관식)

char str[] = "Hello\nWorld";
int len = strlen(str);

변수 len의 값은?

정답: 11

• \n은 하나의 문자로 취급
• 널 문자는 길이에 포함되지 않음

문제 4: 포인터와 배열 (주관식)

char str[] = "programming";
char* p = str + 3;
printf("%c\n", *p);
printf("%s\n", p);

출력 결과는?

정답:

g
gramming

문제 5: 문자열 검색 (코딩)

다음 함수를 완성하시오. 문자열에서 특정 문자의 개수를 세는 함수이다.

int count_char(const char* str, char ch) {
    int count = 0;
    // 여기를 완성하시오
    return count;
}

정답:

int count_char(const char* str, char ch) {
    int count = 0;
    while (*str != '\0') {
        if (*str == ch)
            count++;
        str++;
    }
    return count;
}

문제 6: strtok 활용 (코딩)

이메일 주소 "user@domain.com"에서 사용자명과 도메인을 분리하는 코드를 작성하시오.

정답:

#include <stdio.h>
#include <string.h>

int main(void) {
    char email[] = "user@domain.com";
    char* user = strtok(email, "@");
    char* domain = strtok(NULL, "@");

    printf("사용자명: %s\n", user);
    printf("도메인: %s\n", domain);
    return 0;
}

🎯 실전 대비 체크리스트

✅ 암기해야 할 것들

• 주요 문자열 함수들의 반환 타입과 매개변수
• strcmp() 함수의 반환값 (0: 같음, 양수: 첫 번째가 큰 경우, 음수: 두 번째가 큰 경우)
• 문자 상수 vs 문자열 상수 표기법
• 포인터 산술 연산 규칙

✅ 실수하기 쉬운 부분

• 문자열 비교 시 == 대신 strcmp() 사용
• 배열 크기 계산 시 널 문자 고려
• strtok() 사용 후 원본 문자열 변경됨 주의
• 문자열 리터럴은 수정 불가능

✅ 코딩 문제 대비

• 문자열 뒤집기 함수 작성
• 회문(palindrome) 검사 함수
• 문자열에서 공백 제거 함수
• 문자열 분할 및 조합 문제

🔧 디버깅 팁

1. 세그멘테이션 오류 방지
   • 배열 경계 확인
   • 널 포인터 체크
   • 문자열 끝 널 문자 확인
2. 메모리 관리
   • 동적 할당된 문자열의 해제
   • 스택 오버플로우 방지
3. 컴파일러 경고 주의
   • 문자열 관련 보안 경고
   • 타입 불일치 경고

📖 마지막 점검 문제

종합 문제: 단어 카운터 프로그램

사용자로부터 문장을 입력받아 단어의 개수를 세는 프로그램을 작성하시오. (단어는 공백으로 구분됨)

해답:

#include <stdio.h>
#include <string.h>
#include <ctype.h>

int count_words(const char* sentence) {
    int count = 0;
    int in_word = 0;

    while (*sentence) {
        if (isspace(*sentence)) {
            in_word = 0;
        } else if (!in_word) {
            in_word = 1;
            count++;
        }
        sentence++;
    }
    return count;
}

int main(void) {
    char sentence[100];
    printf("문장을 입력하세요: ");
    fgets(sentence, sizeof(sentence), stdin);

    printf("단어 개수: %d\n", count_words(sentence));
    return 0;
}