#지난 내용 : 파이썬의 자료형 + 반복문(for) + 제어문(if)
#변수 : 어떠한 값 / 대상을 연결해 주는 것!
==> 값을 할당하거나, 연결하는 것 = (왼쪽은 변수명) (오른쪽 대상)
#자료형 : 값을 종류
case1) 1개 값 : 파이썬이 만들어둔 자료형
--> 숫자 : 정수 , 실수, 복소수 등
: 좀 더 엄밀하게 사용할 때는 numpy, etc pkg
--> 논리값 : True/False
--> 문자 : "a", 'a', """a""", '''a'''
: 참고 : 특수문자 \(해당문자)
case2) 여러개의 값을 나타내는 자료형
--> 리스트 : [ 값,값, 값,값, 값,..]
: 추가, 제거 etc
--> 튜플 : (값,값,값,...)
: 추가, 제거의 변경에 대한 기능이 없음!
: 값에 대한 접근 !!
: 리스트/튜플 개별 값에 대한 접근 : 몇 번째 --> 정수 인덱스 [위치정수]
0/양수 : forward
음수 : backward
: 여러개 & 규칙 --> 슬라이싱 [시작점 : 끝점 : 간격]
--> 집합 : {값,값,값,...} ==> 수학적인 집합으로 동작!
{1,1,1,1,2,2,2,2} = {1,2}
: 코테에서는 간단하게 유니크한 값들 처리할 때!!
: 위치 인덱스로 접근 X ==> 형을 변환을 해서 사용을 해야함
------------------------------------------------------------------
--> 문자열 : "hello"
: 문자들을 값으로 가지는 리스트!!
: for 문이 돌아값니다!!
-------------------------------------------------------------------
--> Dict : {값1:값1, 값2:값2, 값3:값3}
: 주민번호/이름, 학번/이름
: 핵심 : key
: 값에 대한 접근 : [키값]
: .keys(), .values()
: dict.items() : k/v를 한 번에 분리해서 사용가능함!
참고 : 리스트 --> enumerate(리스트) : 정수인덱스, 값
#주의사항!! 코테같은 문제나 앞으로 하실 부분에서는
정답이 없는 문제이므로, 스스로 기준과 방식을 정하시면 됨!!
------------------------------------------------------------------- -------------------------------------------------------------------
# 골격 : 반복문 & 제어문!!
1) 제어문 : if~~ else~~
if~~ elif~~elif~~,,,~~else~~
: 위의 제어문은 구조가 하나의 덩어리로 생각!
=> 중간에 조건 1개라고 맞아서 처리가 되면,, 아래코드 skip
=> 조건의 순서!!(크게 잘 걸리는 조건을 위로!)
: else 특별하지 않으면 pass를 사용해서 문법적으로 구색만 맞춤
안할 것이면 else는 생략! (코테에서는 생략!!)
: 실제 실무를 하실 때는 사용을 권장!
2) 반복문 : for / while
=> 데이터 분석 : 주로 for 문을 주로 사용을 함!
: 데이터의 갯수가 정해져 있음!
=> 코테 : for + while(탐색/최단거리 etc)
=> for : 딱 정해진 여러개의 값들을 롤링!
for 대표 대표문자(들) in 여러개 값 자료형(리스트, 튜플, dict, 문자열 etc)
=> while 조건 : 조건이 만족할 때까지 주구장창!!
+ 탈출 할 조건에 대한 설계!!
++ 필요한 여러개가 숫자인 경우 : range(시작점,끝점,간격)
## 반복문 & 제어문에 같이 사용되는 기능!!
==> continue, pass, break
- pass : 그냥 아무것도 안 하고 아래 작성된 내용 skip : 형식상 맞춤!!
: else ~ pass
: 코테에서는 주로 생략을 함!!
- continue : for/ while 다음 순번으로 넘겨줄 때
- break : for/while에 대해서 다음 순서가 남아 있어서도 그냥 stop
#break 예
a = [3,4,5,6,7,8,9]
for i in a: # a ==> range(3,10,1)
print(i)
a = [3,4,5,6,7,8,9]
for i in a:
print("체크 전의 값: ", i)
# 중간에 혹시 5가 나오면,,, 그만 롤링 하고 싶다!!
if i == 5
print(i)
break
# ==> 코테에서는 간혹 효율성/시간 이런 부분을 채점할 때
# 명확하게 불필요하면 반복문을 멈추는 것들에 대해서 엄밀하게 사용할
#pass 예
---> pass는 그 아래 코드를 skip(단, 동일 라인 내에 있는 것들)
==> 아래 예와 같은 식으로 코드를 쓸 일이 없음!!
else:
pass
--> 아래와 같은 코드는 굳이 사용하지 않습니다;; 다만 기능적인 보여주기용 코드
a = [3,4,5,6,7,8,9]
for i in a:
print("체크 전의 값: ", i)
if i == 5
print(i)
pass
print(i+1000000)
print("PAASSSSSS")
#continue 예 *** //pass와의 차이 이해하기
a = [3,4,5,6,7,8,9]
for i in a:
print("체크 전의 값: ", i)
if i == 5
print(i)
continue
print(i+1000000)
print("PAASSSSSS")
**** 코테 + 앞으로 코드에서
: for / while + if
+ pass, continue, break
--> 원하는 대로 코드의 구조와 흐름을 작성할 수 있음!!!!
#파이썬 틱하게 코드를 쓰는 방법 중 하나
==> 리스트 컴프리핸션!!
: 여러개의 값을 돌려서 모은다!!
장점 : 코드가 간결
단점 : 너무 중첩을 하면,, 오히려 가독성이 문제가 생김!!
: 1개 for, 2개 for 이 정도까지만 사용을 함!
기능 : 값을 돌려가면서(for문), 원하는 값을 모은다(리스트)
형식 : [모을 값 for i in 여러개]
a= ["a","b","c","d","e","f","g","c","i"]
예) a 리스트에서 c 인 원소를 제러해 주세요!
b=[]
for i in a:
if i =="c" :
b.append(i)
print(b)
[i for i in a]
[i for i in a if i != "c"] <== 리스트 컴프리핸션!!!!!!
#연습문제
예) 위에 있는 a 리스트에서
홀수 번째 위치한 값들만 "h"라는 문자를 추가하려고 함!! //값X, 위치
=> 결과 : ["ah","ch","eh","gh","ih"]
--> for/if etc
--> LC로 구현 //LC:리스트 컴프리 핸션
len(a)
for i in range(len(a)): #range(0,len(a),1):
if i % 2 == 0: //0,2,4,6,8 <-- 홀수번째 의미
#print(i)
print(a[i]+"h")
[ a[i]+"h" for i in range(len(a)) if i % 2 == 0]
for i,v in enumerate(a): //enumerate 함수 공부하기
if i % 2 == 0:
print(v+"h")
#print(i,v)
else:
pass
[ v+"h" for i in enumerate (a) if i % 2 == 0]
예) a의 원소들 중에서 짝수번째 값은 e문자를 더하고(0,2,4,..)
홀수번째 값은 o문자를 더하자!(1,3,5,...)
==> 앞의 경우와의 차이는 경우가 2가지가 되는 것!! case by case
for i,v in enumerate(a):
if i % 2 == 0: # 짝수번째
print(v+"e")
else: # 홀수번째
print(v+"o")
[v+"e" if i%2==0 else v+"o" for i,v in enumerate(a) ]
#정리!!
==> 리스트컴프리핸션 자유롭게 하실 수 있으면 편함!!
돌리는 것도 다양하게 : a, range(), .items(), enumerate(), etc ...
조건이 있다면 [ 모을값 for 롤링 (if 조건) ] *****
[ 모을값1 if 조건 else 모을값2 for 롤링]
#덩어리 중심으로 코드 정리!!
함수 --> 클래스 --> 패키지
# 가장 기본적인 구조화 : 함수!! y=f(x)
==> 3가지 요소 : 입력, 출력, 입출에 대한 관계(기능)
중심은 무엇을 수행/기능할지를 작성하는 것이 핵심!!
==> 코드를 읽을 때 기능 중심으로 읽을 수 있다!!
+ 한 번 만들면... 여러번 재사용이 가능함!!
# 플젝/팀플/개인적으로도 구현하기에 급급해서 코드를 줄~~줄~~
==> 코드를 정리하시는 습관!!!
# 함수를 만드는 기본적인 구조!!
def 함수명(입력인자): # --> 입력 x에 대한 세팅
무엇을 하지 구현 # 입출에 대한 관계/기능 : f
return 출력 # y 출력에 대한 세팅
def 함수명(입력1, 입력2,,,):
무엇을 할지 구현
return 출력1, 출력2,,,,
# 예) 파이썬에 더하는 함수 --> sum()
==> 조금 불편함 점 : sum([10,20,30])
--> 내가 원하는 더하는 함수 : sum2(10,20) ==> 30
입력 : 숫자 2개
기능 : 입력받은 2개 숫자를 더한 값을 생성 출력
출력 : 더한 값
==> 이러한 기능을 제가 입력값이 다른 상태에서 여러번 재활용을 하겠다!!
def sum2(a,b):
# 입력으로 받은 a,b를 가지고 무엇을 할지 기술!!
# + 파이썬의 문법 + 코테경우는 알고리즘도 ...
result = a+b
return result
# 참고) 함수 내에서 만든 변수들을 특별한 조치를 하지 않는 이상 함수 내에서만 생존
sum([1,2,3,4,6])
sum2(10,20)
sum2(100,900)
a = 999999
sum2(10,20)
# 더하기가 이항연산자 --> 여러개의 숫자들을 더하고 싶어요!
10+20+30+40+50...
==> 입력이 가변적으로 여러개가 들어와도 처리를 하면 어떨까?
가변적인 입력을 처리할 때 " *args ==> 파이썬의 리스트처럼
**args ==> 파이썬의 dict --> 특정 파라미터값
sumrandom(10,20,30)
sumerandom(10,2,2,3,3,22,3,3,2,2,3,3,3,3,3)
def sumrandom(*args): //sumrandom(*args) 함수 이해하기
# args : 파이썬의 리스트 처럼 생각하면 된다!!
# args = [ 10,20,30], args = [ 10,2,2,3,3,22,3,3,2,2,3,3,3,3,3]
# 개별원소들을 꺼내면서 누적합
# ++ 처음 시작에 대해서는 초기값 0
temp = 0 # 입력을 받은 것들을 누적합!!
# 입력받은 것들을 다 롤링!! --> for, 값자체
for i in args:
#temp = temp + i
temp += i
return temp
sumrandom(10,20,30)
sumrandom( 10,2,2,3,3,22,3,3,2,2,3,3,3,3,3)
sumrandom(10) //한개 짜리도 상관없음
# 참고) 코테나 간단하게 작업들을 할 때는 예외처리 신경안써도 됨!!
=> 대면 면접이나, 실제 일을 하실 때는 꼭!! 신경쓰세요!!
#참고) 출력을 여러개를 내보내는 경우!!
==> 입력 2개 숫자,
출력 : 사칙연산 결과 4개를 출력
def multiple(a,b):
return a+b, a-b, a*b, a/b
multiple(1,2) //튜플 형태
multiple(1,2)[2] #여러개 출력 중에서 필요한 곱에 대한 것은 인덱스로 접근!
# 혹시 조작해서 써야 한다면,,, 형을 list로 변경해서 사용하면 됨!!
###여기까지가 FM적인 함수에 대한 이야기!!!
### 함수 : 입력/출력을 중심으로 내가 무엇을 할지에 대한 기능화!!
==> 여러번 재사용이 용이 + 가독성 + 구조화 etc
ctrl + c/v 효율화!!
# 참고) 여러번 까지는 아니고,,, 그런데,, 뭔가 기능적인 롤 규칙!!
==> 데이터를 전처리를 할 때... 사용가능성은 낮지만, 규칙적인 구현/표현!!
*** lambda함수 : 데이터 전처리 + 코테(정렬 구현) //정렬 함수
예) 데이터 전처리 : id_0001, id_0002, id_0003
==> 1,2,3,4
==> 규칙을 람다함수로 표현을 많이 함!!
def sum2(a,b):
temp = a+b
return temp
sum2(30,40)
---> 간단한 기능 중심의 표현/ 규칙의 표현 : lambda 함수
(lambda a,b:a+b)(10,20)
(lambda a,b:a+b)(30,40)
### lambda 함수는 중요!!
==> 데이터 전처리 : apply + 어떤 일을 처리할 지에 대한 규칙 표현!!
==> 코테 : 특이한 정렬 조건에 대한 규칙을 표현할 때 --> 정답지 제출 전에..
avg_score = tot/cnt
print(avg_score)
#참고 : 점수가 80점 이상인 과목들이 몇 과목인가?
--> 필터링 : 점수에 --> if
zumsu_list = [80,75,55,90]
cnt = 0
for i in zumsu_list:
if i >= 80:
cnt += 1 //코테에서는 cnt 함수 중요!!
print(cnt)
len([ for i in zumsu_list if i >=80 ] )
--> 가변적인 입력을 받을 때 파이썬 함수 : input() 함수
입력 : 키보드
기능 : 키보드 입력값을 출력
출력 : 눌린 키보드의 값을 문자열1!
a = input("성적을 입력하세요") //input은 문자열로 리턴 해준다
a
print(a)
a+10 <-- TypeError
int(a) + 10
# 예전부터 유명한 사이트(백준) : 직접 입력을 하면서
# 최근 사이트 프로그래머스 : 직접 입력을 설계할 필요가 없음!! --> 함수
01_과목평균
# 방법1) 꾸역꾸역
korean = int(input("국어점수를 입력하세요"))
math = int(input("수학점수를 입력하세요"))
englisgh = int(input("영어점수를 입력하세요"))
social = int(input("사점수를 입력하세요"))
# --> 주어진 문제에 대한 표현/코드화
# 할 일 : 4과목의 평균을 구하는 일!!!!!!
# : 앞에서 설정한 변수들의 관계/ 기능.......
avg_score = (korean + math + englisgh + social) / 4
# 관계 /기능 /./////알고리즘을 녹여야 함!!!!!!
print(avg_score)
#방법2를 가변적인 입력으로 하면..
#zumsu_list = [80, 75, 55, 90]
zumsu_list = []
zumsu_list.append( int(input("국어점수를 입력하세요")))
zumsu_list.append( int(input("수학점수를 입력하세요")))
zumsu_list.append( int(input("영어점수를 입력하세요")))
zumsu_list.append( int(input("사회점수를 입력하세요"))) //ctrl c/v 로 비효육적임
# 평균 : 리스트의 모든 원소의 합 sum// 리스트의 원소 갯수 len
avg_score= sum(zumsu_list )/ len(zumsu_list)
print(avg_score)
+++ 과목이 더 늘어나면 어쩔까요??
==> ctrl + c/v : 고정적인 부분 + 가변적인 부분 체크
고정적인 부분 : 하드코딩
가변적인 부분 : 필요한 것들을 리스트업 .// 규칙!!
subjects = ["국어", "수학", "영어", "사회","과학","음악"]
#방법2를 가변적인 입력으로 하면..
#zumsu_list = [80, 75, 55, 90]
zumsu_list = []
for i in subjects:
#print(sub) # zumsu_list.append( int(input("국어점수를 입력하세요")) ) //규칙들을 코드
txt = sub + "를 입력하세요"
#print(txt)
zumsu_list.appen( int(input(txt)) )
# 평균 : 리스트의 모든 원소의 합 sum// 리스트의 원소 갯수 len
avg_score= sum(zumsu_list )/ len(zumsu_list)
print(avg_score)
02_리스트변경
# 문제 : a = [ "one","two","three","four"] 로 되어있다
# for 문을 사용해서..
# b = ["one1","two2","three3","four4"]로 만들어보자!!
a = [ "one","two","three","four"]
# 시도1) for & range : 정수 인덱스 중심
# 시도 2) for & 값 자체
# ==> 파이썬에서는 크게 2가지 방식이 존재하므로, 양쪽을 다 알아야 함!!
+++ 리스트컴프리핸션으로도...
["one1","two2","three3","four4"]
# sol1) 내가 필요한 것이 숫자 --> range ---> 0,1,2,3 (리스트 정수인덱스)
---> 1,2,3,4 (뒤에 붙일 값 중심)
for i in range(1,5,1):
print(i)
--> 붙일 값을 중심으로 돌리고
붙일 대상에 대한 접근에 대한 룰 : i ---> i-1
b=[]
for i in range(1,5,1):
print(i)
print(a[i]) //IndexError
b=[]
for i in range(1,5,1):
print(i)
print(a[i-1])
b.append( a[i-1] + str(i))
b
# 대상을 리스트의 값의 접근를 정수인덱스로 하면
b=[]
for i in range(len(a)): #range(0,len(a),1)
print(i)
print(a[i])
b.append(a[i]+str(i+1))
b
#sol2) 값을 직접 돌리는 방식!!
==> 붙일려는 숫자가 없어요!!
없으면.. 만들지 뭐!!
필요한 것들이 1부터 1씩 증가하는 값이 필요함!!
==> 카운팅!!
cnt = 1
for i in a:
print(i+str(cnt))
cnt += 1
# 참고) 어찌되었던지 간에,,, 뭔가 값을 모으네!!
===> LC을 생각해 볼 수 있음!!
b=[]
for i in range(1,5,1):
b.append( a[i-1] + str(i))
b
[a[i-1] + str(i) for i in range(1,5,1) ]
[a[i] + str(i+1) for i in range(len(a) ] //둘의 차이 이해하기
--> 정수 인덱스 중심으로 할 때!!
### 스스로 코드 작성의 기준이 있어야 한다는 점!!
### ==> 기준은 개인적인 부분!!!
### ==> 스스로 여러 문제 # 상황들을 하시면서 기준을 잡아 가셔야 함!!
03_리스트필터링
# 문제 : a = [1,2,3,4,5] 리스트가 있다면..
==> [1,3,5] 의 리스트로 만들어 보세요!!
==> 기존의 값들에서 필요한 조건에 맞는 값들을 필터링!!
# sol1) 내가 제거 / 모을 값들에 대한 규칙이 있나 없나? yes
규칙 : 홀수/짝수 판별
--> 살리는 값을 중심으로 하면 : 홀수만 살리자!!
2로 나눠서 나머지가 1인 모든 수 : %
--> a의 모든 원소들을 대상으로 규칙을 적용을 해야함 for
a = [1,2,3,4,5]
a
b=[]
for i in a:
if i %2==1:
b.append(i)
b
==> LC로 보여야 한다!!
[ for i in a if i % 2 ==1]
+++ a 중에서 홀수인 값들에 대해서만 *10을 해서 모으세요!!
[i*10 for i in a if i%2==1]
####
#sol2) 규칙이 없다고 가정하면,,,
==> 데이터를 수집할 때 : 예외 처리쪽에서
==> 코테에서도 종종 사용이 된다!!
# 규칙이 없다면 ---> 예외적인 상황들을 다 나열을 해야한다!!
a=[1,2,3,4,5]
for i in a:
if (i==1) or (i==3) or ( i==5): // 반복이 있는 상황!
print(i)
+++ 필터링을 하려고 하는 여러개들을 나열!!
==> 필터링을 하고자 하는 애들을 모아두면 좋지 않을까?
a = [1,1,1,1,2,3,3,3,4,5,6,7,8,8,6,5,5,5,5,5]
b = [1,3,5,7]
for i in a :
if i not in b: # (i==1) or (i==3) of ( i==5) or (i==7) //i%2 ==1
print(i)
# a = [1,1,2,3,4,4,4,5,6,6,3,2,2,2]
# 1,3,5를 제외한 모든 원소들에 대해서 + 10을 하세요!!
# [12,14,14,14,16,16,12,12,12]
==> LC로 구현!!
a= [1,1,2,3,4,4,4,5,6,6,3,2,2,2]
a
[i+10 for i in a if i not in [1,3,5]]
# 정리!!)
# 값/조건에 대해서 정리/필터링 ==> 규칙이 있는지 없는지 판단!!
==> 규칙이 있다면 : 규칙에 대한 코드화!!
: 어려운 코테 ( 알고리즘+복잡한 상황)
==> 규칙이 없다면 : 최소한의 리스트업을 하는 방식을 고민!!
: in, not in
+++ 기본적인 구조 : for ~~~~ if ~~~~
==> 파이썬에서는 간단하게 "리스트컴프리핸션!!"
04_Dict관련
# Dict은 데이터 처리를 하는 입장에서는 간혹 사용되는 자료형!!
==> 파이썬으로 코테를 하는 입장에서는 잘 활용을 해야 편하다
Dict을 잘 활용하는 습관&연습
# 문제) a={"A':90, "B":80,"C":70}
--> 이 중에서 B학생의 점수를 출력하세요
a= {"A':90, "B":80,"C":70}
a[0]
a["b"] //KeyError
==> 오타, 대소문자, 공백을 주의하자
a["B"]
# 참고) a가 어떤 자료형!!
a[~~~] : 공통점 --> 값을 접근..
a : 리스트 --> a[정수], a[슬라이싱]
a:dict --------> a[키값]: exact matching!!
a:numpy array --> a[정수], a[슬라이싱], a[리스트]
a:panda DF/Serises -> a[정수], a[슬라이싱]
a[여러개]
a[내가만든인덱스(1개or여러개)]
===> 변수에 대한 기본 자료형!!
Q)
a = {"a":30, "b":50,"c":10,"d":45,"e":85,"f":77}
최고점과 최저점을 찾아보자!!!
--> 가정 : 많은 학생이 있다고 생각하고!!
max([10,20,10,33,43,3,3,3,3,32,2])
min([10,20,10,33,43,3,3,3,3,32,2])
max(a) //키를 중심으로 max값을 구하기 때문에 f가 출력됨
==> f에 대한 문자열에 대한 숫자 코드값이 제일 커서!!
ord("A") //ord 함수 이해!!
ord("F")
ord("B")
==> ord 함수는 문자와 문자에 대한 코드값을 사용할 때 종종 코테에서 사용함!!!
#Dict은 key 중심의 자료형!!
==> 어떤 항목을 중심으로 할지를 명시를 해야함!!
대상이 keys : dict.keys()
대상이 values : dict.values()
+++ 같이 : dict.items()
max(a.values())
min(a.values())
# 문제) a = {"a":30, "b":50,"c":10,"d":45,"e":85,"f":77}
누가 최고점을 받았고, 누가 최저점을 받았는지 이름 출력!!
--> Dict에서 내가 필터링의 조건(최고점,최저점) : values
출력을 하기 위해서는 이름 정보 : keys
==> 같이 봅시다!! item() ---> (k,v)
min_val=min(a.values())
max_val=max(a.values())
# 우리반 학생들 모두에게 물어봐야 함!! --> 롤링!!!
==> k,v 모두 한 번에 처리하고자, items()
#가상 : a-10 ,b-10, c-10
for name, score in a.items():
if score == min_val:
print("최소점 학생:", name)
elif score == max_val:
print("최고점 학생:", name)
else:
pass
#print(name, score)
for name, score in a.items():
if score == min_val:
print("최소점 학생:", name)
if score == max_val:
print("최고점 학생:", name) // if, if 로도 코테에서는 사용함
05_범위(in_out)
# 문제) 한 점을 구성하는 x, y좌표를 입력 받아서,,,
이 점의 좌표가 (50,40), (50,80), (100,40), (100,80)
4개의 점을 꼭지점으로 하는 사각형의 내부에 있는지
외부에 있는지를 판별해보세요!!
==> 의도 : 문제들을 어떻게 코테 문제들로 변형이 되는지...
# part1) 사용자한테 좌표를 입력을 받아서,,, 이상한 입력없다고 가정
x = int(input("x좌표값 입력하세요"))
y = int(input("y좌표값 입력하세요"))
print(x,y)
# part2) in/out 판단!!
==> 좌표를 도입을 하면 편하다!!
각 기준별로 독립적으로 조건을 설정할 수 있음!
==> 부등식
==> 안쪽을 중심!!(가정)
x좌표가 50~100사이에 : 조건1 --> (x>50 and x<100)
y좌표는 40~80사이에 : 조건 2
조건1과 조건2는 and
if (x>50 and x<100) and (y>40 and y<80):
print("사각형 안쪽!!!")
else:
print("경계 또는 외각에 있습니다!!")
# 아주 아주 기본적인 문제!!
===> 범위에 대한 표현을 코드로 어떻게 할 것인가!!
좌표를 도입!! 수치화!! >> 범위(부등식, 범위) 영역!!
===> 2차원을,,, 3차원으로
'ASAC 빅데이터 분석가 7기 > ASAC 일일 기록' 카테고리의 다른 글
| ASAC 빅데이터 분석가 과정 5일차 - 1 (24.12.10) (0) | 2024.12.10 |
|---|---|
| ASAC 빅데이터 분석가 과정 4일차 - 2 (24.12.09) (0) | 2024.12.09 |
| ASAC 빅데이터 분석가 과정 3일차 - 2 (24.12.06) (0) | 2024.12.06 |
| ASAC 빅데이터 분석가 과정 3일차 - 1 (24.12.06) (0) | 2024.12.06 |
| ASAC 빅데이터 분석가 과정 2일차 (24.12.05) (0) | 2024.12.05 |