AWS에서 제공하는 관계형 데이터베이스 서비스

AWS RDS 접속

터미널에서 mysql -h <엔드포인트> -P <포트> -u <유저이름> -p

SQL File

SQL FILE이란, SQL 쿼리를 모아 놓은 파일

실행 방법 1. mysql 로그인 후

(1) source 파일경로/파일이름.sql (2) . 파일경로/파일이름.sql (source 대신 . 사용 가능) (3) . 파일이름.sql (파일이 있는 폴더를 사용중인 경우)

실행방법 2. 외부에서 바로 실행

mysql -u username -p dbname < 파일경로/파일이름.sql

Database Backup

특정 DB 백업

SQL File로 Database를 백업할 수 있다. mysqldump -u username -p dbname > backup.sql

모든 DB 백업

mysqldump -u username -p --all-databases > backup.sql

예시) zerobase 백업 mysqldump -u root -p zerobase > zerobase.sql

Database Restore

데이터베이스를 백업한 SQL File을 실행하여 그 시점으로 복구하거나 이전 할 수 있다. 실행 방법 - source name.sql

Table Backup

Table 단위 백업 mysqldump -u username -p dbname tablename >backup.sql

예시) # celeb 테이블 백업 mysqldump -u root -p zerobase celeb > celeb.sql

Table Restore

Table을 백업한 파일을 실행하여, 해당 테이블을 복구하거나 이전할 수 있다. SQL File을 실행하는 방법과 동일함

Table Schema Backup

데이터를 제외하고 테이블 생성 쿼리만 백업할 수 있다.

특정 Table Schema Backup

mysqldump -d -u username -p dbname tablename > backup.sql

모든 Table Schema Backup

mysqldump -d -u username -p dbname > backup.sql

여러 개의 SQL문을 합쳐서 하나의 SQL 문으로 만들어주는 방법 (주의, 칼럼의 개수가 같아야함)

Union: 중복된 값을 제거하여 알려준다. Union ALL: 중복된 값도 모두 보여준다.

select col1, col2 from table A Union | Union ALL select col1, col2 from table B;

Join

두 개 이상의 테이블을 결합하는 것

출처 - 제로베이스

Inner join

두 개의 테이블에서 공통된 요소들을 통해 결합하는 조인방식

select col1, col2, ... from tableA inner join tableB on tableA.column = tableB.column where condition;

select celeb.id, celeb.name, snlshow.id, snlshow.host
from celeb
inner join snlshow
on celeb.name = snlshow.host;

Left join

두 개의 테이블에서 공통영역을 포함해 왼쪽 테이블의 다른 대이터를 포함하는 조인방식

select col1, col2, ... from tableA left join tableB on tableA.column = tableB.column where condition;

select celeb.id, celeb.name, snlshow.id, snlshow.host
from celeb
left join snlshow
on celeb.name = snlshow.host;

Right join

두 개의 테이블에서 공통영역을 포함해 오른쪽 테이블의 다른 데이터를 포함하는 조인방식

select col1, col2, ... from tableA right join tableB on tableA.column = tableB.column where condition;

select celeb.id, celeb.name, snlshow.id, snlshow.host
from celeb
right join snlshow
on celeb.name = snlshow.host;

Full outer join

두 개의 테이블에서 공통영역을 포함하여 양쪽 테이블의 다른 영역을 모두 포함하는 조인방식 (MySQL에서 지원 안함)

select col1, col2, ... from tableA full outer join tableB on tableA.column = tableB.column where condition;

MySQL에서는 FULL JOIN을 지원하지 않으므로 다음의 쿼리로 같은 결과를 만들 수 있다.

select col1, col2, ...
from tableA
left join tableB
on tableA.column = tableB.column

UNION

select col1, col2, ...
from tableA
right join tableB
on tableA.column = tableB.column
where conditionl

self join

가장 많이 사용되는 방식, inner join과 같은 결과 -> join되는 테이블 간의 공통된 데이터를 가져옴

select col1, col2, ... from tableA, tableB where condition (tableA.col1 = tableB.col2);

Concat

여러 문자열을 하나로 합치거나 연결 select concat('string1' , 'string2') from tablename;

예제 select concat('이름: ', name) from celeb

Alias

컬럼이나 테이블 이름에 별칭 생성

ALIAS 문법1- Column select column as alias from tablename;

예제 1) select name as '이름' from celeb;

ALIAS 문법2- Table select column1 , column2 from tablename as alias

예제2) select name as '이름', agency as '소속사' from celeb;

예시3) name과 job_title을 합쳐서 profile 이라는 별칭 만들어서 검색

select concat(name, ' : ', job_title) as profile from celeb;

예제4) snl_show에 출연한 celeb을 기준으로 두 테이블을 조인하여, celeb 테이블을 c, snl_show는 s라는 별칭을 만들어서 출연한 시즌과 에피소드, 이름, 직업을 검색

select s.season, s.episode,c.name, c.job_title from celeb as c, snlshow as s where c.name = s.host;

Distinct

검색한 결과의 중복 제거 select distinct column1, column2 from tablename;

예제1) #연예인 소속사 종류를 검색 - 중복 제외

Limit

검색결과를 정렬된 순으로 주어진 숫자만큼 조회 select column1, column2,... from tablename where condition limit number;

• 요소들의 모음을 나타내는 자료형
• 요소들을 대괄호([])로 감싸주어 만들 수 있습니다.
• 모든 자료형을 리스트의 요소로 담을 수 있습니다.

리스트 함수

len: 리스트의 길이를 구함.

a = [1,2,3,4,5]
len(a)
깂 = 5

sum, min, max: 리스트 요소들의 합, 최솟값, 최댓값을 구함.

sum(a)/len(a)
값 = 3.0

in: 특정 요소가 리스트 안에 있는지 확인

a = ['a','b','c','d','e']
'a' in a
값 = True

append: 리스트의 맨 마지막에 요소를 추가

a = [1,2,3]
a.append(4)
print(a) #[1,2,3,4]

extend: 리스트의 맨 마지막에 다른 리스트를 추가

a = [1,2,3]
a.extend([4,5])
print(a) #[1, 2, 3, 4, 5]

insert: 리스트의 특정 위치에 특정 요소를 삽입

a = [1,2,3,4]
a.insert(3,2) #4 번째 자리에 '2' 추가 -> 
print(a) # [1,2,3,2,4]

remove, pop: 리스트의 요소를 삭제

#remove: 특정 요소를 제거
a = [1,2,3,4]
print(a)
a.remove(4) #'4'제거
print(a) #[1,2,3]

#pop: 특정 위치의 요소를 제거하여 그 요소를 반환
a.pop(2) #3 번째 위치인 3을 반환
print(a) # [1.2]

count: 리스트의 특정 요소의 개수를 반환

a = [1,1,2,3]
a.count(1) #'1'이 리스트안에 2개 있음 -> 값 = 2

index: 리스트에 요소가 있는 경우 인덱스 값을 반환

a = ['a','b',1,2]
a.index(1) #2

sort, sorted, reverse: 리스트를 정렬

#sort: 정렬된 리스트를 변환
a = [1,20,23,2]
a.sort()
print(a) #[1,2,20,23[]

#sorted: 정렬된 리스트를 출력만 함 (리스트 자체 변경x)
a = [1,20,23,2]
sorted(a) #[1,2,20,23]

print(a) #리스트 변경 x -> [1,20,23,2]

#내림차순으로 바꾸고 싶은 경우
a = [1,20,23,2]
sorted(a, reverse=True) #[23, 20, 2, 1]

#오름차순으로 바꾸고 싶은 경우
a = [1,20,23,2]
sorted(a, reverse=False) #[1, 2, 20, 23]

join: 리스트의 요소들을 하나의 문자열로 함침 (문자일 경우만 사용 가능)

a = ['a','b','c','d','e']
print('-'.join(a)) #a-b-c-d-e
print('/'.join(a)) #a/b/c/d/e
print(''.join(a)) #abcde

split: 문자영을 리스트의 요소들로 쪼갭니다.

a = 'a b c d e'
a.split() #공백을 기준으로 split ->['a', 'b', 'c', 'd', 'e']

a = 'a,b,c,d,e'
a.split(',') #','를 기준으로 split -> ['a', 'b', 'c', 'd', 'e']

튜플

튜플이란?

• 리스트와 비슷하게 여러 요소들을 묶을 수 있습니다.
• 다만 튜플의 요소는 수정이나 삭제가 불가능합니다. (값 치환 불가능)
• 프로그램 실행 중 절대 변하지 않거나 변해서는 안되는 값들이 있다면 튜플로 저장하는 것이 좋습니다.
• 요소들을 괄호(())로 감싸주면 튜플이 됩니다.

튜플 함수

• len: 튜플의 길이를 구합니다.
• sum, min, max: 튜플의 요소들의 합, 최솟값, 최댓값을 구합니다.
• in: 특정 요소가 튜플 안에 있는지 확인합니다.
• count: 튜플의 특정 요소의 개수를 반환합니다.
• index: 튜플에 요소가 있는 경우 인덱스 값을 반환합니다.
• join: 튜플의 요소들을 하나의 문자열로 합칩니다.

튜플 함수 심화

• max(튜플, key = lambda x:x[인덱스]) : 다중 튜플의 경우 정렬 기준을 정의하여 튜플 내 최댓값을 탐색함
• min(튜플, key = lambda x:x[인덱스]) : 다중 튜플의 경우 정렬 기준을 정의하여 튜플 내 최솟값을 탐색함

  a = (('a', 1), ('b',7), ('c', 3), ('d', -5), ('e', -9))
  print(max(a, key = lambda x:x[0])) #인덱스 0인 a (문자)를 기준으로 최댓값 탐색
  print(max(a, key = lambda x:x[1])) #인덱스 1인 1 (숫자)를 기준으로 최댓값 탐색
  

