1/2

08:55 정태옥 대학원장님 말씀

• 천하대란 ⇒ 신질서
  • 휴일/방학에 해야 성장. 계주 비유
  • 동탁 화웅 관우 이야기

(빙 이미지 크리에이터는 관우 키워드 다 이런 화풍인듯)

- 전공과 다른 공부를 하는 현재..도자기 가소성의 시기

09:00

• 기업프로젝트 전에 개인 이력서 작성을 미리해야
• 개인과제를 다양한 방면에서 시도해야
• 6월달까지 죽자고 해야.. 자격증, 공모전, 프로젝트 해야할 건 많고 많음

ex_list_01.py

# ---------------------------------------------------------
# List 자료형
# - 기본 data 타입 - 숫자 / 글자 / 논리 / 바이트
# - 참조 Data 타입(컨테이너 Data 타입)
#       - 여러 개 Data 저장 - list / tuple / dict / set
# ---------------------------------------------------------

# ---------------------------------------------------------
# List => 여러 개의 데이터를 저장하는 데이터 타입
# - 문법 => [데이터1, 데이터2, ..., 데이터n]
# - 원소 / 요소 => 식별하기 위해서 인덱스(Index) : 파이썬에서 명명
# - 인덱싱 기능 / 슬라이싱 기능 모두 사용 가능
# ---------------------------------------------------------

# 1~50 범위의 7의 배수에 해당하는 정수로 구성된 리스트
# => 7, 14, 21, 28, 35, 42, 49
# => 시작 7
# => 끝 51
# => 간격 7
sevens = list(range(7,51,7))
print(sevens)

# str 데이터 타입 => 인덱싱 -----> 요소 변경 안 됨
# list는 각가의 원소/요소마다 데이터의 주소를 가지고 있기 때문에 요소 변경 가능

# 제일 첫 번째 인덱스에 있는 원소 삭제
# ==> del 삭제하고 싶은 데이터 또는 del(삭제할 데이터)
del sevens[0]
del(sevens[0])
print(sevens)

#del sevens # 리스트 객체 주소를 저장한느 변수 삭제

# ---------------------------------------------------------
# str 데이터 타입 => 인덱싱 ------> 요소 변경 x
# 리스트에 인덱싱 방식으로 원소/요소 데이터 변경/삭제는 가능, 추가는 안 됨
# ---------------------------------------------------------
# 요소 갯수 5개 => 0 ~ 4

# sevens[5] = 56 IndexError: list assignment index out of range
sevens[4] = 56
print(f'sevens => {sevens}') # 요소 추가가 아니라 값이 변경됨

ex_list_method.py

# ---------------------------------------------------------
# 메서드 => 특정 데이터 타입의 전용 함수를 메서드(Method)라고 부름
# - 범용의 함수와 식별하기 위해서 지정한 호침
# - 사용법 : 데이터, 메서드명() 또는 변수명,메서드명()
# ---------------------------------------------------------
# List 전용 메서드 살펴보기
# [1] 리스트에 데이터 추가해주는 메서드 => append() 맨 끝에 원소로 추가
import numpy

nums=[]

print(f'{len(nums)}개')

nums.append(10)
nums.append('One')
nums.append(True)
print(f'nums : {len(nums)}개, {nums}') #nums : 3개, [10, 'One', True]

# [1] 리스트에 데이터 추가해주는 메서드 => inser(위치인덱스, 데이터) 지정위치에 추가

nums.insert(0, 2024)
print(f'nums : {len(nums)}개, {nums}') # nums : 4개, [2024, 10, 'One', True]

nums.insert(-1,["ABC", "DEF"])
print(f'nums : {len(nums)}개, {nums}') # nums : 5개, [2024, 10, 'One', ['ABC', 'DEF'], True]

del nums[-2][-1]
print(f'nums : {len(nums)}개, {nums}') # nums : 5개, [2024, 10, 'One', ['ABC'], True]

# 리스트 아에 모드 워소 삭제해서 빈 리스트를 만들어주세요
del nums[:]
print(f'nums : {len(nums)}개, {nums}')

# [2] 리스트 안에 원소/요소 정렬해주는 메서드 => sort() 오름차순 정렬
# - 오름차순 : 작은 데이터부터 큰 데이터 순으로 정렬
nums.append(98)
nums.append(-2)
nums.append(4)
nums.append(0)
nums.append(0.1)

nums.sort()
print(f'nums : {len(nums)}개, {nums}')
#nums = nums.sort() None 이기 때문에 저장해도 안됨

# - 내림차순 : 큰 데이터부터 작은 데이터 순으로 정렬
nums.sort(reverse=True)
print(f'nums : {len(nums)}개, {nums}')

