Hello PYTHON 기초 문법;

주석

코드를 작성할 때 사용자가 쓰는 메모 때문에 컴퓨터에는 전달되지 않는다.
코드를 임시로 작동하도록 꺼 두기 위해서도 사용한다.

주석의 종류
한 줄 주석 : #
- 한 줄 주석은 #(샵 기호) 뒤에 쓴다. # 뒤의 문장 전체가 주석처리 되어 출력되지 않는다.
여러 줄 주석 : ''' ~ ''' """ ~ """
- 여러 줄 주석은 3개의 따옴표 사이에 들어간 모든 문장을 주석처리 한다.

#이 아래 줄은 주석처리 되었기 때문에 실행되지 않습니다.
#print('너는 누구니?')

"""
여러줄을
한 번에
주석처리할 때는 이렇게 따옴표 3개로 
내용을 감싸준다.
"""

들여쓰기

파이썬에서는 들여쓰기 규칙을 사용하며, 들여쓰기 규칙을 지키지 못하면 에러가 발생한다.
들여쓰기는 포함 관계를 나타낸다.
가장 바깥쪽에 있는 코드는 공백 없이 시작한다.
내부 블록은 같은 수의 공백을 사용하지 않으면 에러가 발생한다.

# 들여쓰기 규칙을 지켰을 때
print('A')
print('A')
print('A')

# 들여쓰기 규칙을 어겼을 때
print('A')
 print('A') # err가 난다.
print('A')

변수

프로그램을 작성할 때 필요한 데이터를 저장하는 그릇으로 담아둔 값을 바꿀 수 있고,
필요할 때마다 가져와 사용할 수도 있다.

변수 사용 시 주의사항
첫 글자는 영문 혹은 _(underscore)로 시작한다.
영문자, 숫자, _(underscore)만으로 구성되며, 대소문자를 구분해서 사용한다.
파이썬에서 이미 다른 용도로 사용되고 있는 예약어(for, if 등)는 변수명으로 사용할 수 없다.

identity = '지구인' # 변수의 이름을 가지고 그 값을 불러와서 사용할 수 있다.
# 다음 두 코드는 같은 결과를 출력한다.
print('안녕 나는','지구인','이야')
print('안녕 나는',identity,'이야')

표준 입출력

표준 출력 : print()

• 문자열 출력 시에는 따옴표와 함께 사용한다.
• 출력 대상이 1개 일 때 : print(‘출력 문구’)
• 출력 대상이 여러 개일 때 : print(‘A’, ‘B’, ‘C’)
• 줄 바꿈을 없애고 싶을 때는 end=' ' 사용한다.
• 문자에도 +, * 연산 사용 가능하다.
• \n \t \' \" 등의 확장 문자를 활용한다.

표준 입력 : input()

• 사용자가 입력한 값을 반환합니다.
• 반환된 값은 주로 변수에 담아 사용합니다.
• 사용자가 숫자를 입력하더라도 문자열 형태로 입력 받습니다.
• 입력 받은 문자열을 숫자로 사용하기 위해서는 형 변환이 필요합니다. ex) int( ), float( ) 등

name = input('당신의 이름은?')
print(name + '님 반가워요!')

str1 = input('1번 단어 입력:') # hello
str2 = input('2번 단어 입력:') # hi
print(str1, str2) # hello hi
print(str2, str1) # hi hello

age = int(input('나이 입력:')) # 20 # 정수로 입력된다.
print('당신의 10년 뒤 나이')
print(age + 10) # 30

height = float(input('키 입력:')) # 실수로 입력된다.
weight = float(input('몸무게 입력:'))
print('당신의 비만도 W/(H*H)*10000')
print(weight/(height*height)*10000)

자료형

자료형은 파이썬에서 데이터를 다룰 때 데이터의 종류를 의미한다.
변수를 만들 때 사용자가 자료형을 결정하지 않아도 파이썬 내부에서 자료형을 판단하여 적용한다.
자료형 확인은 type( ) 함수로 알 수 있고, 필요에 따라 자료형을 변경할 수 있다.

숫자형
a + b (더하기)
a - b (빼기)
a * b (곡하기)
a / b (나누기)
a // b (a를 b로 나눈 몫(정수))
a % b (a를 b로 나눈 나머지)
a ** b (a의 b 제곱)

