포스트

정보처리기사 실기 / Vi - 프로그래밍 언어 활용 ☆☆☆

게시
Preview Image
By Jeremiah Lee 39 분 : 읽는 시간

실기 시험 준비

수제비 2023 참조




C1. 프로그래밍을 위한 기본 사항


i. 진수

  • 특정 개수의 숫자만을 이용하여 수를 나타내는 수 체계

A. 진수 변환

  • 10진수를 n진수로 변환
    • 10진수 값을 몫이 n보다 작을 때까지 n으로 나누고 나머지 값들을 표시한 후 나머지 값들을 읽음
1
2
3
4
5
6

ex) 10진수 13을 2진수로 변환
13을 2로 나누면 몫은 6, 나머지는 1
6을 2로 나누면 몫은 3, 나머지는 0
3을 2로 나누면 몫은 1, 나머지는 1

13의 2진수는 1101
  • n진수를 10진수로 변환
    • n진수에서 마지막 자리는 자리 숫자에 자릿값인 n^0을 곱하고, 이후부터 n^n 곱하고 자리 숫자와 자릿값을 더해 10진수로 변환
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

ex) 2진수 1101을 10진수로 변환
2의 n[자리수]승
1101 = 2^3 + 2^2 + 2^1 + 2^0 = 13

ex) 16진수 C9를 10진수로 변환
C9 = (C * 16^1) + (9 * 16^0) = (12 * 16) + (9 * 1) = 201

16진수 표기법
10진수  |   16진수
0~9    |    0~9
10     |    A
11     |    B
12     |    C
13     |    D
14     |    E
15     |    F



B. 아스키 코드

  • 미국 ANSI에서 표준화한 정보교환용 부호체계
1
2
3
4
5
6

아스키 코드 (10진수)
0 = NULL
32 = ' ' (Space)
48 = 0 ~
65 = A ~
97 = a ~





C2. C언어


i. C언어 기본

  • 본문 전에 처리하는 전처리 부분과 본문으로 구성
  • 헤더는 xxx.h 파일, 헤더 = 라이브러리

A. 전처리기

  • 실행 파일을 생성하는 과정에서 소스 파일 내에 존재하는 전처리 지시문을 처리하는 작업
  • #include : 헤더 파일을 포함할 때 사용하는 전처리기
  • #define : 매크로를 정의할 때 사용하는 전처리기, 상숫값을 지정하기 위한 예약어로 구문의 상수로 치환
1
2
3
4
5
6
7
8
9

#include <stdio.h>
#define A 5

int main() {
  printf("문자열 %d", A);
  return 0;
}

// 출력 : 문자열 5




ii. 자료형

  • 실숫값, 정숫값과 같은 여러 종류의 데이터를 식별하는 형태
  • 문자 : char
  • 정수 : int
  • 부동 소수점 : float, double




iii. 식별자

  • 변수, 상수, 함수 등 서로 구분하기 위해 사용되는 이름
  • 언더바(_), 대문자/소문자 가능 // 첫 자리 숫자, 예약어 불가

A. 식별자 표기법

  • 카멜 표기법 : inputFunction
  • 파스칼 표기법 : InputFunction
  • 스네이크 표기법 : input_Function
  • 헝가리안 표기법 : nScore (두어에 자료형 붙임 / int = n, char = c, String = sz)




iV. 변수

  • 저장하고자 하는 어떠한 값이 있을 때, 그 값을 주기억장치에 기억하기 위한 공간

A. 변수 선언

  • 변수나 함수가 있음을 알려주는 행위
  • 초기화하지 않는 경우 : int a;
  • 초기화하는 경우 : int a = 1;



B. 변수 유효범위

1. 전역 변수

  • 어떤 블록에도 속하지 않는 변수


2. 지역 변수

  • 블록 내에서 선언하는 변수
1
2
3
4
5

#includ <stdio.h>
int a = 5; // 전역 변수
void main() {
  b = 4; // 지역 변수
}


3. static 변수

  • 블록 내외부 상관없이 선언 가능
  • static 키워드 붙음
  • static = 프로그램 시작 시 생성, 종료 시 소멸 (생명주기 동안 고정)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