# [3] 리스트 안에 원소/요소의 현재 위치를 반대로 뒤집어 주는 메서드 => reverse()
# 원소/요소 데이터 값 비교 안 함!! 순서만 변경함!
nums.reverse() # 반환값 None이기 때문에 저장해도 안됨
print(f'nums : {len(nums)}개, {nums}')

# [4] 리스트 안에 특정 원소/요소 삭제해주는 메서드 => remove()
# - 리스트에서 지정된 값의 원소 삭제
# - 없는 값/데이터 삭제 요청 시 Error 발생시킴!!
nums.remove(0) # 인덱스가 아니라 해당 값으로 삭제함, 반환값 None
print(f'nums : {len(nums)}개, {nums}')

# nums.remove(0) #없는 값 지워보기
# print(f'nums : {len(nums)}개, {nums}') ValueError: list.remove(x): x not in list

# [5] 리스트 안에 모든 원소/요소 삭제해주는 메서드 => clear()
nums.clear()
print(f'nums : {len(nums)}개, {nums}')

# nums[0] = 'A'

# [6] 리스트 안에 원소/요소 꺼내는 메서드 => pop()

nums.append(10)
nums.append(True)
nums.append(7)
print(f'nums : {len(nums)}개, {nums}')

nums.pop()
print(f'nums : {len(nums)}개, {nums}')

# [6] 리스트 안에 원소/요소 꺼내는 메서드 => pop(인덱스)
a = nums.pop(0) #remove와 다르게 꺼낸 것이기 때문에 해당 내용 저장하면 재사용 가능
print(f'nums : {len(nums)}개, {nums}')
print(a)
# print(f'a : {len(a)}개, {a}')

# [7] 리스트에서 특정 원소/요소 데이터가 몇 개 존재하는지 카운팅해주는 메서드 => count(데이터)
print(nums.count('A'))
print(nums.count(-3))

# [8] 리스트를 확장시키는 메서드=> extend(여러 개 데이터 저장한 데이터 타입)
nums.extend([11,22,33]) # 원본 문자열이 바뀜
print(f'nums : {len(nums)}개, {nums}')
# a = [1, 2, 3]
# b = [4, 5, 6]
# print( a+b, a, b) #이렇게 만들면 원본 데이터에 변화는 없음

nums.extend([])
print(f'nums : {len(nums)}개, {nums}')

nums.extend("새해 복 많이 받으세요") #공백 포함 모두 들어감, 이건 int
print(f'nums : {len(nums)}개, {nums}') # nums : 16개, [True, 11, 22, 33, '새', '해', ' ', '복', ' ', '많', '이', ' ', '받', '으', '세', '요']

nums.extend(["새해 복 많이 받으세요"]) #공백 포함 모두 들어감, 이건 list
print(f'nums : {len(nums)}개, {nums}') # nums : 17개, [True, 11, 22, 33, '새', '해', ' ', '복', ' ', '많', '이', ' ', '받', '으', '세', '요', '새해 복 많이 받으세요']

# nums.extend(2024) #TypeError: 'int' object is not iterable
# print(f'nums : {len(nums)}개, {nums}') #시퀀스 또는 반복가능한 데이터만 가능

# [9] 리스트를 복사해주는 메서드 => 얕은 복사()
nums.append([100,200])
nums2 = nums.copy() #복사본이 나오므로 저장해야 함
print(f'nums : {len(nums)}개, {nums}') # nums : 17개, [True, 11, 22, 33, '새', '해', ' ', '복', ' ', '많', '이', ' ', '받', '으', '세', '요', '새해 복 많이 받으세요']
print(f'nums2 : {len(nums)}개, {nums2}') # nums : 17개, [True, 11, 22, 33, '새', '해', ' ', '복', ' ', '많', '이', ' ', '받', '으', '세', '요', '새해 복 많이 받으세요']

# nums의 -1번 요소의 데이터를 2024로 변경
nums[-2]=2024
print(f'nums : {len(nums)}개, {nums}') # nums : 17개, [True, 11, 22, 33, '새', '해', ' ', '복', ' ', '많', '이', ' ', '받', '으', '세', '요', '새해 복 많이 받으세요']
print(f'nums2 : {len(nums)}개, {nums2}') # nums : 17개, [True, 11, 22, 33, '새', '해', ' ', '복', ' ', '많', '이', ' ', '받', '으', '세', '요', '새해 복 많이 받으세요']
# nums2는 새해 복 많이 받으세요가 덩어리라서 2024로 안 바뀜

