# define a function invovling the default value for a list
def append_score(score, scores=[]):
    scores.append(score)
    print(scores)

append_score(98)
# [98]
append_score(92, [100, 95])
# [100, 95, 92]
append_score(94)
# [98, 94]

# updated function to show the id for the scores
def append_score(score, scores=[]):
    scores.append(score)
    print(f'scores: {scores} & id: {id(scores)}')

append_score.__defaults__
# ([],)
id(append_score.__defaults__[0])
# 4650019968
append_score(95)
# scores: [95] & id: 4650019968
append_score(98)
# scores: [95, 98] & id: 4650019968

# use None as the default value
def append_score(score, scores=None):
    if not scores:
        scores = []
    scores.append(score)
    print(scores)

append_score(98)
# [98]
append_score(92, [100, 95])
# [100, 95, 92]
append_score(94)
# [94]

def f(x):
  import warnings, xyz, numpy 
  #do something 
 
def g(x):
  import pandas, numpy 

a = [1,2,3]
1 in a
# True

a = [1,2,3]
1 in set(a)
# True

for _ in range(5):
  do_something

beer = ('light', 'bitter', 70, 153)
 color, _, _, calories = beer

def func(arg1: str, arg2: int, arg3: 'This is your name.') -> bool:
    print(arg1)
    print(arg2)
    print(arg3)
    return True

from typing import List
nums: List[int] = [1, 2, 3]

from typing import Dict
countries: Dict[str, str] = {"KR": "South Korea", "US": "United States", "CN": "China"}

from typing import Tuple
user: Tuple[int, str, bool] = (3, "Dale", True)

from typing import Set
chars: Set[str] = {"A", "B", "C"}

# 여러 개의 annotation을 추가하고 싶을 때 사용
from typing import Union
def toString(num: Union[int, float]) -> str:
    return str(num)


# Optional은 Union에서 None을 추가한 것과 같은 의미를 가집니다.
from typing import Optional
def repeat(message: str, times: Optional[int] = None) -> list:
    if times:
        return [message] * times
    else:
        return [message]


# Call 가능한 인자를 표현할 때 사용합니다.
from typing import Callable
def repeat(greet: Callable[[str], str], name: str, times: int = 2) -> None:
    for _ in range(times):
        print(greet(name))


from typing import Iterable, List
def toStrings(nums: Iterable[int]) -> List[str]:
    return [str(x) for x in nums]

a = [1,2,3]
b = a
c = [1,2,3]

# id는 실행 환경에 따라 다릅니다.
print(id(a))
# 2763955372808
print(id(b))
# 2763955372808 
print(id(c))
# 2764303112200 

print(a is b)
# True
print(a is c)
# False
print(a == b)
# True
print(a == c)
# True

zero_list = [0] * 10
# [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

zero_tuple = (0,) * 10
# (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

def print_name(first, second, third=None, fourth=None):
    names = {}
    names[1], names[2] = first, second
    names[3] = third if third is not None else 'Nobody'
    names[4] = fourth if fourth is not None else 'Nobody'
    print(names)    

# 2개의 위치 인수(positional argument)를 전달합니다.
print_name('ming', 'alice')
# 2개의 위치 인수와 1개의 키워드 인수를 전달합니다.
print_name('alice', 'ming', third='mike')
# 2개의 위치 인수와 2개의 키워드 인수를 전달합니다. (2개의 키워드 인수 중 1개인 마치 위치 인수 처럼 전달하였습니다.)
print_name('alice', 'ming', 'mike', fourth='jim')

def print_name(first, second=None, third, fourth=None):
    ...

def print_name(*args):
    print(args) 

print_name('ming', 'alice', 'tom', 'wilson', 'roy')
# ('ming', 'alice', 'tom', 'wilson', 'roy')

def print_name(**kwargs):
    print(kwargs)
print_name(first='ming', second='alice', fourth='wilson', third='tom', fifth='roy')
# {'first': 'ming', 'second': 'alice', 'fourth': 'wilson', 'third': 'tom', 'fifth': 'roy'}

# error code
def print_name(**kwargs, *args):
    ...

primes = [2, 3, 5, 7, 11, 13]

def product(*numbers):
    print(numbers, type(numbers))    
    
product(*primes)
product(primes)

headers = {
    'Accept': 'text/plain',
    'Content-Length': 348, 
    'Host': 'http://mingrammer.com' 
}  

def pre_process(**headers): 
    content_length = headers['Content-Length'] 
    print('content length: ', content_length) 
    
    host = headers['Host']
    if 'https' not in host: 
        raise ValueError('You must use SSL for http communication')  
        
pre_process(**headers)
# content length:  348