#includ <stdio.h>
void fn() {
  static int a = 3;
  a = a + 1;
  printf("%d\n", a);
}
void main() {
  fn();
  fn();
}

// 출력 : 
// 4
// 5




V. 표준 입출력 함수

A. printf

  • 지정된 포맷 스트링으로 데이터 출력

1. 단순 출력

  • printf(“문자열”)


2. 이스케이프 문자를 이용한 출력

  • \n : 개행
  • \t : 탭


3. 포맷 스트링을 이용한 변수 출력

  • %c : Character
  • %s : String
  • %u : 부호 없는 10진수 정수
  • %d : 10진수 정수
  • %o : 8진수 정수
  • %x : 16진수 정수(소문자)
  • %X : 16진수 정수(대문자)
  • %e : 지수 표기 (소문자)
  • %E : 지수 표기 (대문자)
  • %f : 부동 소수점 표기
  • %lf : 부동 소수점 표기 (Long 큰 수)


4. 포맷 스트링을 이용한 변수 상세 출력

  • printf(%[-][0][전체자리수][소수자리수]문자열)
  • - : 붙으면 왼쪽 정렬 / 붙지 않으면 [전체자리수] 있는 경우 오른쪽 정렬
  • 0 : 붙으면 전체 자릿수에서 앞의 빈공간 만큼 0으로 채움
  • 전체자리수 : 만큼 공간 확보, 점도 한 자릿수
  • 소수점자리수 : 만큼 소수점 출력, 실수형일 경우만
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#includ <stdio.h>
void main() {
  float a = 1.234;
  int b = 10;
  
  printf("%.2f\n", a);
  printf("%05.1f\n", a);
  printf("%-05.1f\n", a);
  printf("%05d\n", b);
  printf("%-5d\n", b);
  printf("%-05d\n", b);
}

// 출력
// 1.23
// 001.2
// 1.2
// 00010
// 10
// 10


5. scanf

  • scanf(포맷_스트링_문자열, 변수_주솟값);
1
2
3
4
5
6
7
8
9
10
11
12

#includ <stdio.h>
void main() {
  int a;
  char b;
  scanf("%d %c", &a, &b);
  printf("%d, %c", a, b);
}

// 입력
// 1 B
// 출력
// 1 B




Vi. 연산자

A. 연산자 우선순위

  • 단항 > 이항 > 삼항 > 대입
  • 증감 > 산술 > 시프트 > 관계 > 비트 > 논리 > 삼항 > 대입
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 연산자 우선순위 위에서 아래로 (생략 포함)
x++
++x
!
~
*
/
%
+
-
<<
>>
<
<=
>
>=
==
!=
&
^
|
&&
||
? a:b
=
+=
-=
*=
/=
%=

1. 증감 연산자

1
2
3
4
5
6
7
8
9
10
11

#includ <stdio.h>
void main() {
  int x = 3, y = 3;
  printf("%d", x++);
  printf("%d", x);
  printf("%d", ++y);
  printf("%d", y);
}

// 출력
// 3444


2. 시프트 연산자

  • « : 왼쪽 값을 오른쪽 값만큼 비트를 왼쪽으로 이동
  • » : 왼쪽 값에 오른쪽 값만큼의 부호 비트를 채우면서 오른쪽으로 이동
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#includ <stdio.h>
void main() {
  int x = 11;
  printf("%d", x<<3);
  printf(" %d", x>>1);
}

// 출력
// 88 5

// 해석
/* 
* x<<3
* 11을 2진수로 변환 = 1011
* 왼쪽으로 3비트 이동 = 1011000
* 1011000을 다시 10진수로 변환 = 2^6 + 2^4 + 2^3 = 88
*/

/*
* x>>1
* 11을 2진수로 변환 = 1011
* 오른쪽으로 1비트 이동 = 101
* 101을 다시 10진수로 변환 = 2^2 + 1 = 5
*/


3. 비트 연산자

  • ^ : (XOR) 두 값을 비트로 연산하여 같은 비트의 값이 서로 다르면 해당 비트 값이 1이 되고, 그렇지 않으면 0이 되는 연산자
  • ~ : (NOT) 모든 비트의 값을 반대로 바꾸는 반전 기능 (복잡하기 때문에 (부호를_반대로_바꾼_값) - 1 로 계산)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#includ <stdio.h>