# nums의 -1번 요소의 0번 요소를 77로 변경
nums[-1][0]=77
print(f'nums : {len(nums)}개, {nums}') # nums : 17개, [True, 11, 22, 33, '새', '해', ' ', '복', ' ', '많', '이', ' ', '받', '으', '세', '요', '새해 복 많이 받으세요']
print(f'nums2 : {len(nums)}개, {nums2}') # nums : 17개, [True, 11, 22, 33, '새', '해', ' ', '복', ' ', '많', '이', ' ', '받', '으', '세', '요', '새해 복 많이 받으세요']
# nums2도 77로 바뀜 - 리스트에는 해당 리스트의 원소별 주소가 있기 때문에
# 얕은 복사는 해당 리스트의 주소가 있기 때문에 원소만 바꾸는 것이고
# 깊은 복사는 주소를 가진 복사본 리스트가 생겨서 두 개의 리스트에서 각각 운영돼야 함
# python tutor에서 확인해보기-------------------------------------------
# aList = [11, 22, [1, 2]]
# bList = aList.copy()
#
# print(aList, bList, sep='\n')
# print(id(aList), id(bList), sep='\n')
# print(id(aList[-1]), id(bList[-1]), sep='\n')
#
# aList[-1][0]='A'
# print(id(aList), id(bList), sep='\n')
# print(id(aList[-1]), id(bList[-1]), sep='\n')
# -----------------------------------------------------------------

11:20

ex_tuple_01.py

# ----------------------------------------------------------------
# 튜풀(Tuple) : 읽기 전용의 리스트라고 함
# - 저장 후 수정, 삭제, 추가, 변경 안됨!
# - 용도 : 변경되면 안되는 데이터를 저장
# - 예시 : 성별, 주미번호, 국가코드, 프로그램 상에서 변경되면 안되는 데이터
# - 문법 : (데이터1, 데이터2, ..., 데이터n)
#         데이터1, 데이터2, ..., 데이터n
#         (데이터1,) 또는 데이터1,         반드시 ','가 있어야 함
# ----------------------------------------------------------------
# 다르프로그램은 변수는 계속 데이터 변경, 상수는 변경 안됨
# 그러나 파이썬은 전부 변수이기 때문에, 튜플 만을 변경되는 안되는 Data로 저장하는 타입 제공
# 튜플 데이터 생성----------------------------------------------------
# 성별, 주민번호를 저장하기
# myInfo = ['F', '123456-1234567'] 인 경우 변경가능하기 때문에
myInfo = ('F', '123456-1234567')
print(f'myInfo => {type(myInfo)}, {myInfo}')

# 성별 데이터 읽기
print(f'myInfo => {type(myInfo)}, 성별 : {myInfo[0]}')
print(f'myInfo => {type(myInfo)}, 주민등록번호 : {myInfo[-1]}')

# 성별 데이터 변경 ==> 여자에서 남자로
# 미지원 기능
# myInfo[0] = 'M' #TypeError: 'tuple' object does not support item assignment

# 성별 데이터 삭제 == 미지원
# del myInfo[0] #TypeError: 'tuple' object doesn't support item deletion

# 생일 데이터 추가 == 미지원

# 튜플 ==> 리스트 형변환
myInfo = list(myInfo)
print(f'myInfo => {type(myInfo)}, {myInfo}')

myInfo[0] = 'M'
print(f'myInfo => {type(myInfo)}, {myInfo}')

myInfo[1]=myInfo[1].replace('2','3',1)
print(f'myInfo => {type(myInfo)}, {myInfo}')

# 리스트 ==> 튜플
myInfo = tuple(myInfo)

# 변수 재선언하는 것도 가능한 듯..수업에선 안함
myInfo = "남자"
print(f'myInfo => {type(myInfo)}, 성별 : {myInfo[0]}')

myInfo = ('M', '123456-1234567')
print(f'myInfo => {type(myInfo)}, 성별 : {myInfo[0]}')

# ----------------------------------------------------------------
# 1개 원소를 가진 튜플 생성
# ----------------------------------------------------------------
myData= '82'   #는 str을 저장
print(f'type(myData): {type(myData)}')
myData2= ('82')   #는 str을 저장 / 그저 가독성 향상용일 뿐
print(f'type(myData): {type(myData2)}')
myData3= '82',  #는 tuple로 저장
print(f'type(myData): {type(myData3)}')
myData4= ('82',)  #는 tuple로 저장
print(f'type(myData): {type(myData4)}')

# ----------------------------------------------------------------
# 리스트 안에 원소/요소 데이터가 몇 개 존재하는 지 카운트를 알려주는 메서드 count(원소데이터)
a = [1, 2, 1, 1, 5, ['A', 'C'], 1, 1, ['A', 'C']]

print(a.count(1))
print(a.count(['A','C']))
print(a.count('A'))
print(a.count(['A']))

• 13:00 - ex_tuple_01.py 이어서 (추가해둠)