print(min(a, key = lambda x:x[0]))인덱스 0인 a (문자)를 기준으로 최솟값 탐색 print(min(a, key = lambda x:x[1]))인덱스 0인 a (문자)를 기준으로 최솟값 탐색

#두번째 요소의 절댓값을 기준으로 최댓값/최솟값을 탐색하고 싶다면? print(max(a, key = lambda x:abs(x[1]))) #('e', -9) print(min(a, key = lambda x:abs(x[1]))) #('a', 1)

### 딕셔너리
#### 딕셔너리란? 
* 키(Key): 값(Value)의 쌍이 모여있는 사전 형태의 자료형입니다.
* 키: 값의 쌍을 중괄호({})로 감싸줍니다.
* 변수명 = {'키1':값, '키2':값, ...}
* 키는 중복될 수 없고, 리스트는 키가 될 수 없습니다.
위치로 인덱싱이 되지 않습니다.

dic = {'name':'merry',
'num':1,
'birth':'jan'} dic # output {'name': 'merry', 'num': 1, 'birth': 'jan'}

#### 딕셔너리 요소 추가, 삭제하기
추가: 딕셔너리변수명[추가할키]=추가할값

print(dic) #{'name': ['merry', 'john'], 'num': [1, 2, 3], 'birth': ['jan', 'feb', 'nov'] dic['country'] = ['Korea','US'] print(dic) #{'name': ['merry', 'john'], 'num': [1, 2, 3], 'birth': ['jan', 'feb', 'nov'], 'country': ['Korea', 'US']}

삭제: del 딕셔너리변수명[삭제할키]

del dic['country'] print(dic) #{'name': ['merry', 'john'], 'num': [1, 2, 3], 'birth': ['jan', 'feb', 'nov']}

#### 딕셔너리 키로 값 찾기
딕셔너리변수명[찾을키]

print(dic['name']) #['merry', 'john'] print(dic['num']) #[1, 2, 3]

#### 딕셔너리 함수
keys(): 키들을 반환합니다.
values(): 값들을 반환합니다.
items(): 키와 값의 튜플 쌍들을 반환합니다.

dic #{'name': ['merry', 'john'], 'num': [1, 2, 3], 'birth': ['jan', 'feb', 'nov']}

print(dic.keys()) #dict_keys(['name', 'num', 'birth'])

print(dic.values()) #dict_values([['merry', 'john', 'kevin'], [1, 2, 3], ['jan', 'feb', 'nov']])

print(dic.items())#dict_items([('name', ['merry', 'john', 'kevin']), ('num', [1, 2, 3]), ('birth', ['jan', 'feb', 'nov'])]) #위의 값들의 타입은 dict_keys or values ,or items라는 유니크한 값을 가짐. 따라서 리스트의 형태로 변환하고 싶으면 list()함수로 감싸줘야됨.

get(원하는키값): 원하는 키 값에 대응되는 값을 반환합니다.
딕셔너리변수명[원하는키값]과 똑같은 값을 반환합니다.

dic.get('name')#['merry', 'john'] dic['name'] #위와 같은 값

update: 딕셔너리에 새로운 딕셔너리를 추가합니다.

dic1 = {'a':[1,2], 'b':3, 'c':[4,5,6]} dic2 = {'d':10, 'e':[102,101]} dic1.update(dic2) dic1 #{'a': [1, 2], 'b': 3, 'c': [4, 5, 6], 'd': 10, 'e': [102, 101]}

zip: 튜플/리스트 두 개를 하나의 딕셔너리로 변환합니다.

keys = ("a", "b") values = (1,2) result = dict(zip(keys, values)) print(result) #{'a': 1, 'b': 2}

keys = ["a", "b"] values = [1,2] result = dict(zip(keys, values)) print(result) #{'a': 1, 'b': 2}

주요 용어들

database란, 여러 사람이 공유하여 사용할 목적으로 체계화해 통합, 관리하는 데이터의 집합체

DBMS 란 (Database Management System), 사용자와 데이터베이스 사이에서 사용자의 요구에 따라 정보를 생성해주고 데이터베이스를 관리해주는 소프트웨어

관계형 데이터 베이스란 (RDB: Relational Database), 서로간에 관계가 있는 데이터 테이블들을 모아둔 데이터 저장공간

SQL

SQL이란, 데이터베이스에서 데이터를 정의, 조작, 제어하기 위해 사용하는 언어

SQL 구성

데이터 정의 언어(DDL: Data Definition Language) -CREAT, ALTER, DROP 등의 명령어

데이터 제어 언어 (DLC: Data Control Languages) -GRANT, REVOKE, COMMIT, ROLLBACK 등의 명령어

Database 관리

CREAT - 데이터 베이스 생성 ex)CREATE DATABASE testdb;

USE - 해당 데이터베이스로 이동 ex) USE testdb;

DROP - 데이터베이스 삭제 ex) DROP DATABASE dbname;

User 관리

User 생성 - localhost (현재 PC에서 접근 가능한 계정) 현재 PC에서만 접속 가능한 사용자를 비밀번호화 함께 생성 CREAT USER 'username'@'localhost' identified by 'password';

현재 PC에서 접근 가능한 계정 삭제 DROP USER 'noma'@'localhost'

User 생성 - % (외부에서 접속 가능) CREAT USER 'username'@%'localhost' identified by 'password';

외부 유저 계정 삭제 DROP USER 'noma'@'%'

User권한 관리

user 권한 확인 사용자에게 부여된 모든 권한 목록을 확인 SHOW GRANTS FOR 'username'@'localhost';

사용자에게 특정 데이터베이스의 모든 권한을 부여 GRANT ALL ON dbname.* to 'username'@'localhost';

사용자에게 특정 데이터베이스의 모든 권한을 삭제 REVOKE ALL ON dbname.* from 'username'@'localhost';

Table

Table이란, 데이터베이스 안에서 실제 데이터가 저장되는 형태이고, 행(row)과 열(column)로 구성된 데이터 모음

Table 생성 create table tablename (column datatype, column datatype);

Table 목록 확인 문법 show tables;

Table 정보 확인 문법 (description) desc tablename;

Table 이름 변경 alter table tablename rename new_table;

Table Column 추가 alter table tablename add column columnname datatype;

Table Column 데이터타입 변경 alter table tablename modify column columnname datatype;

Table Column 이름 변경 alter table tablename chage column old_columnname, new_columnname, new_datatype;

Table Column 삭제 alter table tablename drop column columnname;

insert - 데이터를 추가하는 명령어 입력한 컬럼 이름의 순서와 값의 순서가 일치하도록 주의! insert into tablename (col1, col2,...) values (value1, value2,....);

모든 컬럼값을 추가하는 경우 모든 컬럼값을 추가하는 경우에는 다음과 같이 컬럼 이름을 지정하지 않아도 되지만, 입력하는 값의 순서가 테이블의 컬럼 순서와 일치하도록 주의! insert into tablename values (val1, val2, ...);

select - 데이터를 조회하는 명령어 태이블 내의 특정 칼럼에 대한 데이터를 조회 select column1, column2, ... from tablename;

테이블 내의 모든 컬럼에 대한 데이터를 조회하는 경우 select * from tablename;

where - 테이블 내에서 조건을 만족하는 데이터 조회 select column1, column2, ... from tablename where condition;

update - 데이터를 수정하는 명령어 update tablename set column1 = value1, column2 = value 2, ... where condition;

delete - 데이터를 삭제하는 명령어 delete from tablename where condition;

order by - select 문에서 데이터를 특정 컬럼을 기준으로 오름차순 혹은 내림차순 정렬 asc (Ascending): 오름차순 정렬 desc(descending): 내림차순 정렬

select col1, col2 from tablename order by col1, col2, acs | desc;

Logical operators

And 문법 조건을 모두 만족하는 경우 True select col1, col2 from tablename where condition1 AND condition2 ..

OR 문법 하나의 조건이라도 만족하는 경우 TRUE select col1, col2 from tablename where condition1 or condition2 ..

NOT 문법 조건을 만족하지 않는 경우 True select col1, col2 from tablename where not condition

Between 문법 조건값이 범위 사위에 있으면 True select col1, col2 from tablename where col1 BETWEEN value1 AND value2;

In 문법 목록 안에 조건이 존재하는 경우 True select col1, col2 from tablename where column IN (value1, value2);

Like 문법 조건값이 패턴에 맞으면 True select col1, col2 from tablename where column like pettern;

#소속사 이름이 'YG엔터테이먼트'인 데이터  검색
select * from celeb where agency like 'YG엔터테이먼트';

#'YG'로 시작하는 소속사 이름을 가진 데이터 검색
select * from celeb where agency like 'YG%';

#'엔터테이먼트'로 끝나는 소속사 이름을 가진 데이터를 검색
select * from celeb where agency like '%엔터테이먼트';

#직업명에 '가수'가 포함된 데이터를 검색
select * from celeb where job_title like '%가수%';

#소속사 이름의 두 번째 글자가 G인 데이터를 검색
select * from celeb where agency like '_G%';

#직업명이 '가'로 시작하고 최소 2글자 이상인 데이터 검색
select * from celeb job_title like '가_%';


#직업명이 '가'로 시작하고 최소 5글자 이상인 데이터 검색
select * from celeb job_title like '가____%';

#직업명이 '영'으로 시작하고 '모델'로 끝나는 데이터 검색
select * from celeb where job_title like '영%모델';