numbers = [1, 2, 3, 4, 5, 6]

# The left side of unpacking should be list or tuple.
*a, = numbers
# a = [1, 2, 3, 4, 5, 6]

*a, b = numbers
# a = [1, 2, 3, 4, 5]
# b = 6

a, *b, = numbers
# a = 1 
# b = [2, 3, 4, 5, 6]

a, *b, c = numbers
# a = 1
# b = [2, 3, 4, 5]
# c = 6

'{0} is an {1}'.format('dog', 'animal')
'{name} is an {type}'.format(name='dog', type='animal')

# A list of numbers and strings
numbers = [1, 3, 7, 2, 5, 4]
words = ['yay', 'bill', 'zen', 'del']
# Sort them
print(sorted(numbers))
# [1, 2, 3, 4, 5, 7]
print(sorted(words))
# ['bill', 'del', 'yay', 'zen']

# Sort them in descending order
print(sorted(numbers, reverse=True))
# [7, 5, 4, 3, 2, 1]
print(sorted(words, reverse=True))
# ['zen', 'yay', 'del', 'bill']

#  Create a list of tuples
grades = [('John', 95), ('Aaron', 99), ('Zack', 97), ('Don', 92), ('Jennifer', 100), ('Abby', 94), ('Zoe', 99), ('Dee', 93)]
# Sort by the grades, descending
sorted(grades, key=lambda x: x[1], reverse=True)
# [('Jennifer', 100), ('Aaron', 99), ('Zoe', 99), ('Zack', 97), ('John', 95), ('Abby', 94), ('Dee', 93), ('Don', 92)]

# Sort by the name's initial letter, ascending
sorted(grades, key=lambda x: x[0][0])
# [('Aaron', 99), ('Abby', 94), ('Don', 92), ('Dee', 93), ('John', 95), ('Jennifer', 100), ('Zack', 97), ('Zoe', 99)]

# Requirement: sort by name initial ascending, and by grades, descending
# Both won't work
sorted(grades, key=lambda x: (x[0][0], x[1]), reverse=True)
#  [('Zoe', 99), ('Zack', 97), ('Jennifer', 100), ('John', 95), ('Dee', 93), ('Don', 92), ('Aaron', 99), ('Abby', 94)]
sorted(grades, key=lambda x: (x[0][0], x[1]), reverse=False)
# [('Abby', 94), ('Aaron', 99), ('Don', 92), ('Dee', 93), ('John', 95), ('Jennifer', 100), ('Zack', 97), ('Zoe', 99)]
# This will do the trick
sorted(grades, key=lambda x: (x[0][0], -x[1]))
# [('Aaron', 99), ('Abby', 94), ('Dee', 93), ('Don', 92), ('Jennifer', 100), ('John', 95), ('Zoe', 99), ('Zack', 97)]

sorted(iterable, key, reverse)

sorted(A, key=lambda x:foo(x))

def foo(x):
    return x.age

sorted(A, key=lambda x:foo(x))

# iterable - a list of booleans
all([True, True, True])
# True
all([True, False, False])
# False

# iterable - a list of integers (0 is considered false)
all([1, 2, 3])
# True
all([0, 1, 2])
# False

# iterable - a tuple of string (an empty string is considered false)
all(('AA', 'BB', 'CC'))
# True
all(('AA', 'BB', ''))
# False