ex_tuple_02.py

# ---------------------------------------------------------------
# 튜플과 리스트
# ---------------------------------------------------------------
myData = (10, 20, ['Hong', 30], ('KIM',12))
          # 0    1       2            3

# 튜플의 원소/요소 갯수 확인 함수 => len()
print(f'myData 원소 수 : {len(myData)}개')

# 인덱스 범위
print(f'myData 인덱스 : 0 ~ {len(myData)-1}')

# 튜플에서 원소/요소 데이터 읽기
print(f'myData : {type(myData[2])}')
print(f'myData : {type(myData[3])}')
print(f'myData : {type(myData[0])}')

# 튜플에서 0번째 원소의 데이터를 변경하기
# myData[0] = 'Ten' 튜플이기 때문에 안 바뀜
# myData[2] = 'Ten'   #튜플의 2번째 요소 변경 => 미지원
myData[2][0] = 'PARK'
print(myData) #(10, 20, ['PARK', 30], ('KIM', 12)) 튜플 내 리스트는 변경 가능

# ---------------------------------------------------------------
# 튜플과 연산
# ---------------------------------------------------------------
# 1~10 범위에서 2의 배수로 구성된 정수 튜플 1개 => two
# 1~10 범위에엇 5의 배수로 구성된 정수 튜플 1개 => five
two = tuple(range(2,11,2))
five = tuple(range(5,11,5))
print(two+five, two, five, sep='\n') # 튜플의 덧셈
print(two*2, two, sep='\n')          # 튜플의 곱셈

ex_dict_01.py

# ---------------------------------------------------------------
# [질문] 10명 학생에 대한 학점을 젖아 하기
# - 학생의 이름과 학점
# 방법1) 학생 이름 변수 10개 => stdName1 ~ stdName10
#       학점변수 10개      => jumsu1 ~ jumsu10

stdNum01 = 'std01'
stdNum02 = 'std01'
stdNum03 = 'std01'
stdNum04 = 'std01'
stdNum05 = 'std02'
stdjumsu01 = ('90')
stdjumsu01 = ('89')
stdjumsu01 = ('100')
stdjumsu01 = ('76')
stdjumsu01 = ('34')

#한 개의 변수 이름으로 10개의 정보를 관리하고 싶을 때 사용
# 방법2) 학생 이름 변수 10개 => stdNames=[학생 이름1, ...,  학생 이름5]
#       학점변수 10개      => stdJumsus=[점수1, ..., 점수5]
stdNums = ['std01', 'std02', 'std03', 'std04', 'std05']
stdJumsus = [90, 89, 100, 76, 34]

# => 학번03번 학생의 학번과 점수를 출력하세요
idx = stdNums.index('std03')
print(f"{stdNums[idx]}학번 학생의 점수 {stdJumsus[idx]}점")

# 방법3) 학생 이름 변수 10개 => stdNames=[학생 이름1, ...,  학생 이름5]
#       학점변수 10개      => stdJumsus=[점수1, ..., 점수5]
stdNumsJumsu=[['std01',90], ['std02', 89], ['std03', 100], ['std04', 76], ['std05', 34]]
print(stdNumsJumsu)

# ---------------------------------------------------------------
# dict 자료형
# - 연관되어 있는 데이터를 하나로 묶어서 저장하는 방식 => 연관배열
# - 형태 => 키 : 데이터    ( 예시 => 주민번호 : 이름, 학번 : 전공 )
# - 조건 => 키가 중복되면 안됨!
# - 문법 => {키1 : 데이터1, 키2: 데이터2, ... 키N : 데이터N} dict
#          [ 데이터1, 데이터2, ..., 데이터n] 리스트
#          ( 데이터1, 데이터2, ..., 데이터n) 튜플
# ---------------------------------------------------------------
stdNumsJumsu = {'std01' : 90, 'std02' : 89, 'std03' : 100, 'std04' : 76, 'std05' : 34}
                        # 0             1             2              3             4
print(f'stdNumsJumsu : {len(stdNumsJumsu)}개, {type(stdNumsJumsu)}, {stdNumsJumsu}')

# 원소 읽는 방법 => 변수명[Key]
print(f'stdNumsJumsu : {stdNumsJumsu["std03"]}')

# 마지막 원소 지정하는 -1 사용 => -1에 대한 키가 없으면 ERROR.
#print(f'stdNumsJumsu[-1] => {stdNumsJumsu[-1]}') 인덱스 없음. [-1], [0] 등 불가

# ---------------------------------------------------------------
# 원소/요소 추가 방법 => 변수명[새로운 키] = 데이터
# ---------------------------------------------------------------
stdNumsJumsu['std10'] = 99.8
print(f'stdNumsJumsu : {len(stdNumsJumsu)}개, {type(stdNumsJumsu)}, {stdNumsJumsu}')