용어 정리 (출처- https://youtu.be/FRHGtAvU03Q?si=WU-AqPXehcSQOAe6)

클래스: 제품의 설계도 객체: 설계도로 만든 제품 속성: 클래스안의 변수 메서드: 클래스안의 함수 생성자: 객체를 만들 때 실행되는 함수 인스턴스: 메모리에 살아있는 객체

실습

속성이 색, 길이, 무게를 가진 5가지의 다른 비행기 객체 만들기
class Airplane:
    def __init__(self, color, length, weight):
        self.color = color
        self.length = length
        self.weight = weight

    def take_off(self):
        print('take_off')

    def landing(self):
        print('landing')

    def print_plane_info(self):
        print(f'flight\'s color is {self.color}')
        print(f'flight\'s length is {self.length}')
        print(f'flight\'s weight is {self.weight}')

plane1 = Airplane('red', 200, 400)
plane2 = Airplane('blue', 210, 433)
plane3 = Airplane('white', 260, 4600)
plane4 = Airplane('orange', 240, 490)
plane5 = Airplane('black', 230, 404)

plane1.print_plane_info()
plane2.print_plane_info()
plane3.print_plane_info()
plane4.print_plane_info()
plane5.print_plane_info()

객체와 메모리

변수는 객체의 메모리 주소를 저장하고 이를 이용해서 객체를 참조한다.

class Robot:
  def __init__(self, color, height, weight):
    self.color = color
    self.height = height
    self.weight = weight

   def print_robot_infor(self):
    print(f'color = {self.color}')
    print(f'height = {self.height}')
    print(f'weight = {self.weight}')

rb1 = Robot('red', 200, 88) #생성된 객체가 있는 메모리의 주소값이 rb1에 들어감
rb2 = Robot('blue', 230, 188)
rb3 = rb1 #rb3는 rb1이 가지고 있는 주소값이 카피된것. 즉, 하나의 객체를 공유

# rb1.print_robot_infor()
# rb2.print_robot_infor()
# rb3.print_robot_infor()

#속성 변경
rb1.color = 'gray'
rb1.height = 3000
rb1.weight = 300000

rb1.print_robot_infor()
rb2.print_robot_infor()
rb3.print_robot_infor() #rb1과 같은 값을 나타냄

객체 복사에 대한 이해 (얕은 복사와 깊은 복사)

얕은 복사란, 객체 주소를 복사하는 것으로 객체 자체가 복사되지 않는다.

class TemCls:

  def __init__(self, n, s):
      self.number = n
      self.str = s

  def print_cls_info(self):
    print(f'self.number: {self.number}')
    print(f'self.str: {self.str}')

#얕은 복사
tc1 = TemCls(10, 'hello')
tc2 = tc1
#
# tc1.print_cls_info()
# tc2.print_cls_info()
tc2.number = 22
tc2.str = 'ddd'

tc1.print_cls_info()
tc2.print_cls_info()

깊은 복사 깊은 복사란, 객체 자체를 복사하는 것으로 또 하나의 객체가 만들어진다.

#깊은 복사
import copy

tc1 = TemCls(10, 'hello')
tc2 = copy.copy(tc1)#레퍼런스가 갖고 있는 객체를 복사. 즉, tc1이랑은 아예 다른 객체가 됨
tc2.str = 'www'
tc2.number = 22

tc1.print_cls_info()
tc2.print_cls_info()#다른 속성을 가진 객체 정보가 출력

다양한 깊은 복사 방법

1. 반복문 이용하기

   import copy
   scores = [2,4,5,5,2,1,3]
   scores_copy = []
   

for s in scores: scores_copy.append(s) print(f'id(scores): {id(scores)}') print(f'id(scores_copy): {id(scores_copy)}') #서로 다른 값이 출력

2. extend 이용하기

scores_copy.extend(scores) print(f'id(scores): {id(scores)}') print(f'id(scores_copy): {id(scores_copy)}') #서로 다른 값이 출력

3. 카피 이용하기

scores_copy = scores.copy() print(f'id(scores): {id(scores)}') print(f'id(scores_copy): {id(scores_copy)}') #서로 다른 값이 출력

4. 리스트 슬라이싱 이용하기

scores_copy = scores[:]#리스트 슬라이싱 print(f'id(scores): {id(scores)}') print(f'id(scores_copy): {id(scores_copy)}') #서로 다른 값이 출력

_실습_

선수의 원본 점수를 이용해서 평균을 출력하고, 최고값과 최저값을 제외한 평균을 출력하는 프로그램을 만들어보자.

player_original_score = [8.7, 9.1, 8.9, 9.0, 7.9, 9.5, 8.8, 8.3] player_original_score.sort() #원본 점수 정렬

print(player_original_score) #정렬 확인

copy_score = player_original_score.copy() #복사본 만들기

print(copy_score) #복사본 확인

copy_score.sort() #복사본 정렬

print(copy_score) #정렬 확인

del copy_score[0] #복사본의 최솟값 제거 del copy_score[-1] #복사본의 최댓값 제거

print(copy_score) #제거 확인

print(f'player original score is: {player_original_score}') print(f'player copy score is: {copy_score}')

original_total = round(sum(player_original_score),2) #원본 점수 총합 소수 둘 째자리까지 저장 original_avg = round(original_total/len(player_original_score),2) #원본 평균 점수 소수 둘 째자리까지 저장 print(f'original total score is {original_total}') print(f'original avg score is {original_avg}')

copy_total = round(sum(copy_score),2) #복사본 점수 총합 소수 둘 째자리까지 저장 copy_avg = round(original_total/len(copy_score),2) #원본과의 평균 비교를 위해 원본의 총합/ 복사본의 수 (6) print(f'copy total score is {copy_total}') print(f'copy avg score is {copy_avg}')

print(f'original avg - copy avg is {original_avg - copy_avg}')

#결과 player original score is: [7.9, 8.3, 8.7, 8.8, 8.9, 9.0, 9.1, 9.5] player copy score is: [8.3, 8.7, 8.8, 8.9, 9.0, 9.1] original total score is 70.2 original avg score is 8.78 copy total score is 52.8 copy avg score is 11.7 original avg - copy avg is -2.92

### 클래스 상속
클래스는 또 다른 클래스를 상속해서 내 것처럼 사용할 수 있다. 

class Normal_car:

def drive(self): print('{normal_car} drive() called!')

def back(self): print('{normal_car] back() called!')

class Turbo_car(Normal_car): #Turbo_car 클래스가 Normal_car를 상속

def turbo(self): print('{turbo_car} turbo() called!')

my_turbo_car = Turbo_car()

my_turbo_car.turbo() #Turbo_car 클래스가 Normal_car를 상속했기 때문에 back과 drive 둘 다 사용 가능. my_turbo_car.back() my_turbo_car.drive()

_실습_

덧셈, 뺄셈 기능이 있는 클래스를 만들고, 이를 상속하는 클래스를 만들어서 곱셈과 나눗셈 기능을 추가해 보자.

class Calculator_super: def add(self, n1, n2): return n1 + n2 def sub(self, n1, n2): return n1 - n2

class Caculator_child(Calculator_super): def multi(self, n1, n2): return n1 * n2

def div(self, n1, n2): return n1 / n2

my_calculator = Caculator_child()

print(f'add: {my_calculator.add(10,20)}') print(f'sub: {my_calculator.sub(10,20)}') print(f'multiply: {my_calculator.multi(10,20)}') print(f'divide: {my_calculator.div(10,20)}')

### 생성자
객체가 생성될 때 호출하면 ____int____()가 자동으로 호출된다.
____int____()가 속성을 초기화 한다.

class Calculator(): def init(self, n1, n2): print('[Calculator]inti() called!') self.num1 = n1 self.num2 = n2 cal = Calculator(10,20) #속성 초기화 print(f'num1: {cal.num1}') print(f'num2: {cal.num2}')

양식 업데이트를 위한 super():

class P_Class:

def __init__(self, pnum1, pnum2):
    print('[P_Class] __init__() called!')

    self.pnum1 = pnum1
    self.pnum2 = pnum2

class C_Class(P_Class):

def __init__(self, cnum1, cnum2): #위 P_Class의 속성이 사라짐
    print('[C_Class] __init__() called!')

        super().__init__(cnum1,cnum2) #P_Class의 속성을 상속하기 위해선 super(). 사용. 즉, 그 전(P_Class)의 내용을 가져옴

    self.cnum1 = cnum1
    self.cnum2 = cnum2

cls = C_Class(10, 20)

print(f'cls.cNum1: {cls.cNum1}') print(f'cls.cNum2: {cls.cNum2}')

print(f'cls.pNum1: {cls.pNum1}') print(f'cls.pNum2: {cls.pNum2}')

_실습_

중간고사 클래스와 기말고사 클래스를 상속관계로 만들고 각각의 점수를 초기화하자. 또한 총점 및 평균을 반환하는 기능도 만들어보자.

class MidExam:

def __init__(self, s1, s2, s3):
    print('[MidExam] __init__()')

      self.mid_kor_score = s1
      self.mid_eng_score = s2
      self.mid_math_score = s3

def print_score(self):
      print(f'mid_kor_score is {self.mid_kor_score}')
      print(f'mid_eng_score is {self.mid_eng_score}')
      print(f'mid_math_score is {self.mid_math_score}')

class FinalExam(MidExam):

def __init__(self, s1, s2, s3, s4, s5, s6):

    super().__init__(s1, s2, s3)

    self.final_kor_score = s4
    self.final_eng_score = s5
    self.final_math_score = s6

def print_score(self):
    super().print_score()
    print(f'final_kor_score is {self.final_kor_score}')
    print(f'final_eng_score is {self.final_eng_score}')
    print(f'final_math_score is {self.final_math_score}')

def get_total_score(self):
    total = self.mid_kor_score + self.mid_eng_score +                 self.mid_math_score + self.final_math_score

    total += self.final_kor_score + self.final_eng_score                     
    return total

return self.mid_kor_score + self.mid_eng_score + self.mid_math_score + \

self.final_kor_score + self.final_eng_score + self.final_math_score

def get_avg(self):
    return self.get_total_score()/6

exam = FinalExam(33, 55, 99, 44, 59, 88) exam.print_score() print(f'total score: {exam.get_total_score()}') print(f'total score: {exam.get_avg()}')

### 다중 상속
2개 이상의 클래스를 상속하는 것.

class Car01: def drive(self): print('drive() method called')

class Car02: def turbo(self): print('turbo() method called')

class Car03: def fly(self): print('fly() method called')

class Car (Car01, Car02, Car03): def init(self): pass

my_car = Car() my_car.drive() my_car.fly() my_car.turbo()

_실습_

BasicCalculator와 DeveloperCalculator 클래스를 다음과 같이 만들고 이들 클래스를 상속해서 Calculator 클래스를 만들고 사용해보자. class BasicCalculator:

def add(self, n1, n2):
    return n1 + n2

def sub(self, n1, n2):
    return n1 - n2

def mul(self, n1, n2):
    return n1 * n2

def div(self, n1, n2):
    return n1 / n2

class DeveloperCalculator:

def mod(self, n1, n2):
    return n1 % n2

def flo(self, n1, n2):
    return n1 // n2

def exp(self, n1, n2):
    return n1 ** n2

class Caculator(BasicCalculator, DeveloperCalculator): def init(self): pass

cal = Caculator() print(cal.flo(10, 20)) print(cal.add(10, 20)) print(cal.sub(10, 20)) print(cal.mul(10, 20)) print(cal.mod(10, 20)) print(cal.exp(10, 20))

### 오버라이딩
하위 클래스에서 상위 클래스의 매서드를 재정의 한다.

class Robot:

def __init__(self, c, h, w):
  self.color = c
  self.height = h
  self.weight = w

def fire(self):
    print('미사일 발사!')

def print_Robot_info(self):
  print(f'self.color = {self.color}')
  print(f'self.height = {self.height}')
  print(f'self.weight = {self.weight}')

class New_Robot(Robot):

def __init__(self, c, h, w):
    super().__init__(c,h,w)

def fire(self): #fire 재정의 (override)
    #super().fire()
    print('레이저 발사')

my_robot.fire()
    my_robot = New_Robot('red', 100, 200)
    my_robot.print_Robot_info()

_실습_

삼각형 넓이를 계산하는 클래스를 만들고 이를 상속하는 클래스에서 get_triangle_area()를 오버라이딩 해서 출력 결과가 다음과 같을 수 있도록 클래스를 만들어보자.

class Triangle_Area: def init(self, w, h): self.width = w self.height = h

def print_triangle_info(self):
  print(f'triangle width : {self.width}')
  print(f'triangle height : {self.height}')

def get_traingle_area(self):
    return self.width * self.height/ 2

class New_Triangle_Area(Triangle_Area):

def __init__(self, w, h):
    super().__init__(w,h)

def get_traingle_area(self):
    return str(super().get_traingle_area()) + '㎠'

ta = New_Triangle_Area(20, 4) ta.print_triangle_info() ta_area = ta.get_traingle_area()

print(f'area: {ta_area}')

### 추상클래스
상위 클래스에서 하위 클래으세 메서드 구현을 강요한다.

from abc import ABCMeta from abc import abstractmethod

class AirPlane(metaclass=ABCMeta):

@abstractmethod #강제로 구현해야 되는 메소드 위에 붙여줌줌
def flight(self): #AirPlane을 상속하기 위해서는 이 부분을 구현해서 써야됨
    pass

def forward(self):
    print('전진!')

def backward(self):
    print('후진!')

class Airliner(AirPlane):

def __init__(self, c):
    self.color = c

def flight(self):
    print('시속 300km/h 비행')

al = Airliner('White') al.forward() al.backward() al.flight()

_실습_

계산기 추상 클래스를 만들고 이를 이용해서 새로운 계산기 클래스를 만들어보자. 추상 클래스에는 덧셈, 뺄셈, 곱셈, 나눗셈 기능이 선언되어 있어야 한다.

from abc import ABCMeta from abc import abstractmethod

class Calculator(metaclass= ABCMeta):

@abstractmethod
def add(self,n1,n2):
    pass

@abstractmethod
def sub(self, n1, n2):
    pass

@abstractmethod
def multi(self, n1, n2):
    pass

@abstractmethod
def div(self,n1,n2):
    pass

class DevelopCalculator(Calculator):

def add(self,n1,n2):
    print(n1 + n2)

def sub(self,n1,n2):
    print(n1 - n2)

def multi(self,n1,n2):
    print(n1 * n2)

def div(self,n1,n2):
    print(n1 / n2)

def mod(self, n1,n2):
    print(n1 % n2)

def flo(self, n1, n2):
    print(n1//n2)

cal = DevelopCalculator() cal.flo(10,20) cal.mod(10,20) cal.div(10,20) cal.sub(10,20) cal.multi(10,20) cal.add(10,20)

### 예외
예외란, 문법적인 문제는 없으나 실행 중 발생하는 예상하지 못한 문제이다.
ex) 어떤 수를 0으로 나눈 경우

#### 예외처리 (try~except)
발생된 예외를 별도 처리함으로써 프로그램 전체의 실행에 문제가 없도록 함.
예외 발생 예상 구문을 try~except로 감싼다.

n1 = 10; n2 = 0

try: print(n1/n2) except: print('예상치 못한 예외가 발생했습니다.') print('다른 프로그램 실행에는 문제 없습니다.')

print(n1 * n2) print(n1 - n2) print(n1 + n2)

_실습_

사용자로부터 숫자 5개를 입력 받을 때 숫자가 아닌 자료형이 입력되면 예외 처리하는 프로그램을 만들어보자. nums = []

n = 1 while n < 6: try: num = int(input('숫자 입력: '))

except:
    print('예외발생!')
    continue

    nums.append(num)
    n += 1
    print(nums)

예외가 발생하지 않았을 때 실행하는 구문 (try~except~else)
else는 try, except를 사용한 후에만 사용할 수 있다.

nums = [] n =1 while n < 6:

try:
    num = int(input('input number: '))

except:
    print('please type number.')
    continue

else:
    if num % 2 == 0:
        nums.append(num)
        n += 1
else:
    print('The number you typed is odd number.', end = '')
    print('please type the numebr agian')
    continue

print(f'nums = {nums}')

_실습_

사용자로부터 숫자 5개를 입력받아 짝수, 홀수, 실수로 구분해서 각각을 리스트에 저장하는 프로그램을 만들어보자. even_list = []; odd_list=[]; float_list = []

n = 1 while n <6:

try:
    number = float(input('type number: '))
    n += 1
    except:
    print('please type number')
    continue

else:
    if number - int(number) != 0:
        print('it is a float number')
        float_list.append(number)

elif number % 2 == 0:
    print('its an even number')
    even_list.append(int(number))

else:
    print('it is an odd number')
    odd_list.append(int(number))

print(f'float list = {float_list}') print(f'even list = {even_list}') print(f'odd list = {odd_list}')

### Finally, exeption 클래스, raise
Finally - 예외 발생과 상관없이 항상 실행한다.

try: input_Data = input('input number: ') num_int = int(input_Data)

except: print('plase tpye a number')

else: if num_int % 2 == 0: print('its an even number') else: print('its an odd number')

finally: print(f'input data: {input_Data}')

Exception 클래스

num1 = int(input('input num1: ')) num2 = int(input('input num2: '))

try: print(f'num1 / num2 = {num1/num2}') except Exception as e: print(f'exepction: {e}') # print: exepction: division by zero

print(f'num1 + num2 = {num1 + num2}') print(f'num1 - num2 = {num1 - num2}') print(f'num1 * num2 = {num1 * num2}')

raise
raise 키워드를 이용하면 예외를 발생시킬 수 있다.

def div_calculation(n1,n2): if n2 != 0: print(f'{n1} / {n2} = {n1/n2}') else: raise Exception('0으로 나눌 수 없습니다.')

num1 = int(input('input number1: ')) num2 = int(input('input number2: '))

try: div_calculation(num1, num2) except Exception as e: print(f'Exception: {e}')

_실습_

사용자가 문자 메세지를 보낼 때 10글자 이하면 SMS로 발송하고, 10글자를 초과하면 MMS로 발송하는 프로그램을 예외 처리를 이용해서 만들어보자. def sendSMS(msg): if len(msg) > 10: raise Exception('길이초과! MMS로 전환 후 발송',1) else: print('SMS 발송')

def sendMMS (msg): if len(msg) <= 10: raise Exception('길이 미달! SMS로 전환 후 발송',2) else: print('MMS 발송')

msg = input('input message: ')

try: sendSMS(msg) except Exception as e: print(f'e: [e.args[0]') print(f'e: [e.args[1]')

if e.args[1] == 1:
    sendMMS(msg)
elif e.args[1] == 2:
    sendSMS(msg)

#### 사용자 예외 클래스
Exception 클래스를 상속해서 사용자 예외 클래스를 만들 수 있다.

_실습_

관리자 암호를 입력하고 다음 상태에 따라 예외 처리하는 예외 클래스를 만들어보자. class PasswordLengthShortExeption(Exception): def init(self,str): super().init(f'{str}: 길이 5 미만')

class PasswordLengthLongExeption(Exception): def init(self,str): super().init(f'{str}: 길이 10 초과')

class PasswordLengthWrongExeption(Exception): def init(self,str): super().init(f'{str}: 잘못된 비밀번호')

adminPw = input('password: ')

try: if len(adminPw) < 5: raise PasswordLengthShortExeption(adminPw)

elif len(adminPw) > 10:
    raise PasswordLengthLongExeption(adminPw)

elif adminPw != 'admin1234':
    raise PasswordLengthWrongExeption(adminPw)

elif adminPw == 'admin1234':
    print('bingo!')

except PasswordLengthShortExeption as e1: print(e1)

except PasswordLengthLongExeption as e2: print(e2)

except PasswordLengthWrongExeption as e3: print(e3)

### 텍스트 파일 쓰기
#### 파일 열기 - open()

file = open('C:/pythonTxt/test.txt','w') #/test.txt 파일 생성/ ,'w' -> 쓰기모드 strCnt = file.write(dateStr + todaySchedule) print(f'strCnt: {strCnt}')

file.close()

#### 읽기 또는 쓰기 - read() or write()

#예시 1 file = open('C:/pythonTxt/test.txt','r') str = file.read() print(f'str: {str}')

file.close()

예시 2 file = open('C:/pythonTxt/about_python.txt', 'r', encoding= 'UTF8')

str = file.read() print(f'str: {str}') file.close()

str = str.replace('Python', '파이썬', 2) #2개의 Python 문자를 파이썬으로 바꿈 print(f'str: {str}')

with open('C:/pythonTxt/about_python.txt', 'w', encoding='utf-8') as f:

f.write(str) f.close()

#### 파일 닫기 - close()

#### 텍스트파일 열기 모드
#'w': 쓰기 전용 (파일이 있으면 덮어씌움)

url = 'C:/pythonTxt/'

file = open(url + 'hello.txt', 'w') file.write('HELLO PYTHON') file.close()

#'a': 쓰기 전용 (파일이 있으면 덧붙임)

url = 'C:/pythonTxt/'

file = open(url + 'hello.txt', 'a') file.write('\nnice to meet you') file.close()

#'x': 쓰기 전용 (파일이 있으면 에러 발생)

url = 'C:/pythonTxt/'

file = open(url + 'hello.txt', 'x') file.write('\nnice to meet you') file.close()

#'r': 읽기 전용 (파일이 없으면 에러 발생)

url = 'C:/pythonTxt/'

file = open(url + 'hello.txt', 'r') str = file.read() print(str) file.close()

_실습_

사용자가 입력한 숫자에 대한 소수를 구하고 이를 파일에 작성해보자 url = 'C:/pythonTxt/'

def write_prime_numers(n): file = open(url + 'prime_numbers.txt', 'a') file.write(str(n)) file.write('\n') file.close()

input_number = int(input('0보다 큰 정수 입력: ')) for number in range(2,input_number + 1): flag = True for n in range(2, number + 1): if number % n == 0: flag = False break

        if flag:
            write_prime_numers(number)

### with ~ as 문
#읽기

with open(url + '5_036.txt', 'a') as f: f.write('python study!')

#쓰기

with open(url + '5_036.txt', 'r') as f: print(f.read())

_실습_

로또 번호 생성기 프로그램을 만들고 파일에 번호를 출력해보자 import random

url = 'C:/pythonTxt/'

def write_numbers(nums): for idx, num in enumerate(nums): with open(url + 'lotto_num.txt', 'a') as f: if idx < len(nums) -2: f.write(str(num) + ',') elif idx == len(nums) - 2: f.write(str(num) + ',') elif idx == len(nums) - 1: f.write('\n') f.write('Bonus: ' + str(num))

rNums = random.sample(range(1,46),7)

print(f'rNums: {rNums}') write_numbers(rNums)

### writelines()
writelines()는 리스트 또는 튜플 데이터를 파일에 쓰기 위한 함수이다.

languages = ['c++', 'java', 'c#', 'python']

url = 'C:/pythonTxt/' with open(url + 'languages.txt', 'a') as f: f.writelines(languages) #f.writelines(item + '\n' for item in languages) 아이템 하나씩 개행하려면 이렇게

_실습_

딕셔너리에 저장된 과목별 점수를 파일에 저장하는 코드를 작성하자. url = 'C:/pythonTxt/' #특정한 포멧으로 만들고 싶을 때 scoreDic = {'kor': 85, 'eng': 95, 'math': 85, 'sci': 95, 'his': 35}

for key in scoreDic.keys(): with open(url + 'score_dic.txt', 'a') as f: f.write(key + '\t:' + str(scoreDic[key]) + '\n')

scoreDic = {'kor': 85, 'eng': 95, 'math': 85, 'sci': 95, 'his': 35} with open(url + 'scores.txt', 'a') as f: print(scoreDic, file= f) #딕셔너리나 리스트 자체를 저장하고 싶을 때

### readlines()
파일의 모든 데이터를 읽어서 리스트 형태로 변환한다.

url = 'C:/pythonTxt/'

with open(url + 'lans.txt', 'r') as f: lanList = f.readlines()

#### readline()
한 행을 읽어서 문자열로 반환한다.

with open(url + 'lans.txt', 'r') as f: line = f.readline()

while line != '' print(f'line: {line}', end = '') line = f.readline()

_실습_

파일에 저장된 과목별 점수를 파이썬에서 읽어, 딕셔너리에 저장하는 코드를 만들어보자. scoreDic = {} with open(url + 'scores.txt', 'r') as f: line = f.readline()

while line != '': templist = line.split(':') #()것을 기준으로 (구분자) 해서 다 리스트로 분리해줌. scoreDic[templist[0]] = int(templist[1].strip('\n')) #\n 문자 삭제 line = f.readline()

print(f'scoredic: {scoreDic}') ```

함수란, 특정 기능을 재사용하기 위해서 사용한다.

def add_cal ():
    n1 = int(input('n1: '))
    n2 = int(input('n2: '))
print(f'n1 + n2 = {n1+n2}')
add_cal()

def cal_fun():
    n1 = int(input('num1: '))
    n2 = int(input('num2: '))

print(f'n1 * n2 = {n1 * n2}')
print(f'n1 / n2 = {round(n1/n2)}')
cal_fun()

인수와 매개변수

def greet(customer): ---> 매개변수
    print(f'{customer})

greet('홍길동') ---> 인수

#매개변수 개수가 정해지지 않은 경우 '*'를 이용한다.
def print_number(*numbers):
    for number in numbers:
        print(number, end= '')
    print()

print_number()
print_number(1,2,3)
print_number(1,2,3,4,5,6)

실습

국어, 영어, 수학 점수를 입력받고, 입력받은 점수를 이용해서 총점과 평균을 출력하는 함수를 만들어 보자.

def print_score(kor, eng, math):
    sum = kor +eng + math
    avg = sum / 3

    print(f'총점: {sum}')
    print(f'평균: {avg}')
kor_score = int(input('korean score: '))
eng_score = int(input('english score: '))
math_score = int(input('math score: '))

print_score(kor_score, eng_score, math_score)

전역 변수 & 지역 변수

젼역 변수란, 함수 밖에서 정의한 변수. 함수 내부에서 수정할 수 없다. 지역 변수란, 함수 내에서 정의된 변수. 함수가 호출되는 그 순간에만 존재한다.

num_out = 10 #전역변수
def print_numbers():
    num_out = 20 #지역변수
    print(f'num_out: {num_out}')

print_numbers() #값은 20 지역변수 영향
print(f'num_out: {num_out}') #값은 10 전역변수 영향

실습

사용자가 가로, 세로 길이를 입력하면 삼각형과 사각형의 넓이를 출력하는 함수를 만들어보자.

width = int(input('가로 길이: '))
height = int(input('세로 길이: '))

def print_area():
    triangle = width * height/2
    square = width * height
    print(f'삼각형의 넓이는: {triangle}')
    print(f'사각형의 넓이는: {square}')
print_area()

global 키워드

global을 사용하면 함수 안에서도 전역 변수의 값을 수정할 수 있다.

num_out = 10
def print_numbers():
global num_out #전역변수 값 수정 가능
num_out = 20
print(f'num_out: {num_out}')

print_numbers() #값은 20 지역변수 영향
print(f'num_out: {num_out}') #값은 20 global 영향

실습

방문객 수를 카운트하는 함수를 만들어보자.
total_visit = 0

def total_visit_count():
    global total_visit

    total_visit = total_visit + 1
    print(f'누적 방문객 = {total_visit}')

total_visit_count()#누적 방문객 = 1
total_visit_count()#누적 방문객 = 2
total_visit_count()#누적 방문객 = 3
total_visit_count()#누적 방문객 = 4

중첩 함수

중첩 함수란, 함수안에 또 다른 함수가 있는 형태이다. 내부 함수를 함수 밖에서 호출할 수 없다.

def out_func():
    print('outfunc called')

def in_func():
    print('infunc called')
    in_func()

out_func()
in_func() --> error

실습

calculator()함수를 선언하고 이 함수안에 덧셈, 뺄셈, 곱셈, 나눗셈 함수를 선언하자.

def calculator(n1, n2, operator):

    def add_cal():
    print(f'덧셈 = {n1 + n2}')

    def sub_cal():
    print(f'뺄셈 = {n1 - n2}')

    def mul_cal():
    print(f'곱셈 = {n1 * n2}')

    def div_cal():
    print(f'나눗셈 = {n1 / n2}')

    if operator == 1:
        add_cal()
    elif operator == 2:
        sub_cal()
    elif operator == 3:
        mul_cal()
    elif operator == 4:
        div_cal()

while True:
    num1 = float(input('첫 번째 숫자 입력: '))
    num2 = float(input('두 번째 숫자 입력: '))
    operator = int(input('1. 덧셈, 2. 뺄셈, 3. 곱셈, 4. 나눗셈, 5. 종료'))

    if operator == 5:
        print('Thank you')
        break
calculator(num1, num2, operator)

lambda

lambda 키워드를 이용하면 함수 선언을 보다 간단하게 할 수 있다.

def calculator(n1,n2):
    return n1 + n2
    return_value = calculator(10,20)
    print(f'result = {return_value}')

#lambda를 사용하면

calculator = lambda n1,n2: n1 + n2
return_value = calculator(10,20)
print(f'result = {return_value}')

실습

삼각형, 사각형, 원의 넓이를 반환하는 lambda 함수를 만들어보자.

get_triangle_area = lambda n1,n2: n1 * n2 / 2
get_square_area = lambda n1,n2: n1 * n2
get_circle_area = lambda r: r * r * 3.14

weight = int(input('가로 길이: '))
height = int(input('세로 길이: '))
radius = int(input('반지름 길이: '))

triangle = get_triangle_area(weight, height)
square = get_square_area(weight, height)
circle = get_circle_area(radius)

print(f'triangle area = {triangle}')
print(f'square area = {square}')
print(f'circle area = {circle}')

모듈

모듈이란, 이미 만들어진 훌륭한 기능으로 사용자들이 쉽게 사용할 수 있다.

실습

1. random 모듈을 이용해서 1부터 10까지의 정수 중 난수 1개를 발생시켜 보자.
2. random 모듈을 이용해서 0부터 100사이의 난수 10개를 발생시켜 보자.

import random

r_number = random.randint(1,10) #random.randint(범위)
print(f'random number = {r_number}')

r_numbers = random.sample(range(1,101),10) #random.sample(범위, 갯수)
print(f'random numbers = {r_numbers}')

모듈 만들기

1. 파이썬 파일을 만든다. (예시, calculator)

   def add(n1, n2):
    print(f'덧셈의 결과 = {n1 + n2}')
   

def sub(n1, n2): print(f'뺄셈의 결과 = {n1 - n2}')

def mul(n1, n2): print(f'곱셈의 결과 = {n1 * n2}')

def div(n1, n2): print(f'나눗셈의 결과 = {n1 / n2}')

2. 만든 파일의 이름을 import한 후 사용한다.

import calculator

calculator.add(10,20) calculator.sub(10,20) calculator.mul(10,20) calculator.div(10,20)

#### 모듈 사용(import, from, as)
import 키워드를 이용해서 모듈을 임포트 한다.

import키워드를 이용해서 모듈을 임포트 한다. import calculator

calculator.add(10,20) calculator.sub(10,20) calculator.mul(10,20) calculator.div(10,20)

as 키워드를 이용해서 모듈 이름을 단축 시킬 수 있다.

import calculator as cal

calculator.add(10,20) calculator.sub(10,20) calculator.mul(10,20) calculator.div(10,20)

from~as 키워드를 이용해서 모듈의 특정 기능만 사용할 수 있다. 

from calculator import add add(10,20)

from calculator import add, sub add(10,20) sub(10,20)

from calculator import * -> 칼큘레이터에 있는 모든것을 가져오겠다.

### 실행(메인) 파일
실행 파일: 내가 모듈을 실행하는 파일

____name____ 전역 변수: 모듈 이름이 저장되거나, 실행 파일일 경우 '____main____'이 저장된다.

_실습_

실습 #1번 모듈 파일 (unitconversion) def cm_to_mm(n): return round(n * 10,3)

def cm_to_inch(n): return round(n *0.393, 3)

def cm_to_m(n): return round(n * 0.01, 3)

def cm_to_ft(n): return round(n * 0.032, 3)

if name == 'main': print(f'10cm: {cm_to_mm(10)}mm') print(f'10cm: {cm_to_inch(10)}inch') print(f'10cm: {cm_to_ft(10)}ft') print(f'10cm: {cm_to_m(10)}m')

2번 실행 파일 import unitconversion as uc

if name == 'main': user_number = int(input('길이(cm) 입력: '))

result_mm = uc.cm_to_mm(user_number) result_inch = uc.cm_to_inch(user_number) result_m = uc.cm_to_m(user_number) result_ft = uc.cm_to_ft(user_number)

print(f'해당 길이의 mm 변환은 {result_mm}mm입니다.') print(f'해당 길이의 inch 변환은 {result_inch}inch입니다.') print(f'해당 길이의 m 변환은 {result_m}m입니다.') print(f'해당 길이의 ft 변환은 {result_ft}ft입니다.')

#### 자주 사용하는 모듈 모음

math 모듈: 수학 관련 모듈

#합 list = [2, 4, 5, 3, 29] print(sum(list))

#최댓값 print(max(list))

#최솟값 print(min(list))

#거듭제곱 print(pow(12,2)) #12의 2제곱

#반올림 print(round(3.13432,2))

import math

#절댓값 print(math.abs(-10))

#올림 print(math.ceil(5.81))

#내림 print(math.floor(5.22))

#버림 print(math.trunc(5.32))

#최대공약수 print(math.gcd(14,21))

#팩토리얼 print(math.factorial(10))

#제곱근 print(math.sqrt(4))

random 모듈: 난수 관련 모듈

#1~10까지 난수 1개 random.randint(1,10)

#1~50까지 난수 5개 random.sample(range(1,50),5)

time 모듈: 시간 관련 모듈

#년도 print(f'localtime year: {local_time.tm_year}') #월 print(f'localtime month: {local_time.tm_mon}') #일자 print(f'localtime day: {local_time.tm_mday}') #시 print(f'localtime hour: {local_time.tm_hour}') #분 print(f'localtime min: {local_time.tm_min}') #초 print(f'localtime second: {local_time.tm_sec}') #요일 (0부터 월요일) print(f'localtime week of day: {local_time.tm_wday}') ```

참일 경우 앞이 출력, 불인 경우 뒤가 출력

num1 = 10
num2 = 100

numResult = True if num1> num2 else False
print('num1 > num2: {}'.format(numResult))
OR
print('num1 > num2 크다') if numResult else print('num2> num1')

실습

**국어, 영어, 수학 점수를 입력하면 조건식을 이용해서 과목별 결과와 전체 결과를 출력하는 코드를 작성해보자. (과목별 합격 점수: 60점, 전페 합격 평균 점수: 70점)**

import operator
passScore = 60
passAvgScore = 70

kor = int(input('국어 점수: '))
eng = int(input('영어 점수: '))
math = int(input('수학 점수: '))
totalScore = kor + eng + math
avg = totalScore/3

print('국어: PASS')if operator.gt(kor, passScore) else print('국어: FAIL')
print('영어: PASS')if operator.gt(eng, passScore) else print('영어: FAIL')
print('수학: PASS')if operator.gt(math, passScore) else print('수학: FAIL')
print('시험: PASS')if operator.gt(avg, passAvgScore) else print('시험: FAIL')
print('총점: %d, 평균: %.2f' % (totalScore, avg))

조건문 (if문)

if문 -> 단일조건 실습

**실내 온도를 입력하고 온도가 28도 이상이면 '냉방 작동', 20도 이하면 '난방 작동'이 출력되는 코드를 작성하자**

highTem = 28
lowTem = 20
insideTem = int(input('실내 온도 입력: '))

if insideTem <= lowTem:
    print('난방 작동')

if insideTem >= highTem:
    print('냉방 작동')

양자택일 조건문 (if~else문)

if my_score >= pass_score:
    print('PASS')
else:
    print('FAIL')

실습

**소수점 첫 번째 자리에서 반올림하는 프로그램을 만들어 보자.**

floatNum = float(input('소수 입력: '))

if floatNum - int(floatNum) >= 0.5:
    print('{}: {}'.format('올림',floatNum+1))
else:
    print('{}: {}'.format('버림', int(floatNum)))

다자택일 조건문 (if~elif)

주의할 점: 조건식 순서가 중요하다. 조건 범위를 명시한다.

example_score = int(input('시험 성적 입력: '))
grades = ' '

if example_score >= 90:
grades = 'A'
elif example_score >= 80:
grades = 'B'
elif example_score >= 70:
grades = 'C'
elif example_score >= 60:
grades = 'D'
else:
grades = 'F'
print('성적: {} \t 학점: {}'.format(example_score, grades))

반복문

반복문 이란? 특정 실행을 반복한느 것. 반복문을 사용하면 프로그래밍이 간결하고 유지 보수가 쉽다.

for i in range(1,20):
print('{} * {} = {}'.format(5,i,(5*i))

횟수에 의한 반복

for i in range(10):
result = 7 * i
print('{} * {} = {}'.format(7,i,result))

range() 기본 사용 방법 range(시작, 끝, 단계) ex) range(1,11,1) -> 1부터 10까지 1씩 증가 단계 매개변수 생략 -> 단계가 1인 경우 생략 가능, 시작이 0인 경우 생략 가능

조건에 의한 반복

n = 1
while n< 10:
result = 7 * n
print('{} * {} = {}'.format(7,n, (7*n)))
n += 1

실습

multi = int(input('희망 구구단 입력: '))

n = 1
while n < 10:
result = multi * n
print('{} * {} = {}'.format(multi, n, result))
n += 1

무한 반복 실형 논리형 데이터 사용 실습

**하루에 독감으로 병원에 내방하는 환자 수가 50명에서 100명 사이일 때, 누적 독감 환자 수가 최초 10,000명을 넘는 날짜를 구해보자.**
import random
flag = True
sum = 0
date = 0
while flag:
dayPatient = random.randint(50,100)
sum += dayPatient
date += 1
print('날짜: {}, \t 오늘 환자 수: {}, \t 누적 환자수: {}'.format(date, dayPatient, sum))

if sum >= 10000:
flag = False

반복문 제어

Continue 키워드

반복 실행 중 continue를 만나면 실행을 생략하고, 다음 반복 실행문으로 넘어간다.

for i in range(100):
if i % 7 != 0:
continue
print('{}는 7의 배수 입니다.'.format(i))

else 키워드

반복문이 종료된 후 실행된다.

cnt = 0
for i in range(1,100):
if i % 7 != 0:
continue

print('{}는 7의 배수 입니다.'.format(i))
cnt += 1
else:
print('99까지의 정수 중 7이 배수는 {}입니다.'.format(cnt))

break 키워드

반복 실행 중 break를 만나면 반복문을 빠져나온다.

sum = 0
searchNum = 0

for i in range(100):
sum += i

if sum > 100:
searchNum = i
break
print('searchNum = {}'.format(searchNum ))

실습

**새끼 강아지 체중이 2.2KG이 넘으면 이유식을 중단하려고 한다. 한번 이유식을 먹을 때 체주이 70g 증가한다고 할 때, 예상되는 이유식 날짜를 구하자. (현재 체중은 800g)**
limitedWeight = 2200
curentWeight = 800
date = 1

while True:
date += 1
curentWeight += 70

if curentWeight >= limitedWeight:
break
print('이유식 중단 날짜: {}'.format(date))

중첩 반복문

반복문안에 또 다른 반복문을 선언한다.

for i in range(1,10):
for j in range(i):
print('*', end='')
print()

실습

**구구단 전체 출력**
for i in range(1,10):
for j in range(2,10):
result = j * i
print('{} * {} = {}\t'.format(j,i,result),end= '')
print()

input(): 데이터 입력을 위한 함수

input() 함수를 이용해서 입력한 데이터는 항상 문자(열) 자료형. 따라서, 형 변환 함수를 이용하여 형 변환을 해야함. ex) userInputData = int(input('정수형을 입력하세요.'))