# 정수형 자료형과 정수형 자료형의 연산
a=10
b=5

print(a+b) 15
print(a-b) 5
print(a*b) 50
print(a/b) 2.0
print(a//b) 2
print(a%b) 0
print(a**b) 100000

# 정수형 자료형과 실수형 자료형의 연산
b=5
c=2.0

print(b+c) 7.0
print(b-c) 3.0
print(b*c) 10.0
print(b/c) 2.5
print(b//c) 2.0
print(b%c) 1.0
print(b**c) 25.0

# 실수형 자료형과 실수형 자료형의 연산
c=2.0
d=0.5

print(d+c) 2.5
print(d-c) -1.5
print(d*c) 1.0
print(d/c) 0.25
print(d//c) 0.0
print(d%c) 0.5
print(d**c) 0.25

논리형
참과 거짓을 나타내는 자료형으로 비교&논리 연산자로 만들어지며, 조건문에 많이 활용된다.

비교 연산자
< (작다)
<= (작거나 같다)
> (크다)
>= (크거나 같다)
== (같다)
!= (같지 않다)

논리 연산자
x or y (x나 y 둘 중 하나만 참이면 참)
x and y (x, y 모두 참이어야 참)
not x (x가 참이면 거짓, x가 거짓이면 참)

x=10
y=-10

print(x>0) # True
print(y>0) # False
print()
print(x>y) # True
print(x<y) # False
print()
print(x==10) # True
print(x==y) # False
print(x!=y) # True
print()
print(x>0 or y>0) # True
print(x>0 and y>0) # False
print()
print(x>0) # True
print(not x>0) # False

문자열형
다른 언어와 달리 문자와 문자열을 따로 구분하지 않는다.
''또는 ""에 감싸져 있다.
'로 감싼 문자열 안에는 "를 쓸 수 있다.
"로 감싼 문자열 안에는 '를 쓸 수 있다.
연산이 불가능하다.(예외 : 문자 + 문자, 문자 * 정수)

string1 = '따옴표로 싼 문자열 안에는 큰따옴표(")를 사용할 수 있다.'
string2 = "큰따옴표로 싼 문자열 안에는 따옴표(')를 사용할 수 있다."
string3 = """줄도 바꾸고
큰따옴표"와 따옴표'를 마음대로 쓸 수 있다."""

# 자료형 연산
a=5
b='5'
c=5.0

print(a+a) # int + int # 10
print()
print(b+b) # str + str # 55
print(a*b) # int * str # 55555

# 자료형 연산 err 예시
a=5
b='5'
c=5.0

print(a+b) #int + str err 발생
print(b+c) #str * float err 발생

# 따옴표 사용 err 예시
print(‘안녕하세요”) # err 발생
print(“안녕하세요’) # err 발생

자료형 변환
파이썬은 사용자가 자료형을 결정하지 않기 때문에 편리하기도 하지만 데이터가 사용자의 의도와 다른 자료형이 될 수도 있다. 이때는 각 데이터들의 자료형을 원하는 것으로 변경해야 한다. ex) input() 사용, 정수와 실수의 사용 등
자료형 변환(typecasting)방법 : 원하는 자료형 함수에 값을 넣는다. ex) str(10), int('10'), int(12.5), list('hello') 등

# input()으로 숫자 입력받기
a = input('숫자를 입력하세요') # 숫자를 입력해도 숫자가 아닌 문자열 출력
print(a+a) 

숫자를 입력하세요9
99

# int(input())으로 숫자 입력받기
a = int(input('숫자를 입력하세요')) 
print(a+a) 

숫자를 입력하세요9
18

# 자료형 변환과 type() 함수
a=input('숫자 하나 입력')
b=int(a)
c=float(a)

print(type(a))
print(type(b))
print(type(c))

숫자 하나 입력7
<class 'str'>
<class 'int'>
<class 'float'>

숫자 입력&출력

# 한 줄에 하나씩 숫자 입력받기
a=int(input('a입력:')) # 만약에 int()로 감싸지 않으면 문자열로 처리된다.
b=int(input('b입력:'))
c=int(input('c입력:'))
print(a,b,c,a+b+c)

a입력:3
b입력:6
c입력:9
3 6 9 18

a=input('a입력:')
b=input('b입력:')
c=input('c입력:')
print(a,b,c,a+b+c)

a입력:3
b입력:6
c입력:9
3 6 9 369


# 한 줄에 여러 개의 숫자 입력받기
a,b,c = map(int,input('a b c값 입력').split())
print(a,b,c,a+b+c)

a b c값 입력 3 6 9
3 6 9 18

# 문자1.split(문자2) : 문자2를 기준으로 문자1을 자르기
# split() 메서드 안에 지정한 문자열을 기준으로 문자열을 자른다.
# split() 메서드 안에 지정한 문자열이 공백이면 공백을 기준으로 문자열을 자른다.
 
# split() 메서드
text = input('날짜 입력 yyyy.mm.dd')
y,m,d = text.split('.')
print(text, y, m, d)

날짜 입력 yyyy.mm.dd2020.02.29
2020.02.29 2020 02 29

# map(함수, 집합 형태-iterable객체)
# map() 함수의 첫 번째 인자는 함수, 두 번째 인자는 집합 형태가 들어간다.
# 예를 들어 [‘1’,‘2’,‘3’]에서 ‘1’을 꺼내서 int 함수를 적용하고, ‘2’를 꺼내서 int 함수를 적용하고,
# ‘3’을 꺼내서 int 함수를 적용한다. 각각 1, 2, 3을 a, b, c 변수에 대입한다.

# map() 함수
a,b,c = map(int, ['1','2','3'])
print(a,b,c,a+b+c)

1 2 3 6

# map() 함수를 하나씩 적용해서 보기
text = input('a b c 값 입력')
print(text) 
text = text.split()
print(text) 
a,b,c = map(int, text)
print(a,b,c,a+b+c)

a b c 값 입력3 6 9
3 6 9
['3', '6', '9']
3 6 9 18

# 숫자와 문자 함께 출력하기 (1) 콤마 & 자료형 변환
x=3
y=5
print(str(x)+'과'+str(y)+'의 합은 '+str(x+y)+'이다.')

3과5의 합은 8이다.

# end=''은 줄 바꿈을 없애준다. 
x=3
y=5
print(x, end='')
print('과', end='')
print(y, end='')
print('의 합은', end='')
print(x+y, end='')
print('이다.')

3과5의 합은8이다.

# {}에는 format() 메서드안의 인자가 순서대로 대입된다.
# 따라서 첫 번째{}에는 3, 두 번째 {}에는 5, 세 번째 중괄호에는 x+y의 결과 8이 대입된다.
# 숫자와 문자 함께 출력하기 (3) format()
x=3
y=5
print('{}과 {}의 합은 {}이다.'.format(x,y,x+y))

3과 5의 합은 8이다.

연산자 우선순위
산술 연산자 > 관계 연산자 > 논리 연산자
ex) 2*5>2+5and not 3*3>10 → true