# ---------------------------------------------------------------
# 원소/요소 데이터 변경  => 변수명[기존 키] = 새로운 데이터
# ---------------------------------------------------------------
# 학번 10인 학생의 점수 99점으로 변경
stdNumsJumsu['std10'] = 99
print(f'stdNumsJumsu : {len(stdNumsJumsu)}개, {type(stdNumsJumsu)}, {stdNumsJumsu}')

# ---------------------------------------------------------------
# 원소/요소 데이터 tkrwp  => del 변수명[키] 또는 del(변수명[키])
# ---------------------------------------------------------------
del stdNumsJumsu['std10']
print(f'stdNumsJumsu : {len(stdNumsJumsu)}개, {type(stdNumsJumsu)}, {stdNumsJumsu}')

del (stdNumsJumsu['std02'])
print(f'stdNumsJumsu : {len(stdNumsJumsu)}개, {type(stdNumsJumsu)}, {stdNumsJumsu}')

# 키는 값을 변경할 수 없기 때문에 튜플만 가능, 리스트 불가, 중복일 경우 뒤의 값만 인식

• 14:00 ex_dict_01.py 이어서
• 14:20 ex_dict_02.py

# ---------------------------------------------------------------
# 다양한 dict 자료형 => key:value <= 데이터 덩어리
# - key로 데이터를 찾기/읽기/삭제/변경
# - key 중복 X => 마지막 데이터의 key의 값으로 저장
# ---------------------------------------------------------------
# 이름, 점수 저장하기
jumsuDict = {'Hong' : 100, 'Park' : 98, 'Kim' : 88, 'Hong' : 50, 'Hong' : 77}

print(f'jumsuDict => {len(jumsuDict)}개, {jumsuDict}')

# 이름/번호를 키로 해서 점수를 저장 하기 ---------------------------------
# jumsuDict = {['Hong',1] : 100, ['Park',3] : 98, ['Kim',3] : 88, ['Hong',4] : 50, ['Hong',2] : 77}
# print(f'jumsuDict => {len(jumsuDict)}개, {jumsuDict}') #TypeError: unhashable type: 'list'
# 리스트는 변경가능하기 때문에 키값이 될 수 없음

jumsuDict = {('Hong',1) : 100, ('Park',3) : 98, ('Kim',3) : 88, ('Hong',4) : 50, ('Hong',2) : 77}
print(f'jumsuDict => {len(jumsuDict)}개, {jumsuDict}')

print(f"jumsuDict[('Hong', 2)] => {(jumsuDict[('Hong', 2)])}")

print(f"jumsuDict[('Hong', 1)] => {(jumsuDict[('Hong', 1)])}")

# 키의 데이터 타입 동일해야 하나요? 아닙니다.
testDict = { 1 : 'Hong', 2.0 : 'Kim', False : 100, "name" : 'HongGilDong', False : 2024}
print(f'testDict => {len(testDict)}개,{testDict}')

# 빈 딕셔너리 생성
emDict = {}
print(f'emDict => {type(emDict)}, {len(emDict)}개')

# Bool Type 으로 보면
a = []
b = ()
c = {}

print(bool(a), bool(b), bool(c)) # 0이기 때문에 False False False

• 14:45
• ex_dict_method.py

# ---------------------------------------------------------------
# dict 데이터 전용 함수 즉 메서드(Method)
# ---------------------------------------------------------------
# 빈 dict----------------------------------------------------
myDict = {}

# 데이터 추가 => myDict[키]=데이터--------------------------
myDict['one']=100

# 데이터 추가 => update() 메서드--------------------------
# myDict.update('two', 200) TypeError: update expected at most 1 argument, got 2
# myDict.update(('two', 200)) TypeError: update expected at most 1 argument, got 2

# 데이터 추가 => myDict[키]=데이터--------------------------
# 주의!!! 키는 str 타입만 가능, str 타입이지만 '', "" 사용 안 됨
myDict.update(two = 200)    # 여기서 two는 매개변수이므로 변수명이라 '' 쓰면 안 됨
                            # 매개변수는 변수명 짓기 위한 변수 - 글로 보니 더 헷갈림..
print(f'myDict : {myDict}')
# myDict.update(2= 200)     # 변수명은 여기서도 숫자로 시작할 수 없음
myDict.update(two = 300, _1 = 1000)
print(f'myDict : {myDict}')

# 키만 추출해서 읽어오는 메서드 => keys() 메서드 --------------------------
keys = myDict.keys() # 뷰 타입을 제공
print(f'myDict의 키들 : {keys}, {type(keys)}')
# myDict의 키들 : dict_keys(['one', 'two', '_1']), <class 'dict_keys'>
# 메모리 문제로 새로운 객체를 만드는 게 아니라 기존 데이터를 활용해 미리보기(view)를 시켜주는 것

