'2020'에 해당되는 글 497건

#dict 예제
def define_dict():
""" 사전의 정의 """
# 기본적인 사전의 생성
dct = dict() # 빈 사전
print(dct, type(dct))
# Literal 이용한 생성 {}
dct = {"basketball": 5, "baseball": 9}
#키에 접근하고자 할 경우
print(dct["baseball"]) #baseball 키에 연결된 값을 참조
#없는 키에 연결된 값의 참조
#print(dct["soccer"]) # -> KeyError
dct["soccer"] = 11 #새 값을 넣을 경우 새로운 키가 생성됩니다.
print("dct:", dct)

# 순서가 없기 때문에 인덱싱, 슬라이싱 불가합니다.
# len, 포함 여부(in,not in) 확인 가능합니다.
# -> 기본적으로 대상이 Key를 기준으로 한다(값이 아니다)

# 길이의 확인 :len
print(dct, "LENGTH:", len(dct))

# in, not in 키를 검색할 수 있다
print("soccer" in dct) # 키 목록에서 soccer 검색
print("volleyball" in dct) # 키 목록에서 volleyball 검색.. False 나와요

#dict는 복합 자료형입니다. 키의 목록, 값의 목록을 별도로 뽑아낼 수 있습니다.
print("KEYS OF dct:", dct.keys()) #keys 메서드 -> 키목록이 출력됩니다.
print("Type of keys:", type(dct.keys())) #타입이 출력됩니다.
print("Values of dct:", dct.values()) #values 메서드 -> 값목록이 출력됩니다.

# 값의 포함 여부를 판단하려면 .values() dict_values를 추출
# 그 안에서 확인
# dct의 값에 9가 포함되어 있는가?
print("dct의 값에 9가 포함되어 있습니까?", 9 in dct.values()) # 출력: true

#사전을 생성하는 다른 방법들은 무엇이 있을까요?
# 키워드 인자를 이용한 사전의 생성
d1 = dict(key1="value1", key2="value2", key3="value3")
print("d1:", d1, type(d1))

#튜플의 리스트로 사전의 생성
d2 = dict([("key1", 1), ("key2", 2), ("key3", 3)])
print("d2:", d2, type(d2))

# 키의 목록과 값이 이미 목록에 있는 경우
# zip 객체로 묶어서 dict에 전달
keys = ("one", "two", "three", "four")
values = (1,2,3,4)
d3 = dict(zip(keys, values))
print("d3:", d3, type(d3))

#사전의 키는 immutable 자료형이어야 합니다.
d4 = {}
d4[True] = "true"
d4[10] = 10
d4["eleven"] = 11
d4[("홍길동", 23)] = "홍길동 23"

# bool, 수치형, 문자열, 튜플 등 불변 자료형 가능
# d4[["홍길동", 23]] = "홍길동 23" # -> Error
print("d4:", d4)

def dict_methods():
""" 사전의 메서드들"""
dct = {"soccer":11, "baseball": 9, "volleyball": 6}
print("dct:", dct)
#key의 목록 추출 : keys 메서드들
keys = dct.keys()
print("keys of dict:", keys, type(keys))
#dict_keys는 순차 자료형으로 변환할 수 있다.
keys_list = list(keys)
print(keys_list)
#값의 목록 추출: values 메서드
values = dct.values()
print("Values of dct:", values, type(values))
# 키 -값 쌍튜플의 목록 추출
pairs = dct.items()
print("key-vale pair of dct:", pairs)

dct.clear() # 비우기
print("dct:", dct)

def using_dict():
""" 사전 사용 연습"""

phones = {
"홍길동": "010-0000-0000",
"장길산": "010-1111-1111",
"임꺽정": "010-2222-2222"
}
print(phones)

#새로운 키의 추가 ['키']
phones['일지매'] = "010-3333-3333"

#키 직접 접근 vs get 비교
if "고길동" in phones:
print(phones['고길동']) # 키 직접 접근은 키가 없으면 에러 발생
print(phones.get("고길동")) # get 메서드는 키가 없을 경우 None 리턴
#키가 없어도 기본값을 리턴하고자 할 경우 get메서드 두번째 인자로
#기본 값을 부여
print(phones.get("고길동", "미등록"))

#삭제 : del
if "일지매" in phones:
del phones['일지매']
print(phones)

#pop 메서드 : 값을 가져오며 해당 객체를 삭제
print(phones.pop('장길산'))
print(phones)
#popitem 메서드 : 키-벨류 쌍튜플을 반환하고 키를 삭제
item = phones.popitem()
print("Name:", item[0], "Phone:", item[1])
print(phones)

