Python 1주차 - 2

 

print 함수

1. 기본서식

 

" " 또는 ' ' 사용

• print(' ') or print(" ")

변수값 출력

• print(변수이름)

2. % 서식 문자 사용

 

print(print("%서식문자" % 출력 값 또는 변수이름)
print('%서식문자' % 출력 값 또는 변수이름)

print('%d' % 100) or print ("%d" % 100)
print("%d, %f" % (200,3,4,))
print('%f' % (100)) = 100.000000
print('%d' % (3.2)) = 3

print("%서식문자" % 수식)

print('%d' % (100+200))
print("%d + %d = %d" % (100,200,100+200))

% 서식문자의 추가 형식

종류	예	설명
필드폭	%10d, %5f, %20s	출력값의 필드폭 설정 기본값은 오른쪽 정렬로 출력
정밀도	%.2f, %5.2f, %.3s, %10.2s	실수 : 소수점 자리수 지정 문자열 : 왼쪽부터 정밀도만큼 출력
플래그문자	%-10d, %-4f, %-10s	왼쪽정렬
	%010d, %04.2f	숫자 오른쪽 정렬시, 빈 앞칸을 0으로 출력

* 정밀도 : 정수형에 사용불가 

   ex) %10.2d 불가

 

3. f-string 사용

var1 = 34
var2 = 5.127
var3 = "Hello Python!"

print( f'{var1}, {var2}, {var3}' )
print( f'{var1:-10d}, {var2:.2f}, {var3:.5s}' )
print( f'{var3}, {var1}, {var2}' )

 

4. 이스케이프(Escape) 문자

 

반드시 print 함수의 "" 또는 '' 안에 작성

\ 뒤에 작성

• \n : 엔터 효과
• \t : 탭 효과
• \\ : \출력
• cf) %%d : %문자까지 출력 -> %d

실습 1 - 키와 몸무게의 차이 구하는 코드 작성

height = 168
weight = 50
cha = int(height) - int(weight)
print("키: {:d}, 몸무게: {:d}, 차이는\{:d}". format(height, weight, cha))

height = float(input("   >>"))
weight = float(input("   >>"))
cha = height - weight
print("키: {:.3f}, 몸무게: {:.3f}\n, 차이는\{:.3f}".format(height, weight, cha))

실습2 - 섭씨온도를 화씨온도로 전환하는 코드 작성

cels = float(input("섭씨온도: "))
fahr = 9/5*cels + 32
print("섭씨온도: {:.1f}, 화씨온도: {:.1f}". format(cels, fahr))

실습3 - cm을 inch로 환산하는 코드 작성

cm = int(input("cm>> "))
print("cm: %.3f, inch: %.3f" % (cm, cm/2.54))    # 1inch == 2.54cm

 

파이썬 연산자

산술연산자, 관계연산자, 논리연산자, 비트연산자

 

1. 산술연산자

연산자	의미	예
=	대입연산자	a = 3
+	더하기	a = 5 + 3
-	빼기	a = 5 -3
*	곱하기	a = 5 * 3
/	나누기	a = 5 / 3
//	나누기의 몫	a = 5 // 3  -> 1
%	나머지 값	a = 5 % 3  -> 2
**	제곱	a = 5 ** 3  -> 125

cf) 복합대입연산자

연산자	의미	예	결과
=	대입연산자	a = 3	a <- 3
+=	더하고 대입	a += 5	a = a + 5
-=	빼고 대입	a -= 5	a = a - 5
*=	곱하고 대입	a *= 5	a = a * 5
/=	나누고 대입	a /= 5	a = a / 5
//=	나누기의 몫 대입	a //= 5	a = a // 5
%=	나머지 값 대입	a %= 5	a = a % 5
**=	제곱계산하고 대입	a **= 5	a = a ** 5

 

산술연산자 예제 - 입력한 금액을 500원, 100원, 50원, 10원으로 교환한 각 개수와 교환을 하지 못하는 나머지 금액을 출력하는 코드 작성

money, c500, c100, c50, c10 = 0, 0, 0, 0, 0
money = int(input("Enter money to exchange>> "))

