04. 파이썬
1. 파이썬 기본 구조
- 파이썬은 사용자 정의 함수, 클래스가 먼저 정의 된 후에 실행 코드가 나옴
- 가독성을 위해 들여쓰기 실행
- def 키워드로 시작되는 명령어 : 사용자 정의 함수
- class 키워드로 시작되는 명령어 : 클래스
- 사용자 정의 함수와 클래스를 제거했을 때 남아있는 명령어들을 순차적으로 실행
def fn(num):
if num % 2 == 0:
return 'Y'
class A:
def fn(self):
print('A')
print('Hello')
# Hello- def 뒤의 fn은 사용자 정의 함수
- class 뒤의 A는 클래스 A
- print('Hello') 구문에 의해 Hello 출력
파이썬의 들여쓰기
들여쓰기가 강제되어 기본 구조 코드에서
def fn(num): 안에 들여쓰기 된 명령어
if num % 2 ==0 과 return 'Y'는 사용자 정의 함수 fn에 속한 명령어이다
def fn(self)와 print('A') 또한 클래스 A에 속한 명령어이다
2. 자료형
(1) 자료형 유형
- 기본 자료형 (Primitive Data Type)
: 직접 자료를 표현하는 자료형
ex ) 숫자형 (Number), 논리형 (Logical)
- 컬렉션 자료형 (Collection Data Type)
: 다수의 데이터를 효과적으로 처리할 수 있는 자료형
ex ) 문자열형(String), 리스트형 (List), 튜플형(Tuple), 딕셔너리형(Dictionary), 세트형(Set)
(2) 기본 자료형 (Primitive Data Type)
- 직접 자료를 표현하는 자료형
- 숫자형, 논리형이 있음
1. 숫자형 (Number)
: 숫자를 저장하고자 할 때 사용하는 자료형
ex. 정수형(int), 실수형(float)
2. 논리형 (Logical; Boolean)
: 변수의 참, 거짓을 나타낼 때 사용하는 자료형
ex. True(참), False(거짓)
# 파이썬 기본 자료형
print(31+2.7)
print(True)
# 33.7
# True- 정수 31과 실수 2.7을 더한 31+2.7=33.7 출력
- 참값인 논리형 True 출력
- 자바와의 차이점
자바는 참과 거짓을 나타낼 때 모두 **소문자** : true/false
파이썬은 첫글자는 **대문자** : True/False
(3) 컬렉션 자료형 (Collection Data Type)
- 컬렉션 자료형은 시퀀스 자료형 / 비시퀀스 자료형이 있음
- 시퀀스 자료형 : 문자열형, 리스트형, 튜플형
- 비시퀀스 자료형 : 세트형, 딕셔너리형
- 시퀀스 자료형 : 순서 있음
- 비시퀀스 자료형 : 순서 없음
- 시퀀스 자료형
1. 문자열형 (String) : 문자 한 개 또는 여러 개 저장할 때 사용하는 자료형
ex. s='Hoxypot'
2. 리스트형 (List) : 크기가 **가변적**으로 변하는 **선형리스트**의 성질을 가지는 자료형, 읽기/쓰기 모두 가능
ex. l=[1, 2, 3]
3. 튜플형 (Tuple) : 초기 선언된 값으로 값 생성, **수정 불가**한 자료형, 읽기 전용으로 속도가 빠름
ex. t=(1, 2, 3)
- 비시퀀스 자료형
1. 세트형 (Set) : **중복**된 원소 **허용하지 않는** 집합의 성질 자료형
ex. s={1, 2, 3}
2. 딕셔너리형 (Dictionary) : **키와 값**으로 구성된 객체를 저장하는 구조로 된 자료형
ex. d={'s':1 , 'j':2 , 'b':3}
- Set 자료형
파이썬의 세트형은 자바 Set 클래스 (HashSet)와 유사
- 리스트 자료형
파이썬 리스트형은 자바 List 클래스 (ArrayList, LinkedList) 와 유사
- 딕셔너리 자료형
파이썬 딕셔너리형은 자바 Map 클래스 (HashMap)와 유사
[1] 시퀀스 자료형 구조
- 시퀀스 자료형은 순서가 존재하는 자료형, ** 순서가 중요 **
- 문자열형, 리스트형, 튜플형 존재
- 시퀀스 자료형 종류
1. 문자열형
: 문자 한 개 또는 여러 개 저장할 때 쓰는 자료형
# 파이썬 문자열형 출력
print('Hoxypot')
print('Hoxypot', 'World')
print('\"Hoxypot\"')
print('Hoxypot'*3)
# Hoxypot
# Hoxypot World
# "Hoxypot"
# HoxypotHoxypotHoxypot- 문자열 Hoxypot 출력
- 문자열 Hoxypot과 문자열 World를 합쳐 Hoxypot world 출력
- 큰 따옴표 (")를 포함하여 문자열 "Hoxypot" 출력
- 문자열 Hoxypot에 3을 곱하면 해당 문자열 3번 출력 > HoxypotHoxypotHoxypot
- print 안 ' , '
파이썬은 print문 안 문자열이 콤마(,)로 구분될 경우, **자동 띄어쓰기**
ex. print('Hoxypot', 'World') > Hoxypot World
- print 문 속 '￦' 기호
파이썬 문자열은 큰 따옴표 (")를 사용하여 표현하므로 print 문 안에 큰 따옴표를 넣고 싶은 경우, C언어와 같이 이스케이프 문자(￦)를 사용
ex. print('\"') > "
- 문자열 곱하기
문자열에 곱하기를 하면 곱한 수 만큼 문자열이 반복 출력됨
- 파이썬 문자열은 **포맷스트링** 이용 문자열 출력 가능
# 파이썬 문자열 포맷스트링 출력
a='hoxypot'
print('%s' %a)
b='%s' %'world'
print(a+b)
c=123
print('%s %d %(a,c))
# hoxypot
# hoxypot world
# hoxypot 123- a 변수에 문자열 'hoxypot' 대입 > 포맷 스트링 %s에 a 문자열 변수 전달하여 'hoxypot' 출력
- b 변수에 포맷 스트링 %s에 문자열 'world' 넣은 값 전달하여 대입 > 문자열 변수 a와 b 연결한 'hoxypot world' 출력
- c 변수에 정수 123 대입 > %s에는 a 값인 'hoxypot'과 %d 에는 c 변수 123 매핑되어 출력 > 'hoxypot 123'
파이썬 출력 시, 괄호 포함 여부
- 컬렉션 자료형 변수 그냥 출력 시, 괄호 표시
- 문자열 변수 출력 시, 괄호 표기 X
- 파이썬 문자열 중 'in' 연산자 이용 문자열 검색 가능 ▷ 존재 시 True, 없으면 False 리턴
# 파이썬 문자열 in
print('hello' in 'hello world')
print('hoxypot' in 'hello world')
# True
# False- 'hello world' 문자열 내에 'hello' 가 존재하므로 참 값인 True 출력
- 'hello world' 문자열 내에 'hoxypot' 은 없으므로 거짓 값인 False 출력
- 문자열 관련 메서드
1. upper( ) : 문자열을 대문자로 변환하는 메서드
2. lower ( ) : 문자열을 소문자로 변환하는 메서드
3. isalnum ( ) : 문자열이 알파벳 또는 숫자로만 구성되어 있으면 True, 아니면 False 리턴
4. isalpha ( ) : 문자열이 알파벳으로만 구성되어 있으면 True, 아니면 False 리턴
5. isdecimal ( ) : 문자열이 정수이면 True, 아니면 False 리턴
6. isdigit ( ) : 문자열이 숫자이면 True, 아니면 False 리턴
7. isspace ( ) : 문자열이 공백으로만 구성되어 있으면 True, 아니면 False 리턴
8. split ( ) : 매개변수로 전달된 **구분자**로 문자열을 나누어 **리스트**로 변환하는 메서드
→ sep = 구분자 (기본값 ' ')
# 파이썬 문자열(str) 메서드
a='Hoxypot 123'
print(a.upper())
print(a.lower())
print(a.isalnum())
print(a.isalpha())
print(a.isdecimal())
print(a.isdigit())
print(a.isspace())
print(a.split())
print(a.split(sep='1'))
str='1,2,3'.split(',')
print(str)
# HOXYPOT 123
# hoxypot 123
# False ## 공백도 있으므로 True가 아닌 False임
# False
# False
# False
# False
# ['Hoxypot', '123']
# ['Hoxypot','23']
# ['1','2','3']- a 변수에 문자열 'Hoxypot 123' 대입
- a 문자열 값 대문자 전환 > 'HOXYPOT 123'
- a 문자열 값 소문자 전환 > 'hoxypot 123'
- isalnum 메서드를 통해 a 문자열이 알파벳과 숫자로만 이루어져있는지 확인 > a 문자열은 알파벳, 공백, 숫자로 이루어져있으므로 False
- isalpha 메서드를 통해 a 문자열이 알파벳으로만 이루어졌는지 확인 > 아니므로 False
- isdecimal 메서드로 a 문자열 정수인지 확인 > False
- isdigit 메서드로 a 문자열 숫자인지 확인 > False
- isspace 메서드로 a 문자열 공백으로만 구성되었는지 확인 > 아니므로 False
- split() 메서드로 문자열 분리해주는데 기본 구분자는 ' ' 공백이므로 'Hoxypot', '123'으로 분리해주고 리스트로 변환
- split( ) 메서드를 적용하되 구분자로 문자열 '1'을 선언 > 1을 기준으로 분리 'Hoxypot', '23'
- 문자열 '1,2,3'에서 구분자를 ','로 하여 분리 > '1', '2', '3' 분리한 값 리스트에 넣어줌
2. 리스트형 (List)
: 크기가 가변적으로 변하는 선형리스트 성질 가지는 자료형
[, ] 이용 리스트형 선언
리스트명 = [요소1, 요소2, ....]
- 리스트형 메서드
1. append(x) : 리스트 마지막 요소 뒤에 값 x 추가하는 메서드
2. clear( ) : 리스트 모든 항목 삭제
3. copy( ) : 리스트 복사하는 메서드
4. count(x) : 리스트 내 x 항목 개수 세는 메서드
5. extend(i) : 리스트 마지막에 컬렉션 자료형 i 추가하는 메서드
6. index(x) : 리스트 내 값 x가 있는 인덱스 번호 알려주는 메서드
7. insert(i, x) : 리스트 i 번째 위치에 값 x 삽입하는 메서드
8. pop( ) : 리스트 마지막 항목 삭제하고 값 꺼내오는 메서드
9. remove(x) : 리스트 내 값 x 삭제하는 메서드, 여러 개 있으면 가장 앞에 있는 것만 제거
10. reverse( ) : 리스트 전체를 역순으로 전환하는 메서드
11. sort ( ) : 리스트 항목 정렬해주는 메서드
# 파이썬 리스트형 메서드
a=[20, 10, 30]
print(a)
a.extend(a)
print(a)
a.pop()
print(a)
a.reverse()
print(a)
# [20,10,30]
# [20, 10, 30, 20, 10, 30]
# [20, 10, 30, 20, 10]
# [10, 20, 30, 10, 20]
- 리스트 a 선언 > [20, 10, 30] 대입 > a 출력 [10, 20, 30]
- 리스트 a 마지막에 리스트 a 추가 > [20, 10, 30, 20, 10, 30] 출력
- 리스트 a 마지막에 있는 요소 꺼내서 삭제 후 출력 > [20, 10, 30, 20, 10]
- 리스트 a 역순으로 전환 > [10, 20, 30, 10, 20]
- append, index 메서드 이용하여 리스트에 값 추가하고 remove 메서드 이용하여 삭제
# 파이썬 리스트형 메서드
l=[3, 5, 7]
l.append(3)
print(l)
l.insert(2,4)
print(l)
l.remove(3)
print(l)
# [3, 5, 7, 3]
# [3, 5, 4, 7, 3]
# [5, 4, 7, 3]- l 변수에 [3, 5, 7] 리스트 대입
- append 메서드로 리스트 마지막에 3 추가 > [3, 5, 7, 3]
- insert 메서드로 리스트 2번 인덱스 값에 4 추가 > [3, 5, 4, 7, 3]
- remove 메서드로 리스트 내에 있는 3 값 제거 > 3이 2개이므로 맨 앞에 있는 값 제거 > [5, 4, 7, 3]
- 2차원 리스트도 가능, 리스트 요소인 '[' 와 ']' 사이에 '[' 와 ']'를 중첩해서 제작
# 파이썬 2차원 리스트
a=[[1, 2], [3, 4], [5, 6]]
print(a)
print(a[0])
print(a[1][0])
b=[[1,2,3], [4,5], [6,7,8,9]]
print(b[0)]
# [[1,2], [3,4], [5,6]]
# [1,2]
# 3
# [1,2,3]- 변수 a에 2차원 리스트 선언 > [[1,2], [3,4], [5,6]]
- 그대로 출력
- 2차원 리스트 a의 0번째 인덱스 값 출력 > a[0]=[1,2]
- 2차원 리스트 a의 1번째 인덱스 값(리스트) 에서 0번째 인덱스 값 출력 > a[1]=[3,4] > a[1][0]=3
- 변수 b에 2차원 리스트 선언 > [[1,2,3], [4,5], [6,7,8,9]]
- 2차원 리스트 b의 0번째 인덱스 값 출력 > b[0] = [1,2,3]
3. 튜플형 (Tuple)
- 초기에 선언된 값에서 값의 생성, 삭제, 수정이 불가능한 자료형
- '(, )' 를 이용하여 튜플 선언
튜플명 = (요소1, 요소1, ...)
# 파이썬 튜플
t=('h','x','p')
print(t)
# ('h','x','p')- 변수 t에 튜플 대입 > ('h', 'x', 'p')
- 튜플 변수 t 출력 > ('h','x','p')
- 시퀀스 자료형 요소 접근 방법 - 인덱싱(Indexing)
- 인덱싱은 시퀀스 자료형에서 특정 요소에 접근하는 방식
시퀀스 자료형이 'n'개 값을 가질 때 인덱스
| 첫 번째 요소 | 두 번째 요소 | ... | 뒤에서 두번째 요소 | 뒤에서 첫 번째 요소 |
| 0 | 1 | ... | (n-2) | (n-1) |
| -n | -(n-1) | ... | -2 | -1 |
ex. a=[4, 2, 7, 3, 5], 요소 개수 5개
| 4 | 2 | 7 | 3 | 5 |
| a[0] | a[1] | a[2] | a[3] | a[4] |
| a[-5] | a[-4] | a[-3] | a[-2] | a[-1] |
- 인덱싱은 문자열, 리스트와 같은 자료구조에서 사용
- 문자열 인덱싱은 문자열에 부여된 번호로 원하는 문자 가리킬 때 사용
- 문자열 앞에서부터 인덱스는 0으로 시작, 뒤에서부터 시작 시 -1로 시작
# 파이썬 문자열 인덱싱
print('hoxypot'[3])
print('hoxypot'[-7])
str='hoxypot'
print(str[1])
# y
# h
# o- 문자열 hoxypot에서 3번 인덱스에 있는 값 출력 > 즉, 4번째 값 y
- 문자열 hoxypot에서 뒤에서부터 시작하여 7번째 인덱스 값 출력 > 즉, 뒤에서 7번째 값인 h
- 변수 str에 문자열 'hoxypot' 대입 > 문자열 변수 str의 1번 인덱스 값 출력 > 즉, 앞에서 2번째 값 o
- 튜플 요소 접근을 위해서도 인덱싱 사용
# 파이썬 튜플 인덱싱
t= ('h', 'x', 'p')
print(t[0])
# h- 변수 t에 튜플 ('h', 'x', 'p') 대입 > 튜플 t의 0번 인덱스 값 출력 > 즉, 앞에서 첫번째 값 h
- 시퀀스 자료형 요소 접근 방법 - 슬라이싱(Slicing)
- 시퀀스 자료형에서 여러 개 데이터에 동시에 접근하는 기법
시퀀스변수명[시작 : 종료 : 스텝]
시작
- 슬라이싱 시작할 인덱스 번호
- 생략할 경우, 처음부터 슬라이싱 (ex. 시퀀스변수명[ : 종료], 시퀀스변수명[ : 종료 : 스텝])
종료
- 슬라이싱 종료할 인덱스 번호
- 종료 인덱스의 **전 인덱스**까지 슬라이싱
- 생략할 경우, 마지막까지 슬라이싱 (ex. 시퀀스변수명[시작: ], 시퀀스변수명[시작: : 스텝])
스텝
- 몇 개씩 끊어 슬라이싱 할 지 결정하는 값
- 생략할 경우, 1이 기본값 (ex. 시퀀스변수명 [시작 : 종료], 시퀀스변수명 [시작 : 종료 : ] )
① 문자열 슬라이싱
: 문자열의 부분 문자열 추출
# 파이썬 문자열 슬라이싱
print('hoxypot'[1:])
print('hoxypot'[2:4])
print('hoxypot'[:3])
# oxypot
# xy
# hox- hoxypot 문자열에서 1번 인덱스부터 끝까지 접근 > 'oxypot'
- hoxypot 문자열에서 2번 인덱스부터 4번 인덱스 전인 3번 까지 접근 > 'xy'
- hoxypot 문자열에서 처음부터 3번 인덱스 전인 2번 까지 접근 > 'hox'
슬라이싱 괄호 여부
슬라이싱 출력은 괄호가 표시되지만, 문자열 슬라이싱은 다른 시퀀스 자료형과 달리 출력에 괄호 표시 X
② 리스트 슬라이싱
: 리스트 원하는 부분 추출
# 파이썬 리스트 슬라이싱
a=[4, 2, 7, 3, 5]
print(a[0: 4: 2]
# [4, 7]- 변수 a에 리스트 [4, 2, 7, 3 5] 대입
- 리스트 0번 인덱스부터 4번 인덱스 전인 3번 인덱스까지 2개씩 끊어서 슬라이싱 > [4, 7]
③ 튜플 슬라이싱
: 튜플 원하는 부분 추출
# 파이썬 튜플 예제
t= ('h', 'x', 'p')
print(t[1:])
# ('x', 'p')- 변수 t에 튜플 대입 > ('h', 'x', 'p')
- 변수 t의 1번 인덱스부터 끝까지 추출 > 즉, 2번째 값부터 끝까지 ('x', 'p')
- **슬라이싱**은 출력 시, **괄호** 포함
- 시퀀스 자료형 연산자
- 연결, 반복 연산자
1. '+' : 두 시퀀스 자료형을 연결하는 연산자
2. '*' : 시퀀스 자료형을 반복하는 연산자
# 리스트 연결, 반복 연산자
a=[1,2,3]
b=[4,5,6]
print(a+b)
print(a*3)
# [1,2,3,4,5,6]
# [1,2,3,1,2,3,1,2,3]- 변수 a에 리스트 [1,2,3] 대입
- 변수 b에 리스트 [4,5,6] 대입
- '+'연산자 이용하여 리스트 a와 리스트 b 연결 > [1,2,3,4,5,6]
- '*' 연산자 이용하여 리스트 a 3번 반복 > [1,2,3,1,2,3,1,2,3]
- in, not in 연산자
자료형 내부에 특정 값이 있는지 확인하기 위해 활용
1. in : 리스트 내부에 특정 값이 존재하는지 확인
2. not in : 리스트 내부에 특정 값이 없는지 확인
# 리스트 in, not in 연산자
a=[1,2,3,4,5]
1 in a
7 in a
8 not in a
# True
# False
# True- 변수 a에 리스트 [1,2,3,4,5] 대입
- 리스트 a에 1이 있는가 > 있으므로 True
- 리스트 a에 7이 있는가 > 없으므로 False
- 리스트 a에 8이 없는가 > 없으므로 False
[2] 비시퀀스 자료형 구조
- 순서가 존재하지 않는 자료형
1. 세트형 (Set)
- 중복된 원소를 허용하지 않는 집합 성질의 자료형
- 'set' 키워드로 세트형을 초기화하거나 {, } 이용 세트형 선언
세트명=set{[요소1, 요소2, ...]}
세트명= {요소1, 요소2, ...}
- 세트형 메서드
1. add(값) : 값을 1개 추가하는 메서드
2. update([값1, 값2, ...]) : 여러 개 값을 한번에 추가하는 메서드
3. remove(값) : 특정 값을 제거하는 메서드
# 파이썬 세트형
s={1, 5, 7}
s.add(3)
print(s)
s.add(5)
print(s)
s.update([1,2,3,4])
print(s)
s.remove(1)
print(s)
# {1,3,5,7}
# {1,3,5,7}
# {1,2,3,4,5,7}
# {2,3,4,5,7}- 변수 s에 세트형 {1, 5, 7} 대입
- 세트 s에 3 추가 > {1,3,5,7}
- 세트 s에 5 추가 > 5는 s에 이미 있는 값이므로 세트는 중복이 안 되기 때문에 변형 없음 > {1,3,5,7}
- 세트 s에 [1, 2, 3, 4] 한 번에 추가 > s에 1, 3 은 이미 있는 값이므로 2와 4만 추가 > {1,2,3,4,5,7}
- 세트 s에 1 값 제거 > {2, 3, 4, 5, 7}
2. 딕셔너리형 (Dictionary)
- 키와 값으로 구성된 객체를 저장하는 구조
- 딕셔너리형 요소 생성/ 변경/ 삭제
① 생성 ( 딕셔너리명={키1:값1, 키2:값2, ....} )
: {, } 안에 콜론(:)을 이용하여 키와 값을 구분해서 선언
② 변경 ( 딕셔너리명[키]= 값 )
: 기존 변수에 키와 값 추가 or 기존 변수에 해당 키 값 있으면 값 변경
③ 삭제 ( del 딕셔너리명[키] )
: 기존 변수에 해당 키와 키에 해당하는 값 삭제
# 파이썬 딕셔너리형
d={'A':5, 'C':4}
print(d)
d['K']=7
print(d)
del d['C']
print(d)
d['K']=6
print(d)
# {'A':5, 'C':4}
# {'A':5, 'C':4, 'K'=7}
# {'A':5, 'K'=7}
# {'A':5, 'K'=6}- 변수 d에 딕셔너리 {'A':5, 'C':4} 선언 > 키가 'A'일 때 값 5, 키가 'C'일 때 값 4
- 딕셔너리 d에 키를 'K'로 하고 값을 7로 하는 값 추가 > d에 키 'K'가 없으므로 추가 > {'A':5, 'C':4, 'K':7}
- 딕셔너리 d에 키를 'C'로 하는 값 삭제 > {'A':5, 'K':7}
- 딕셔너리 d에 키를 'K'로 하고 값을 6으로 하는 값 추가 > d에 이미 키 'K'가 있으므로 값만 변경 > {'A':5, 'K':6}
(5) 자료형 함수
[1] type 함수
- 자료형 확인하는 함수
| 유형 | 세부 유형 | 출력 |
| 기본 자료형 (Primitive Data Type) |
정수형 (integer) | <class 'int'> |
| 실수형 (Floating Point) | <class 'float'> | |
| 논리형 (Logical) | <class 'bool'> | |
| 컬렉션 자료형 (Collection Data Type) |
문자열형(String) | <class 'str'> |
| 리스트형(List) | <class 'list'> | |
| 튜플형(Tuple) | <class 'tuple'> | |
| 딕셔너리형(Dictionary) | <class 'dict'> | |
| 세트형(Set) | <class 'set'> |
# 파이썬 type 함수 자료형 확인
print(type(31))
print(type(2.7))
print(type(True))
print(type('Hoxypot'))
print(type([1,2,3])
print(type((1,2,3))
print(type({1,2,3})
print(type({'h':1, 'x':2, 'p':3}))
# <class 'int'>
# <class 'float'>
# <class 'bool'>
# <class 'str'>
# <class 'list'>
# <class 'tuple'>
# <class 'set'>
# <class 'dictionary'>- 31은 정수형이므로 int
- 2.7은 실수형이므로 float
- True는 참/거짓 값을 나타내는 bool
- 'Hoxypot'은 문자열이므로 str
- [1,2,3]은 [ ] 로 묶인 list
- (1,2,3)은 ( )로 묶인 tuple
- {1,2,3}은 { } 로 묶인 set
- {'h':1, 'x':2, 'p':3} 은 { } 로 묶이고 키와 값을 가지는 dictionary
[2] len 함수
- 컬렉션 자료형 크기를 계산하는 함수
# 파이썬 len 함수
print(len('Hoxypot'))
print(len([1,2,3])
print(len((1,2,3))
print(len({1,2,3})
print(len({'h':1, 'x':2, 'p':3})
# 7
# 3
# 3
# 3
# 3- 'Hoxypot' 문자열 길이는 7
- 리스트 요소가 3개이므로 3
- 튜플 요소 3개이므로 3
- set 요소 3개이므로 3
- 딕셔너리 요소 3개이므로 3
'WorkOut > 정보처리기사' 카테고리의 다른 글
| 파이썬 | 함수와 클래스 (4) | 2024.03.29 |
|---|---|
| 파이썬 | 입출력 함수와 연산자, 반복문 (0) | 2024.03.26 |
| 자바 | 메서드와 클래스, 인터페이스 (0) | 2024.03.23 |
| 자바 | 자료형, 변수, 배열, 표준 입출력 함수, 문자열, 반복문 (0) | 2024.03.21 |
| C언어 | 포인터 (0) | 2024.03.19 |