void main() {
  printf("%d", 12 ^ 10);
  printf(" %d", ~12);
}

// 출력
// 6 -13

//해석
/*
* 12 ^ 10
* 12를 2진수로 변환 = 1100 / 10을 2진수로 변환 = 1010
* 1 1 0 0
* 1 0 1 0
* -------
* 0 1 1 0
* 110을 다시 10진수로 변환 = 6
*/

/*
* ~12
* 부호를_반대로_바꾼_값 - 1
* -12 - 1 = -13
*/




Vii. 조건문

A. switch 문

  • break가 없는 경우, 진입한 case부터 break를 만날 때 까지 모든 문장 실행
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#includ <stdio.h>
void main() {
  int score = 101;
  switch(score/10) {
    case 10 :
    case 9 :
      printf("A"); 
    case 8 :
      printf("B");
      break; 
    default :   
      printf("F");
  }
}

// 출력
// AB
// case 10 진입, break 없음
// case 9 진입, "A" 출력, break 없음
// case 8 진입, "B" 출력, break




Viii. 반복문

A. do while 문

  • 무조건 한 번은 실행, 그 다음부터 조건이 참인 경우
1
2
3
4
5
6
7
8
9
10
11
12
13

#include <studio.h>
void main() {
  int i = 1, sum = 0;
  do {
    sum += i;
    i++;
  } while(i < 0);
  printf("%d\n", sum);
}

// 출력
// 1
// 최초 1회 실행 : sum = 1 / 이후 조건 false -> 종료



B. continue

  • 마주치면 바로 다음 반복으로
1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>
void main() {
  int i = 1;
  while(i < 5) {
    i++;
    if(i == 3)
      continue;
    printf("%d ", i);
  }
  printf("%d ", i);
}

// 출력
// 2 4 5 5




iX. 배열

  • C언어는 변수에 [크기]
  • int a[3] = {1, 2};
  • 2차원 배열의 경우, 초기화 되지 않은 인덱스는 초기 값으로 / 이외는 순차적으로 할당
1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 2차원 배열 예시
#include <stdio.h>
void main() {
  int a[2][3] = {1,2,3,4}
  int i, j;
  for(i = 0; i < 2; i++) {
    for(int j = 0; j < 3; j++) {
      printf("%d ", a[i][j]);
    }
  }
}

// 출력
// 1 2 3 4 0 0




X. 문자열

  • c언어에서 문자열 배열은 char 타입으로
  • 문자열 초기화 시 마지막에 NULL 삽입됨, 글자수보다 1 이상 큰 값으로 배열 선언
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <stdio.h>
void main() {
  char a[8] = "Hello";
  printf("%s\n", a);
  printf("%s\n", a+1);
  a[3] = NULL;
  printf("%s\n", a+1);
  printf("%s\n", a+4);
}

// 출력
// Hello
// ello
// el
// o
// 포인터인 경우 해당 인덱스부터 null 직전까지

// 2차원 배열 예시
#include <stdio.h>
void main() {
  char a[2][8] = {"Hello", "soojebi"};
  printf("%s\n", a[0]);
  printf("%s\n", a[1]);
  printf("%s\n", a[1] + 3);
  a[1][4] = NULL;
  printf("%s\n", a[1] + 2);
}

// 출력
// Hello
// soojebi
// jebi
// oj




Xi. 구조체

  • 기본 자료형을 가지고 새롭게 정의할 수 있는 사용자 정의 자료형 (= 객체)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>
struct Student {
  char gender;
  int age;
};
void main() {
  struct Student s = {'F', 21};
  s.gender = 'M';
  printf("%c", s.gender);
  printf("%d", s.age);
}

// 출력
// M21




Xii. 함수

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 매개변수 전달 방법 중 주소값 전달 예시
#include <stdio.h>
void fn(int* m) {
  *m = 7;
}
void main() {
  int n = 5;
  fn(&n);
  printf("%d", n);
}