수학과 관련 함수

# 반올림
# round() 함수
print(round(3.33)) # 5보다 작아서 버림
print(round(3.66)) # 5보다 커서 반올림
print(round(3.66, 1)) # 소수 첫째 자리까지 반올림

3
4
3.7

# 절대값
# abs() 함수
print(abs(3))
print(abs(-3))

3
3

# 제곱
# pow() 함수
print(pow(3,2)) # 3의 2제곱
print(3**2) # 3을 2번 곱한다. 

9
9

# 나눗셈
#  divmod() 함수
x,y = divmod(7,2)
print(x) # 몫
print(y) # 나머지

3
1

# 최대값
# max() 함수
print(max(7,5,1,3))

7

# 최소값
# min() 함수
print(min(7,5,1,3))

1

# 합
# sum(iterable, start = 0)
print(sum([7,5,2,3])) # 출력 : 17(리스트) + 0(start) = 17

17

문자열 인덱스

# 양수 인덱스는 0부터 시작한다.
# 문자열 인덱스
text = 'abc'
print(text[0])
print(text[1])
print(text[2])

a
b
c

# 음수 인덱스는 –1부터 시작한다.
# 문자열 인덱스
text = 'abc'
print(text[-3]) # text[-3] = text[0] # a
print(text[-2]) # text[-2] = text[1] # b
print(text[-1]) # text[-1] = text[2] # c

