'전체 글'에 해당되는 글 508건

copy 는 일반적으로 복사라고 생각하면 됩니다.

a= 1,2,3,4 

b = a 

여기서 b를 바꾸면 a또한 바뀝니다. b가 a의 주소를 가지고 있기 때문이죠

하지만 deepcopy 는 객체 자체를 복제합니다

a= 1,2,3,4

b= a

a가 지고 있는 1,2,3,4 와

b가 가지고 있는 1,2,3,4 는 저장 위치가 다릅니다. ex)집 주소가 다름, 건물이 다름, 지역이 다름

그렇기 때문에 b를 바꿔도 b의 내용이 바뀌는 것이지 a의 내용이 바뀌는 것이 아닙니다.

하나의 주소를 가지고 있느냐? = copy

주소가 다르냐? = deepcopy

#객체의 이해
# 모듈 전체에서 공유되는 심벌들
g_a = 1 #글로벌 변수
g_b = "홍길동" #글로벌 변수

def func():
#내부에 로컬 심볼 영역이 생성
#객체에 접근할 경우, 로컬 영역 먼저 확인
#없을 경우 상위로 이동하여 검색합니다.
l_a = 2
l_b = "임꺽정"
# local 영역 심볼테이블 확인
print(locals())

class MyClass:
x = 10
y = 10

def symbol_table():
# 전역 변수 심볼 테이블 출력
print(globals())
print(type(globals()))
#dict로 반환
# 앞뒤에 __-> 심볼들은 파이썬 내부에서 사용하는 심볼. 변경하면 안된다

func()
#globals() 반환값이 dict
# 포함 여부 확인
print("g_a in global?", "g_a" in globals())

#내부에 __dict__ 를 확인하면 해당 객체 내부의 심볼 테이블 확인 가능
# 사용자 정의 함수 func의 심볼 테이블을 확인
print(func.__dict__)
print(MyClass.__dict__)

def object_id():
# 변수는 심볼명과 객체의 주소 값을 함께 가지고 관리된다
# id() 함수로 객체의 주소 확인
# is 연산자로 두 객체의 동질성을 확인할 수 있다
i1 = 10
i2 =int(10)
print("int:", hex(id(i1)), hex(id(i2)))
print(i1==i2)
print(id(i1) ==id(i2))
# 두 객체의 id() 값이 동일하다면 두 객체는 같은 객체
print(i1 is i2) # 두 객체가 동일 객체인지(같은 주소) 확인하는 연산자

# mutable 객체
lst1 = [1,2,3]
lst2 = [1,2,3]

print("lst1 == lst2 ?", lst1 == lst2) #동등성의 비교
print("lst1 is lst2 ?", lst1 is lst2) #is는 동일성의 비교

def object_copy():
a = [1,2,3]
b = a #단순 레퍼런스 복사
print(a,b)

b[0] = 4
print(a,b)

a = [1,2,3]
b = [4,5,6]
c = [a,b,100]
print(c)
# 단순 레퍼런스 복사는 주소만 카피

#객체 복제를 위한 copy import
import copy
#c를 복제해서 새객체 생성 d에 할당
d = copy.copy(c)
print(d)

d[2] = 10
print(c,d)

d[1][0] = 10
print(c,d)
print("얕은 복제: c is d?", c is d)
print("얕은 복제: c[0] is d[0]?", c[0] is d[0])
# -> 얕은 복제 : 새 객체를 만들지만 내부에 있는 요소의 주소값들을 그대로 복제
# -> 이 문제 해결을 위해서는 깊은 복제가 필요
d = copy.deepcopy(c) # 깊은 복제, 재귀적 복제
print(c,d)

#c[0] 객체와 d[0]객체는 같은ㅇ 객체인가?
print("c is d?", c is d)
print("c[0] is d[0]?", c[0] is d[0])


if __name__ == "__main__":
#func()
#symbol_table()
#object_id()
object_copy()

정답은 아래쪽에!!