// 출력
// 7

// 해설
/*
* n = 5로 초기화
* fn 함수에 n의 주소값을 전달
* fn 함수가 m이라는 이름으로 주소값을 받아옴
* m의 주소값에 7 할당 -> 주소값에 할당 = 메모리에 할당
* m의 주소값 = n의 주소값 / 즉, n의 주소에 7을 할당함
* n은 7이기 때문에 출력하면 7
*/

A. 표준 함수

1. 문자열 함수

  • strcat(dest, src) : src를 dest 뒤에 붙임
  • strncat(dest, src, maxlen) : src를 maxlen 만큼 dest 뒤에 붙임
  • strcpy(dest, src) : src를 dest에 복사
  • strncpy(dest, src, maxlen) : src를 maxlen 만큼 dest에 복사 (기존 문자 대체)
  • strcmp(s1, s2) : s1, s2 대소 비교 (각 인덱스를 ASKII로 비교)
  • strncmp(s1, s2, maxlen) : maxlen 만큼 s1, s2 대소 비교 (각 인덱스를 ASKII로 비교)
  • strlen(s) : s의 길이 리턴
  • strrev(str) : str 리버스
  • strchr(str, c) : str 내에 c의 존재 여부 (가장 처음 마주치면 리턴)


2. 수학 함수

  • sqrt(n) : n의 제곱근
  • ceil(n) : 소수점 올림
  • floor(n) : 소수점 내림


3. 유틸리티 함수

  • rand() : 임의의 정숫값 1개 생성
  • strand(seed) : seed 값에 따라 난수 발생기 초기화
  • time(NULL) : 1970년 1월 1일 0시 0분 0초(UTC(유닉스 시간의 시작점))부터 현재까지를 초단위로 리턴
  • atoi(str) : 문자열을 정수형으로 변환
  • atof(str) : 문자열을 실수형으로 변환
  • itoa(value, str, radix) : value를 변환하여 str에 radix 진수로 저장




Xiii. 포인터

  • 변수의 주솟값을 저장하는 공간
  • 주소에 해당하는 값을 가리키는 * 연산과 변수에 주솟값을 나타내는 & 연산은 반대 기능
  • *(&)의 경우 상쇄됨
  • int* b = &a;
1
2
3
4
5
6
7
8
9
10

#include <stdio.h>
void main() {
  int a = 10;
  int* b = &a;
  printf("%d %d %d", a, *b, *(&a));
}

// 출력
// 10 10 10
// *(&a) = a

A. 배열과 포인터

  • 배열의 i번째 주소 = 배열+i == &배열[i];
  • 배열의 i번째 값 = *(배열+i) == 배열[i];
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// 1차원 배열
#include <stdio.h>
void main() {
  int a[3] = {1,2};
  int *p = a+1;
  printf("%d %d %d\n", a[0], a[1], a[2]);
  printf("%d %d %d\n", *a, *(a+1), *(a+2));
  printf("%d %d %d\n", *p, *(p+1), *(p+2));
  printf("%d %d %d\n", p[0], p[1], p[2]);
}

// 출력
// 1 2 0
// 1 2 0
// 1 2 0
// 1 2 0
// *p는 a의 0번째 인덱스 주솟값을 가짐
// *p가 a+1인 경우 p 포인터 출력 값은
// 2 0 213064192
// 2 0 213064192
// 이렇게 변경됨 (3번째 값은 무시)

// 2차원 배열
#include <stdio.h>
void main() {
  int a[3][2] = ((1,2), (3,4), (5,6)); // jekyll 빌드 문제로 중괄호를 소괄호로 변경함
  int *p = a[1];
  printf("%d %d %d\n", *a[0], *a[1], *a[2]);
  printf("%d %d %d\n", **a, **(a+1), **(a+2));
  printf("%d %d\n", *p, *(p+1));
  printf("%d %d\n", p[0], p[1]);
}

// 출력
// 1 3 5
// 1 3 5
// 3 4
// 3 4
// *p는 a[1][0]의 주솟값
// 참고로 **a 와 같은 연산은 *(&a[0]) 과 같기 때문에 결과적으로 a[0]이 되고 a[0]은 a[0][0] 이기 때문에 1