# 문자열 슬라이스[시작:끝-1]
text = 'abcde fgh ijk'
print(text[2:5]) # cde
print(text[1:8]) # bcde fg
print(text[-5:-1]) # h ij

cde
bcde fg
h ij

# 문자열 슬라이스
text = 'abcde fgh ijk'
print(text[5:]) # fgh ijk
print(text[:5]) # abcde
print(text[:]) # abcde fgh ijk

fgh ijk
abcde
abcde fgh ijk

# 문자열 슬라이스
text = 'abcde fgh ijk'
print(text[0:8:2]) # acef
print(text[1:8:2]) # bd g

acef
bd g

# 문자열 슬라이스
text = 'abcde fgh ijk'
# 시작하는 인덱스가 뒤에 있어야 한다.
print(text[8:0:-1]) # hgf edcb

hgf edcb

# 문자열 슬라이스
text = 'abcde fgh ijk'
print(text[::-1]) # kji hgf edcba

kji hgf edcba

# 출력 지정
# format() 메서드
text = 'abcde {} {}'
print(text.format('ABC',123))

abcde ABC 123

# 대체하기
# replace() 메서드
text = 'abcde ABC ABC'
print(text.replace('A','K'))

abcde KBC KBC

text = 'abcde ABC ABC'
print(text.replace('ABC','KKK'))

abcde KKK KKK

# 자르기
# split() 메서드
text = 'abcde A/B/C A.B.C'
a,b,c = text.split() #  공백을 기준으로 자른다.
print(a)
print(b)
print(c)

abcde
A/B/C
A.B.C

text = 'abcde A/B/C A.B.C'
a,b,c = text.split('.') # . 을 기준으로 자른다.
print(a)
print(b)
print(c)

abcde A/B/C A
B
C

text = 'abcde A/B/C A.B.C'
a,b,c = text.split('/') # / 를 기준으로 자른다.
print(a)
print(b)
print(c)

abcde A
B
C A.B.C

# 합치기
# a.join() 메서드
text = 'abcde' # abcde문자열 사이에 /를 추가
print('/'.join(text))

a/b/c/d/e

# 개수 확인하기
# count() 메서드
text = 'abcde ABC ABC'
print(text.count('a')) # 소문자 a가 몇 개 있는가?
print(text.count('A')) # 대문자 A가 몇 개 있는가?
print(text.count('1')) # 숫자 문자 1이 몇 개 있는가?

1
2
0

# 제거하기
# strip() 메서드
text = ' abcde ' print(text.strip()) # 양쪽의 공백제거
print(text.lstrip()) # 왼쪽의 공백제거
print(text.rstrip()) # 오른쪽의 공백제거

abcde
abcde 
 abcde

# 인덱스 찾기
# find() / index() 메서드
# find() 메서드는 찾은 문자열이 없으면 –1을 반환하고, index() 메서드는 ValueError를 발생한다.
text = 'ABC ABC'
print(text.find('A')) # 왼쪽에서 부터 해당 문자열의 인덱스를 가져온다.
print(text.rfind('A')) # 오른쪽에서 부터 해당 문자열의 인덱스를 가져온다.
print(text.index('A')) # 왼쪽에서 부터 해당 문자열의 인덱스를 가져온다.
print(text.rindex('A')) # 오른쪽에서 부터 해당 문자열의 인덱스를 가져온다.

0
4
0
4

# 확인하기
# isalpha() / isdigit() / isalnum() / isupper() / islower()
# isalpha() : 알파벳으로만 이루어졌는가?
# isdigit() : 숫자 문자열로만 이루어졌는가?
# isalnum() : 알파벳과 숫자 문자열로만 이루어졌는가?
# isupper() : 대문자로 이루어졌는가?
# islower() : 소문자로 이루어졌는가?
text1 = 'ABCabc123'
print(text1.isalpha()) # 알파벳으로만 이루어졌는가
print(text1.isdigit()) # 숫자문자열로만 이루어졌는가
print(text1.isalnum()) # 알파벳과 숫자문자열로 이루어졌는가
print(text1.isupper()) # 대문자인가
print(text1.islower()) # 소문자인가

False
False
True
False
False

# 대/소문자 만들기
# upper() / lower() 메서드
text = 'ABCabc'
print(text.upper()) # 문자열을 모두 대문자로 변경
print(text.lower()) # 문자열을 모두 소문자로 변경

