🤍

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/43

import csv

우선 파이썬에서 csv를 사용하기 위해 import 해준다. 

- 예제 1 

with open('./resource/sample1.csv', 'r') as f:
    reader = csv.reader(f)
    # next(reader) # Header 스킵
    
    # 확인 
    print(reader)
    print(type(reader))
    print(dir(reader))
    print()

    for c in reader:
        print(c)  # 하나의 row가 리스트 형식으로 나온다.

<_csv.reader object at 0x0000013CD5F8E868>
<class '_csv.reader'>
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'dialect', 'line_num']

['번호', '이름', '가입일시', '나이']
['1', '김정수', '2017-01-19 11:30:00', '25']
['2', '박민구', '2017-02-07 10:22:00', '35']
['3', '정순미', '2017-01-22 09:10:00', '33']
['4', '김정현', '2017-02-22 14:09:00', '45']
['5', '홍미진', '2017-04-01 18:00:00', '17']
['6', '김순철', '2017-05-14 22:33:07', '22']
['7', '이동철', '2017-03-01 23:44:45', '27']
['8', '박지숙', '2017-01-11 06:04:18', '30']
['9', '김은미', '2017-02-08 07:44:33', '51']
['10', '장혁철', '2017-12-01 13:01:11', '16']

여기서 header를 제거하고 싶으면 위의 주석으로 작성되어 있는 next(reader)를 사용하면 된다. 

- 예제 2 : delimiter 

vs로 여니까 글씨가 깨지지만 콤마가 아닌 |로 구분되어 있는 csv파일이기 때문에 구분자를 , 에서 | 로 바꾸어주어야 한다. 

with open('./resource/sample2.csv', 'r') as f:
    reader = csv.reader(f, delimiter='|')
    # next(reader) # Header 스킵

    # 확인 
    print(reader)
    print(type(reader))
    print(dir(reader))
    print()

    for c in reader:
        print(c)

<_csv.reader object at 0x0000013CD5EA5798>
<class '_csv.reader'>
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'dialect', 'line_num']

['번호', '이름', '가입일시', '나이']
['1', '김정수', '2017-01-19 11:30:00', '25']
['2', '박민구', '2017-02-07 10:22:00', '35']
['3', '정순미', '2017-01-22 09:10:00', '33']
['4', '김정현', '2017-02-22 14:09:00', '45']
['5', '홍미진', '2017-04-01 18:00:00', '17']
['6', '김순철', '2017-05-14 22:33:07', '22']
['7', '이동철', '2017-03-01 23:44:45', '27']
['8', '박지숙', '2017-01-11 06:04:18', '30']
['9', '김은미', '2017-02-08 07:44:33', '51']
['10', '장혁철', '2017-12-01 13:01:11', '16']

delimiter = '|' 를 사용했더니 잘 나누어진 것을 볼 수 있다. 

- 예제 3 : dictionary로 읽어오기 => DictReader

with open('./resource/sample1.csv', 'r') as f:
    reader = csv.DictReader(f)

    for c in reader:
        for k, v in c.items():
            print(k, v)
        print("------------------")

번호 1
이름 김정수
가입일시 2017-01-19 11:30:00
나이 25
------------------
번호 2
이름 박민구
가입일시 2017-02-07 10:22:00
나이 35
------------------
번호 3
이름 정순미
가입일시 2017-01-22 09:10:00
나이 33
------------------
번호 4
이름 김정현
가입일시 2017-02-22 14:09:00
나이 45
------------------
번호 5
이름 홍미진
가입일시 2017-04-01 18:00:00
나이 17
------------------
번호 6
이름 김순철
가입일시 2017-05-14 22:33:07
나이 22
------------------
번호 7
이름 이동철
가입일시 2017-03-01 23:44:45
나이 27
------------------
번호 8
이름 박지숙
가입일시 2017-01-11 06:04:18
나이 30
------------------
번호 9
이름 김은미
가입일시 2017-02-08 07:44:33
나이 51
------------------

DictReader를 통하여 딕셔너리로 읽어오면 , 

OrderedDict([('번호', '1'), ('이름', '김정수'), ('가입일시', '2017-01-19 11:30:00'), ('나이', '25')])

이런 식으로 하나의 줄마다 OrderedDict가 생성된다. 따라서 위와 같은 코드로 key와 value를 뽑아내줄 수 있는 것이다. 

- 예제 4 : writerow

w = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]]

with open('./resource/sample3.csv', 'w', newline='') as f:
    wt = csv.writer(f)

    for v in w:
        wt.writerow(v)  # 하나하나 검수해서 쓸 떄 (if같은 조건이 들어갈 때 )

writerow로 한줄씩 검수해가며 작성을 해줄 수 있다.

- 예제 5 : writerows 

with open('./resource/sample4.csv', 'w', newline='') as f:
    wt = csv.writer(f)
    wt.writerows(w)  # 아에 한번에 쓰는 것

한번에 쓰는 writerows함수도 존재한다. for문을 사용할 필요가 없다. 

- 예제 6 : excel

* XSL, XLSX 

: openpyxl, xlswriter, xlrd, xlwt, xlutils 

: pandas 를 주로 사용 (openpyxl, xlrd) 

* 설치 (pandas, openpyxl, xlrd) 

- pip install xlrd

- pip install openpyxl

- pip install pandas 

* 불러오기 

import pandas as pd 

xlsx = pd.read_excel('./resource/sample.xlsx')

pandas를 import하고, read_excel을 이용하여 엑셀 파일을 불러와 준다. 

* 상위 데이터 확인 

print(xlsx.head())

  Sap Co.      대리점 영업사원       전월       금월  TEAM  총 판매수량
0  KI1316  경기수원대리점  이기정  1720000  2952000     1     123
1  KI1451  충청홍성대리점  정미진  4080000  2706000     2     220
2  KI1534  경기화성대리점  경인선   600000  2214000     1     320
3  KI1636  강원속초대리점  이동권  3720000  2870000     3     110
4  KI1735  경기안양대리점  강준석  4800000  2296000     1     134

기본적으로 가장 위의 5개 데이터가 나온다. 

* 하위 데이터 확인 

print(xlsx.tail())

   Sap Co.       대리점 영업사원       전월       금월  TEAM  총 판매수량
15  KI2870  경기구리시대리점  박진형  6000000  3400000     2     143
16  KI2910   강원춘천대리점  김은향  4800000  4896000     1     176
17  KI3030   강원영동대리점  전수창  4560000  3128000     2      98
18  KI3131   경기하남대리점  김민정  2750000  7268000     3     293
19  KI3252   강원포천대리점  서가은  2420000  4740000     4     240

하위 5개의 데이터를 보여준다. 

* 데이터의 구조 

print(xlsx.shape) # 행, 열

 (20, 7) 

shape를 이용하여 행과 열의 크기가 얼마나 되는지 확인해 볼 수 있다. 