_실습_
**사용자가 가로, 세로 길이를 입력하면 삼각형과 사각형의 넓이가 출력되는 코드를 작성해보자.**
width = float(input('가로길이: '))
height = float(input('높이: '))

triangle = width * height /2
square = width * height

print('삼각형의 넓이는 =', triangle)
print('사각형의 넓이는 =', square)

데이터 출력

format() 함수를 이용한 데이터 출력

userName = "hong"
userAge = 21

print('User Name: {}'.format(userName))
print('User Age: {}'.format(userAge))

print('Use Name: {}, User Age: {}'.format(userName, userAge))
print('Use Name: {1}, User Age: {0}'.format(userName, userAge)) #순서를 바꾸고 싶을 땐

print('나의 이름은 {0}이고, 나이는 {1}살 입니다. {0}이름은 아버지께서 지어주셨습니다.'. format(userName,userAge))

형식 문자를 이용한 데이터 출력

%s -> 문자열
%d -> 정수
%f -> 실수
userName = "hong"
userAge = 21

print('User Name: %s' % userName)
print('User Age: %d' % userAge)
print('User Name: %s, User Age: %d' % (userName,userAge))

소수점 자릿수 정하기

%.nf -> 소수점 n자리 표현
pi = 3.14
print('Pie: %f' % pi)
print('Pie: %1f' % pi) #소수 첫 째자리