ABCABC
abcabc

# 0 채우기
# zfill() 메서드
y='2022'
m='3'
d='1'
print(y.zfill(4))
print(m.zfill(2))
print(d.zfill(2))

2022
03
01

함수, 매개변수

함수

• 함수는 코드의 덩어리에 이름을 붙인 것이다.
• 새 함수를 정의할 수 있다.
• print는 미리 만들어진 함수이다.

def function():			# 함수의 정의
		print('hello')

	print('첫줄 실행')
	function()		# hello # 함수의 호출
	print('끝줄 실행')

매개변수
함수를 정의할 때 사용하는 이름이다.
실행 인자
함수를 실행할 때 넘기는 변수, 값이다.

• 매개변수와 실행 인자의 개수는 동일해야 한다.
• 여러 개일 경우 쉼표로 구분한다.

def print_round(number):	# 함수의 정의
    rounded = round(number)
    print(rounded)	

print_round(4.6)		# 함수의 호출
print_round(2.2)

• return을 이용해 값을 돌려줄 수 있다.
• return 뒤에 여러 값을 쉼표로 구분해서 값을 보내고, 받을때도 쉼표로 구분하여 받는다.

def add_10(value):
	result = value + 10
	return result

n = add_10(5)
print(n) # 15

if문

특정 조건을 만족할 때와 만족하지 않을 때를 나누어 코드를 실행하는 조건문이다.
조건이 참일 때 = 실행
조건이 거짓일 때 = 실행하지 않음

# if 문
num = int(input('숫자 하나 입력: '))
if num>0:
 print('{}은(는) 양수입니다.'.format(num))
 
숫자 하나 입력: 5
5은(는) 양수입니다.

if else문
if 조건:
실행 코드1
else:
실행 코드2
조건이 참일 때 = 실행 코드1 실행
조건이 거짓일 때 = 실행 코드2 실행

# if ~ else
num = int(input('숫자 하나 입력: '))
if num%2==0:
 print('{}은(는) 짝수입니다.'.format(num))
else:
 print('{}은(는) 홀수입니다.'.format(num))
 
숫자 하나 입력: 6
6은(는) 짝수입니다.

숫자 하나 입력: 5
5은(는) 홀수입니다.

if elif else문
if 조건1:
실행 코드1
elif 조건2:
실행 코드2
else
실행 코드3
조건1이 참일 때 = 실행코드1 실행
아니라면 실행하지 않고 건너뜀
조건2가 참일 때 = 실행코드2 실행
조건 1, 2가 모두 거짓일 때 = 실행코드3 실행

# if ~ elif ~ else
text = input('알파벳 입력: ')
if text.isupper(): # 대문자인가?
 print('대문자') # 조건이 참일 때 실행
elif text.islower(): # 소문자인가?
 print('소문자') # 다른 조건이 참일 때 실행
else:
 print('대/소문자 구분 불가능') # 조건이 거짓일 때 실행
 
알파벳 입력: asdf
소문자

알파벳 입력: ASDF
대문자

for문

for 변수 in 열거형:
실행 코드
특정 범위만큼 코드를 반복 실행하는 조건문
열거형 데이터를 하나씩 변수 값에 대입하며 실행

numbers= [1, 2, 3, 4, 5]

for number in numbers:
    print(number)
1
2
3
4
5

range() 함수
숫자의 범위와 증감 값을 정하면 규칙적인 수들의 집합으로 만들어 주는 함수

# 0~9까지 출력
for i in range(10):
 print(i)
 
0
1
2
3
4
5
6
7
8
9

# a에서 b까지 출력
a,b = map(int, input('a b: ').split())
for i in range(a, b+1):
 print(i)
 
a b: 5 10
5
6
7
8
9
10

# n에서 0까지 출력
n = int(input('n: '))
for i in range(n,-1,-1):
 print(i)
 
n: 3
3
2
1
0

# enumerate() 함수
names = ['철수', '영희', '영수']
for i, name in enumerate(names):
	print('{}번: {}'.format(i + 1, name))
    
1번: 철수
2번: 영희
3번: 영수

제어문 중첩