# 값만 추출해서 읽어오는 메서드 => values() 메서드 --------------------------
values = myDict.values() # 뷰 타입을 제공
print(f'myDict의 밸류들 : {values}, {type(values)}')

# 키와 값을 묶은 아이템을 추출해서 읽어오는 메서드 => items() 메서드 --------------------------
# (키, 값) 튜플 형식으로 묶어서
items = myDict.items() # 뷰 타입을 제공
print(f'myDict의 키/값 묶음들 : {items}, {type(items)}')

# 딕셔너리는 인덱스가 없기 때문에 keys, values, items는 아주 많이 사용

myDict2 = { 1 : 2, 3 : 4}
keys2 = myDict2.keys()
print(f'myDict2의 키들 : {keys2}, {type(keys2)}')
#  myDict2의 키들 : dict_keys([1, 3]), <class 'dict_keys'>

# 원소/요소 단위 접근 위해서는 형변환 필요함!!
items = list(myDict.items())
print(f'myDict의 키/값 묶음들 : {items[0]}, {type(items)}')

# 원소/요소 모두 삭제해주는 메서드 => clear() 메서드
# del myDict의 경우 키마다 삭제해줘야해서
# myDict.clear()
# print(f'myDict : {myDict}, {len(myDict)}개') # {} 빈 딕셔너리가 됨

# 원소/요소 데이터 읽기 메서드 => 변수명[키] ==> 값, get(키) 메서드
print(f'myDict.get("one") : {myDict.get("one")}, {(myDict["one"])}개') # {} 빈 딕셔너리가 됨
print(f'myDict.get("three") : {myDict.get("three")}') # None으로 반환
# print(f'myDict.["three"] : {myDict.["three"]}')       # 에러남

# 원소/요소 데이터 읽기 메서드 => 변수명[키] ==. 값, get(키, 기본값) 메서드
# => 키가 존재하지 않으면 기본값 반환
print(f'myDict.get("three", 0) : {myDict.get("three", 0)}') # None으로 반환
print(f'myDict.get("three", "존재 하지 않음") : {myDict.get("three", "존재 하지 않음")}') # None으로 반환

# ---------------------------------------------------------------
# 멤버 연산자 => 원소 in 여러개 저장 타입
#          => 원소 not in 여러개 저장 타입
# - 여러개 저장 타입 : str, list, tuple, dict, set
# - 연산 결과 => True / False
# ---------------------------------------------------------------
aList = [1, 2, 3]
aTuple = 11, 22
aDict = {1 : 100, 2 : 100}

print(f'''1 in aList : {1 in aList}    
1 in aTuple : {1 in aTuple}
1 in aDict : {1 in aDict}
1 in aDict : {100 in aDict}''')
# True False True False(Dict는 키 존재여부만 봄)
# 딕셔너리의 값, 아이템 형식의 리스트/튜플을 넣어도 False 나옴

• 15:40

ex_set_01.py

# ---------------------------------------------------------------
# set 데이터 타입
# - 제일 마지막에 추가된 타입
# - 목적 : 중복 데이터 제거
# - 특징 : 이미 존재하는 데이터는 존재하지 않음!!
# - 문법 : {데이터1, 데이터2, ..., 데이터N}
# ---------------------------------------------------------------
# 빈 데이터 타입 생성=================================
aList = []
aTuple = ()
aDict = {}
aSet = set()
aStr = ''

print(f'aList => {type(aList)}, {len(aList)}개')
print(f'aTuple => {type(aTuple)}, {len(aTuple)}개')
print(f'aDict => {type(aDict)}, {len(aDict)}개')
print(f'aSet => {type(aSet)}, {len(aSet)}개')
print(f'aStr => {type(aStr)}, {len(aStr)}개')

# ---------------------------------------------------------------
# 생성자 함수 => 타입 이름과 동일한 함수명
# - 힙 영역에 메모리 공간 잡고 데이터 초기화 기능 수행
# ---------------------------------------------------------------
print("#"*30)
aList = list()
aTuple = tuple()
aDict = dict()
aSet = set()
aStr = str()

print(f'aList => {type(aList)}, {len(aList)}개')
print(f'aTuple => {type(aTuple)}, {len(aTuple)}개')
print(f'aDict => {type(aDict)}, {len(aDict)}개')
print(f'aSet => {type(aSet)}, {len(aSet)}개')
print(f'aStr => {type(aStr)}, {len(aStr)}개')