실습

반지름 입력: 3
원주율 입력: 3.14192
radius: 3.0
pi: 3.14192
radius: 3.000000, pi: 3.141920
radius: 3.00, pi: 3.14

radius= float(input('반지름 입력: '))
pi = float(input('원주율 입력: '))

print('radius: {}\npi: {}'.format(radius, pi))
print('radius: %.6f, pi: %.6f' % (radius, pi))
print('radius: %.2f, pi: %.2f' % (radius, pi))

산술 연산자 (덧셈, 뺄셈)

실습

국어 점수: 85
영어 점수: 90
영어 점수: 95
국어 점수 85
영어 점수 90
수학 점수 95
합계 점수 270

kor = int(input('국어 점수: '))
eng = int(input('영어 점수: '))
math = int(input('영어 점수: '))

total = kor + eng + math

print('국어 점수 {}'.format(kor))
print('영어 점수 {}'.format(eng))
print('수학 점수 {}'.format(math))
print('합계 점수 {}'.format(total))

실습2

알바비: 800000
카드 값: 453700
partTimeMoney: 800000원
cardMoney: 453700원
남는 돈: 346300원

partTimeMoney = int(input('알바비: '))
cardMoney = int(input('카드 값: '))
result = partTimeMoney - cardMoney

print('partTimeMoney: {}원'.format(partTimeMoney))
print('cardMoney: {}원'.format(cardMoney))
print('남는 돈: {}원'.format(result))