c500 = money // 500
money %= 500
c100 = money //100
money %= 100
c50 = money //50
money %= 50
c10 = money //10
money %= 10

print("\n 500원짜리:: %5d개" %c500)
print("\n 100원짜리:: %5d개" %c100)
print("\n 50원짜리:: %5d개" %c50)
print("\n 10원짜리:: %5d개" %c10
print("\n 나머지:: %5d원" % money)

 

2. 관계연산자

 

이항 연산자. 두 개의 항 중 어떤 항의 값이 크거나, 작거나, 또는 같은지 비교하는 연산자

연산의 결과값은 Bool타입 (참이면 True, 거짓이면 False)

주로 조건문이나 반복문에서 사용

연산자	의미	결과
==	같다	True 또는 False
!=	같지 않다	True 또는 False
>	왼쪽항이 크다	True 또는 False
<	왼쪽항이 작다	True 또는 False
>=	왼쪽항이 크거나 같다	True 또는 False
<=	왼쪽항이 작거나 같다	True 또는 False

a = 100; b =200
if a > b:
	print(a)
else:
	print(b)

a = 1
while a < 10:
	print(a)
    a += 1

 

3. 논리연산자

연산자	의미	설명	예
and	~이고, 그리고 (논리곱)	양쪽 항이 모두 참인 경우에만 True	(a>100) and (a<200)
or	~이거나, 또는 (논리합)	양쪽 항이 모두 거짓인 경우에만 False	(a>100) or (a<200)
not	~아니다, 부정 (논리부정)	참이면 거짓으로, 거짓이면 참으로 변경	not(a>100)

4. 비트연산자

 

정수를 2진수로 변환한 후 각 자리의 비트끼리 연산 수행

이항연산자

연산자	의미	결과
&	비트 논리곱	비트값이 둘 다 1이면 1
|	비트 논리합	비트값이 둘 중 하나만 1이면 1
^	비트 논리적 배타합(xor)	비트값이 같으면 0, 다르면 1
-	비트 부정 (1의 보수)	0은 1로 1은 0으로 변경
<<	비트 이동 (왼쪽 방향)	비트값 전체를 왼쪽으로 이동
>>	비트 이동 (오른쪽 방향)	비트값 전체를 오른쪽으로 이동

파이썬 주석 처리

• 한 줄 주석 처리 : # 사용
• 여러 줄 주석 처리 : ''' ''', 또는 """ """ 사용

집합형 자료형

1. 문자열 기본

 

문자열은 기본자료형이면서, 집합형 자료형의 성질을 가짐

len 함수 : 문자열의 길이 반환

  ex) name = "python"

       print(len(name))

 

index slicing

• 문자열 범위 선택
• 인덱스 번호는 왼쪽에서 오른쪽으로 0부터 1씩 순차적으로 매겨짐
• [start:end:step] 표현 가능     ex) strawberry[0:5:2]  -> start, step은 생략 가능함
• end의 값은 생략 시 마지막 (인덱스번호+1)을 가지며, slicing에 end값은 제외됨 
•  ex) [:3] -> [0],[1],[2] 의 인덱스 번호 문자열까지만 slicing 됨
• 문자열 역순으로 출력시 [::-1] -> -1부터 -1씩 순차적으로

문자열 함수

1) 대, 소문자 변환

• upper() : 대문자 변환 
• lower() : 소문자 변환 
• swapcase() : 대->소문자, 소->대문자 
• title() : 첫글자를 대문자로 

2) 문자열 찾기

• count() : 찾는 문자열의 개수
• find() : 찾는 문자열의 인덱스 번호 (왼쪽부터). 없을 경우 -1 반환
• rfind() : 찾는 문자열의 인덱스 번호 (오른쪽부터)
• index() : find 함수와 동일. 없을 경우 오류 발생
• rindex() : rfind 함수와 동일
• startswith() : 찾는 문자열로 시작하면 True. 찾는 문자열의 시작이 위치값이면 True
• endswith() : 찾는 문자열로 끝나면 True

3) 공백 삭제/변경