# iterable - a nested list (an empty list is considered false)
all([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# True
all([[1, 2, 3], [4, 5, 6], []])
# False

# The typical ways
if a < 10 and b > 5 and c == 4:
    # do something
if a < 10 or b > 5 or c == 4:
    # do something
# Do these instead
if all([a < 10, b > 5, c == 4]):
    # do something
if any([a < 10, b > 5, c == 4]):
    # do something

l = lambda x: x**2
print(l(3))
: 9 

f = lambda x, y: x + y

print(f(4, 4))
: 8

r = map(function, iterable1, iterable2, ...)

a = [1,2,3,4]
b = [17,12,11,10]
list(map(lambda x, y:x+y, a,b))
: [18, 14, 14, 14]

r = filter(function, iterable)

functools.reduce(function, iterable[, initializer])

from functools import reduce
reduce(lambda x,y: x+y, [1,2,3,4,5])
: 15

py_list = ['P', 'y', 't', 'h', 'o', 'n']
py_tuple = ('P', 'y', 't', 'h', 'o', 'n')

# contains indices 0, 1 and 2
slice_object = slice(3)
print(py_list[slice_object]) # ['P', 'y', 't']

# contains indices 1 and 3
slice_object = slice(1, 5, 2)
print(py_tuple[slice_object]) # ('y', 'h')    

from collections import Counter
cnt = Counter()
for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:
    cnt[word] += 1

print(cnt)
# Counter({'blue': 3, 'red': 2, 'green': 1})

c = Counter()                           # a new, empty counter
c = Counter('gallahad')                 # a new counter from an iterable (each chracter)
c = Counter({'red': 4, 'blue': 2})      # a new counter from a mapping
c = Counter(cats=4, dogs=8)             # a new counter from keyword args

c = Counter(a=4, b=2, c=0, d=-2)
d = Counter(a=1, b=2, c=3, d=4)
c.subtract(d)
print(c)
# Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

c = Counter(a=4, b=2, c=0, d=-2)
d = Counter(a=1, b=2, c=3, d=4)
print(c - d)
# Counter({'a': 3})

c = Counter(a=4, b=2, c=0, d=-2)
d = Counter(a=1, b=2, c=3, d=4)
c.update(d)
print(c)
# Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2})

c = Counter(a=4, b=2, c=0, d=-2)
d = Counter(a=1, b=2, c=3, d=4)
print(c + d)
# Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2})

c = Counter(a=4, b=2, c=0, d=-2)
d = Counter(a=1, b=2, c=3, d=4)
print(c & d)
# Counter({'a': 1, 'b': 2})
print(c | d)
# Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2})

from collections import defaultdict
# 첫번째 케이스
md = defaultdict(list)
md[1].append('a')
md[1].append('b')
md[2].append('c')
md[1]
# ['a', 'b']
md[2]
# ['c']

# 두번째 케이스
md = defaultdict(set)
md[1].add('a')
md[1].add('b')
md[2].add('c')
md[1]
# {'a', 'b'}
md[2]
# {'c'}

from collections import OrderedDict
 
# 기본 딕셔너리 
d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange':2}
 
# 키(key)를 기준으로 정렬한 OrderedDict
ordered_d1 = OrderedDict(sorted(d.items(), key=lambda t:t[0]))
print(ordered_d1)
# OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
 
# 값(value)를 기준으로 정렬한 OrderedDict
ordered_d2 = OrderedDict(sorted(d.items(), key=lambda t:t[1]))
print(ordered_d2)
#OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

ordered_d1.update({'grape': 5}) # ordered_d1['grape'] = 5
print(ordered_d1)
# OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1), ('grape', 5)])

import operator
from collections import OrderedDict
 
# 기본 딕셔너리 
d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange':2}
 
# 키(key)를 기준으로 정렬한 OrderedDict
ordered_d = OrderedDict(sorted(d.items(), key=operator.itemgetter(0), reverse=False))
print(ordered_d)
 
# popitem(last=True) 일경우 : LIFO(Last In Last Out)방식으로 pop, default는 True임
for i in range(len(ordered_d)):
    print(ordered_d.popitem(last=True))
    
print('='*50)
    
# 키(key)를 기준으로 정렬한 OrderedDict
ordered_d = OrderedDict(sorted(d.items(), key=operator.itemgetter(0), reverse=False))
print(ordered_d)
 
# popitem(last=False) 일경우 : FIFO(First In First Out)방식으로 pop
for i in range(len(ordered_d)):
    print(ordered_d.popitem(last=False))
    
'''
결과
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
('pear', 1)
('orange', 2)
('banana', 3)
('apple', 4)
==================================================
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
('apple', 4)
('banana', 3)
('orange', 2)
('pear', 1)

import bisect 
a = [1,3,5,7,9]

# 찾고자 하는 값 2는 없으므로 2보다 크면서 가장 작은 값인 3의 인덱스인 1을 반환한다.
bisect.bisect_left(a, 2, 0, len(a))
# 1

# 찾고자 하는 값이 배열의 모든 값보다 크므로 배열의 마지막 인덱스 + 1 인 위치를 가리킨다.
bisect.bisect_left(a, 10, 0, len(a))
# 5

# 찾고자 하는 값이 배열의 가장 작은 값 보다 작으므로 배열의 첫번째 인덱스인 0의 위치를 가리킨다.
bisect.bisect_left(a, -1, 0, len(a))
# 0

# 정확히 찾고자 하는 값이 있는 경우 그 값의 인덱스를 반환한다.
bisect.bisect_left(a, 5, 0, len(a))
# 2

# 정렬된 배열에서 배열의 정렬 상태를 유지하면서 값을 삽입한다.
# 삽입 위치를 찾는 데에는 O(log(n))의 시간이 걸리지만 실제 삽입할 때, O(n)의 시간이 걸린다.
bisect.insort_left(a, 6, 0, len(a))

print(a)
# [1, 3, 5, 6, 7, 9]

odds = [1,3,5,7,9]
evens = [2,4,6,8,10]
for oddnum, evennum in zip(odds,evens):
    print(oddnum)
    print(evennum)

for i in range(10):
    print(i)    

A = [10, 20, 30, 40, 50]
for i, data in ennerate(A, start=1):
    print(i, data)

l = [15,6,1,8]
for i in sorted(l):
    print(i)
    
for i in sorted(l,reverse = True):
    print(i)

people = [{"name": "John", "id": 1}, {"name": "Mike", "id": 4}, {"name": "Sandra", "id": 2}, {"name": "Jennifer", "id": 3}]
for person in filter(lambda i: i["id"] % 2 == 0, people):
...     print(person)
... 
{'name': 'Mike', 'id': 4}
{'name': 'Sandra', 'id': 2}

from collections import deque
dq = deque(maxlen=3)
dq.append(1)
dq.append(2)
dq.append(3)
dq.append(4)

print(dq)
: deque([2, 3, 4], maxlen=3)

import sys
sys.exit()

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--input', required=True, help='Enter the input')
args = parser.parse_args()
print(args.input)

from argparse import ArgumentParser
import json

parser = ArgumentParser()
parser.add_argument('--seed', type=int, default=8)
parser.add_argument('--resume', type=str, default='a/b/c.ckpt')
parser.add_argument('--surgery', type=str, default='190', choices=['190', '417'])
args = parser.parse_args()

with open('commandline_args.json', 'w') as f:
    json.dump(args.__dict__, f, indent=2)

parser = ArgumentParser()
args = parser.parse_args()
with open('commandline_args.json', 'r') as f:
    args.__dict__ = json.load(f)

print(args)

>> s = 'this is string.'
>> s.startswith('this')
True

>> s = 'this is string.'
>> s.endswith('string.')
True

>> s = 'this is string.'
>> 'is' in s
True

>> s = 'this is string.'
>> s.find('string')
8
>> s.find('no')
-1

import shutil
src = './dir1'
dest = './dir2'
shutil.copytree(src, dest)

import shutil

def OnlyDirectoryCopy(dir, files):
    return [f for f in files if os.path.isfile(os.path.join(dir, f))]

src = './dir1'
dest = './dir2'
shutil.copytree(src, dest, ignore=OnlyDirectoryCopy)

>> s = 'image.png'
>> s.split('.')
['image', 'png']

import re

>> s = 'A_B_C.png'
>> re.split('[_.]', s)
['A', 'B', 'C', 'png']

a = '\n \t aaaa     '
a.strip()
>>> 'aaaa'

a.lstrip()
>>> 'aaaa     '

a.rstrip()
>>> '\n \t aaaa'

os.environ['HOME'] # 'HOME' 대신에 다양한 시스템 정보들이 들어갈 수 있습니다.
os.environ.get('HOME')
os.path.isfile('filename')
os.path.isdir('dirname')

# path가 존재하는 지 확인
os.path.exists(path) 

# 현재 경로에 folder 생성
os.mkdir(folder_name) 

# 지정된 path에 folder 생성하며 path에 포함된 branch 까지 생성
# 예를 들어 path가 ./A/B/C 이고 B/C가 없다면 마지막 C를 생성할 때까지 중간에 필요한 폴더 계층을 모두 생성합니다.
# mkdir과 유사하지만 중간에 sub directory 까지 한번에 만들어 줍니다.
os.makedirs(path) 

# 현재 디렉토리의 절대 경로를 출력함
os.path.abspath(os.getcwd())
# 경로 변경
os.chdir(path)

# cmd 명령어 입력
command = "ls -al"
os.system(command)

# 작업하고 있는 디렉토리 변경
os.chdir(path)

# 현재 프로세스의 작업 디렉토리 얻기
os.getcwd()

# 파일이나 디렉토리 지우기
os.remove(file_path or path)

# 파일의 상대 경로를 절대 경로로 바꾸는 함수
os.path.abspath(file_path)

# 주어진 경로의 파일이 있는지 확인하는 함수
os.path.exists(file_path)

# 현재 디렉토리 얻기
os.curdir()

# 부모 디렉토리 얻기
os.pardir()

# 디렉토리 분리 문자 얻기. . windows는 \ linux는 / 를 반환합니다.
os.sep() 

# 파일명만 추출
os.path.basename(file_path)

# 디렉토리 경로 추출
os.path.dirname(file_path)

# 마지막 디렉토리 폴더명 추출
path = "folder_A/folder_B/folder_C/folder_D"
os.path.basename(os.path.normpath(path))
# folder_D

# 경로와 파일명을 분리
os.path.split(file_path)

# 드라이브명과 나머지 분리 (MS Windows의 경우)
os.path.splitdrive(file_path)

# 확장자와 나머지 분리
os.path.splitext(file_path)

# 파일 사이즈 계산
MB = 1024 ** 2
GB = 1024 ** 3
# Mega Byte 단위로 표현
os.path.getsize(file_path) // MB
# Giga Byte 단위로 표현
os.path.getsize(file_path) // GB

import glob

path = "./*/*.py"
file_list = glob.glob(path)
file_list_py = [file for file in file_list]
# file_list_py = [file for file in file_list if file.endswith(".py")]

print ("file_list_py: {}".format(file_list_py))

import pickle

# 샘플 데이터를 생성하기 위해 numpy를 이용해 보겠습니다.
# 이 때, 어느 데이터든 상관없습니다. numpy 말고 list, dictionary 등등 아무 거나 사용하셔도 됩니다.
import numpy as np
A = np.random.rand(10, 10, 10)
 
## Save pickle
with open("data.pickle","wb") as fw:
    pickle.dump(A, fw)
 
## Load pickle
with open("data.pickle","rb") as fr:
    B = pickle.load(fr)

>> exec("%s = %d" % ("x", 10))
>> print(x)

10

def func():
    exec("a = 5", globals())
    
>> print(a)
5

>> isinstance(1, int)
True

temp_str = "sample"
temp_int = 1
temp_float = 1.23

class Temp():
    pass    
temp_class = Temp()

>> type(temp_str)
str
>> isinstance(temp_str, str)
True

>> type(temp_int)
int
>> isinstance(temp_int, int)
True

>> type(temp_float)
float
>> isinstance(temp_float, float)
True

>> type(temp_class)
__main__.Temp
isinstance(temp_class, Temp)
>> True

>> dir('.')

['DirEntry',  'F_OK',  'MutableMapping',  'O_APPEND',  'O_BINARY',  'O_CREAT', ...]

class Test():
    def func1():
        pass
    def func2():
        pass

test = Test()
>> dir(test)
['__class__','__delattr__','__dict__','__dir__','__doc__',
'__eq__','__format__','__ge__','__getattribute__','__gt__',
'__hash__','__init__','__init_subclass__','__le__','__lt__',
'__module__','__ne__','__new__','__reduce__','__reduce_ex__',
'__repr__','__setattr__','__sizeof__','__str__','__subclasshook__',
'__weakref__','func1','func2']

alphabets = ['A', 'B', 'C', 'D']

# create an enumerate object
enumberate_alphabet = enumerate(alphabets)

# obtain the next tuple from the enumerate object
>> next(enumerate_object)
(0, 'A')

>> next(enumerate_object)
(1, 'B')

>> next(enumerate_object)
(2, 'C')

>> next(enumerate_object)
(3, 'D')

alphabets = ['A', 'B', 'C', 'D']
enumberate_alphabet = enumerate(alphabets)
>> list(enumberate_alphabet)
[(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D')]

alphabets = [index_alphabet for index_alphabet in enumerate(alphabets, start=1)]
>> print(alphabets)
[(1, 'A'), (2, 'B'), (3, 'C'), (4, 'D')]

words = ['an', 'boy', 'girl', 'an', 'boy', 'dog', 'cat', 'Dog', 'CAT',
 'an','GIRL', 'AN', 'dog', 'cat', 'cat', 'bag', 'BAG', 'BOY', 'boy', 'an']
unique_words = {x.lower() for x in set(words)}
for word in unique_words:
    print(f"* Count of {word}: {words.count(word)}")
# * Count of cat: 3
# * Count of bag: 1
# * Count of boy: 3
# * Count of dog: 2
# * Count of an: 5
# * Count of girl: 1

from collections import Counter

word_counter = Counter(x.lower() for x in words)
print("Word Counts:", word_counter)
# Word Counts: Counter({'an': 5, 'boy': 4, 'cat': 4, 'dog': 3, 'girl': 2, 'bag': 2})
print("Most Frequent:", word_counter.most_common(1))
# Most Frequent: [('an', 5)]
print("Most Frequent:", word_counter.most_common(2))
# Most Frequent: [('an', 5), ('boy', 4)]

import sys
sys.path.append("..") # 상위 디렉토리 접근
from B import bb # 이동된 디렉토리에서는 B가 하위디렉토리 이기 때문에 접근 가능하다.

A = ["a", "b", "c", "d"]
A_dict = {A[i] : i for i in range(len(A))}
# {'a': 0, 'b': 1, 'c': 2, 'd': 3}

A = ["a", "b", "c", "d"]
B = [1,2,3,4]
AB_dict = dict(zip(A, B))
# {'a': 1, 'b': 2, 'c': 3, 'd': 4}

list_of_tuple = [("A", 1), ("B", 2), ("C", 3), ("D", 4)]
list_of_list = [["A", 1], ["B", 2], ["C", 3], ["D", 4]]
dict_tuple = dict(list_of_tuple)
# {'A': 1, 'B': 2, 'C': 3, 'D': 4}
dict_list = dict(list_of_list)
# {'A': 1, 'B': 2, 'C': 3, 'D': 4}

a = [1,1,2,2,3,3,4,4,5,5]
a_unique = list(set(a))
# a = [1,2,3,4,5]

import sys
path = "path/to/the/file"
sys.path.append(path)

import importlib
np = importlib.import_module('numpy')

import json
Person = {
    'Name' : "Jinsol",
    'Man': True,
    "age" : 30,
    'friend': ["jisu", "suji"],
    "Pet" : None
}

print(Person)
# {'Name': 'Jinsol', 'Man': True, 'age': 30, 'friend': ['jisu', 'suji'], 'Pet': None}

print(type(Person))
# dict

json_string = json.dumps(Person)
print(json_string)
# {"Name": "Jinsol", "Man": true, "age": 30, "friend": ["jisu", "suji"], "Pet": null}
print(type(json_string))
# str

json_string = json.dumps(Person, indent=4, sort_keys=True)
print(json_string)

# {
#     "Man": true,
#     "Name": "Jinsol",
#     "Pet": null,
#     "age": 30,
#     "friend": [
#         "jisu",
#         "suji"
#     ]
# }

import json
Person = {
    'Name' : "Jinsol",
    'Man': True,
    "age" : 30,
    'friend': ["jisu", "suji"],
    "Pet" : None
}

with open("file.json", "w", encoding='utf-8') as fp:
    json.dump(Person, fp, indent=4, ensure_ascii=False)

# json.load를 이용하여 json 파일을 읽는 예시
with open("file.json","r", encoding='utf-8') as fp:
    data = json.load(fp)

# json.loads를 이용하여 json 문자열을 읽는 예시
print(json_string)
# {
#     "Man": true,
#     "Name": "Jinsol",
#     "Pet": null,
#     "age": 30,
#     "friend": [
#         "jisu",
#         "suji"
#     ]
# }

json_dict = json.loads(json_string)
print(type(json_dict))
# dict

a = {"a" : 1, "b" : 2, "c" : 3, "d":4}
print(max(a, key=lambda k : a[k]))
# d
print(min(a, key=lambda k : a[k]))
# a

people = [
    { 'name': 'John', "age": 64 },
    { 'name': 'Janet', "age": 34 },
    { 'name': 'Ed', "age": 24 },
    { 'name': 'Sara', "age": 64 },
    { 'name': 'John', "age": 32 },
    { 'name': 'Jane', "age": 34 },
    { 'name': 'John', "age": 99 },
]

import operator

people.sort(key=operator.itemgetter('age'))
people.sort(key=operator.itemgetter('name'))

# [{'name': 'Ed', 'age': 24},
#  {'name': 'Jane', 'age': 34},
#  {'name': 'Janet', 'age': 34},
#  {'name': 'John', 'age': 32},
#  {'name': 'John', 'age': 64},
#  {'name': 'John', 'age': 99},
#  {'name': 'Sara', 'age': 64}]

dict1 = { 'a': 1, 'b': 2 }
dict2 = { 'b': 3, 'c': 4 }
merged = { **dict1, **dict2 }

print (merged)
# {'a': 1, 'b': 3, 'c': 4}

# Python >= 3.9 only
merged = dict1 | dict2

print (merged)
# {'a': 1, 'b': 3, 'c': 4}

from copy import deepcopy
object2 = deepcopy(object1)

# 지정된 디렉토리의 전체 파일 목록을 얻을 수 있다. 
os.listdir(path)

import zipfile
import os

def extract_zipfile(src_file_path, dest_path):
    with zipfile.ZipFile(src_file_path,"r") as zip_ref:
        zip_ref.extractall(dest_path)
    os.remove(src_file_path)

src_file_path = "src_path/.../.../file.zip"
dest_path = "dest_path/../../"
extract_zipfile(src_file_path, dest_path)

from random import shuffle

A = [1,2,3,4,5]
shuffle(A)
print(A)
# [3, 2, 1, 5, 4]

from random import shuffle

A = [1,2,3,4,5]
B = ["1", "2", "3", "4", "5"]

C = list(zip(A, B)
shuffle(C)
A, B = zip(*C)
print(A)
# (1, 5, 4, 2, 3)   
print(B)
# ('1', '5', '4', '2', '3')

# 읽을 파일의 경로와 파일 이름을 입력합니다.
filepath = "C://"
filename = "test.txt"

# 텍스트 파일을 입력 받기 위한 stream을 open 합니다.
with open(filepath + '/' + filename, 'r') as file_read:
    while (1):
        # 텍스트에서 1줄을 읽습니다.
        line = file_read.readline()
        # 개행 문자를 찾고 그 인덱스를 저장합니다.
        # 개행 문자가 가장 처음에 있으면 0이 저장됩니다.
        try:
            valid = line.index('\n')
        # 개행 문자가 없으면 입력받은 텍스트의 길이를 저장합니다.
        except:
            valid = len(line)
        # 만약 line이 없으면 valid == 0 또는 line은 있으나 개행문자만 있으면 valid == 0
        # 만약 line은 있으나 개행문자가 없으면 valid > 0
        # 만약 line이 있고 개행문자도 있으면 valid > 0
        # 따라서 valid > 0 경우만 parsing 실행
        if valid:
            # parsing 구분자로 parsing 처리
            line_to_list = line.split(' ')       

            # 아래 parsing 처리한 리스트를 처리하는 코드 필요
            ############## 코드 ##############
            ############## 코드 ##############
        else:
            break

def FileToList(filepath, filename, sep=','):
    # 텍스트 파일을 입력 받기 위한 stream을 open 합니다.
    with open(filepath + '/' + filename, 'r') as file_read:
        file_to_list = []
        while (1):
            # 텍스트에서 1줄을 읽습니다.
            line = file_read.readline()
            # 개행 문자를 찾고 그 인덱스를 저장합니다.
            # 개행 문자가 가장 처음에 있으면 0이 저장됩니다.
            try:
                valid = line.index('\n')
            # 개행 문자가 없으면 입력받은 텍스트의 길이를 저장합니다.
            except:
                valid = len(line)
            # 만약 line이 없으면 valid == 0 또는 line은 있으나 개행문자만 있으면 valid == 0
            # 만약 line은 있으나 개행문자가 없으면 valid > 0
            # 만약 line이 있고 개행문자도 있으면 valid > 0
            # 따라서 valid > 0 경우만 parsing 실행
            if valid:
                # parsing 구분자로 parsing 처리
                line_to_list = line.split(sep)                
                # 아래 parsing 처리한 리스트를 처리하는 코드 필요
                ############## 코드 ##############
                ############## 코드 ##############
                file_to_list.append(line_to_list)
            else:
                break
    return file_to_list

# 텍스트 파일을 출력 하기 위한 stream을 with를 통하여 open 합니다.
with open(filepath + '/' + filename, 'r') as file_write:
    s = 'contents...'
    file_write.write(s)

# 텍스트 파일을 출력 하기 위한 stream을 open 합니다.
file_write = open(filepath + '/' + filename, 'w')
s = 'contents...'
file_write.write(s)
file_write.close()

text_to_list = open(file_path).read().split("\n")
# ["aaa", "bbb", "ccc"]

file_name = "sample.txt"
with open(file_name, "r") as file:
    first_line = file.readline()
    for last_line in file:
        pass
print(first_line)
print(last_line)

 import os
 file_name = "sample.txt"
 first_line = os.popen("head -1" + file_name).read()
 last_line = os.popen("tail -1" + file_name).read()

import time

def GetCurrentTime():
    now = time.localtime()
    now_str = "%02d_%02d_%02d_%02d_%02d_%02d" % (now.tm_year - 2000, now.tm_mon, now.tm_mday, now.tm_hour, now.tm_min, now.tm_sec)
    return now

from datetime import datetime
now = datetime.now()
print( now )
print( now.year )
print( now.month )
print( now.day )
print( now.hour )
print( now.minute )
print( now.second )
print ( '%s-%s-%s' % ( now.year, now.month, now.day ) )

def GetPresentTime():
    now = datetime.now()
    ret = "%s_%s_%s_%s_%s_%s" % ( now.year, now.month, now.day, now.hour, now.minute, now.second)
    return ret

import os

folder_name = "test"

if os.path.isdir(folder_name) == False:
    os.mkdir(folder_name)

if os.path.exists(folder_name) == False:
    os.makedirs(folder_name)

import os

file_name = "test.txt"

if os.path.isfile(file_name) == False:
    f = open("file_name", "w")
    ...

from itertools import product

items = [['a', 'b', 'c,'], ['1', '2', '3', '4'], ['!', '@', '#']]
list(product(*items))
# [('a', '1', '!'), ('a', '1', '@'), ('a', '1', '#'), ('a', '2', '!'), ('a', '2', '@'), ('a', '2', '#'), ('a', '3', '!'), ('a', '3', '@'), ('a', '3', '#'), ('a', '4', '!'), ('a', '4', '@'), ('a', '4', '#'), ('b', '1', '!'), ('b', '1', '@'), ('b', '1', '#'), ('b', '2', '!'), ('b', '2', '@'), ('b', '2', '#'), ('b', '3', '!'), ('b', '3', '@'), ('b', '3', '#'), ('b', '4', '!'), ('b', '4', '@'), ('b', '4', '#'), ('c,', '1', '!'), ('c,', '1', '@'), ('c,', '1', '#'), ('c,', '2', '!'), ('c,', '2', '@'), ('c,', '2', '#'), ('c,', '3', '!'), ('c,', '3', '@'), ('c,', '3', '#'), ('c,', '4', '!'), ('c,', '4', '@'), ('c,', '4', '#')]

# Calculate all profucs of an input
list(itertools.product('abc', repeat=2))
# [('a', 'a'), ('a', 'b'), ('a', 'c'), 
#  ('b', 'a'), ('b', 'b'), ('b', 'c'), 
#  ('c', 'a'), ('c', 'b'), ('c', 'c')]
 
# Calculate all permutations
list(itertools.permutations('abc'))
# [('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), 
#  ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]

>>> # Take elements for iterator as long as predicate is True
>>> list(itertools.takewhile(lambda x: x<5, [1,4,6,4,1]))
[1, 4]

import sys
'numpy' in sys.modules
>> True

import sys
import subprocess

# pip가 없으면 pip를 설치한다.
try:
    import pip
except ImportError:
    print("Install pip for python3")
    subprocess.call(['sudo', 'apt-get', 'install', 'python3-pip'])

import sys
import subprocess

# pandas가 없으면 pandas를 설치한다.
try:
    import pandas as pd
except ModuleNotFoundError:
    print("Install pandas in python3")
    subprocess.call([sys.executable, "-m", "pip", "install", 'pandas'])
finally:
    import pandas as pd

import os
os.path.abspath(os.path.join(input_path, os.pardir))

import os
import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--path', required = True)
parser.add_argument('--ext', required = True)
parser.add_argument('--prefix', required= True)
args = parser.parse_args()

temp_filenames = os.listdir(args.path)
filenames = []

for filename in temp_filenames:
    extension = filename.split('.')[-1]
    if extension == args.ext:
        filenames.append(filename)

for filename in filenames:
    os.rename(args.path + '/' + filename, args.path + '/' + args.prefix + filename)

import os
import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--path', required = True)
parser.add_argument('--ext', required = True)
parser.add_argument('--suffix', required= True)
args = parser.parse_args()

temp_filenames = os.listdir(args.path)
filenames = []

for filename in temp_filenames:
    extension = filename.split('.')[-1]
    if extension == args.ext:
        filenames.append(filename)

for filename in filenames:
    os.rename(args.path + '/' + filename, args.path + '/' + filename.split('.')[-2] + args.suffix + '.' + filename.split('.')[-1])

def GlobalImport(modulename, shortname = None, asfunction = False):
    if shortname is None: 
        shortname = modulename
    if asfunction is False:
        globals()[shortname] = __import__(modulename)
    else:        
        globals()[shortname] = eval(modulename + "." + shortname)

def func():
    # import numpy as np 를 global에서 선언한 것과 같은 효과
    GlobalImport('numpy', 'np)

A = [9, 4, 5, 8, 10, 14]
index_list = [1, 3, 4]

result_list = [ A[i] for i in index_list ] 

A = [1,2,3,4]

# 1. 먼저 숫자를 문자로 변환한 형태의 list를 만들어야 합니다. 이는 `map`을 이용하여 쉽게 구현할 수 있습니다.
list(map(str, A)

# 2. 그 다음 특정 문자 (seperator)를 기준으로 list의 문자열 원소를 연결하여 하나의 문자열로 만들 수 있습니다.
seperator = ','
seperator.join(list(map(str, A))

a = [1, 2, 3, 4, 5, 6]  
group_adjacent = lambda a, k: zip(*([iter(a)] * k)) 
group_a = [e for e in group_adjacent(a, 3)]
print(group_a)
# [(1, 2, 3), (4, 5, 6)]

import os
current_file_path = os.path.abspath(__file__)

import os
current_file_path = os.path.abspath(__file__)
current_dir = os.path.dirname(current_file_path)

import os
import shutil

src = "path/to/the/src"
dst = "path/to/the/dst"

if os.path.isdir(dst):
    shutil.rmtree(dst)

shutil.copytree(src, dst)

import os
file_path = "path/to/the/file.txt"
os.path.dirname(file_path)
# path/to/the
os.path.basename(file_path)
# file.txt