산술 연산자 (곱셈, 나눗셈)

실습

국어 점수: 85
영어 점수: 90
수학 점수: 90
국어 점수: 85
영어 점수: 90
수학 점수: 90
합계: 265
평균: 88.33333333333333
평균 88.33

kor = int(input('국어 점수: '))
eng = int(input('영어 점수: '))
math = int(input('수학 점수: '))
total = kor + eng + math
avg = total/3

print('국어 점수: {}'.format(kor))
print('영어 점수: {}'.format(eng))
print('수학 점수: {}'.format(math))
print('합계: {}'.format(total))
print('평균: {}'.format(avg))
print('평균 %.2f' % (avg))

산술 연산자 (나머지와 몫)

나머지 구하기: /

num1 = 10 num2 = 3 result = num1/ num2 print('num1: {}, num2: {}, result: {}'. format(num1, num2, result))

몫 구하기: %

result = num1 % num2 print('num1: {}, num2: {}, result: {}'.format(num1, num2, result1))

나머지와 몫 한 번에 구하기: divmod()

result = divmod(num1, num2) print('result: {}'.format(result)) print('몫: {}'.format(result[0])) print('나머지: {}'.format(result[1]))

실습

전체 학생 수: 25
한 모둠 학생 수: 4
전체 학생 수: 25
한 모둠의 학생 수: 4
모둠 수: 6
남는 학생 수: 1