B. 구조체와 포인터

  • 일반 구조체 변수로 접근은 .
  • 구조체 포인터로 접근 시 ->
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <stdio.h>
struct Student {
  char gender;
  int age;
};
void main() {
  struct Student s = {'F', 21};
  struct Student *p = &s;
  printf("%c %d\n", s.gender, s.age);
  printf("%c %d\n", (&s)->gender), (&s)->age);
  printf("%c %d\n", p->gender, p->age);
  printf("%c %d\n", (*p).gender, (*p).age);
  printf("%c %d\n", p[0].gender, p[0].age);
}

// 출력
// F 21
// F 21
// F 21
// F 21
// F 21
// *p = p[0]

// 1차원 구조체 배열, 1차원 구조체 포인터 예시
s[3] = {'F', 21, 'M', 20, 'M', 24} 의 경우
p[0] = {'F', 21}
p[1] = {'M', 20}
p[2] = {'M', 24}



C. 함수 포인터

  • 리턴타입 (*함수_포인터)(함수 파라미터);
  • 함수의 주소 저장, 해당 주소의 함수 호출
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <stdio.h>
void fn1() {
  printf("fn1 함수\n");
}
int fn2(int a) {
  printf("fn2 함수: %d\n", a);
  return 0;
}
void main() {
  void (*pf1)(); // 함수 포인터 선언만
  int (*pf2)(int); // 함수 포인터 선언만
  fn1();
  fn2(5);
  pf1 = fn1;
  pf2 = fn2;
  pf1();
  pf2(2);
}

// 출력
// fn1 함수
// fn2 함수: 5
// fn1 함수
// fn2 함수: 2





C3. 자바


i. 자바 기본 구조

  • 모든 소스 코드는 클래스 단위




ii. 자료형

  • 정수형 : byte, short, int, long
  • 부동 소수점형 : float, double




iii. 변수

  • static : 프로그램이 시작되면 생성, 종료되면 소멸




iV. 배열

  • 자료형 []배열명 < 자료형과 배열명 사이에만 있음 됨
  • 자료형 배열명[] < C언어 스타일 (되긴 함)




V. 표준입출력 함수




Vi. 연산자

  • 문자열과 정수 혹은 실수를 더하면 문자열




Vii. 반복문 for each 문




Viii. 메서드

  • static : (메서드에서) 인스턴스 생성 없이 호출 가능
  • 프로그램의 생명 주기 동안 생성되어 있기 때문




iX. 클래스

  • 생성자 : 클래스의 객체가 생성될 때 자동으로 호출되는 특수 메서드
  • 인스턴스화 시 생성자 호출됨 (생성자 로직있음 실행됨)


X. 클래스 상속

  • 하위 클래스 생성 시 상위 클래스 생성자 실행 후 하위 클래스 생성자 실행
  • 오버로딩 : 메서드의 이름을 동일하게 매개변수만 변경
  • 오버라이딩 : (상속 관계에서) 상위 클래스의 메서드를 하위 클래스에서 재정의, 이름, 매개변수, 리턴 타입 같아야함




Xi. 추상 클래스

  • 추상 메서드 한 개 이상 보유, 하위 클래스에서 해당 추상 메서드 구현
  • 일반 메서드 정의 가능




Xii. 인터페이스

  • 추상 메서드와 상수만 보유




Xiii. 스레드

  • 프로세스보다 가벼운, 독립적으로 수행되는 순차적인 제어의 흐름, 실행 단위

A. 스레드 구현

1. Thread 클래스 상속

  • Tread 클래스 상속 받고, run() 메서드에 스레드 동작 시 수행할 코드 작성 (run 메서드 오버라이딩)
  • 자바는 단일 상속만 가능함, Thread 클래스 상속 시 타 상속 제한
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Main extends Thread {
  public static void main(String[] args) {
    Thread t1 = new Main();
    Thread t2 = new Thread(new Main());
    Thread t3 = new Thread(new Main());

    t1.start();
    t2.start();
    t3.start();
  }
  public void run() {
    System.out.println("a");
    System.out.println("b");
    System.out.println("c");
  }
}