• strip() : 문자열 앞뒤의 공백제거  / 앞뒤의 특정 문자 제거 - 문자열.strip('제거문자')
• rstrip() : 문자열 오른쪽 공백 제거
• lstrip() : 문자열 왼쪽 공백 제거
• replace() : 문자열 변경

4) 분리/결합

• split() : 문자열을 공백 또는 다른 문자로 분리 - 문자열.split() / 문자열.split('분리문자')
• splitlines() : 행 단위로 분리
• join() : 문자열 합치기

5) 정렬/채우기

• center() : field 폭에서 가운데 배치
• ljust() : field 폭에서 왼쪽 정렬
• rjust() : field 폭에서 오른쪽 정렬
• zfill() : field 폭에서 오른쪽 정렬, 앞쪽의 빈 공간은 0으로 채움

2. 리스트 (list)

 

[ ] 로 묶으며, 읽기 및 쓰기 모두 가능 하고 모든 자료형을 혼합하여 묶을 수 있음
리스트 이름 = [리스트값, 리스트값, 리스트값, ...]
ex) books = [ ]
     items = [10, 20, 30, 40, 50]
     titles = [10, "abc", 3.4, [1,2,3]]

 

1) 리스트 사용법

shopping_lists = ['milk', 'cheese', 'apple', 'orange', ['butter', 'sugar']] 
print(shopping_lists[0])  
print(shopping_lists[-1]) 
print(shopping_lists[2])[2]    # 'app' -> 리스트에서 문자열 추출 시 인덱스 번호를 한번 더 작성 
print(shopping_listst[4][0])    # 'butter' -> 리스트 안의 리스트 요소 추출 가능 
shopping_lists[3] = "pear"     # 인덱스 번호에 일치하는 리스트 요소 값 변경

2) 리스트 산술연산자 + 와 *

items = [10, 20, 30, 40, 50, 60, 70] 
fruits = ["apple", "mango", "pear", "banana"] 
adds = items + fruits         # [10, 20, 30, 40, 50, 60, 70, "apple", "mango", "pear", "banana"] 
multis = items * 2            # [10, 20, 30, 40, 50, 60, 70, 10, 20, 30, 40, 50, 60, 70] 
print(adds);print(multis)

3) 리스트 범위표현

리스트 이름[범위시작 인덱스 : 범위끝 인덱스 : step 값]

items = [10, 20, 30, 40, 50, 60, 70] 
print(items[1:5]) 
print(items[:]) 
print(items[:3]) 
print(itmes[2:]) 
print(items[-3:-1]) 
print(items[::2])        # step 값이 2 
print(items[::-2])       # 오른쪽에서 부터 step값이 2 
print(items[2::2])       
print(items[1:5:2])

4) 리스트 범위 사용법 - 여러 값 변경

items = [10, 20, 30, 40, 50, 60, 70] 
items[3:4] = [4000, 5000]     # items[3:4] = 4000,5000 (오류) -> 데이터 추가 시 리스트 형식 사용  
print(itmes)

5) 리스트 메서드

 

- append()

리스트에 값 추가

리스트 이름.append(추가할 값) -> 리스트 맨 뒤에 값을 추가함

items = []
items.append(0)
items.append(1)
items.append(2)
print(items)     # [0,1,2,3]

- insert()

원하는 위치에 값 추가
리스트 이름.insert(추가할 인덱스번호, 추가할 값)

a = [10, 20, 30, 40]
a.insert(2, 100)
print(a)       # [10,20,100,30,40]

- pop, remove, del, clear

  리스트 값 삭제

• 리스트 이름.pop() -> 맨 마지막 값 삭제
• 리스트 이름.pop(삭제할 인덱스 번호)
• 리스트 이름.remove(삭제할 값)
• del(리스트 이름[삭제할 인덱스 번호])
• del 리스트이름[삭제할 인덱스 번호]
• del 리스트 이름 -> 리스트 자체를 삭제

- 리스트 범위 삭제
numbers = [1, 2, 3, 4, 5]
numbers[0:2] = []    # [3, 4, 5]

 