* 엑셀 or CSV 다시 쓰기 

xlsx.to_excel('./resource/result.xlsx', index=False)
xlsx.to_csv('./resource/result.csv', index=False)

이렇게 to_excel과 to_csv를 이용하여 파일을 생성할 수도 있다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/42

* 문법적으로 에러가 없지만, 코드 실행 (런타임) 프로세스에서 발생하는 예외 처리도 중요하다. 

* (cf) linter : 코드 스타일, 문법 체크 

오늘은 바보코딩을 하면서 오류가 어떻게 발생하게 되는지 살펴보자! 

 [ 예외 종류 ] 

(1) SyntaxError : 잘못된 문법 

print('Test)

 SyntaxError: EOL while scanning string literal 

if True
    pass

 SyntaxError: invalid syntax 

x => y

 SyntaxError: invalid syntax 

(2) NameError : 참조변수 없음 

a = 10 
b = 15 

print(c)

 NameError: name 'c' is not defined 

(3) ZeroDivisionError : 0 나누기 에러 

print(10 / 0)

 ZeroDivisionError: division by zero 

(4) IndexError : 인덱스 범위 오버 

x = [10, 20, 30]
print(x[0])
print(x[3]) # 예외 발생

 10 

 IndexError: list index out of range 

(5) KeyError : 주로 딕셔너리에서 발생 

dic = {'name': 'Kim', 'Age': 33, 'city': 'Seoul'}
print(dic['hobby'])

 KeyError: 'hobby' 

print(dic.get('hobby'))  # 권장

 None 

에러가 발생하지 않고 None을 반환하는 get함수 사용을 권장한다. 

(6) AttributeError : 모듈 , 클래스에 있는 잘못된 속성 사용 시 

import time
print(time.time())
print(time.month())

 1627887313.5666506 
Traceback (most recent call last):
  File "c:/Users/./Desktop/python_study/python_easy/section10.py", line 45, in <module>
    print(time.month())
 AttributeError: module 'time' has no attribute 'month' 

(7) ValueError

x = [1, 5, 9]
x.remove(10)

 ValueError: list.remove(x): x not in list 

x.index(10)

 ValueError: 10 is not in list 

(8) FileNotFoundError 

f = open('test.txt', 'r')  # 예외 발생

 FileNotFoundError: [Errno 2] No such file or directory: 'test.txt' 

(9) TypeError 

x = [1, 2]
y = (1, 2)
z = 'test'

print(x + y)

 TypeError: can only concatenate list (not "tuple") to list 

print(x + z)

 TypeError: can only concatenate list (not "str") to list 

print(x + list(y))

 [1, 2, 1, 2] 

리스트는 리스트끼리만 합칠 수 있다는 에러가 났고, 위와 같이 list로 형변환을 해주면 연산이 가능해진다. 

* 항상 예외가 발생하지 않을 것으로 가정하고 먼저 코딩 

-> 그 후 런타임 예외 발생 시 예외 처리 코딩 권장 ( EAFP 코딩 스타일 ) 

[ 예외 처리 기본 ] 

* try : 에러가 발생할 가능성이 있는 코드 실행 (여기서 에러가 나면 except로 간다. ) 

* except : 에러명 

* else : 에러가 발생하지 않았을 경우 실행 

* finally : 항상 실행 

- 예제 1 

name = ['Kim', 'Lee', 'Park']

try: 
    z = 'Kim'  # Cho : 예외 발생 
    x = name.index(z)
    print('{} Found it! in name'.format(z, x + 1))

except ValueError:
    print('Not found it! - Occured ValueError!')
else:
    print('OK! else!')

 Kim Found it! in name 

 OK! else! 

name = ['Kim', 'Lee', 'Park']

try: 
    z = 'Cho' 
    x = name.index(z)
    print('{} Found it! in name'.format(z, x + 1))

except ValueError:
    print('Not found it! - Occured ValueError!')
else:
    print('OK! else!')

 Not found it! - Occured ValueError! 

오류가 발생하였기 때문에 except 블럭이 실행되었다. 

- 예제 2 

try: 
    z = 'jim' 
    x = name.index(z)
    print('{} Found it! in name'.format(z, x + 1))

except:
    print('Not found it! - Occured Error!')
else:
    print('OK! else!')

 Not found it! - Occured Error! 

- 예제 3 

try: 
    z = 'Kim' 
    x = name.index(z)
    print('{} Found it! in name'.format(z, x + 1))

except:
    print('Not found it! - Occured Error!')
else:
    print('OK! else!')
finally:
    print("finally ok !")

 Kim Found it! in name 
 OK! else! 
 finally ok ! 

finally는 무조건 실행된다. 

- 예제 4 : 예외처리는 하지 않지만 , 무조건 수행되는 코딩 패턴 

try:
    print('try')
finally:
    print("ok finally!!!")

 try 
 ok finally!!! 

- 예제 5 : 여러 개의 except 블럭 

try: 
    z = 'Kim' 
    x = name.index(z)
    print('{} Found it! in name'.format(z, x + 1))
# except Exception:  # 이걸 처음에 놓으면 안됨 ! 
#     print('Not found it! - Occured Error!')
except ValueError:
    print('Not found it! - Occured ValueError!')
except IndexError:
    print('Not found it! - Occured IndexError!')
except Exception:
    print('Not found it! - Occured Error!')
else:
    print('OK! else!')
finally:
    print("finally ok !")

 Kim Found it! in name 
 OK! else! 
 finally ok ! 

위와 같이 에러를 여러 개 잡아줄 수도 있다. 이 때 Exception을 가장 첫 번째 넣어주면 밑에 자세한 에러는 나지 않기 때문에 위치 선정을 주의하여야 한다. ( Exception이 큰 범위이기 때문 ) 

- 예제 6 

* 예외 발생 : raise ( raise 키워드로 예외 직접 발생 ) 

try: 
    a = 'Jim'
    if a == 'Kim':
        print('OK 허가!')
    else:
        raise ValueError
except ValueError:
    print('문제발생!')
except Exception as f: 
    print(f)
else:
    print('oK!')

 문제발생! 

raise를 이용하여 직접 예외를 발생시킬 수도 있다. 이 예제에서는 ValueError를 발생시키라고 하였으므로 except ValueError부분이 실행된 것을 볼 수 있다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/41

<참고> 

https://docs.python.org/3.7/library/functions.html#open

* 읽기모드 : r / 쓰기모드 (기존 파일 삭제) : w / 추가모드 (파일 생성 또는 추가 ) 

* 본 포스팅의 txt 파일 : 패스트 캠퍼스 제공 (resource - *.txt) 

1. 파일 읽기 

- 예제 1 

f = open('./resource/review.txt', 'r')
content = f.read()
print(content)
print(dir(f))
# 반드시 close 리소스 반환 
f.close()

The film, projected in the form of animation, 
imparts the lesson of how wars can be eluded through reasoning and peaceful dialogues, 
which eventually paves the path for gaining a fresh perspective on an age-old problem. 
The story also happens to centre around two parallel characters, Shundi King and Hundi King, 
who are twins, but they constantly fight over unresolved issues planted in their minds 
by external forces from within their very own units. 

 ['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', 
'__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines'] 

open의 인자에 'r'을 작성하여 읽기모드로 txt파일을 가져 온다. dir을 출력해서 사용할 수 있는 메소드들을 확인할 수 있다. 

- 예제 2 : close 생략 가능 

with open('./resource/review.txt', 'r') as f:
    c = f.read()
    print(c)
    print(list(c))
    print(iter(c))

The film, projected in the form of animation,
imparts the lesson of how wars can be eluded through reasoning and peaceful dialogues,
which eventually paves the path for gaining a fresh perspective on an age-old problem.
The story also happens to centre around two parallel characters, Shundi King and Hundi King,
who are twins, but they constantly fight over unresolved issues planted in their minds
by external forces from within their very own units.
['T', 'h', 'e', ' ', 'f', 'i', 'l', 'm', ',', ' ', 'p', 'r', 'o', 'j', 'e', 'c', 't', 'e', 'd', ' ', 'i', 'n', ' ', 't', 'h', 'e', ' ', 'f', 'o', 'r', 'm', ' ', 'o', 'f', ' ', 'a', 'n', 'i', 'm', 'a', 't', 'i', 'o', 'n', ',', '\n', 'i', 'm', 'p', 'a', 
'r', 't', 's', ' ', 't', 'h', 'e', ' ', 'l', 'e', 's', 's', 'o', 'n', ' ', 'o', 'f', ' ', 'h', 'o', 'w', ' ', 'w', 'a', 'r', 's', ' ', 'c', 'a', 'n', ' ', 'b', 'e', ' ', 'e', 'l', 'u', 'd', 'e', 'd', ' ', 't', 'h', 'r', 'o', 'u', 'g', 'h', ' ', 'r', 'e', 'a', 's', 'o', 'n', 'i', 'n', 'g', ' ', 'a', 'n', 'd', ' ', 'p', 'e', 'a', 'c', 'e', 'f', 'u', 'l', ' ', 'd', 'i', 'a', 'l', 'o', 'g', 'u', 'e', 's', ',', '\n', 'w', 'h', 'i', 'c', 'h', ' ', 'e', 'v', 'e', 'n', 't', 'u', 'a', 'l', 'l', 'y', ' ', 'p', 'a', 'v', 'e', 's', ' ', 't', 'h', 'e', ' ', 'p', 'a', 't', 'h', ' ', 'f', 'o', 'r', ' ', 'g', 'a', 'i', 'n', 'i', 'n', 'g', ' ', 'a', ' ', 'f', 'r', 'e', 's', 'h', ' ', 'p', 'e', 'r', 's', 'p', 'e', 'c', 't', 'i', 'v', 'e', ' ', 'o', 'n', ' ', 'a', 
'n', ' ', 'a', 'g', 'e', '-', 'o', 'l', 'd', ' ', 'p', 'r', 'o', 'b', 'l', 'e', 'm', '.', '\n', 'T', 'h', 'e', ' ', 's', 't', 'o', 'r', 'y', ' ', 'a', 'l', 's', 'o', ' 
', 'h', 'a', 'p', 'p', 'e', 'n', 's', ' ', 't', 'o', ' ', 'c', 'e', 'n', 't', 'r', 'e', ' ', 'a', 'r', 'o', 'u', 'n', 'd', ' ', 't', 'w', 'o', ' ', 'p', 'a', 'r', 'a', 
'l', 'l', 'e', 'l', ' ', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ',', ' ', 'S', 'h', 'u', 'n', 'd', 'i', ' ', 'K', 'i', 'n', 'g', ' ', 'a', 'n', 'd', ' ', 'H', 'u', 'n', 'd', 'i', ' ', 'K', 'i', 'n', 'g', ',', '\n', 'w', 'h', 'o', ' ', 'a', 'r', 'e', ' ', 't', 'w', 'i', 'n', 's', ',', ' ', 'b', 'u', 't', ' ', 't', 'h', 'e', 
'y', ' ', 'c', 'o', 'n', 's', 't', 'a', 'n', 't', 'l', 'y', ' ', 'f', 'i', 'g', 'h', 't', ' ', 'o', 'v', 'e', 'r', ' ', 'u', 'n', 'r', 'e', 's', 'o', 'l', 'v', 'e', 'd', ' ', 'i', 's', 's', 'u', 'e', 's', ' ', 'p', 'l', 'a', 'n', 't', 'e', 'd', ' ', 'i', 'n', ' ', 't', 'h', 'e', 'i', 'r', ' ', 'm', 'i', 'n', 'd', 's', '\n', 'b', 'y', 
' ', 'e', 'x', 't', 'e', 'r', 'n', 'a', 'l', ' ', 'f', 'o', 'r', 'c', 'e', 's', ' ', 'f', 'r', 'o', 'm', ' ', 'w', 'i', 't', 'h', 'i', 'n', ' ', 't', 'h', 'e', 'i', 'r', ' ', 'v', 'e', 'r', 'y', ' ', 'o', 'w', 'n', ' ', 'u', 'n', 'i', 't', 's', '.']   
 <str_iterator object at 0x00000230D67D2160> 

위와 같이 with를 사용하면 close를 생략 가능하다. with문을 사용하지 않으면 close를 꼭 작성해주어야 하는 것을 잊지 말기. 

- 예제 3 

with open('./resource/review.txt', 'r') as f:
    for c in f:
        print(c.strip())

 The film, projected in the form of animation, 
 imparts the lesson of how wars can be eluded through reasoning and peaceful dialogues, 
 which eventually paves the path for gaining a fresh perspective on an age-old problem. 
 The story also happens to centre around two parallel characters, Shundi King and Hundi King, 
 who are twins, but they constantly fight over unresolved issues planted in their minds 
 by external forces from within their very own units. 

for문으로 출력해볼 수 도 있다. strip함수로 공백을 제거한 뒤 출력해 준다. 

- 예제 4 

with open('./resource/review.txt', 'r') as f:
    content = f.read()
    print('>>>', content)
    content = f.read()  # 내용 없음 
    print('>>>', content)

 >>> The film, projected in the form of animation, 
 imparts the lesson of how wars can be eluded through reasoning and peaceful dialogues, 
 which eventually paves the path for gaining a fresh perspective on an age-old problem. 
 The story also happens to centre around two parallel characters, Shundi King and Hundi King, 
 who are twins, but they constantly fight over unresolved issues planted in their minds 
 by external forces from within their very own units. 
 >>> 

이렇게 모든 line을 출력하고 나면, 중복해서 line을 불러올 수 없다. 이미 커서가 끝까지 갔기 때문이다. 

- 예제 5 : readline() 

with open('./resource/review.txt', 'r') as f:
    line = f.readline()
    # print(line)
    while line:
        print(line, end='####')
        line = f.readline()

The film, projected in the form of animation,
####imparts the lesson of how wars can be eluded through reasoning and peaceful dialogues,
####which eventually paves the path for gaining a fresh perspective on an age-old problem.
####The story also happens to centre around two parallel characters, Shundi King and Hundi King,
####who are twins, but they constantly fight over unresolved issues planted in their minds
####by external forces from within their very own units.####

readline()은 한줄씩 반환 해 준다. 

- 예제 6 : readlines() 

with open('./resource/review.txt', 'r') as f:
    contents = f.readlines()
    print(contents)
    for c in contents:
        print(c, end=" ****** ")

['The film, projected in the form of animation,\n', 'imparts the lesson of how wars 
can be eluded through reasoning and peaceful dialogues,\n', 'which eventually paves 
the path for gaining a fresh perspective on an age-old problem.\n', 'The story also 
happens to centre around two parallel characters, Shundi King and Hundi King,\n', 'who are twins, but they constantly fight over unresolved issues planted in their minds\n', 'by external forces from within their very own units.']
The film, projected in the form of animation,
 ****** imparts the lesson of how wars can be eluded through reasoning and peaceful 
dialogues,
 ****** which eventually paves the path for gaining a fresh perspective on an age-old problem.
 ****** The story also happens to centre around two parallel characters, Shundi King and Hundi King,
 ****** who are twins, but they constantly fight over unresolved issues planted in their minds
 ****** by external forces from within their very own units. ******

readlines는 모든 문장을 리스트에 넣어준다. 

- 예제 7 

score = []

with open('./resource/score.txt', 'r') as f:
    for line in f:
        score.append(int(line))
    print(score)
    
print('Average : {:6.3}'.format(sum(score)/len(score)))

 [95, 78, 92, 89, 100, 66] 
 Average :   86.7 

형변환을 하고, 리스트에 추가해서 평균을 구해주는 예제이다. 

2. 파일 쓰기 

- 예제 1 

with open('./resource/text1.txt', 'w') as f:
    f.write("Nicegirl!\n")

open의 인자에 'w'를 사용하여 파일을 생성 및 글을 작성할 수 있다. 

- 예제 2 

with open('./resource/text1.txt', 'a') as f:
    f.write("Goodgirl!")

open의 인자에 'a'를 사용하여 글씨를 추가할 수 있다. 

- 예제 3 

from random import randint
with open('./resource/text2.txt', 'w') as f:
    for cnt in range(6):
        f.write(str(randint(1, 50)))
        f.write('\n')

for문을 이용하여 6개의 랜덤 숫자를 각 줄에 한개씩 작성해 주는 코드이다. 

- 예제 4 >>> writelines : 리스트 -> txt 파일로 저장 

# writelines : 리스트 -> 파일로 저장
with open('./resource/text3.txt', 'w') as f:
    list = ['Kim\n', 'Park\n', 'Cho\n']
    f.writelines(list)

writelines를 사용하여 리스트를 파일로 저장해줄 수도 있다. 

- 예제 5 : 프린트 함수로 파일 생성 

with open('./resource/text4.txt', 'w') as f:
    print('Test Contents1!', file=f)
    print('Test Contents2!', file=f)

print함수의 인자에 file=f 를 넣어주면 파일로 생성이 가능하다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/40

* 폴더 - 패키지, 파일 - 모듈 이라고 할 수 있다. 

* 상대 경로 - . : 부모 디렉토리 / .. : 현재 디렉토리 

우선 오늘 실습을 위해서 

pkg 폴더를 생성하고, 그 안에 파일을 만들어 준다. 

(1) __init__.py 

* 용도 : 해당 디렉토리가 패키지임을 선언 

* Python 3.x : 파일이 없어도 패키지를 인식 하지만 , 하위 호환을 위해 생성해 놓는 것을 추천한다. 

(2) fibonacci.py 

class Fibonacci:
    def __init__(self, title='fibonacci'):
        self.title = title 

    def fib(n):  # 피보나치 출력
        a, b = 0, 1 
        while a < n:
            print(a, end=' ')
            a, b = b, a + b 
        print()

    def fib2(n): # 피보나치 리스트 리턴 
        result = []
        a, b = 0, 1 
        while a < n:
            result.append(a)
            a, b = b, a + b 

        return result

fib는 피보나치 수열을 출력, fib2는 리스트로 출력해 주는 함수이다. 

(3) calculations.py

def add(l, r):
    return l + r

def mul(l, r):
    return l * r

def div(l, r):
    return l / r

더하기, 곱하기, 나누기 단순 계산 함수다. 

(4) prints.py

def prt1():
    print("I'm NiceGirl!")


def prt2():
    print("I'm GoodGirl!")


# 단위 실행 (독립적으로 파일 실행) : 함수가 잘 만들어 졌는지 확인하기 위해 이 파일에서만 실행하도록 설정 
if __name__ == "main":
    prt1()
    prt2()

단순 출력문이고, 단위실행으로 다른 파일에서 이 모듈을 실행했을 때 출력되지 않고, 현재 파일에서만 실행이 되도록 하는 if문은 선언한다. 

- 예제 1 : 클래스 

from pkg.fibonacci import Fibonacci

위와 같이 클래스를 import해 올 수 있다. 

Fibonacci.fib(300)

 0 1 1 2 3 5 8 13 21 34 55 89 144 233 

인스턴스 메소드가 아닌 클래스 메소드였으므로 클래스 자체로 접근이 가능하다. 

print("ex1 : ", Fibonacci.fib2(400))
print('ex1 : ', Fibonacci().title)  # 인스턴스화 시켜야 함.

 ex1 :  [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377] 
 ex1 :  fibonacci 

title은 인스턴스 변수기 때문에 인스턴스화 시켜 가져올 수 있다. 

- 예제 2 : 클래스 2 

from pkg.fibonacci import *

모듈의 모든 클래스를 가져오는 방법이다. 이 방법은 메모리를 많이 차지하므로 권장되지 않는다. 필요한 것만 불러오는 것이 효율적이다. 

Fibonacci.fib(500)
print("ex2 : ", Fibonacci.fib2(600))
print('ex2 : ', Fibonacci().title)  # 인스턴스화 시켜야 함.

 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 
 ex2 :  [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377] 
 ex2 :  fibonacci 

- 예제 3 : 클래스 - 권장하는 방법 

from pkg.fibonacci import Fibonacci as fb

이와 같이 사용하는 방법을 많이 보았을 것이다. 

fb.fib(1000)
print("ex3 : ", fb.fib2(1600))
print('ex3 : ', fb().title)

 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 
 ex3 :  [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597]     
 ex3 :  fibonacci 

- 예제 4 : 함수 

import pkg.calculations as c

print("ex4 : ", c.add(10, 100))
print("ex4 : ", c.mul(10, 100))

 ex4 :  110 
 ex4 :  1000 

- 예제 5 : 함수 - 권장하는 방법 (필요한 만큼만 사용하는 것이 좋은 습관이다. ) 

from pkg.calculations import div as d

print('ex5 : ', int(d(100, 10)))

 ex5 :  10 

이렇게 필요한 함수만 불러와서 사용할 수 있다. 

- 예제 6 

import pkg.prints as p
import builtins  # 파이썬에서 기본적으로 제공하는 함수들

p.prt1()
p.prt2()
print()
print(dir(builtins))

 I'm NiceGirl! 
 I'm GoodGirl! 

 ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip'] 

builtins에는 파이썬에서 기본적으로 제공하는 함수들인데, prints.py에서 사용했던 __name__이 들어가 있는 것을 볼 수 있다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/39

- 본 포스팅에서 다룰 내용 요약 

* 클래스 변수 & 인스턴스 변수 차이 (중요)

* 클래스 변수 : 직접 사용 가능, 객체보다 먼저 생성 

* 인스턴스 변수 : 객체 마다 별도로 존재, 인스턴스 생성 후 사용 

* 네임스페이스 : 객체를 인스턴스화 할 때 저장된 공간 ( (ex)이름, 주소, .... -> 독립적인 공간 )   

* 클래스 상속과 다중 상속 

* 클래스 선언

class 클래스명:

    함수

    함수

    함수 

 [클래스 기본 사용] 

- 예제 1 

class UserInfo:
    # 속성, 메소드 
    def __init__(self, name):
        self.name = name
        print("초기화", name)

    def user_info_p(self):
        print('Name : ', self.name)

초기에 name을 받는 클래스 UserInfo를 선언한다. user_info_p메소드를 호출하면 self.name이 출력된다. 

user1 = UserInfo('Silver')
print(user1.name)
user1.user_info_p()

 초기화 Silver 
 Silver 
 Name :  Silver 

user2 = UserInfo('Park')
print(user1.name)
user2.user_info_p()

 초기화 Park 
 Park 
 Name :  Park 

print(id(user1))
print(id(user2))

 2535817860096 
 2535817860544 

같은 클래스에서 나왔지만 user1과 user2 는 서로 다르다. id값이 다르다는 것으로 증명할 수 있다. 

* 네임스페이스 확인 

print(user1.__dict__)
print(user2.__dict__)

 {'name': 'Silver'} 
 {'name': 'Park'} 

 __dict__ 메서드를 사용하여 인스턴스의 네임스페이스를 확인할 수 있다. 저장된 변수와 값이 key, value형식인 dictionary로 출력된다. 

- 예제 2 

* self 의 이해 (클래스 메소드 vs 인스턴스 메소드) 

<참고 포스팅> 

https://silvercoding.tistory.com/20?category=957523 

class SelfTest():
    def function1():
        print('function1 called ! ')

    def function2(self):
        print(id(self))
        print('function2 called ! ')

메서드를 2개 생성해 준다. functionn1은 self를 인자로 받지 않고, function2는 self를 인자로 받는다. 이 경우에 각 두개의 메서드에 어떻게 접근하는지 실험해 본다. 

self_test = SelfTest()

self_test.function1()

 TypeError: function1() takes 0 positional arguments but 1 was given 

function1 함수에 인스턴스로 접근했더니 TypeError가 발생하게 된다. self를 인자로 받지 않기 때문에 클래스 메소드이고, 누구(어떤 인스턴스)의 function1 함수인지 모르는 것이다. 

SelfTest.function1() # 클래스 메소드

 function1 called ! 

따라서 이렇게 클래스 자체로 접근해 주어야 호출이 가능하다. 

self_test.function2() # 인스턴스 메소드 
print(id(self_test))

 1805035034104 
 function2 called ! 
 1805035034104 

반면 self를 인자로 받았던 function2 메소드는 인스턴스를 통해 호출 가능하다. self의 id를 출력하도록 생성 했었는데, self_test 인스턴스와 id값이 같은 것을 볼 수 있다. 따라서 self를 인자로 받는 클래스의 메소드의 인자인 self에는 인스턴스가 들어가게 되는 것이다. 

SelfTest.function2() # -> 예외

 TypeError: function2() missing 1 required positional argument: 'self' 

이처럼 인스턴스가 아닌 클래스 자체로 접근하면 똑같이 TypeError가 나게 된다. 오류 내용에 따르면 인스턴스를 인자에 넣어주면 실행될 것이다. 

SelfTest.function2(self_test)  # 인자에 인스턴스 넣어주면 클래스자체로 호출 가능

 2385469756864 
 function2 called ! 

- 예제 3 

: 클래스 변수 vs 인스턴스 변수 

<참고 포스팅> 

https://silvercoding.tistory.com/19?category=957523 

class WareHouse: 
    # 클래스 변수 
    stock_num = 0 
    def __init__(self, name): 
    	# 인스턴스 변수
        self.name = name 
        WareHouse.stock_num += 1 

    def __del__ (self):
        WareHouse.stock_num -= 1

클래스 변수와 인스턴스 변수를 각각 생성해 주었다. 

user1 = WareHouse('Kim')
user2 = WareHouse("Park")
user3 = WareHouse("Lee")

인스턴스를 3개 만들어 준다. 

* 인스턴스 네임스페이스, 클래스 변수 (모든 인스턴스에 공유) 

print(user1.__dict__)
print(user2.__dict__)
print(user3.__dict__)

 {'name': 'Kim'} 
 {'name': 'Park'} 
 {'name': 'Lee'} 

위와 같이 인스턴스의 네임스페이스를 출력하면 name이 제대로 나오는 것을 볼 수 있다. 

print(user1.name)
print(user2.name)
print(user3.name)

 Kim 
 Park 
 Lee 

* 클래스 네임스페이스, 클래스 변수 (모든 인스턴스에 공유) 

print(WareHouse.__dict__)  # ---> 클래스 자체의 네임 스페이스에서 클래스변수 확인 가능

 {'__module__': '__main__', 'stock_num': 3, '__init__': <function WareHouse.__init__  
 at 0x0000022B69124510>, '__del__': <function WareHouse.__del__ at 0x0000022B69124598>, '__dict__': <attribute  '__di ct__' of 'WareHouse' objects>, '__weakref__': <attribute '__weakref__' of 'WareHouse' objects>, '__doc__': None} 

이렇게 클래스 변수는 클래스의 네임스페이스를 찍어보면 확인할 수 있다. 

print(user1.stock_num) # 자신의 네임스페이스에 없으면 클래스의 네임스페이스에서 찾고, 클래스의 네임스페이스에도 없으면 그때 에러가 난다. 
print(user2.stock_num)
print(user3.stock_num)

 3 
 3 
 3 

클래스 변수는 인스턴스를 통하여 접근할 수도 있다. 자기 자신의 인스턴스 네임스페이스에 찾는 변수가 없으면 클래스의 네임스페이스에서 찾고 , 클래스의 네임스페이스에도 해당 변수가 없으면 그때 오류가 나게 되는 것이다. 

del user1

del로 user1을 지우면, 위에 선언해 놓은 대로 sock_num 도 -1이 될 것이다. 

# print(user1.stock_num)
print(user2.stock_num)
print(user3.stock_num)

 2 
 2 

 [클래스 상속] 

- 예제 1 

* Car : 부모 클래스 

class Car: 
    """"Parent Class"""
    def __init__(self, tp, color):
        self.type = tp
        self.color = color

    def show(self):
        return 'Car Class "Show Method!"'

* BmwCar : 자식 클래스 1

class BmwCar(Car):
    """Sub Class"""
    def __init__(self, car_name, tp, color):
        super().__init__(tp, color)
        self.car_name = car_name

    def show_model(self) -> None:
        return "Your Car Name : %s" % self.car_name

* BenzCar : 자식 클래스 2

class BenzCar(Car):
    """Sub Class"""
    def __init__(self, car_name, tp, color):
        super().__init__(tp, color)
        self.car_name = car_name

    def show_model(self) -> None:
        return "Your Car Name : %s" % self.car_name

    def show(self):
        print(super().show())
        return 'Car Info: %s %s %s' % (self.car_name, self.type, self.color)

* 사용 

model1 = BmwCar('520d', 'sedan', 'red')

우선 객체를 생성해 준다. 

print(model1.color) # Super 
print(model1.type)  # Super
print(model1.car_name) # Sub
print(model1.show()) # Super    
print(model1.show_model()) # Sub
print(model1.__dict__)

 red 
 sedan 
 520d 
 Car Class "Show Method!" 
 Your Car Name : 520d 
 {'type': 'sedan', 'color': 'red', 'car_name': '520d'} 

부모클래스에서 선언해 놓았던 color, type변수와 show() 메소드가 정상적으로 출력된 것을 볼 수 있다. 인스턴스의 네임스페이스에도 변수가 들어 가 있다. 

# Method Overriding (오버라이드 : 올라타다)

model2 = BenzCar("220d", 'suv', 'black')
print(model2.show())

 Car Class "Show Method!" 
 Car Info: 220d suv black 

# Parent Method Call 
model3 = BenzCar('350s', 'sedan', 'silver')
print(model3.show())

 Car Class "Show Method!" 
 Car Info: 350s sedan silver 

BenzCar 클래스의 show() 메소드에서 super.show()를 사용하여 부모클래스의 메소드를 오버라이딩 하였다. 따라서 부모 클래스에서 선언하였던 내용도 함께 출력된 것을 볼 수 있다. 

# Inheritance Info (상속정보 리스트 형태로 나옴)

print(BmwCar.mro())  # 상속 관계를 보여준다. 
print(BenzCar.mro())
# 모든 클래스는 object를 상속받는다.

 [<class '__main__.BmwCar'>, <class '__main__.Car'>, <class 'object'>] 
 [<class '__main__.BenzCar'>, <class '__main__.Car'>, <class 'object'>] 

mro 함수를 사용하여 상속 관계를 리스트로 출력해볼 수 있다. 모든 클래스는 object를 상속 받는 것 또한 알아두기 ! 

- 예제 2 : 다중 상속 

class X:
    pass

class Y:
    pass

class Z:
    pass

class A(X, Y):
    pass

class B(Y, Z):
    pass

class M(B, A, Z):
    pass

우선 클래스 X, Y, Z를 선언하고, A는 X, Y를 , B는 Y, Z 를 , M은 B, A, Z 를 다중상속 받는다. 이 때의 Inheritance Info를 출력해 보자. 

print(M.mro())
print(A.mro())

 [<class '__main__.M'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.X'>, <class '__main__.Y'>, <class '__main__.Z'>, <class 'object'>] 
 [<class '__main__.A'>, <class '__main__.X'>, <class '__main__.Y'>, <class 'object'>] 

이처럼 다중상속이 가능하지만 , 너무 많이 상속 받게 되면 코드를 해석하기 어렵게 만들어질 수도 있으므로 주의하여 사용하는 것이 권장된다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/38

* 함수 정의 방법 

def 함수명(parameter):

    code 

- 예제 1 : 출력(print) 

def hello(world):
    print('Hello', world)

hello('Silver !')
hello(77777)

 Hello Silver ! 
 Hello 77777 

함수명(parameter) 의 형태로 함수를 호출할 수 있다. 

- 예제 2 : 리턴(return) 

def hello_return(world):
    val = "Hello" + str(world)
    return val

str = hello_return("Silver !!!!!")
print(str)

 HelloSilver !!!!! 

함수 안에서 return하여 변수로 리턴값을 받아줄 수도 있다. 

- 예제 3 : 여러 값 리턴 

def func_mul(x):
    y1 = x * 100 
    y2 = x * 200 
    y3 = x * 300 
    return y1, y2, y3

val1, val2, val3 = func_mul(100)
print(type(val1), val1, val2, val3)

 <class 'int'> 10000 20000 30000 

여러 값을 리턴하여 각각의 변수에 값을 받아줄 수 있다. 

- 예제 4 : 리스트 리턴 

def func_mul2(x):
    y1 = x * 100 
    y2 = x * 200 
    y3 = x * 300 
    return [y1, y2, y3]

lt = func_mul2(100)
print(lt, type(lt))

 [10000, 20000, 30000] <class 'list'> 

- 예제 5 : 가변 인자 받기 (*args / **kwargs) 

(1) *args 

: 튜플 형태로 받음 ( 가변 튜플 ) 

def args_func(*args):
    print(args)

def args_func2(*args):
    for t in args:
        print(t)

def args_func3(*args):
    for i, v in enumerate(args):
        print(i, v)

args_func('Kim')
args_func('Kim', 'Park')
args_func2('Kim', 'Park', 'Lee')
args_func3('Kim', 'Park', 'Lee')

 ('Kim',) 

 ('Kim', 'Park') 

위와 같이 파라미터에 입력한 개수 만큼  튜플안의 값이 생성되는 것을 볼 수 있다. 
 Kim 
 Park 

 Lee 

튜플이므로 반복문에서 사용해줄 수도 있다. 
 0 Kim 
 1 Park 
 2 Lee 

인덱스와 값을 모두 iterable 하게 반환해주는 enumerate를 사용하여 반복문을 사용한 코드이다. 

(2) **kwargs

: dictionary로 받음 ( 가변 딕셔너리 ) 

def kwargs_func(**kwargs):
    print(kwargs)

def kwargs_func2(**kwargs):
    for k, v in kwargs.items():
        print(k, v)

kwargs_func(name1='Kim')
kwargs_func(name1='Kim', name2='Park', name3='Lee')
kwargs_func2(name1='Kim', name2='Park', name3='Lee')

 {'name1': 'Kim'} 
 {'name1': 'Kim', 'name2': 'Park', 'name3': 'Lee'} 

인자에 key = value 형태로 넣어주면 그 개수 대로 딕셔너리 값이 생성되는 것을 볼 수 있다. 
 name1 Kim 
 name2 Park 
 name3 Lee 

dictionary 객체이므로 반복문도 사용 가능하다. 

(3) 전체 혼합 

def example_mul(arg1, arg2, *args, **kwargs):
    print(arg1, arg2, args, kwargs)

일반, 가변 튜플, 가변 딕셔너리를 모두 받는 함수를 선언한다.  

example_mul(10, 20)
example_mul(10, 20, 'park', 'kim')
example_mul(10, 20, 'park', 'kim', age1=24, age2=35)

 10 20 () {} 
 10 20 ('park', 'kim') {} 
 10 20 ('park', 'kim') {'age1': 24, 'age2': 35} 

- 예제 6 : 충첩합수 (클로저) - 효율적인 메모리 관리 가능 

def nested_func(num):
    def func_in_func(num):
        print('>>>', num)
    print('in func')
    func_in_func(num + 10000)

nested_func(10000)

 in func 
 >>> 20000 

nested_fun(10000)으로 함수를 호출하면 print문이 실행되고, func_in_func(10000 + 10000)이 호출이 되어 func_in_func안의 print문이 실행되는 것이다. 

<참고 : 클로저 포스팅>

https://silvercoding.tistory.com/26?category=957523 

- 예제 7 : hint -> 인자 타입과 리턴 타입 명시해주기 

def func_mul3(x: int) -> list:
    y1 = x * 100 
    y2 = x * 200 
    y3 = x * 300 
    return [y1, y2, y3]

print(func_mul3(5))

 [500, 1000, 1500] 

인자 x는 int, 리턴타입은 list라고 기입해주어 명확히 사용할 수 있다. 

- 예제 8 : lambda 

* 람다식 : 메모리 절약, 가독성 향상, 코드 간결 

* 함수 : 객체 생성 -> 리소스 (메모리) 할당 vs 람다 : 즉시 실행 (Heap 초기화) -> 메모리 초기화 

(1) 일반적 함수 : 변수 할당 

def mul_10(num: int) -> int:
    return num * 10

val_func = mul_10   # ---> 객체 생성 -> 메모리 할당 
print(val_func) 
print(type(val_func))

print(val_func(10))

 <function mul_10 at 0x00000212CEA148C8> 
 <class 'function'> 
 100 

(2) 람다식 

lambda_mul_10 = lambda num : num * 10 
print(">>>", lambda_mul_10(10))

 >>> 100 

* 함수의 인자에 함수 넣기 

def func_final(x, y, func):
    print(x * y * func(10))

인자에 함수를 넣는 함수를 선언한다. 

func_final(10, 10, lambda_mul_10)

 10000 

print(func_final(10, 10, lambda x: x * 1000))

 1000000 
 None 

이렇게 바로 lambda 함수를 사용해주어도 된다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/37

(1) while 문 

- 예제 1

v1 = 1
while v1 < 11:
    print("v1 is : ", v1)
    v1 += 1

 v1 is :  1 
 v1 is :  2 
 v1 is :  3 
 v1 is :  4 
 v1 is :  5 
 v1 is :  6 
 v1 is :  7 
 v1 is :  8 
 v1 is :  9 
 v1 is :  10 

while문은 조건이 참일 동안 계속 반복한다. 이 예제에서는 11보다 작을 때, 즉 10까지 반복한다. 

- 예제 2 

sum1 = 0 
cnt1 = 1

while cnt1 <= 100: 
    sum1 += cnt1
    cnt1 += 1

print('1 ~ 100: ', sum1)

 1 ~ 100:  5050 

cnt1이 100 이하일 동안 반복문을 실행하게 된다. sum1에 1씩 증가하는 cnt1을 계속 더해줌으로써 1부터 100까지의 합을 구하는 코드이다. 

* 참고 - 같은 결과를 낼 수 있는 함수 sum(), range()이용

print('1 ~ 100: ', sum(range(1, 101)))
print('1 ~ 100: ', sum(range(1, 101, 2)))

 1 ~ 100:  5050 
 1 ~ 100:  2500 

더 간단한 방법으로 합을 구해줄 수 있다. 1부터 100까지 홀수의 합만을 구하려면 range(1, 101, 2) 를 사용하면 된다. 

(2) for 문 

* 시퀀스 (순서가 있는) 자료형 반복 : 문자열, 리스트, 튜플, 집합, 사전 

* iterable 리턴 함수 : range. reversed, enumerate, filter, map, zip 

- 예제1 - range() 

for v3 in range(1, 11):
    print('v3 is : ', v3)

 v3 is :  1 
 v3 is :  2 
 v3 is :  3 
 v3 is :  4 
 v3 is :  5 
 v3 is :  6 
 v3 is :  7 
 v3 is :  8 
 v3 is :  9 
 v3 is :  10 

시퀀스 자료형을 반복한다. 위와 같은 경우에서는 1부터 10까지 차례대로 v3에 들어가는 것을 반복하며 출력해 준다. 

- 예제2 - 리스트 (ilst)

names = ['Kim', 'Park', 'Cho', 'Choi', 'Yoo']

for v in names: 
    print('You are: ', v)

 You are:  Kim 
 You are:  Park 
 You are:  Cho 
 You are:  Choi 
 You are:  Yoo 

리스트 자료형을 넣어주어도 반복이 가능하다! 

- 예제3 - 문자열 (str)

word = "dreams"

for s in word:
    print("Word: ", s)

 Word:  d 
 Word:  r 
 Word:  e 
 Word:  a 
 Word:  m 
 Word:  s 

문자열도 반복이 가능하다. 

- 예제4 - 딕셔너리 (dictionary) 

my_info = {
    'name' : 'kim',
    'age' : 33, 
    'city' : 'Seoul'
}

우선 딕셔너리 선언하기 

(1) 기본 : key

for key in my_info:
    print('my_info', key)

 my_info name 
 my_info age 
 my_info city 
딕셔너리 자체를 반복문에 넣으면 기본적으로 키가 반복된다. 

(2) values

for key in my_info.values():
    print('my_info', key)

 my_info kim 
 my_info 33 
 my_info Seoul 

(3) keys

for key in my_info.keys():
    print('my_info', key)

 my_info name 
 my_info age 
 my_info city 

(4) items 

for key, value in my_info.items():
    print('my_info', key, value)

 my_info name kim 
 my_info age 33 
 my_info city Seoul 

- 예제5 : 반복문 + 조건문 

name = 'KennRY'
name2 = ""

KennRY 에서 대문자는 소문자로, 소문자는 대문자로 바꾸고, 최종적으로 name2에 바뀐 문자열을 저장하는 코드를 생성한다. 

for n in name:
    if n.isupper():
        print(n.lower())
        name2+=n.lower()
    else:
        print(n.upper())
        name2+=n.upper()

 k 
 E 
 N 
 N 
 r 
 y 

print(name2)

 kENNry 

문자열을 반복하여, 글자가 대문자면 소문자로 바꾸고 name2에 글자를 더해준다. 그 반대의 경우도 동일하게 해준다. 그럼 이처럼 원하는 결과가 나오는 것을 볼 수 있다. 

- 예제6 : break

numbers = [14, 3, 4, 7, 10, 24, 17, 2, 33, 35, 36, 38]
numbers2 = [14, 3, 4, 7, 10, 24, 17, 2, 37, 35, 36, 38]

for num in numbers: 
    if num == 33:
        print('found : 33 !')
        break
    else:
        print('not found : 33!')

 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 found : 33 ! 

33을 발견하면 break를 사용하여 반복문을 탈출하는 코드이다. 실제로 33 차례가 왔을 때, found : 33 ! 이 출력되고, 그 이후로는 아무것도 출력되지 않는 것을 볼 수 있다. 

- 예제7 : for-else 구문 
: 반복문이 정상적으로 수행(모든 값 순회 ) 된 경우 else 블럭 수행 

for num in numbers2: 
    if num == 33:
        print('found : 33 !')
        break
    else:
        print('not found : 33!')
else:
    print('Not found 33 ...........')

 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 not found : 33! 
 Not found 33 ........... 

break문 등으로 인하여 반복문이 정상적으로 모든 값을 순회하지 못할 경우 else블럭은 수행되지 않는다. 예제7과 같은 경우에는 33이 리스트에 존재하지 않기 때문에 정상적으로 모든 값을 순회하여 else블럭이 수행되었다. 

- 예제8 : continue

lt = ['1', 2, 5, True, 4.3, complex(4)]

for v in lt: 
    if type(v) is float:
        continue
    print('타입 : ', type(v))

 타입 :  <class 'str'> 
 타입 :  <class 'int'>
 타입 :  <class 'int'> 
 타입 :  <class 'bool'> 
 타입 :  <class 'complex'> 

continue를 만나면 그 다음 코드를 실행하지 않고 곧바로 for문의 첫번째로 되돌아 가 반복을 그대로 수행한다. 예제8에서는 float타입이면 continue를 실행한다. float 타입인 4.3을 중간에 넣어놓았더니 그 후의 print문은 실행되지 않고 complex타입은 정상적으로 출력된 것을 볼 수 있다.

- 예제9 : reversed 함수 

name = 'Niceman'
print(reversed(name))
print(list(reversed(name)))
print(tuple(reversed(name)))

 <reversed object at 0x000001C1CC70D898> 
 ['n', 'a', 'm', 'e', 'c', 'i', 'N'] 
 ('n', 'a', 'm', 'e', 'c', 'i', 'N') 

reversed 함수는 그대로 출력해서 보기 위해 list나 tuple객체로 변환해주어야 한다. 

for i in reversed(name):
    print(i)

 n 
 a 
 m 
 e 
 c 
 i 
 N 

하지만 iterable을 반환해주는 함수이기 때문에 for문에서는 곧바로 사용할 수 있다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/36

* 조건문을 사용하기 위한 배경지식 & 기초 if문 작성해보기

- 참(True) , 거짓(False) 종류 

(1) 참 : "내용", [내용], (내용), {내용}, 1, True

(2) 거짓 : "", [], (), {}, 0, False 

기본적으로 여러 데이터 타입에서 내용이 채워져 있으면 참, 비어 있으면 거짓이다. 

# 예 1
if True:
    print('Yes')

# 예 2
if False:
    print('No')

# 예 3
if False:
    print('No')
else:
    print('Yes2')

 Yes 
 Yes2 

우선 이처럼 if문은 True일 때 실행되고, False일 때 실행되지 않는다. 이를 이용하여 위에서 배운 참과 거짓을 사용하여 if문을 활용한다. 

city = ""

if city:
    print('>>>>True')
else:
    print('>>>>False')

 >>>>False 

이처럼 비어있는 문자열일 경우 False로 인식하여 else로 넘어가 else의 부분이 실행 되는 것이다. 

- 관계 연산자 

: >, >=, <, <=, ==, != 

a = 10 
b = 0

print(a == b)
print(a != b)
print(a > b)
print(a >= b)
print(a < b)
print(a <= b)

 False 
 True 
 True 

 True 

 False 
 False 

- 논리 연산자 

: and, or, not

a = 100 
b = 60 
c = 15

print('and: ', a > b and b > c)
print('or: ', a > b or c > b)
print('not: ', not a > b)
print(not True)
print(not False)

 and:  True 
 or:  True 
 not:  False 
 False 
 True 

* 산술, 관계 , 논리 연산자 적용 순서 

: 산술 > 관계 > 논리 

print('ex1: ', 5 + 10 > 0 and not 7 + 3 == 10)

 ex1:  False 

* if 문 사용 

score1 = 90
score2 = 'A'

if score1 >= 90 and score2 == 'A':
    print('합격하셨습니다. ')
else:
    print('더 공부하세요. 불합격입니다. ')

 합격하셨습니다. 

score1이 90이상이면서 score2가 A이므로 (True & True = True) if문이 실행된다. 

- 다중 조건문 

num = 82

if num >= 90:
    print("num 등급 A", num)
elif num >= 80:
    print("num 등급 B", num)
elif num >= 70:
    print("num 등급 C", num)
else:
    print("꽝")

 num 등급 B 82 

num 이 82 이므로 등급 B가 출력된다. elif는 else if 의 줄임말이다. if가 실행되지 않으면 elif로 가게 된다. 만약 위의 경우에서 elif 대신 if를 쓴다면 ,

 num 등급 B 82 
 num 등급 C 82 

이와 같은 결과가 나올 것이다. 윗줄의 if문이 실행이 되든 안되든 모든 if문을 검사하기 때문이다. 이것이 elif가 필요한 이유다. 

- 중첩 조건문 

age = 27 
height = 175

if age >= 20: 
    if height >= 170:
        print('A 지망 지원 가능')
    elif height > 160:
        print('B 지망 지원 가능')
    else:
        print('지원 불가')

else:
    print('20세 이상 지원 가능')

 A 지망 지원 가능 

이처럼 if문 안에 if문을 사용할 수 있다. age가 20 이상일 때 , height 를 검사하는 중첩 조건문이다.