// 출력 : 실행 시 마다 바뀜 (병렬 동작하기 때문)


2. Runnable 인터페이스 상속

  • Runnable 인터페이스 상속 받고, run() 메서드에 동작 코드 작성
  • 다른 클래스를 상속받으면서 스레드 기능 구현 가능, 인터페이스라 유연함
1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Main implements Runnable {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Main());
        Thread t2 = new Thread(new Main());

        t1.start();
        t2.start();
    }
    public void run() {
        System.out.println("a");
        System.out.println("b");
        System.out.println("c");
    }
}




XiV. 컬렉션

  • Collection
    • List : 순서 O, 중복 O
      • LinkedList
      • Stack : LIFO
      • Vector : 동기화 보장
      • ArrayList : 동기화 보장 하지 않음
    • Set : 순서 X, 중복 X
      • HashSet
      • SortedSet
        • TreeSet
  • Map : 키 : 값, 키 중복 X
    • Hashtable
    • HashMap
    • SortedMap
      • TreeMap

1. TreeSet 메서드

  • headSet(값) : 값보다 작은 객체 반환
  • tailSet(값) : 값보다 큰 객체 반환




XV. 예외 처리

1
2
3
4
5
6
7
8

try {
    t1.start();
    t2.start();
} catch (Exception e) {
    System.out.println(e.getMessage());
} finally {
    System.out.println("asd");
}





C4. 파이썬


i. 파이썬 기본 구조

  • 파이썬은 함수, 클래스가 먼저 정의되고 그 다음 실행 코드가 나옴
  • 세미콜론으로 마치지 않고 들여쓰기로 파악함
  • 파이썬 주석은 # 처리
1
2
3
4
5
6
7
8
9
10
11
12

def fn(num);
  if num % 2 == 0:
    return 'Y'
    
class A:
  def fn(self):
    print('A')
    
print('Hello')

# 출력
# Hello




ii. 자료형

  • 기본 자료형
    • 숫자형 : int, float
    • 논리형 : True, False
  • 컬렉션 자료형
    • 시퀀스 자료형 : 순서 O
      • 문자열형 : String
        • isalnum() : 문자열이 알파벳 또는 숫자로만 True / 아니면 False
        • isdemical() : 정수 여부
      • 리스트형 : List
        • index(x) : x 값의 인덱스 리턴
        • remove(x) : x 값을 제거 (인덱스 아님)
      • 튜플형 : Tuple / 초기에 선언된 값에서 CUD 불가
    • 비시퀀스 자료형 : 순서 X
      • 딕셔너리형 : Dictionary (자바의 hashMap = 키:값)
      • 세트형 : Set : 중복 X
        • update([값1, 값2, 값3]) : 여러 값을 한번에 추가
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

# 시퀀스 자료형

# 문자열
a = "soojebi"
print("%s" % a)
b = "%s" % " world"
print(a + b)
c = 123
print("%s %d" % (a, c))

# 출력
# soojebi
# soojebi world
# soojebi 123


# 리스트
a = [10, 20, 30]
print(a)
a.extend(a)
print(a)
a.pop()
print(a)
a.reverse()
print(a)

# 출력
# [10, 20, 30]
# [10, 20, 30, 10, 20, 30]
# [10, 20, 30, 10, 20]
# [20, 10, 30, 20, 10]

# 2차원 생성시
a = [[1,2], [3,4], [5,6]]


# 튜플
t = ('1', '2', '3')
print(t)

# 출력
// ('1','2','3')

# 시퀀스 자료형 인덱스 접근 시 (튜플 포함) = 인덱싱
a = [1,2,3,4]
a[0]
a[1] = a[-3]
a[2] = a[-2]
a[3] = a[-1]

# 시퀀스 자료형 동시 접근 시 (튜플 포함) = 슬라이싱
# 문자열
# 시퀀스변수명[시작:종료] (생략 시 1)
"slice"[1:] // lice
"slice"[2:4] // ic
"slice"[:3] // sli
# 리스트
# 시퀀스변수명[시작:종료:개수] (생략 시 1)
a = [1,2,3,4,5]
a[0 : 4 : 2] // [1, 3]
# 튜플
t = ('a', 'b', 'c')
t[1:] // ('b', 'c')