aaaaaa

a

a

a

a

a

a

a

a

a

a

a

a

a

a

a

a

a

a

a

a

a

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

qq

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

q

def using_range():
""" range
- 순차 자료형
- len, in, not in
- 인덱싱, 슬라이싱, 가능하지만 슬라이싱 활용
- 지환, 착제는 불가능하다
"""

#범위의 생성 : 인자가 1개일 때 to 값
seq = range(10) # 0부터 10 "이전"까지 간격1
print(seq, type(seq))

#인자가 2개일 때 : 시작값, 끝경계
seq2 = range(2,10)
print(seq2, type(seq2))
#range 자료형은 범위 내부의 모든 값을 미리 반들어두는 것이 아니라
#필요할 때 그 때 생성 _-> 효율적이다
print("Contents of seq2:", list(seq2))

# 인자가 3개 : 시작값, 끝값, 간격값
seq3 = range(2,10,2)
print(seq3, list(seq3))
#간격이음수일 경우 큰 값 -> 작은 값으로 내려간다

#range는 그 자체로 효율적인 순차자료형
seq4 = range(1,100,2)# 홀수들
#길이 산정 가능
print(seq4, "LENGTH:", len(seq4))
#포함 이후 여부 확인 가능 : in, not in
print("10 in seq4?", 10 in seq4)
print("11 in seq4?", 11 in seq4)
#인덱싱과 슬라이싱
print(seq4[0], seq[1], seq4[2]) #정방향 인덱싱
print(seq4[-1], seq[-2], seq4[-3]) # 정방향 인덱싱
#내부 데이터 변경은 불가
#seq4[10]= "something" -> Error
print("Slcing:", seq4[:5])

#range 객체를 순회
for num in range(2,10):
print(num, end = " ")
print()

def using_enumerate():
""" enumerate 함수
- 순차형 Loop 순회시 인덱스가 필요할 경우 enumerate 함수를 사용
- (인덱스, 요소) 쌍튜플을 반환
"""
words = "Life is short You need Python".upper().split()
print("WORDS:", words)

for word in words:
print("WORDS:", word)
#루프를 돌면서 인덱스가 필요할 경우 enumerate 함수로 묶어준다
print("==== using enumerate")
for word in enumerate(words):
print("WORDS:", word)

for index, word in enumerate(words):
print(index, "번째의 word:", word)

def using_zip():
""" zip 객체의 사용
- 두 개 이상의 순차 자료형을 하나로 묶어
- 같은 위치에 있는 요소들을 튜플로 묶는다
- 길이가 다를 경우 가장 짧은 순차자료형의 길이에 맞춘다
"""
# 영어 단어의 목록과 한글 단어의 목록이 있을 경우, 쌍으로 묶어본다
english = "Sunday", "Monday", "Tuesday", "Wednesday"
print(english, type(english))
korean = "일요일", "월요일", "화요일", "수요일", "목요일"
# 두 순차자료형을 하나로 묶어보자
engkor = zip(english,korean)
print(engkor, type(engkor))
for item in engkor:
print(item)

#zip 객체는 순회를 돌고 나면 비어버린다
for eng, kor in engkor:
print(eng, "=>", kor)

engkor = zip(english, korean)
for eng, kor in engkor:
print(eng, "=>", kor)
#여러 순차형을 Loop 돌릴 때 인덱스도 필요할 경우
# enumerate로 묶어 준다
engkor = zip(english, korean)

for index, pair in enumerate(engkor):
print(index, "번째 단어", pair)

engkor = zip(english, korean)

for index, (eng, kor) in enumerate(engkor):
print(index, "번째 단어:", eng, "=>", kor)

#zip 객체로 키 목록과 값 목록을 묶어 주고 dict 함수에 넘겨주면
#dict 작성할 수 있다
print(dict(zip(english,korean)))

if __name__ == "__main__":
#using_range()
#using_enumerate()
using_zip()

#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()