- 리스트 요소의 전체 삭제
numbers = [1, 2, 3, 4, 5]

numbers = [] or numbers.clear()

cf) numbers = None    # object 'None type'이 됨. 리스트 값 지울때 사용하지 않음

 

- len() : 리스트 길이 계산

ex) len([1,2,3]) -> 3

 

- sort() : 리스트 오름 정렬

ex) my_var.sort()

cf) my)var.sort(reverse=True)  # 내림정렬

 

6) 리스트 언패킹 (unpacking)

연산자 ' * ' 사용하여 리스트를 언패킹 할 수 있음
변수 할당문에서 = 의 왼쪽엔 2개 이상의 변수를 사용, * 연산자는 = 의 왼쪽 변수에만 적용됨

items = [10, 20, 30, 40, 20, 50, 20]
one, *others = items           # temp = *others -> 에러
print(one, others)             # [10], [20,30,40,20,50,20]

*others, one = ['apple', 'pine', 'lime']   
print(others, one)             # ['apple', 'pine'], ['lime']

3. 튜플 (tuple)

 

() 또는 () 없이 표현되며, 읽기만 가능하고 모든 자료형을 혼합하여 묶을 수 있음
리스트와 동일 -> 차이점 : 값 변경 불가

튜플 이름 = (튜플값, 튜플값, 튜플값, ...) 또는 튜플 이름 = 튜플값, 튜플값, 튜플값, ...

 

items = 10, 20, 30, 40

print(items[0], items[1], items[2], items[3])

 

items = 10,

tups = 30,        # 요소 하나만 가지는 튜플 -> 반드시 ' , ' 입력

 

튜플은 입력함수 사용 불가능 (append, insert 등)

튜플 값 삭제 불가능 (del, clear 등) 

  cf) del 튜플이름 -> 전체 삭제는 가능

튜플의 연산자 : +, * 는 가능

튜플 -> 리스트, 리스트 -> 튜플로 변경하는 함수 : list(), tuple()

 

튜플 메서드

1) count() : 항목의 개수를 반환

2) index() : 인덱스 번호를 반환

- 튜플 언패킹 : 리스트와 동일. 튜플 언패킹시 리스트로 변함

- 튜플 인덱스 슬라이싱 : 리스트와 동일

- 함수와 관련해서 사용될 때

   리턴 시 () 필요 없이 여러 개의 값을 반환하고 싶을때 사용

   ex) def test():

             return 10, 20

       a, b = test()

       print(a, b)          

 

4. 딕셔너리 (dictionary)

 

{ } 로 묶으며 키:값 의 형식으로 데이터가 구성되므로 인덱스번호 대신 키를 사용함

키 (key) : 숫자형, 자료형 (문자형, 튜플형) -> 리스트 불가(값이 변경 가능해서)

값 (value) : 숫자형, 자료형 (문자형, 튜플형, 리스트형)

키의 중복성을 허용하지 않음, 키 값은 수정 불가

 

딕셔너리 이름 = {키:값, 키:값, 키:값, ...}

ex) dicts = {'name':'Alice', 'age':22, 'major':'engineering'}

     print(dicts['name']

 

딕셔너리 값 수정

dicts = {'name':'Alice', 'age':22, 'major':'engineering'}
dicts['name'] = 'Yuna'
print(dicts)

딕셔너리에 값 삭제

dicts = {'name':'Alice', 'age':22, 'major':'engineering'}
del dicts['name']		# 전체 값 삭제 : dicts.clear() 또는 dicts={}
print(dicts)			# 딕셔너리 자체 삭제 : del dicts

pop() 사용 시

dicts = {'name':'Alice', 'age':22, 'major':'engineering'}
dicts.pop('major')		# 인덱스 대신 키값 사용
print(dicts)			# dicts.pop() : 오류 발생 (키값이 없으므로)

동일한 키 생성 시 마지막에 추가된 키만 인식 -> 키 값은 중복성이 없기 때문

dicts = {'name':'Alice', 'age':22, 'major':'engineering', 'name':'Hong-gil'}
print(dicts)     # {'age':22, 'major':'engineering', 'name':'Hong-gil'}

 

딕셔너리 관련 함수 및 연산자

 

1) get()