# ---------------------------------------------------------------
# set 타입의 데이터 생성
# ---------------------------------------------------------------
a1 = {1, 1, 2, 3, 4, 5, 1, 1, 1, 1}
a2 = [1, 1, 2, 3, 4, 5, 1, 1, 1, 1]
a3 = (1, 1, 2, 3, 4, 5, 1, 1, 1, 1)

print(f'a1 => {type(a1)}, {len(a1)}개, {a1}')
print(f'a2 => {type(a2)}, {len(a2)}개, {a2}')
print(f'a3 => {type(a3)}, {len(a3)}개, {a3}')

# 다른 데이터 타입에서 중복 데이터 제거 시에 활용  => 형변환!!
a2 = list( set(a2))
print(f'a2 => {type(a2)}, {len(a2)}개, {a2}')

# ---------------------------------------------------------------
# set 타입의 연산 수행 => 미지원
#---------------------------------------------------------------
a1 = {1, 3, 5, 1, 2}
b1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

# 연산 수행하려면 ==> 형변환 후 수행 시 가능-----------------------------
# print(a1+b1) set끼리 연산 안됨
# print(a1*2) set이라서 연산 안됨

#---------------------------------------------------------------
# 원소/요소 읽기/수정/삭제/추가 ===> 인덱스X, 키X ==> 메서드 제공
#---------------------------------------------------------------
# 원소/요소 추가 => 1개 추가 : add()메서드
print(f'a1 => {type(a1)}, {len(a1)}개, {a1}')
a1.add(10)
a1.add(10)
print(f'a1 => {type(a1)}, {len(a1)}개, {a1}')

a1.add('A')
print(f'a1 => {type(a1)}, {len(a1)}개, {a1}')

# 여러 개의 원소/요소 추가 => update() 메서드
a1.update([11,22,33,44])
print(f'a1 => {type(a1)}, {len(a1)}개, {a1}')
# 인덱스가 없어서 순서가 없음.. 매번 다르게 출력될 수도..
# 한개 추가는 .add(), 여러개 추가는 .update()

a1.update("Good Luck !!")
print(f'a1 => {type(a1)}, {len(a1)}개, {a1}') # 중복제외하고 하나씩, 순서없이

a1.add("Good Luck !!")
print(f'a1 => {type(a1)}, {len(a1)}개, {a1}') # 덩어리 째로

# 원소/요소 삭제 => remove(데이터)
a1.remove('G')
print(f'a1 => {type(a1)}, {len(a1)}개, {a1}') # 덩어리 째로
# a1.remove('G')
# print(f'a1 => {type(a1)}, {len(a1)}개, {a1}') # 덩어리 째로
# 없는 경우에는 KeyError: 'G'

# 원소/요소 꺼내기 => pop(데이터)
data = a1.pop()
print(f'a1 => {data}, {type(a1)}, {len(a1)}개, {a1}') # 덩어리 째로
data = a1.pop()
print(f'a1 => {data}, {type(a1)}, {len(a1)}개, {a1}') # 덩어리 째로
data = a1.pop()
print(f'a1 => {data}, {type(a1)}, {len(a1)}개, {a1}') # 덩어리 째로
data = a1.pop()
print(f'a1 => {data}, {type(a1)}, {len(a1)}개, {a1}') # 덩어리 째로
# 시행할 때마다 꺼내는 내용은 달라짐 - 순서가 없기 때문인 듯..?

# 원소/요소 꺼내기 => discard(데이터)
#discard()는 remove()와 달리 Key Error가 일어나지 않음
a1.discard('G')
print(f'a1 => {type(a1)}, {len(a1)}개, {a1}') # 덩어리 째로
a1.discard('G')
print(f'a1 => {type(a1)}, {len(a1)}개, {a1}') # 덩어리 째로

#---------------------------------------------------------------
# 집합에 관련된 메서드들과 기호 / 연산자
#---------------------------------------------------------------

# 교집합 ---------------------------------------------------------
# - 여러 개의 집합에 공통으로 존재하는 데이터만 추출
# - 기호/연산자 : &
# - 메서드 : intersection()
#---------------------------------------------------------------

a1.clear()
a1.update("Happy")
print(a1)
a2 = a1.intersection({'a', 'A', 'b', 'B'})
print(f'a2 => {a2}')
print(a1 & {'a', 'A', 'b', 'B'})

# 합집합 ---------------------------------------------------------
# - 여러 개의 집합에서 중복은 1개만 포함한 모든 원소의 집합
# - 기호/연산자 : | or 연산자
# - 메서드 : union()
#---------------------------------------------------------------
a2 = a1.union({'a', 'A', 'b', 'B'})
print(f'a2 => {a2}', a1|{'a', 'A', 'b', 'B'})