def loop():
""" 사전 객체의 순회 """
phones = {
"홍길동": "010-0000-0000",
"장길산": "010-1111-1111",
"임꺽정": "010-2222-2222"
}
print(phones)

# 기본적인 loop
for key in phones: # 루프를 진행하면 keys() 목록을 대상으로 한다
print(key, ":" , phones[key])

# 키와 값을 함께 loop
for t in phones.items(): # item 메서드는 키-값 쌍튜플의 목록
print(t)

for key, value in phones.items():
print(key, ":", value)



if __name__ =="__main__":
define_dict()
dict_methods()
using_dict()
loop()

#Tuple 예제
def define_tuple():
"""튜플의 정의"""
""" 튜플
- 리스트와 거의 비슷하나 immutable
- (), tuple 객체 함수 이용
- 요소 값이 1개일 경우는 , 를 직어줘야 한다
"""
tp = tuple()
print(tp, type(tp))

tp2 = () # 공튜플 (Literal)
tp3 = (1,) # 항목이 한개면 뒤에 반드시 콤마가 있어야 한다.
tp4 = (1,2,3)
print(tp2, tp3, tp4)

def tuple_oper():
""" 튜플의 연산자 """
# len, 포함 여부(in, not in)
# index 접근, 슬라이싱 가능
# immutable 자료형 -> 내부 자료 변경 불가
# 반복(*)과 연결(+)이 가능하다
tp = 1,2,3,4,5 # ()를 안써줘도 튜플로 인식
print(tp, "LENGTH:", len(tp))
# 포함 여부 확인
print("3 in tp?", 3 in tp)
#인덱스 접근
print("정인덱스 tp:", tp[0],tp[1], tp[2])
print("역인덱스 tp:", tp[-5], tp[-4], tp[-3])
# 슬라이싱 [시작경계: 끝경계: 간격]
print("슬라이싱 tp:", tp[1:4], type(tp[1:4]))
print("튜플 전체:", tp[:]) #튜플 전체
# 반복 (* int)
print("반복 tp:", tp * 2) # 2번 반복
# 연결(+튜플)
print("연결 tp:", tp+ (6,7,8))

def tuple_assignment():
""" 튜 플 의 할 당"""
#튜플을 활용, 여러 개의 변수를 동시 할당
x,y,z = 10, 20, 30
print(x, y, z)

#튜플을 이용한 변수의 값 Swap( 값 교체)
x,y = 10 , 20
print("x={}, y={}".format(x,y))
x,y = y, x
print("SWAP: x={}, y={}".format(x,y))

def tuple_methods():
""" 튜플의 메서드들"""
tp = (20, 30, 10, 20)
#특정 객체의 index
print(tp.index(20)) # 20객체의 인덱스
print(tp.index(20,1))# 인덱스 검색의 범위 제한

#요소의 갯수 확인
print("COUNT:", tp.count(20)) #내부의 20객체의 개수

def packing_unpacking():
"""튜플의 패킹과 언패킹"""
tp=10,20,30, "Python" #()묶지 않아도 자동으로 Packing
print(tp, type(tp))

# 기본 Unpacking : 튜플의 요소 개수만큼 변수를 부여
a,b,c,d = tp
print(a,b,c,d)
# 기본 Unpacking은 변수의 개수와 요소의 개수가 동일해야 한다.
# a,b,c = tp #요소의 개수보다 변수가 더 적은 경우 - > Error
# a,b,c,d,e = tp #요소의 개수보다 변수가 더 많은 경우 - > Error

# 확장 언패킹
# 지정되지 않은 개수의 튜플으르 할당 받을 변수의 이름 앞에 *
a, *b = tp
print("a",a, type(a))
print("b",b, type(b))
# 앞에서 1개, 뒤에서 1개를 추출
a, *b, c = tp
print("a:",a, type(a))
print("b:",b, type(b))
print("c:",c, type(c))

def loop():
""" 튜플의 순회 """
tp= (10,20,30,40,50)
for item in tp:
print(item, end=" ")
print()

if __name__ == "__main__" :
#define_tuple()
#tuple_oper()
#tuple_assignment()
#tuple_methods()
#packing_unpacking()
loop()

#Set연습
evens = {0,2,4,6,8,} # 짝수 집합
odds = {1,3,5,7,9} # 홀수 집합
numbers = {0,1,2,3,4,5,6,7,8,9} #전체 집합
mthree = {0,3,6,9} # 3의 배수 집합