딕셔너리 키 존재 유무 함수

키가 존재하면 키에 해당되는 value를, 아니면 None 반환

dict1 = {'name':'7D 건조망고', 'type':'절임'}

value = dict1.get('origin')
print('origin : ', value)

if value == None:
	print("키가 딕셔너리에 없습니다")

2) keys()

딕셔너리의 키값만 반환하는 함수

jelly = {'name':'Mango', 'type':'절임', 'ingredient':['mango','sugar','yellow dye'], 'origin':'필리핀'}
keys = jelly.keys()
print(keys)     # dict_keys(['origin', 'type', 'name', 'ingredient'])

keys = list(jelly.keys())
print(keys)		# ['origin', 'type', 'name', 'ingredient']

3) values()

딕셔너리의 value값만 반환하는 함수

jelly = {'name':'Mango', 'type':'절임', 'ingredient':['mango','sugar','yellow dye'], 'origin':'필리핀'}
jelly_values = jelly.values()
print(jelly_values)     # dict_values(['필리핀', '절임', 'Mango', ['mango','sugar','yellow dye'])

jelly_values = list(jelly.values())
print(jelly_values)		# ['필리핀', '절임', 'Mango', ['mango','sugar','yellow dye']

4) items()

딕셔너리의 key와 value를 모두 반환하는 함수

jelly = {'name':'Mango', 'type':'절임', 'ingredient':['mango','sugar','yellow dye'], 'origin':'필리핀'}
jelly_keys_values = list(jelly.items())
print(jelly_keys_values)
# [('name', 'Mango'), ('type', '절임'), ('ingredient', ['mango', 'sugar', 'yellow dye']), ('origin', '필리핀')]

5) update()

딕셔너리에 데이터를 추가하는 함수

jelly = {'name':'Mango', 'type':'절임', 'ingredient':['mango','sugar','yellow dye'], 'origin':'필리핀'}
items = {1:'한국', 2:'스페인', 3:'캐나다'}

jelly.update(items)
print(jelly)

6) in

존재의 유무를 확인하는 연산자 in 사용 가능

jelly = {'name':'Mango', 'type':'절임', 'ingredient':['mango','sugar','yellow dye'], 'origin':'필리핀'}
if 'color' in jelly.keys():
	print(jelly['color'])

5. 집합 (set)

 

딕셔너리의 키값들의 모음

딕셔너리의 키는 중복 불허이므로 set에 들어 있는 값은 항상 유일한 값

value 값, index가 없음 (순서가 없음)

set 생성 -> { } 사용, : 는 사용하지 않음

리스트, 튜플, 딕셔너리를 set함수를 사용하여 set형태로 변경 가능함

items = ['piano','violin','gitar','cello','flute','piano','cello','piano']
set_items = set(items)    # 중복값 제거
print("items: " , items)
print("set_items: ", set_items)
print("type of items: ", type(items),"&", "type of set_items: ", type(set_items)) 

# items:  ['piano', 'violin', 'gitar', 'cello', 'flute', 'piano', 'cello', 'piano']
# set_items:  {'piano', 'violin', 'cello', 'flute', 'gitar'}
# type of items:  <class 'list'> & type of set_items:  <class 'set'>

리스트 또는 튜플 형태로 변경 -> 인덱스 사용 가능

foods = {'pizza':'color', 'steak':'wine', 'cake':'coffee', 'cookie':'coffee'}
set_foods = set(foods)
print(set_foods)				# {'cake', 'steak', 'pizza', 'cookie'}
set_foods_list = list(set_foods)          
print(set_foods_list[2])

set 사이의 교집합, 합집합, 차집합, 대칭 차집합 구하기

mySet1 = {1,2,3,4}
mySet2 = {3,4,5,6}
print(mySet1 & mySet2)			# {3, 4}
print(mySet1 | mySet2)			# {1, 2, 3, 4, 5, 6}
print(mySet1 - mySet2)			# {1, 2}
print(mySet1 ^ mySet2)			# {1, 2, 5, 6}