totalStu = int(input("전체 학생 수: "))
stu_of_group = int(input('한 모둠 학생 수: '))
result = divmod(totalStu, stu_of_group)

print("전체 학생 수: {}". format(totalStu))
print("한 모둠의 학생 수: {}". format(stu_of_group))
print("모둠 수: {}". format(result[0]))
print("남는 학생 수: {}". format(result[1]))

실습2

Q. 123개의 사과를 4개씩 직원들에게 나누어 주려고 한다. 최대 나누어 줄 수 있는 직원수와 남는 사과 개수를 출력해보자.

A. 직원당 사과 수: 30, 남는 사과: 3
employee = 123
apple = 4
result = divmod(employee,apple)

print('직원당 사과 수: {}'. format(result[0])) #30
print('남는 사과 수: {}'. format(result[1])) #3

산술 연산자 (거듭제곱)

거듭제곱 구하기: **

num1 = 2 num2 = 3 result = num1 ** num2 print("result:{}".format(result))

제곱근 구하기: n ** (1/m)

#2의 제곱근 구하기 result = 2 ** (1/2) print('result: {}'.format(result)) print('2의 제곱근 %.2f' % result)

#2의 3제곱근 result2 = 2 ** (1/3) print('result: {}'.format(result2)) print('3의 제곱근 %.2f' % result2)

#2의 4제곱근 result3 = 2 ** (1/4) print('result: {}'.format(result3)) print('4제곱근: %.2f' % result3)

sqrt()함수를 이용한 제곱근 구하기 (단, sqrt() 함수는 오직 제곱근만 구해줌)

import math #2의 제곱근 print('2의 제곱근 %f' % math.sqrt(2)) print('2의 제곱근 %.2f' % math.sqrt(2))

#3의 제곱근 print('3의 제곱근 %f' % math.sqrt(3)) print('3의 제곱근 %.2f' % math.sqrt(3))

#4의 제곱근 print('4의 제곱근 %.2f' % math.sqrt(4))

pow() 함수를 이용한 거듭제곱 구하기

import math #2^3 print('2의 3제곱 %.2f' % math.pow(2,3))

#3^4 print('3의 4제곱 %.2f' % math.pow(3,4))

실습 아들이 엄마한테 용돈을 받는데, 첫 달에는 200원을 받고 매월 이전 달의 2배씩 인상하기로 했다. 12개월째 되는 달에는 얼마를 받을 수 있는지 계산해 보자.

firstMon = 200 after12 = ((firstMon0.01) * 12) * 100 print('12개월 후 총액: {}'. format(after12))

*****3자리수 마다 ,찍기 after12 = int(after12) after12 = format(after12, ',') print(after12, '원')

복합 연산자

+= --> 덧셈 연산 후 할당

num += 3 #num= num + 3 print('num: {}'. format(num))

-= --> 뺄셈 연산 후 할당

num -= 3 #num= num - 3 print('num: {}'. format(num))

*= --> 곱셈 연산 후 할당

num *= 3 #num= num * 3 print('num: {}'. format(num))

/= --> 나눗셉 연산 후 할당

num /= 3 #num= num / 3 print('num: {}'. format(num))

%= --> 나머지 연산 후 할당

num %= 3 #num= num % 3 print('num: {}'. format(num))

//= --> 몫 연산 후 할당

num //= 3 #num= num // 3 print('num: {}'. format(num))

**= --> 거듭제곱 연산 후 할당

num *= 3 #num= num * 3 print('num: {}'. format(num))

실습(누적 강수량 찾기)

rainamount = 0
totalRain = 0

totalRain += 30
print('1월 누적 강수량: {}'.format(totalRain))

totalRain += 45
print('2월 누적 강수량: {}'.format(totalRain))

totalRain += 47
print('3월 누적 강수량: {}'.format(totalRain))

totalRain += 55
print('4월 누적 강수량: {}'.format(totalRain))