if + if
if 조건1:
if 조건2:
실행코드1
else:
실행코드2
조건1이 참일 때 아래 if문의 조건2로 → 조건2가 참이라면? 실행코드1 실행
조건1이 거짓일 때 아래 if문의 조건2를 검사하지 않고 else의 실행코드2 실행

# if + if
age = int(input('나이 입력: '))
if age<=7:
 print('유아입니다.')
elif age<=19:
 print('청소년입니다.')
 if age<=13:
   print('초등학생')
 elif age<=16:
   print('중학생')
 else:
   print('고등학생')
else:
 print('성인입니다.')
 
나이 입력: 5
유아입니다.

나이 입력: 18
청소년입니다.
고등학생

for + if
for i in range(1, 11):
if i == 5:
break
print(i)
1부터 10까지 for문 실행, 만약 i가 5면? break로 중지한다.

while+ if
i = 0
while i<10:
print(i)
i += 1
if i == 5:
break
i가 10보다 작은 동안,
i를 출력하고 1씩 증가한다.
만약 i가 5면? break로 중지한다.

# for + if
n = int(input('n: '))
for i in range(1,n+1):
 if i%3==0: # i가 3의 배수일 때
 print('X')
 else: 
 print(i)
 
n: 10
1
2
X
4
5
X
7
8
X
10

# while + if
num1 = 0
num2 = int(input('n: '))
while True:
 num1=num1+1
 print(num1)
 if num1==num2:
   break
 
n: 5
1
2
3
4
5

for + for
for i in range(2):
for j in range(3):
print(i, j)
첫번째 for문 i의 범위 = 0, 1
두번째 for문 j의 범위 = 0, 1, 2

# for + for
for i in range(1,6):
 for j in range(1,7):
 print(i, j)
 
1 1
1 2
1 3
1 4
1 5
1 6
2 1
2 2
2 3
2 4
2 5
2 6
3 1
3 2
3 3
3 4
3 5
3 6
4 1
4 2
4 3
4 4
4 5
4 6
5 1
5 2
5 3
5 4
5 5
5 6

while문

while 조건:
실행 코드
특정 조건을 만족할 때 코드를 반복 실행하는 조건문이다.
for문으로 작성한 코드는 while문으로 작성할 수 있다.
조건이 참일 때 = 반복 실행
조건이 거짓일 때 = 반복 종료

# while문
print('a가 0보다 같거나 크면 실행, 작으면 정지')
a = int(input('a: '))
while a>=0:
 print('실행')
 a=int(input('a: '))
 
a가 0보다 같거나 크면 실행, 작으면 정지
a: 5
실행
a: 3
실행
a: 7
실행
a: 0
실행
a: -5

# 무한루프
a=10
while a>=0:
 print('실행')
실행
실행
....
실행
실행
실행

# n번 반복하기
n = int(input('n: '))
while n:
 print(n)
 n=n-1
5
4
3
2
1

# 1~5까지 숫자 반복하기
n=1
while n<=5:
 print(n)
 n=n+1 # n+=1 와 같다.
 
1
2
3
4
5

continue, break, pass

continue
해당 단계만 건너띄고 다음 단계로 간다.
반복문의 나머지 부분을 보지 않고, 반복문의 처음으로 돌아가는 기능이다.
핵심이 되는 블럭이 너무 들여쓰기 되지 않게 한다.

# continue
for i in range(1,11):
 if i==5: # i가 5와 같으면 건너띈다.
 	continue 
 print(i) # 핵심이 되는 블럭이 너무 들여쓰기 되지 않게 한다.
 
1
2
3
4
6
7
8
9
10

break
반복문을 중단하고 빠져나간다.

# break 
for i in range(1,11):
 if i==5: # i가 5와 같으면 반복을 빠져나간다.
  break
 print(i)
 
1
2
3
4

pass
아무 작업도 하지 않는다.
파이썬은 들여쓰기로 포함관계를 나타내기 때문에
만약 특정 일을 할 때에 제어문 안쪽을 잠깐 비어두었을 때 err가 나기 때문에
아무것도 안 하지만 비어두지 않은 상태를 유지하기 위해 사용한다.

# pass
for i in range(1,11):
 if i==5: # i가 5와 같으면 
  pass # 아무것도 안 함.
 print(i)
 
1
2
3
4
5
6
7
8
9
10