def define_set():
""" Set 정의 연습 """
"""
- 순서가 없고, 중복 허용이 X
- 인덱싱이 안되고, 슬라이싱도 불가하다
- len, 포함 여부(in, not in) 정도만 사용 가능
- 집합을 표현하는 자료형(집합 연산 가능)
"""
# 리터럴 기호 {}
# {} -> set과 dict 양쪽에서 공유하므로 Empty Set을 만들때는 {} -> 불가합니다.
s = set() # Empty Set -> {} (X)
print("s:", type(s)) # = > dict가 나와요,

#길이와 포함 여부는 확인할 수 있다.
print(numbers, "Length:", len(numbers))
# 2가 각 집합에 포함되어 있는가?
print(2 in numbers,
2 in evens,
2 in odds,
2 in mthree)

# set 객체 함수를 이용, 다른 순차 자료형을 set으로 캐스팅 할 수 있다.
s = "Python Programming"
print(s, "Length:", len(s))
chars = set(s.upper())
print(chars, "Length:", len(chars))
#중복허용하지 않는 특서
# -> 리스트 등 자료형에서 중복을 제거할 때 유용
lst = "Python Programming Java Programming R Programming".split()
print(lst)
lst = list(set(lst))
print("중복제거:", lst)

def set_methods():
""" Set의 메서드들"""
#요소의 추가 : add
numbers.add(10)
print("Numbers:", numbers)

print("evens:", evens)
evens.add(2) #중복 추가는 허용되지 않음 -> 집합
print("evens:", evens)

#요소 삭제
# -discard : 요소삭제 -> 요소가 없어도 오류는 내지 않는다.
# - remove : 요소 삭제 -< 요쇼소가 없으면 오류
numbers.discard(10)
print("Numbers:", numbers)
numbers.discard(10) #요소가 없어도 오류 없음
#numbers.remove(10) #요소가 없으면 오류 발생
if 10 in numbers:
numbers.remove(10) # 요소가 없으면 오류 발생
else :
print("삭제할 요소가 없음")
evens.update({10,12,14,16}) #여러 요소를 한번에 업데이트
print("evens:", evens)

evens.clear() # 셋 비우기
print("evens:", evens)

def set_oper():
""" 집합 연산 """
# 합집합 : | , union 메서드
print(evens)
print(odds)
print("짝수 합집합 홀수", evens.union(odds))
print(evens.union(odds) == numbers)

# 모집합, 부분집합의 판단 issuperset, issubset
print(numbers)
print(evens)
print(odds)
print(numbers.issuperset(evens), numbers.issuperset(odds))
print(evens.issubset(numbers), odds.issubset(numbers))
print(evens.issuperset(odds))

# 교집합 : & , intersection 메서드
print(evens.intersection(mthree) == {0,6}) # 짝수와 3의 배수의 교집합
print(odds & mthree == {3,9}) #홀수와 3의 배수의 교집합

#차집합 : -, diffenrece 메서드
print(numbers.difference(evens) == odds) #전체 수와 짝수의 차집합
print(numbers - odds == evens) # 전체 수와 홀수의 차집합

def loop():
""" 세트의 순회"""
print("numbers:", numbers)
#순회
for item in numbers:
print(item,end=" ")
print()

if __name__ =="__main__":
define_set()
set_methods()

set_oper()
loop()

def stack_ex():
"""리스트를 활용한 stack 구현
append와 pop 메서드를 이용하면 stack 자료형을 구현할 수 있다."""
stack = []
stack.append(10)
stack.append(20)
stack.append(30)
print("STACK:", stack)
# output : input 방향과 동일
print(stack.pop())
print(stack.pop(-1))
print(stack.pop())
#pop 하기전에 비어있는지 체크
if len(stack) > 0:
print(stack.pop())
else:
print("스택이 비어있음:")
print("STACK:", stack)

def queue_ex():
"""리스트를 응용한 Queue 자료형의 구현 리스트의 append, pop(0)를 이용하면 Queue 구현 가능"""
queue = []
queue.append(1)
queue.append(2)
queue.append(3)
print("QUEUE:", queue)
#output은ㅇ 앞에서부터 : 0번 인덱스
print(queue.pop(0)) #queue는 먼저 넣은것 부터 튀어나와요 [1,2,3] 중에 1번이 튀어나와요
while(len(queue) > 0):
print("Queue item:", queue.pop(0))

if __name__ == "__main__":
#define_list()
#list_opper()
#list_method()
#loop()
#stack_ex()
queue_ex()