totalRain += 65
print('5월 누적 강수량: {}'.format(totalRain))

totalRain += 100
print('6월 누적 강수량: {}'.format(totalRain))

totalRain += 128
print('7월 누적 강수량: {}'.format(totalRain))

totalRain += 209
print('8월 누적 강수량: {}'.format(totalRain))

totalRain += 204
print('9월 누적 강수량: {}'.format(totalRain))

totalRain += 186
print('10월 누적 강수량: {}'.format(format(totalRain, ',')))

totalRain += 67
print('11월 누적 강수량: {}'.format(format(totalRain, ',')))

totalRain += 25
print('12월 누적 강수량: {}'.format(format(totalRain, ',')))

rain_avg = totalRain/12
print('-'*30)
print('연간 누적 강수량: {}mm'.format(format(totalRain, ',')))
print('연간 평균 강수량: {}mm'.format(format(totalRain, ',')))
print('-'*30)

비교 연산자 (숫자 비교)

같다: ==/ 같지 않다: !=

실습

**자동차의 전장과 전폭을 입력하면 자동차 기계 세차 가능여부를 출력하는 코드를 작성해보자.
(최대 전장 길이: 5200mm, 최전폭: 1985)**
max_length = 5200
max_width = 1985

my_car_length = int(input('전장 길이 입력: '))
my_car_width = int(input('전폭 길이 입력: '))

print('전장 가능 여부: {}'. format(max_length >= my_car_length))
print('전폭 가능 여부: {}'. format(max_width >= my_car_width))

비교 연산자 (문자 비교)

실습

cha1 = 'A' #65
cha2 = 'S' #83

print('\'{} > \'{}\' : {}'.format(cha1,cha2, (cha1 > cha2))) #\를 사용하면 다음 기호 무시
print('\'{} < \'{}\' : {}'.format(cha1,cha2, (cha1 < cha2)))
print('\'{} >= \'{}\' : {}'.format(cha1,cha2, (cha1 >= cha2)))
print('\'{} <= \'{}\' : {}'.format(cha1,cha2, (cha1 <= cha2)))
print('\'{} == \'{}\' : {}'.format(cha1,cha2, (cha1 == cha2)))
print('\'{} != \'{}\' : {}'.format(cha1,cha2, (cha1 != cha2)))

논리 연산자

논리 연산자 종류: and, or, not

실습

**'백신 접종 대상자는 20세 미만 또는 65세 이상자에 한합니다.'를 논리연산자를 이용해서 코딩.
age = int(input("나이를 입력하세요: "))
vaccine = (age<20) or (age>=65)
print('age: {} -> vaccine: {}'.format(age,vaccine))

**국어, 영어, 수학 점수를 입력하고 평균이 70점 이상이면 True를 출력하는 코드를 작성해 보자. (단, 과목별 점수가 최소 60 이상인 경우에 True를 출력한다.)
pass_score1 = 70
pass_score2 = 60

kor = int(input('국어 점수: '))
eng = int(input('영어 점수: '))
math = int(input('수학 점수: '))

avg = (kor + eng + math)/3
avg_result = avg >= pass_score1

result_kor = kor >= pass_score2
result_eng = eng >= pass_score2
result_math = math >= pass_score2

subject_result = result_kor and result_eng and result_math

print('평균: {} -> 결과: {}'.format(avg, avg_result))
print('과락 결과: {}'. format(subject_result))
print('최종 결과: {}'.format(avg_result and subject_result))

Operator 모듈

산술 연산자 관련 함수

덧셈: print('{} + {}: {}'.format(num1, num2, operator.add(num1,num2))) 뺄셈: print('{} - {}: {}'.format(num1, num2, operator.sub(num1,num2))) 곱셈: print('{} * {}: {}'.format(num1, num2, operator.mul(num1,num2))) 나눗셈: print('{} / {}: {}'.format(num1, num2, operator.truediv(num1,num2))) 나머지: print('{} % {}: {}'.format(num1, num2, operator.mod(num1,num2))) #나머지 몫: print('{} // {}: {}'.format(num1, num2, operator.floordiv(num1,num2))) #몫 제곱: print('{} ** {}: {}'.format(num1, num2, operator.pow(num1,num2))) #8의 3승

비교 연산자 관련 함수

같다: print('{} == {}: {}'.format(num1, num2, operator.eq(num1,num2))) 같지 않다: print('{} != {}: {}'.format(num1, num2, operator.ne(num1,num2))) 초과: print('{} > {}: {}'.format(num1, num2, operator.gt(num1,num2))) 이상: print('{} >= {}: {}'.format(num1, num2, operator.ge(num1,num2))) 미만: print('{} < {}: {}'.format(num1, num2, operator.lt(num1,num2))) 이하: print('{} <= {}: {}'.format(num1, num2, operator.le(num1,num2)))

논리 연산자 관련 함수

AND: print('{} and {}: {}'.format(flag1, flag2, operator.and_(flag1,flag2))) OR: print('{} or {}: {}'.format(flag1, flag2, operator.or_(flag1,flag2))) NOT: print('not {}: {}'.format(flag1, flag2, operator.not_(flag1)))

실습

**random과 operator 모듈을 사용해서 10부터 100까지의 난수 중 십의 자리와 일의 자리가 각각 3의 배수인지 판단하는 코드 만들기**
import random

random = random.randint(10,100)

num10 = operator.floordiv(random,10)
num1 = operator.mod(random,10)

print('난수: {}'.format(random))
print('십의 자리: {}'.format(num10))
print('일의 자리: {}'.format(num1))

print('십의 자리는 3의 배수이다: {}'.format(operator.eq(operator.mod(num10,3),0)))
print('일의 자리는 3의 배수이다: {}'.format(operator.eq(operator.mod(num1,3),0)))

Python의 특징

무한 정수 처리가 가능하다. 문법 구조가 쉽다. 다양하고 뛰어난 모듈이 많다. 즉, 다양한 기능 (Library)을 쉽게 사용할 수 있다.

Python 실행 및 종료 방법

윈도우키+R -> 명령 프롬프트 실행 후 python 실행 Ctrl+Z or exit(), or 창 닫기로 프로그램 종료

Pycharm

코드 실행 방법: Run 클릭 or Shift+F10 코드 복사 단축키: Ctrl+D 문자 표기 방법: print()

변수

변수를 사용하는 이유:

데이터를 재사용하기 위한 목적과 프로그램을 보다 효율적으로 관리할 수 있다.

변수 작명법

1. 영문 사용하기

myAddress = '서울' -> *권장*
    나의 주소 = '서울' -> *비권장*

2. 첫 번째는 소문자로

_클래스의 첫 번째 문자가 대문자이므로 혼동의 여지가 있음_
myAddress = '서울' -> *권장*
MyAddress = '서울' -> *비권장*

3. 데이터의 의미를 파악할 수 있는 표기법 사용 4. 카멜 표기법 or 스네이크 표기법 사용

customerBankAccount = '123-232-3232'
customer_bank_account = '123-232-3232'
customerbankaccount = '123-232-3232' -> *비권장*

5. 예약어 (파이썬에서 이미 예약된 단어) 사용 금지 6. 언더바 (_)를 제외한 특수문자 사용금지 ** **7. 공백 사용 금지 8. 숫자 사용 가능하지만 첫 번째 자리 사용 금지

자료형 (Data type)이란?

효율적인 메모리 사용을 위해 데이터를 정수형, 실수형, 문자(열)형, 논리형으로 구분한 것.

자료 타입 찾기: print(type(---))

정수 (int): num = 10, score = 85 ----> 메모리가 허용되는 한 무한 사용 가능

실수 (float): pie = 3.14, height = 180.5 ----> 대략 소수점 이하 17~`8번째에서 데이터 손실이 일어남, ''로 묶으면 문자(열)로 인식함

문자(열)(str): country = 'Korea'
문자 1개: 문자(char)
문자 여러개: 문자열 (string)

논리형 (bool): exampleResult = True, day_off = False

자료형 변환이란?

데이터 타입을 변환하는 것으로 파이썬에서 제공하는 함수를 이용한다. 문자로 변환: str() 정수로 변환: int() 실수로 변환: float() 논리형으로 변환: bool() --> 데이터값 있음 = True (1)/ 없음 = false (0)

"20가지 산업군별 샘플 프로젝트", "취업 100% 보장반"

2023년 미국에서의 생활을 마치고 급하게 한국으로 돌아와 취업에 도전했지만, 한국에서의 취업이 생각보다 쉽지 않았다. 석사과정에서 배웠던 데이터 분석의 역량을 키워 데이터 분석가 직무로 취업하기 위해 여러 방법을 조사하던 중 제로베이스 데이터 분석 스쿨에 대한 광고를 접하게 되었다. 20가지의 다양한 산업에 대한 샘플 프로젝트, 개인및 단체 파이널 프로젝트 등을 통해 실제 기업에서 요구하는 다양한 경험들과 역량을 쌓을 수 있을 것이란 기대감에 큰돈을 들여 입과를 선택하게 되었다.

2024년 01월 02일, 대망의 첫 OT

매니저님이 해주셨던 말 중 여러 가지 말들이 와닿았다. '수료 조건에 목매지 말고 자신의 기준을 높여야 한다.' '추운 겨울 동안 남들보다 더 노력해서 누구보다 화창한 봄을 맞이하자.

매니저님의 진심 어린 동기부여 메시지들과 함께 강의에 대한 전반적인 과정 및 슬랙 사용 방법 등 4개월의 대장정을 시작하기에 앞서 필요한 정보를 습득하고 마음을 다잡을 수 있는 시간이었다.

최고의 성과를 만들기 위해, 최선을 다해보자 :)