'2020/Python'에 해당되는 글 71건

#함수의 스코핑 룰
#local -> Enclosed -> Global -> Builtin
x = 1 #Global 영역

def scope_func(a):
print("scope_func:", locals())
#a-> 외부로부터 넘어온 객체가 local 심볼에 할당
# x-> 로컬이 아니다
print("x is in global?", "x" in globals())
return a+x

scope_func(10)

def scope_func2(a):
x = 2 #global x와 다른 객체다
print("scope_func2:", locals())
return a+x

print(scope_func2(10))

def scope_func3(a):
#rmffhqjf rorcpfmf gkatn soqndptj tkdydgkrhwk gkf ruddn
#global 키워드 사용
global x #지금부터 사용할 x는 로컬로 만들지 않고 글로벌 객체를 사용할 것을 선언
#주의 : 가능하면 글로벌 객체를 내부에서 변경하지 않을 것을 권장
# 어디에서 글로벌 객체가 변경되쓴건지 추적이 힘들기 때문이에요
x = 3
print("scope_func2:", locals())
return a + x

print(scope_func3(10))
print("x:",x) #global영역


#함수의 선언(주로 가변인자와 키워드 인자 중심으로 정리)
#프로그래밍에서의 함수는 기능의 집합
# 입력값이 없을 수도 있고, 출력이 없을 경우도 있다
# 함수를 종료할 때는 return
# return 뒤에 반환값을 명시하면 결과를 받을 수 있다
# 값을 return 하지 않았거나 끝날때까지 아무 return도 없는 경우
# ->None (Java의 Null과 비슷하다)
def times(a,b):
return a*b

#함수 자체도 객체로 판단
# 다른 식별자에 할당할 수 있고
# 다른 함수의 인수로 전달할 수 있다
fun = times

print("fun:", type(fun))
# 객체가 호출 가능한 객체인지(함수) 판별하려면 callable 함수
print("is fun callable?", callable(fun))

# 만약 객체가 함수인지 판별한 이후에 호출
if callable(fun): print(fun(10,20))

# 인수의 기본값
def incr(a, step=1): # 두번째 인자값은 1이 기본값이다
return a+step

print(incr(10)) #두번째 인자 step이 기본값을 가지고 있으므로 기본값으로 세팅
print(incr(10,2)) # 기본값을 무시하고 새로운 값을 할당

#기본적으로 python은 인수의 이름을 명시해서 인자를 전달할 수 있다
#인자의 순서가 중요하지 않게 된다
print(incr(step=3, a=10))

#가변 인수
# 정해지지 않은 개수의 인자를 받을 때
# 가변 인자를 받을 변수의 앞에 * 명시
# -> 순차 자료형으로 변환되어 입력

#연습 : 여러개의 인자를 넘겨 받아서 해당 인자가 int, float이면 합산
# 그렇지 않으면 합산에서 제외 합계를 return

def get_total(*args):
total = 0
print(args, type(args))
for x in args:
# 합산 가능한 타입인지 체크
if isinstance(x, (int, float)):
total += x
return total

print(get_total(1,2,3,4,5))
print(get_total(1,2,3,4,5, "Python", (1,2,3)))

# 고정인자와 가변인자 키워드 인자
# 순서가 중요
# 고정인자 -> 가변인자(*) -> 키워드 인자(**)
def func_args(a,b, *args, **kwd):
# a, b는 고정인자 : 반드시 넘겨줘야 한다
# 그 뒤에 나온 인자의 목록은 args로 넘어올 것(tuple)
# 그 뒤에 나온 인자는 키워드(dict)
print("고정인자:", a,b)
print("가변인자:", args)
print("키워드 인자:", kwd)
if "option1" in kwd:
print("option 1이 {}로 설정되었습니다.".format(kwd['option1']))
else:
print("option1이 설정되지 않았습니다.")
func_args(1,2,3,4,5,6, option1="옵션1", option2="옵션2")


#함수도 객체이므로 다른 함수의 인자로 넘겨줄 수 있다
# Callback 패턴 구현
def calc(a,b, func):
# 계산을 위한 수 2개
# 계산 식 함수 func 를 전달
# 넘겨 받은 func가 호출 가능 객체인지 확인
if callable(func): #func은 함수?
return func(a,b) #계산 함수는 외부로부터 주입

def plus(a,b):
return a+b
def minus(a,b):
return a-b

print(calc(10,20,plus))
print(calc(10, 20, minus))

# lambda 함수 : 익명 함수
print(calc(10,20,lambda a, b: a*b)) # 즉석에서 곱셈함수 전달

# lambda 함수를 이용한 sort(sorted) 키 함수 정의
words = "Life is too short, you need Python".upper().replace(",","").split()
print("WORDS:", words)
# SORT 할 때 정렬 기준 key 함수를 lambda로 전달
# 단어 길이의 역순 정렬 함수를 람다로
sorted_words = sorted(words, key=lambda word: len(word), reverse=True)
print("Sorted Words:", sorted_words)

# 1부터 20까지 수열을 4로 나누었을 때의 나머지 순으로 정렬
nums = range(1,21) # 20까지
print("nums:", list(nums))
print("SORTED num % 4 ASC:", sorted(nums, key=lambda n: n % 4))