1
2
3
4
5
6
7
8
9
10
11

# 비시퀀스 자료형

# set
s = {1, 2, 3}

# dictionary
d = {'A':5, 'B':4}
#요소 추가
d['C'] = 7 // {'A':5, 'B':4, 'C':7}
# 요소 제거
del d['A'] // {'B':4, 'C':7}

A. 자료형 함수

  • type(값) // 출력 = <class ‘타입’>
  • len(값) // 길이 출력 (컬렉션 자료형 전부 해당)




iii. 입출력

A. 표준 출력 함수 (print)

  • print(문자열) = 자바 println
  • print(문자열, end=’’) = 자바 print
1
2
3
4
5
6
7
8

a = 5
print(a)
b = 3
print('a=', a, 'b=', b)

# 출력
# 5
# a= 5 b= 3



B. 표준 입력 함수 (input)

  • 변수명 = input() // 문자열
  • 변수명 = input() 변수명 = eval(변수명) // 숫자
1
2
3
4
5
6
7

# 문자 입력
a = input()

# 숫자 입력
a = input()
a = eval(a)
# eval() = 문자 -> 숫자 변환 함수




iV. 연산자

  • 파이썬은 ++, – 증감 연산자가 없음

A. 연산자 종류

1. Swap 연산자

  • 두 변수의 값을 교환하는 연산자
  • 콤마를 기준으로 두 값을 교환
1
2

a, b = 1, 10
a, b = b, a


2. 산술 연산자

  • // : 나눈 뒤 몫 출력
  • ** : 지수 연산


3. 비교 연산자

  • == : 결과 참인 경우 True 출력, 아닌 경우 False 출력
  • C는 1, 0으로 자바는 true, false로 출력되나 파이썬은 True, False임 (맨 앞 대문자 조심)


4. 대입 연산자

  • 추가적으로 지원하는 연산자만
  • **== : 왼쪽 변수 값을 오른쪽 수로 제곱한 후 왼쪽 변수에 재할당
  • //== : 왼쪽 변수 값을 오른쪽 수로 나눈 후 몫을 왼쪽 변수에 재할당




V. 조건문 - if 문

  • else if 가 아니라 파이썬에서는 elif 임
  • 콜론(‘:’) 조심
1
2
3
4
5
6
7
8
9
10
11

a = input()
score = eval(a)

if score >= 80:
    print("A")
elif score >= 70:
    print("B")
elif score >= 60:
    print("C")
else:
    print("F")




Vi. 반복문

A. while

  • while 조건문 뒤에 반드시 콜론(‘:’)
1
2
3
4
5
6

i = 0
sum = 0
while i < 4:
    i += 1
    sum += i
print(sum)



B. for

  • for 변수 뒤에 in 뒤에 range 함수 사용
  • for 변수 in range(시작, 종료, 스텝):
  • for each 문 : for 변수 in 시퀀스자료형:
1
2
3
4
5
6
7
8
9
10
11
12
13

# 일반 for문
i = 0
sum = 0
for i in range(1, 5):
    sum += i
print(sum)

# for each문
t = (1,2,3)
sum = 0
for i in t:
    sum += i
print(sum)




Vii. 함수

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def 함수명(변수명, ...):
  명령어
  return 반환값
  
def fn(num):
    for i in range(1, 10):
        num += i
    return num
print(fn(10))

// 디폴트 매개변수 사용
def fn(num = 10):
    for i in range(1, 10):
        num += i
    return num
print(fn())

A. 람다 함수

  • map(함수, 리스트) : 리스트 요소를 함수에 전달하여 반복 수행
  • filter(함수, 리스트) : 리스트 요소를 함수에 전달하여 조건이 참인 값을 리턴
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# 람다 함수
# (lambda 매개변수 : 표현식)(매개변수)
(lambda n, m : n + m)(2, 3)


# 사용자 정의 함수로 람다 함수 구현
def fn(n):
    return lambda a:a*n