# 차집합 ---------------------------------------------------------
# - 교집합 데이터 제외한 나머지 데이터
# - 기호/연산자 : - 뺄셈 연산자
# - 메서드 : difference()
#---------------------------------------------------------------
a2 = a1.difference({'a', 'A', 'b', 'B'})
print(f'a2 => {a2}', a1 - {'a', 'A', 'b', 'B'})

a3 = {'a', 'A', 'b', 'B'}.difference(a1)
print(f'a3 => {a3}', {'a', 'A', 'b', 'B'}-a1)

# 정렬 ---------------------------------------------------------
# => 원소 값을 서로 비교해서 작은 데이터 >> 큰 데이터 순서로 저장 => 오름차순 정렬
# => 원소 값을 서로 비교해서 큰 데이터 >> 작은 데이터 순서로 저장 => 내림차순 정렬
# => set 타입에는 정렬 메서드 없음 ==> 내장함수 sorted() 사용 - 내장함수는 타입에 상관없이 사용 가능
# ---------------------------------------------------------------
a1 = sorted(a1)
print(f'a1 => {type(a1)}, {a1}')
# 무조건 반환값은 list

• 16:50

ex_if_01.py

# ---------------------------------------------------------------
# [요청] 키보드로 숫자를 입력 받아서 입력 받은 숫자 만큼
#       *을 화면에 출력해주세요~
# [해결] - (1) 숫자 입력 받기 => input()
#             str => int 형변환
#       - (2) 입력 받은 숫자 만큼 * 출력
#             '*' * 숫자
# ---------------------------------------------------------------
# (1) 숫자 입력 받기
num = input("정수 입력: ")

# 입력 받은 문자가 있다면 => len(num)>0
if len(num)>0:
    # 조건 len(num)>0 True일 때 실행되는 코드 부분
    # (2) str 숫자 => int 숫자 형변환
    num = int(num)

    # (3) '*' 출력
    print( '*' * num)
else :
    # 조건 len(num)>0 False일 때 실행되는 코드 부분
    print("입력된 숫자가 없음")

# 조건에 상관없이 순서대로 실행되는 코드
print("END")

ex_if_02.py

# [실습1] ---------------------------------------------------
# 좋아하는 정수를 하나 저장한 후 짝수면 'OO은 짝수입니다'
# 홀수면 'OO은 홀수입니다'를 출력해주세요
# ----------------------------------------------------------
myNum = 0

if myNum % 2 == 0:
    print(f"{myNum}은(는) 짝수입니다.")
else:
    print(f"{myNum}은(는) 홀수입니다.")

# [실습2] ---------------------------------------------------
# 좋아하는 정수를 하나 저장한 후 양수면 'OO은 양수입니다'
# 음수면 'OO은 음수입니다'
# 0이면 'OO은 영입니다.' 를 출력해주세요
# ----------------------------------------------------------

if myNum>0:
    print(f'{myNum}은 양수입니다.')
elif myNum<0:
    print(f'{myNum}은 음수입니다.')
else:
    print(f'{myNum}은 영입니다.')

#if 2개 이상인 다중조건문
# [실습2] ---------------------------------------------------
# 좋아하는 정수를 하나 저장한 후 양수면 'OO은 양수입니다'
# 음수면 'OO은 음수입니다'
# 0이면 'OO은 영입니다.' 를 출력해주세요
# ----------------------------------------------------------

if myNum == 0:
    print(f"{myNum} 영")
else:
    if myNum>0:
        print(f"{myNum} 양수")
    else:
        print(f"{myNum} 음수")

오늘의 질문

• myDict의 키들 : dict_keys(['one', 'two', '_1']), <class 'dict_keys'>

오늘 한 일

• 깃허브 연동

오늘 할 일

• 영어듣기 GPT 가다듬기 - part.3 듣기!
• 과제 및 복습
  • 12~15장 딕셔너리 ~ if문
  • workdict이름.py / workset이름.py / workif이름.py 드라이브 업로드
• KJI 레포트 작성
• 고령 / 거제 공모전

앞으로 해야 할 일

• 개인 이력서 작성(기업프로젝트 전까지 계속 작성)
  • 일단 있는 거 없는 거 다 써보고 쳐낼 걸 물어보자

이번 주 공모전 정리

• **2024 강원 동계청소년올림픽대회 알리바바클라우드 해커톤**

• 네이버 AI RIDE HyperCLOVA X 공모전(스타트업 단위)

https://navercloud.typeform.com/airide2023?typeform-source=naver.com

• **빅데이터 활용 미래 사회문제 해결 아이디어 해커톤**

공모전) 빅데이터 활용 미래 사회문제 해결 아이디어 해커톤 - 껌이지

• **고령군 브랜드 아이디어 공모**

• 거제시 브랜드 슬로건 공모