# 흐름 제어 ( 조건문, 반복문)
def if_statement():
""" 조건문 """

#키보드로부터 금액을 입력받고
# 10000원 이상이면 by taxi
# 2000원 이상이면 by bus
# 그렇지 않으면 on foot 출력
print("==== if elif else")
#키보드에서 금액 입력
money = input("얼마 가지고 있어?")
money = int(money) # int로 변환

message = ""
if money >= 10000:
message = "by taxi"
elif money >= 2000:
message = "by bus"
else:
message = "on foot"

print("가지고 있는 돈 {}, 이동 방법 {}".format(money, message))

def if_expr():
""" 조건 표현식"""
print("==== if expression")
money = int(input("얼마 가지고 있어?"))

message = "by taxi" if money >=10000 \
else "by bus" if money >= 2000 \
else "on foot"
print("가지고 있는 돈 {}, 이동 방법 {}".format(money, message))


def for_ex():
"""for 반복문"""
# 인덱스 반복 구문은 없고
# 순차자료형의 각 요소를 순회하는 Loop
a = ["개", "고양이", "소", "말"]
for animal in a:
print("item:" , animal)
else:
print("루프가 종료되지 않고 정상 종료되었을 때 단 한번 실행된다")
# 상황 2: 값과 함께 인덱스도 필요한 경우
# enumerate 함수 -> (인덱스, 요소값) 튜플
for animal in enumerate(a):
print(animal[0], animal[1])

for index, animal in enumerate(a):
print("{}번째 동물 {}".format(index, animal))

# 상황 3: dict의 순회 ->key 목록을 loop
dct = {"name": "홍길동", "age": 23, "job": "도적"}
for key in dct:
# 사전에 키가 할당
print("KEY: {} -> VALUE: {}".format(key,dct[key]))

# 상황 4 : dict 순회, key와 value가 함게 필요한 경우
for key, value in dct.items(): #(key, value) 쌍튜플
print("KEY: {} -> VALUE:{}".format(key, value))

# 상황 5: 범위의 loop -> range(시작, 끝경계, 간격)
r = range(1, 101)
# 1~ 100까지의 수 중 짝수의 합
total = 0
for num in r:
if num % 2 == 0:
total += num

print("1~100 짝수의 합:", total)

# 연습 문제1. 구구단을 출력
# 연습문제 2. 삼각형을 그려주세요
"""
****
***
**
*
"""
#continue : 아래에 남아있는 문장은 더이상 실행하지 않고 다음번 loop로 이동
# break : 루프를 더이상 진행하지 않고 루프 밖으로 탈출

def while_ex():
# 특정 조건이 만족되는 동안 루프를 실행
# 조건을 True로 부여하면 무한 루프가 생성된다
# 1부터 100까지 숫자 중에서 짝수만 합산(While 버전)
i = 1
total =0
while i<= 100:
if i % 2 == 0:
total += i
i += 1

else:
print("루프가 정상 종료되면 실행")
print(total)

def list_comp():
"""List Comprehension"""
# 기존 순차자료형을 기반으로 조건에 맞는 데이터를 추출
# 연산식을 수행하여 새로운 리스트를 만들어 낸다

# Synyax: [표현식 for 항목 in 순회가능 객체 if 조건]
# 기존 방식
data = range(1,11)
# data 객체를 제곱해서 새 리스트를 만들자
results = []
for num in data:
results.append(num * num)
print("RESULT:", results)
results = []

#리스트 내포 방식
results = [num*num for num in data]
print("Result(내포):", results)

#내포시 if 표현식을 연결하면 조건에 맞는 데이터만 추출 할 수 있다
# 연산에 포함시킬 수 있다
words = "a as bat cat dove python".split() #list
print("WORDS:", words)
# words(str list)에서 요소의 길이가 3글자 이상인
# 요소들만 추출 새 리스트를 만들자
filtered = [word.upper() for word in words if len(word) >=3 ]
print("Filtered Words:", filtered)

#연습 문제
# 1~ 100까지의 수 중에서 짝수의 리스트를 새로 만들기

number = range(1,101)
filtered = [num*1 for num in number if num % 2 == 0]
print(filtered)

def set_comp():
""" Set Comprehension """
# Syntax : { 표현식 for 객체 in 순회가능 객체 }

# 예1: words 내에서 길이가 2글자 이하인 새로운 세
words =" a as bat cat dove python".split()
filtered = { word.upper() for word in words \
if len(word) <= 2}
print("filtered set:", filtered)

# 예2: 문자열 리스트에서 문자열의 길이를 set으로 저장
filtered = { len(word) for word in words }
print("filtered set(length):", filtered)

def dict_comp(): #comp = comprehension(이해력)
""" 사전의 내포 """
# Syntax: {키표현식: 값표현식 for 객체 in 순회가능객체}
words = "Life is too short You need Python".upper().split()
print("WORDS:",words)
#키로는 개별 단어, 값으로는 해당 단어의 길이
dct = {word:len(word) for word in words}
print(dct)
if __name__ == "__main__":
#if_statement()
#if_expr()
#for_ex()
#while_ex()
#list_comp()
#set_comp()
dict_comp()

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