k = fn(3)
print(k(10))
# 해석
# k = lambda a:a*3
# k(10) = a = 10
# 즉, lambda 10 * 3


# 내장 함수를 이용한 람다 함수 구현

# map 함수
a = [1,2,3,4,5]
m = list(map(lambda num : num + 100, a))
print(m)
# 해석
# num = a
# map 함수로 반복하면서 a 리스트의 값을 +100
# a 리스트의 각 값에 100을 더한 결과 = m
# m = [101,102,103,104,105]

# filter 함수
a = [1,2,3,4,5]
m = list(filter(lambda num : num > 3, a))
print(m)
# 해석은 위와 같음
# num에 a의 각 요소 대입
# 요소가 3 보다 큰 경우만 list 삽입
# m = [4,5]




Viii. 예외처리

  • 파이썬은 throw 대신 raise 사용
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

try:
  명령문
except 예외명1:
  명령문
finally:
  명령문

try:
  명령문
except 예외명1:
  명령문
except 예외명2:
  명령문
else:
  명령문




iX. 클래스

  • 클래스 내부의 메서드의 경우 무조건 첫번째 매개변수가 self 키워드여야함
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class S:
    def setS(self, a):
        self.a = a
    def getS(self):
        return self.a
a = S()
a.setS(5)
print(a.getS())

# 생성자
# def __init__(self)
# 소멸자
# def __del__(self)
class S:
    def __init__(self):
        print("Constructor")
    def __del__(self):
        print("Destructor")
    def fn(self):
        print("Method")
a = S()
a.fn()
del a

A. 접근 제어자

  • 키워드 없음
  • 작명법으로 제어
  • public = 암것도 안함
  • protected = _ 접두
  • private = __ 접두
1
2
3
4
5
6

# public
classA
# protected
_classA
# private
__classA




X. 클래스 상속

  • 오버로딩 없음
1
2
3
4
5
6
7
8
9
10
11
12
13

class 상위_클래스명:
...
class 하위_클래스명(상위_클래스명):

class A:
    def fnA(self):
        print('A')
class B(A):
    def fnB(self):
        print('B')
b = B()
b.fnA()
b.fnB()

A. 오버라이딩

  • 메서드 이름 같음, 매개변수 같음, 타입 같음
  • 다른 언어와 마찬가지로 상위 클래스에 super 키워드로 접근
1
2
3
4
5
6
7
8
9
10
11
12
13

class A:
    def fn(self):
        print('A')
class B(A):
    def fn(self):
        super().fn()
        print('B')
b = B()
b.fn()

// 출력
// A
// B




대망의 언어 과목이다.
알고 있는 내용을 제외하고 작성했다.

그나마 자바를 알고 있기 때문에 C 언어는 포인터 개념만 이해하면 나머지는 비슷해서 다행이었다.

그래도 약간씩 문법이 다르기 때문에 조심하자.

의외로 제일 어려웠던 건 파이썬이었다.
파이썬이 가장 난이도가 쉬운 언어라고는 들었는데, 오히려 지식의 저주가 걸려서
자바와 문법이 완전 다른 것 때문에 엄청 헤맸다.

진짜 다행인 건 파이썬 문제가 비율이 적다는 것…
솔직히 자바 문제가 절반 이상이었으면 좋겠지만 아마 C가 그럴 것이다.

여튼 파이썬은 문법 자체가 생소해서 좀 어려웠고 컬렉션도 좀 어지럽다.

일단 C에서는 포인터 조심하고, 자바에서도 오버라이딩, 오버로딩 헷갈리지 말자.

이제 남은 기간 동안 암기와 SQL, 언어 기출 문제 풀이로 준비하자.


참고로 언어 기출을 좀 풀어봤는데,
4중 반복문 같은 패턴을 찾지 못하면 아예 못 풀겠는 문제를 제외하고는 대부분 뭔가 개념적인 걸 묻는 문제였다.

혹은 간단한 산술 문제거나

그런 걸로 봤을 때 패턴을 못 찾겠으면 다음 문제로 넘어가는 게 맞다고 생각한다.

정보처리기사, 실기
자격증
이 블로그는 저작권자의 CC BY 4.0 라이센스를 따릅니다.