'2020'에 해당되는 글 497건

현재 날짜 시간과 과거의 날짜시간의 대소를 비교해볼까요?

current = datetime.datetime.now() #현재 날짜 시간

past = datetime.datetime(2001, 1,1) #과거 날짜 시간

print(current >past) #current가 past보다 매리인가요? 

출력해보면 True값이 뜨게 됩니다

# 두 datetime은 차이값을 구할 수 있을까요? 

diff = current - past

print(diff)

이렇게 출력이 되는군요^^

#timedelta의 total_second -> 모든 속성을 합산 초단위로 반환

print(diff.days, diff.seconds, diff.microsecond, diff.total_second())

# 현재로부터 365일이 지난 시점의 datetime을 알아봅시다

print("current:", current) # 현재의 시점이 나오죠

future = current + datetime.timedelta(day=365, seconds = 0, microseconds= 0)

print("future:", future)

네 이렇게 출력이 되네요^^

#datetime은 날짜를 위한 date 객체, 시간을 위한 time 객체를 합친 것
#datetime 모듈을 import 사용

datetime은 날짜를 위한 date 객체, 시간을 위한 time 객체를 합친 것입니다.

datetime은 모듈을 import 하여 사용할 수 있습니다.

시간을 획득해 보도록 하겠습니다 현재시간의 datetime의 now() 메서드를 사용합니다.

dt = datetime.datetime.now()

print("now:",dt)

이렇게 출력됩니다.

# 특정 날짜와 시간을 얻을 때는 생성자를 활용하며 최소 년월일은 지정해야 합니다.

dt= datetime.datetime(1999,12,31)

print("dt:" dt)

#만약 실존하지 않는 날짜라면 ValueError이 뜨게 됩니다

dt = datetime.datetime(1999,12,32)

# 주요 속성들로는 year, month, day, hour, minute, second, microsecond를 얻을 수 있습니다.

print("dt의 연월일:", dt.year, dt.month, dt.day)

#요일의 확인 weekday() 메서드로 확인 합니다.

# 월요일은 0부터 시작하며 일요일은 6입니다.

print("1999-12-32일의 요일:" dt.weekday())

datetime에서 날짜만 확인하는 방법은 date() 를 사용하면 되며 date 객체를 반환합니다

마찬가지로 시간만 확인하는 것은 time() -> time 객체로 반환합니다.

import datetime #내장 객체

def get_datetime():
#시간의 획득
#현재 시간 datetime의 now() 메서드
dt = datetime.datetime.now()
print("now:", dt)

#특정 날짜와 시간을 얻을 때는 생성자를 활용
# 최소 년월일은 지정해야 한다
dt = datetime.datetime(1999,12,31)
print("dt:", dt)

#만약 실존하지 않는 날짜라면 ValueError
#dt = datetime.datetime(1999,12,32)

#주요 속성들로 year, month, day, hour, minute, second, microsecond를 얻을 수 있다.
print("dt의 연월일:", dt.year, dt.month, dt.day)

#요일의 확인 weekday() 메서드
# 월: 0~ 일: 6
print("1999-12-32일의 요일:", dt.weekday())

#datetime에서 날짜만 확인 date() -> date 객체 반환
#datetime에서 시간만 확인 time() ->time 객체 반환
nowdate = datetime.datetime.now().date()
nowtime = datetime.datetime.now().time()

print("NOWDATE:", nowdate, type(nowdate))
print("NOWTIME:", nowtime, type(nowtime))
#date 객체는 datetime이 가진 year, month, day 등 날짜 관련 속성들을 가지고 있다
#time 객체는 datetime이 가진 시간 관련 속성과 메서드들을 그대로 사용

def handling_exception():
""" 예외 처리 연습 """
# 인덱스 에러 IndexError
# 캐스팅 에러 ValueError
# 사전 키 접근 에러 KeyError
# 정수를 0으로 나눴을 경우 ZeroDivisionError

lst =[]
try:
#lst[3] =1 #IndexError
4/1 #ZeroDivisionError
#int("String") # valueError
except ValueError as e:
print("정수로 변환할 수 없어요.", e)
except ZeroDivisionError as e:
print("정수를 0으로 나눌 수 없어요.", e)
except IndexError as e:
print("인덱스 범위가 벗어났습니다.", e)
except Exception as e:
#Exception은 모든 예외의 부모 클래스
print("Exception:", e)
else:
print("예외없이 코드가 실행되었습니다.")

finally:
print("예외 여부 관계 없이 항상 마지막에 실행")

def raise_exception():
def beware_dog(animal):
if animal.lower() == "dog":
# 강제 익셉션 발생
raise RuntimeError("강아지는 출입을 제한합니다.")
else:
print("어서오세요!")
try:
beware_dog("cow")
beware_dog("cat")
beware_dog("dog")
except Exception as e:
print(e, type(e))

if __name__ =="__main__":
handling_exception()
raise_exception()

#함수의 스코핑 룰
#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()