list

 

특성
1. 컨테이너이다 = 무언가를 그 안에 담을 수 있는 틀을 제공한다.
2. 안에 담는 내용물은 순서를 가진다. = 정수를 증가시켜 순서대로 접근할 수 있다. = 인덱스로 접근 가능하다.
3. 변경 가능하다. = 내용물을 삭제하거나 단순 추가하거나, 삭제 후 그 자리에 바로 추가(변경) 가능하다.

 

empty_list = [] # 빈 리스트를 만든다.
print(type(empty_list)) # 리스트인가?
# 결과
<class 'list'>

print(len(empty_list)) # 방금 생성한 리스트에는 아무것도 들어있지 않다.
# 결과
0

list_is_Container = []
list_is_Container[0:1] = '1' # 리스트의 첫째 자리에 1이라는 스트링을 넣는다.
print(list_is_Container)
# 결과
['1']

one_list = []
another_list = [2]
one_list.append(another_list) # 리스트 안에 또 다른 리스트를 넣는다.
print(one_list)
# 결과
[[2]]

 

# 리스트 요소의 삭제

planets = ['pluto', 'mars', 'earth', 'venus']
del planets[0] # 원본 리스트에서 삭제하는 방법 #1
print(planets)

print('')

planets = ['pluto', 'mars', 'earth', 'venus']
planets.remove('pluto') # 원본 리스트에서 삭제하는 방법 #2
print(planets)

# ==> del은 index 요소로 삭제 / remove 메서드는 요소 이름으로 삭제

# 결과
['mars', 'earth', 'venus']

['mars', 'earth', 'venus']

 

• 순서가 있음

listIsContainer[:] = '1'# 아직까지는 [:] 의미를 알 수 없어도 'e1'이 리스트에 들어갔음을 알 수 있다.print(listIsContainer)
결과)['1']
listIsContainer[:] = '2'# '1'이 들어 있었는데 그것이 삭제되고 '2'가 들어갔음을 알 수 있다.print(listIsContainer)
결과)['2']
# 리스트의 가장 첫번째 요소는 정수 0으로 접근 가능하다.print(listIsContainer[0:1])
결과)['2']
# 두번째 요소는 정수 1로 접근 가능하다.listIsContainer[1:2] = '3'

print(listIsContainer)

결과)['2', '3']

• 변경 가능함

listIsContainer = []# 리스트에 '1'을 추가listIsContainer[:] = '1'# 리스트에 있는 '1' 자리에 '2'를 넣어서 '1'은 삭제되고 '2'로 바뀜listIsContainer[0:1] = '2'

print(listIsContainer)

(결과)['2']

• 리스트 요소의 빠른 생성

# 리스트는 객체이므로 변수에 할당할 수 있고 그 변수를 통해 객체에도 접근할 수 있다.ln = list('0123456789')

print(ln)

결과)['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
# range() 함수를 쓰면 리스트에 숫자를 담을 수 있다.ln = list(range(0, 10))

print(ln)

결과)[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• 알파벳 a ~ z 문자열을 가진 리스트를 빠르게 생성하려면?

# 알파벳 문자 출력

print('a')

 

결과)a
# 이런 식으로 리스트의 요소를 모두 적는 것도 가능하다.alphaList = list('abcdefghijklmnopqrstuvwxyz')

print(alphaList)

결과)['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
# ranger() 함수에 알파벳 문자를 써서 쉽게 리스트를 만들 수는 없을까?print(list(range('a', 'z')))
결과)TypeError: 'str' object cannot be interpreted as an integer
# 이렇게 하면 정수를 조작해서 알파벳 소문자를 만들 수 있다.print(chr(97))
결과)a
# 이제 range() 함수를 사용해서 알파벳 요소를 가진 리스트를 생성할 수 있다.

결과)

['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

 

다시 

 

코드 실행 과정을 시각적으로 표현해 주는 웹 서비스로 동작 과정을 살펴보자.

 

• 리스트 객체가 가진 메쏘드를 이용해서 요소를 조작하기

# 객체가 무엇인지는 모르지만 list라는 것이 추가로 무엇을 더 가지고 있는지 확인해 보자.help(list)

 

# 리스트 라는 객체 내부에 많은 수의 함수들이 준비되어 있음을 알 수 있다. 이 함수를 불러보자.

# Line 1 에서 리스트를 생성했고 변수 l 에 객체의 주소를 할당했다. 이제 변수 l 을 통해서 우리가 생성한 리스트에 접근할 수 있다.# Line 3의 . (period)는 무엇인가? 이것은 객체에 접근하는 . 연산자 (dor operator)로 리스트의 경우 리스트 내부에 미리 준비된 메쏘드에 접근할 수 있게 해준다. 친절한 편집기가 어떤 메쏘드를 사용할 수 있는지 보여주고 있다.
# 리스트에 요소 추가하기# 리스트 슬라이스 표기법에 의한 요소 추가

l = ['a']

l[1:2] = 'b'

print(l)

 

결과)

['a', 'b']
# 증감 할당 연산자에 의한 요소 추가t = ['hello']t += ['world']

 

print(t)
결과)['hello', 'world']
# 리스트 메쏘드에 의한 요소 추가l = ['a']l.append('b')print(l)
결과)['a', 'b']
# 리스트 인덱스 번호에 의한 요소 추가?l = ['a']l[1] = 'b'print(l)
결과)IndexError: list assignment index out of range
# 존재하지 않는 인덱스 번호로는 요소 추가를 할 수 없다. 존재하지 않는 공간의 인덱스 번호를 사용하여서 '인덱스 범위 벗어남'의 에러가 발생한다.
# 리스트 메쏘드에 의한 요소 제거l = ['a']l.append('b')l.remove('b')print(l)
결과)['a']
# del 키워드에 의한 리스트 요소 제거 (슬라이스 범위 제거)l = [1, 2, 3, 4, 5]
del l[1:4]
결과)[1, 5]
# del 키워드에 의한 리스트 요소 제거 (홀수 개의 정중앙 요소 제거)l = [1, 2, 3, 4, 5]
del l[int(len(l)/2)]
결과)[1, 2, 4, 5]

• 리스트에 원하는 요소가 있는지 판단하기

# in 키워드를 이용하는 방법l = ['a']if 'a' in l:print('a is exist.')else:print('a is not exit.')
결과)a is exist.
# 리스트의 count 메쏘드l = ['a', 'b']pos = l.count('a')print(pos)
결과)1
# 리스트 l 에 a가 첫번째 = 1 에 있는건가?l = ['a', 'b']pos = l.count('b')print(pos)
결과)1
# 리스트는 중복 요소도 허용하며 count() 메쏘드는 요소가 몇 개 있는지 알려준다.l = ['a', 'b', 'a']pos = l.count('a')print(pos)
결과)2
# 리스트의 index 메쏘드l = ['a', 'b', 'a']pos = l.index('a')print(pos)
결과)0
# 리스트의 0 번째 요소가 정말 'a' 인가?l = ['a', 'b', 'a']pos = l.index('a')print(l[0])
결과)a

# 그럼 리스트에 원하는 요소가 있는지는 어떻게 알 수 있는가?

l = ['a', 'b', 'a']if l.count('a'): print('a Index: ' + str(l.index('a')))
결과)a Index: 0

• 복잡한 리스트 슬라이싱

# 명시적인 요소의 시작

l = ['1', '2', '3']print(l[:2])
결과)['1', '2']
# 명시적인 요소의 끝l = ['1', '2', '3']print(l[2:])
결과)['3']
# 시작 요소 하나만l = ['1', '2', '3']print(l[:1])
결과)['1']
l = ['1', '2', '3']print(l[0:1])
결과)['1']
# 마지막 요소 하나만l = ['1', '2', '3']print(l[-1:])
결과)['3']
# 건너뛰면서 요소 선택하기l = ['1', '2', '3', '4', '5']print(l[::2])
결과)['1', '3', '5']
l = ['1', '2', '3', '4', '5']print(l[1::2])
결과)['2', '4']
# 리스트 뒤집기l = ['1', '2', '3', '4', '5']print(l[::-1])
결과)['5', '4', '3', '2', '1']
# 리스트 슬라이싱으로 요소 개수 원하는 만큼 잘라내기colors = ['red', 'yellow', 'black', 'brown', 'white', 'purple']
divider = 5startPos = 0endPos = len(colors)
for i in range(startPos, endPos+divider, divider): printOut = colors[startPos : i] startPos = i

 

if printOut != []: print(printOut)
결과)['red', 'yellow', 'black', 'brown', 'white']

 

['purple']

 

• Pythnic 리스트 사용

# 일반적인 언어에서의 리스트 카운트

l = range(1, 11)
total = []count = 0for n in l:    total.append(n)    count += 1
print('total: ', total)print('count: ', count)
결과)total:  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]count:  10
# 

enumerate 내장함수를 사용한 리스트 카운트

l = range(1, 11)
total = []for c, n in enumerate(l):    total.append(n)
print('total: ', total)print('count: ', c + 1)
결과)total:  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]count:  10
# len() 내장 함수를 이용한 리스트 카운트l = range(1, 11)
total = []for n in l:    total.append(n)
print('total: ', total)print('count: ', len(total))
결과)total:  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 

count:  10
# zip() 함수를 이용한 index 값 얻기l = ['apple', 'lemon', 'grape']

 

print(list(zip(l, range(1, 100))))
결과)[('apple', 1), ('lemon', 2), ('grape', 3)]
# zip() 함수로 생성한 데이터 unzip 하기l = ['apple', 'lemon', 'grape']u = {f: num for f, num in zip(l, range(1, 100))}

 

print(u)
결과){'grape': 3, 'lemon': 2, 'apple': 1}

• 특수기호 모두 제거하기

# 스트링을 가지고 리스트를 만들면 개별 글자를 요소로하는 리스트 전체가 생성되고 요소비교가 가능해진다.fruits = ['banana!', '$apple', 'peach#']
rmTarget = list('!$#')result = []
for f in fruits:    fList = list(f)    for r in rmTarget:        while True:            try:                fList.remove(r)            except:                break    result.append(''.join(fList))
결과)['banana', 'apple', 'peach']

 

# 동일한 로직을 스트링 조작을 이용하도록 바꿀 수 있다.ls = ['##apple!', '!banana$', '!le$$mon#', 'peach']
filter = '!$#'result = []

 

for l in ls:for f in filter:if f in l:
l = l.replace(f, '')result.append(l)print(result)

 

결과)['apple', 'banana', 'lemon', 'peach']

 

# 동일한 로직을 재귀함수를 이용하도록 바꿀 수 있다.ls = ['##apple!', '!banana$', '!le$$mon#', 'peach']
filter = '!$#'
result = []

def removeFilter(word):
    if len(word) < 1:
        return word

    if word[0] in filter:
        return removeFilter(word[1:])
    else:
        return word[0] + removeFilter(word[1:])

for l in ls:
    result.append(''.join(removeFilter(l)))

print(result)

 

결과)

['apple', 'banana', 'lemon', 'peach']

 

• 리스트의 할당과 복사

def main():

    l1 = [1, 2, 3]
    l2 = l1

    # 두 객체는 같은 객체이다.
    print('addr of id1: ', id(l1))
    print('addr of id2: ', id(l2))
    if id(l1) == id(l2):
        print('[l1 is l2] - same object')
    else:
        print('[l1 is not l2]')

    print('\t')

    one = list(range(1, 4))
    another = one.copy()

    # 두 객체는 다른 객체이다.
    print('addr of one: ', id(one))
    print('addr of another: ', id(another))
    if id(one) == id(another):
        print('[one is another]')
    else:
        print('[one is not another] - diff. object')

    pass

if __name__ == '__main__':
    main()

# 결과

addr of id1:  2531229270592
addr of id2:  2531229270592
[l1 is l2] - same object
	
addr of one:  2531230033536
addr of another:  2531229270208
[one is not another] - diff. object

 

# deep copy (cf. shallow copy)
# mutable 객체는 복사에 레퍼런스 참조 사용
# 객체를 직접 복사하려면 copy 모듈 사용
import copy

org_list = [1, 1, 1]
cpy_list = copy.deepcopy(org_list)

print(f'original list: {org_list}')
print(f'copied list: {cpy_list}')

cpy_list[0] = 0
print(f'still original list: {org_list}')
print(f'modify copied list: {cpy_list}')

# 결과
original list: [1, 1, 1]
copied list: [1, 1, 1]
still original list: [1, 1, 1]
modify copied list: [0, 1, 1]

 

# 중첩 리스트의 인덱싱
nested_list = [[1, 2, 3], ['x', 'y'], ['apple', 'banana']]

print("before: ", end='')
print(f'{nested_list}, length: {len(nested_list)}')

nested_list[0].append(4)
nested_list[1].append('z')
nested_list[2].append('cherry')

print("after: ", end='')
print(f'{nested_list}, length: {len(nested_list)}')

# 각 내부 리스트에 요소를 추가했지만 내부 리스트 전체 개수의 변화는 없다.
before: [[1, 2, 3], ['x', 'y'], ['apple', 'banana']], length: 3
after: [[1, 2, 3, 4], ['x', 'y', 'z'], ['apple', 'banana', 'cherry']], length: 3

 

# 리스트의 더블 인덱싱
in_list = [1, 2, 3]
l = []

for i in range(len(in_list)):
    l.append(in_list[i])

print(l)

print([1, 2, 3][0], end=' ')
print([1, 2, 3][1], end=' ')
print([1, 2, 3][2])

# 결과
[1, 2, 3]
1 2 3

 

# 중첩 리스트의 변경
nested_list = [[1, 2, 3], ['x', 'y'], ['apple', 'banana']]

nested_list[1] = ['x', 'y', 'z']
nested_list[2][1] = 'cherry'

print(nested_list)

# 결과
[[1, 2, 3], ['x', 'y', 'z'], ['apple', 'cherry']]

 

# 연속 중첩 리스트의 인덱싱
data_list = ['a', [1, 2, []], [['apple', 'banana'], 'cherry']]

fruits = data_list[2][0][0]

print(fruits)

# 결과
apple

 

# 중첩 리스트를 가지고 kv dict를 생성해 데이터 정리
# isinstance(x, (int, float, complex)) and not isinstance(x, bool)

key_data = ['nums', 'alphas', 'fruits']
nl_dict = { k : [] for k in key_data} # {'nums': [], 'alphas': [], 'fruits': []}

nested_list = [[1, 2, 3], ['x', 'y', 'z'], ['apple', 'cherry']]

for nl in nested_list:
    if isinstance(nl[0], int):
        nl_dict['nums'] = nl
    elif isinstance(nl[0], str) and len(nl[0]) == 1:
        nl_dict['alphas'] = nl
    else:
        nl_dict['fruits'] = nl

print(nl_dict)

# 결과
{'nums': [1, 2, 3], 'alphas': ['x', 'y', 'z'], 'fruits': ['apple', 'cherry']}

 

# Nested Iteration
info = [['1', 10], ['2', 20], ['3', 30]]

values = []

for vl in info:
    values.append(vl[1])

print(values)

# 결과
[10, 20, 30]

 

# Having this mixture is going to make it hard to traverse
# the Nested Data structure.
# (TypeError: 'int' object is not itrerable.)
#
# The solution when we are in control of the data structure
# is to make it very regular with always the same kinds of items
# in the same level of nesting.
# In other words, dont mix integers, lists and dictionaries as items
# in a single list.
#
# Sometimes however, we arent in control of the data structure.

mixture_of_nested_list = [1, 2, ['a', 'b'], ['c'], ['d', 'e', 'f']]

for e in mixture_of_nested_list:
    print("level1: ")
    if type(e) is list:
        print(f"\tlevel2: {e}")
    else:
        print(e)

# 결과
level1: 
1
level1: 
2
level1: 
	level2: ['a', 'b']
level1: 
	level2: ['c']
level1: 
	level2: ['d', 'e', 'f']

 

# shallow copy
original = [[1, 2], ['1', '2']]
copied1 = original
copied2 = original[:]

print(f"Is copied1 equals original? {copied1 is original}")
print(f"Is copied2 equals original? {copied2 is original}")
print("")

original.append([3])

print(f"Now original is {original}")
print(f"Now copied1 is {copied1}")
print(f"Now copied2 is {copied2}")
print("")
# shallow copy (= copied2)는 추가 요소에 대해서는 구별되나
# 기존 요소는 copied1 = copied2 이다.

# 그러면 기존 요소를 바꾸는 경우 두 개가 달라질까?
# 먼저 리스트 요소 자체를 바꾸는 경우
del original[-1]
copied1[0] = ['x']

print(copied1)
print(copied2)
print("")
# ==> 정상이다.

# 그러면 리스트 내의 요소를 바꾸는 경우
copied1 = original
copied2 = original[:]

copied1[0][0] = 'x'
print(copied1)
print(copied2)
# => 안된다. 리스트 요소를 바꾸는 경우 두 객체가 같아지는 문제가 있고, 이것이 shallow copy의 문제이다.

# 결과
Is copied1 equals original? True
Is copied2 equals original? False

Now original is [[1, 2], ['1', '2'], [3]]
Now copied1 is [[1, 2], ['1', '2'], [3]]
Now copied2 is [[1, 2], ['1', '2']]

[['x'], ['1', '2']]
[[1, 2], ['1', '2']]

[['x'], ['1', '2']]
[['x'], ['1', '2']]

 

# list null check

empty_list = []

if not empty_list: # The pretty simple pythonic way.
    print("[1] null list")

if len(empty_list) == 0: # A much explicit way.
    print("[2] null list")

if empty_list == []: # Comparing it to an anonymous empty list.
    print("[3] null list")

if not bool(empty_list): # less readable surely
    print("[4] null list")

# 결과
[1] null list
[2] null list
[3] null list
[4] null list

 

# Reverse the list

ll = [list(), [1], 100]
print(f"original list: {ll}")

reversed_list_by_slice = ll[::-1]
print(f"reversed_list_by_slice: {reversed_list_by_slice}")

ll.reverse()
print(f"reversed_list_by_fx: {ll}")
# sort, sorted의 예를 보듯이
# 함수는 리턴을 하고, 메서드는 리턴을 하지 않고 해당 인스턴스를 변경한다.

# 결과
original list: [[], [1], 100]
reversed_list_by_slice: [100, [1], []]
reversed_list_by_fx: [100, [1], []]

 

# Confirm that the ojects are the same with the id function

list1 = [1, 2, 3]
list2 = list1

list3 = [1, 2, 3]

print(f"id(list1) == id(list2): {id(list1) == id(list2)}")
print(f"list1 is list2: {list1 is list2}")
print(f"list1 == list3: {list1 == list3}", end=' ')
print("* list1 and list3 are different object, but have same values.")

# 결과
id(list1) == id(list2): True
list1 is list2: True
list1 == list3: True * list1 and list3 are different object, but have same values.

 

lst_idx = [1, 2, 3]
lst_idx_len = len(lst_idx)

idx = 0
for idx in range(len(lst_idx)):
    out = lst_idx.pop(0)
    print(f"{out} is popped.")
    idx += 1
    # index로 돌며 무조건 1st를 pop하는 경우는 원하는대로 된다.

print("")

lst_in = [1, 2, 3]

for e in lst_in:
    out = lst_in.pop(0)
    print(f"{out} is popped.")
    # 이건 stop이 변하기 때문에 원하는 결과가 나오지 않는다.

# 결과
1 is popped.
2 is popped.
3 is popped.

1 is popped.
2 is popped.

 

# 리스트 안의 int를 int형으로 변환하기

number: list[int] = [1]

# 리스트 내 int를 int형으로 변환 방법 1
for num in number:
    print(type(num), num)

# 리스트 내 int를 int형으로 변환 방법 2
int_result = int(''.join(map(str, number)))
print(type(int_result), int_result)

# 리스트 내 int를 int형으로 변환 방법 3
ints = int(''.join(str(n) for n in number))
print(type(ints), ints)

# 결과
<class 'int'> 1
<class 'int'> 1
<class 'int'> 1

 

# If you're looping through a list, a good rule of thumb is to
# never modify that list while you're looping through it,
# because it will often lead to unwanted or unexpected behavior
# in your program.
# And in general, you will always want to use a temporary list
# if you decide to make any changes while you're looping through
# the original list, and then transfer the changes from that
# temporary list to the original.

# 간략히 말하면 list 중 요소를 제거하고 싶으면
# looping 중인 list를 변경(제거)하지 말고, 그것을 제외한 나머지를 새로운 list에
# 담는 방식으로 구현하자.

 

# string 처리가 복잡할 때는 list로 변환해서
# 가공 후에 다시 텍스트로 바꾸는 방법도 쉽다.
from string import whitespace, punctuation

title: str = "Section 5: Rewriting an Immutable String"
title_list: list[str] = list(title)
colon_position: int = title_list.index(':')
del title_list[:colon_position+1]

for i in range(len(title_list)):
    if title_list[i] in whitespace+punctuation:
        title_list[i] = '_'

title: str = ''.join(title_list)
print(title)
title = 'prefix' + title
print(title)

# 결과
_Rewriting_an_Immutable_String
prefix_Rewriting_an_Immutable_String

 

# 임의로 리스트 데이터를 가공하는 구현
person_marks: list[str, int] = \
[
    ['Bob', 75],
    ['Sally', 83],
    ['John', 91],
    ['Dave', 77]
]

marks_avg: int = sum([mark for (person, mark) in person_marks]) / len(person_marks)
print("=====" * 5)
print(f"marks avg: {marks_avg}")
print("=====" * 5)
person_marks_evaluation: dict[str, list[int, float]] = \
{person: [mark, "above avg or equal" if mark >= marks_avg else "below avg"] for (person, mark) in person_marks}
for (person, markeval) in person_marks_evaluation.items():
    print(f"{person:<5}, mark:{markeval[0]}, eval:{markeval[1]}")

# 결과
=========================
marks avg: 81.5
=========================
Bob  , mark:75, eval:below avg
Sally, mark:83, eval:above avg or equal
John , mark:91, eval:above avg or equal
Dave , mark:77, eval:below avg

 

# The valueof None is equivalent to "null" in other languages.
# The following values are falsy:
#   - None, 0, False, Empty sequence or mapping, Zero-length String

nums: list[int] = [1, 2, 3, 4, 5]
nums_stats: dict[str, int|float] = {'sum': 0, 'min': 0, 'max': 0, 'avg': 0, 'len': 0}

nums_sum: int = sum(nums)
nums_max: int = max(nums)
nums_min: int = min(nums)
nums_len: int = len(nums)
nums_avg: float = round(nums_sum/nums_len, 2)

nums_stats['avg'] = nums_avg
nums_stats['len'] = nums_len
nums_stats['max'] = nums_max
nums_stats['min'] = nums_min
nums_stats['sum'] = nums_sum

print(f"{nums_stats=}")

# 결과
nums_stats={'sum': 15, 'min': 1, 'max': 5, 'avg': 3.0, 'len': 5}

 

# find longest name (색다르게 구현한 버전)
names: list[str] = ['Cecilia', 'Lise', 'Marie']
names_sorted: list[str] = sorted(names, key=lambda name: len(name), reverse=True)
print(f"longest name: {names_sorted[0]}, len: {len(names_sorted[0])}")

# 결과
longest name: Cecilia, len: 7

 

# 랜덤으로 숫자와 알파벳을 생성해 zip으로 묶고
# dict를 조회하며 min, max, sum, avg 추출

import random
# 97 - 122, min, max, sum, avg

nums: list[int] = random.choices(range(100), k=10)
chrs: list[str] = list(map(chr, random.choices(range(97, 123), k=10)))
num_chr_pairs: dict[str, int] = {chr: num for chr, num in list(zip(chrs, nums))}

def get_avg(d: dict[str, int]) -> float:
    keys: list[str] = list(d.keys())
    total: int = sum([d[k]for k in keys])
    return round(total/len(keys), 2)

# 결과
{'p': 11, 'm': 57, 's': 86, 'u': 21, 'l': 99, 'd': 59}
min key: p, min value: 11
max key: l, max value: 99
sum: 333
avg: 55.5

def get_sum(d: dict[str, int]) -> int:
    keys: list[str] = list(d.keys())
    return sum([d[k]for k in keys])

def get_max(d: dict[str, int]) -> str:
    keys: list[str] = list(d.keys())
    max_key: str = keys[0]

    for k, v in d.items():
        if d[k] >= d[max_key]:
            max_key = k
    return max_key

def get_min(d: dict[str, int]) -> str:
    keys: list[str] = list(d.keys())
    min_key: str = keys[0]

    for k, v in d.items():
        if d[k] <= d[min_key]:
            min_key = k
    return min_key

print(num_chr_pairs)
min_key: str = get_min(num_chr_pairs)
print(f"min key: {min_key}, min value: {num_chr_pairs[min_key]}")

max_key: str = get_max(num_chr_pairs)
print(f"max key: {max_key}, max value: {num_chr_pairs[max_key]}")

sum_keys: str = get_sum(num_chr_pairs)
print(f"sum: {sum_keys}")

avg_keys: str = get_avg(num_chr_pairs)
print(f"avg: {avg_keys}")

 

# To access a member of a sequence type, use []

text: str = "hello"
list_str: list[str] = ['Bob', 'Sally', 'John']

extract_first_two: slice = slice(None, 2)

print(text[extract_first_two])
print(list_str[extract_first_two])

# 결과
he
['Bob', 'Sally']

 

# 조회하는 리스트에서 요소를 제거할 경우
# 조회 대상 자체가 변경되기 때문에 원하는 결과가 나오지 않는다.

# 회피 방법 #1
nums = [1, 2, 3, 4, 5]
pos = 0
result = []

while pos != len(nums):
    n = nums[pos]
    if n % 2 == 0:
        result.append(n)
    nums.remove(nums[0])

print(result)

# 회피 방법 #2 (제거하지 않고 index를 증가한다.)
nums = [1, 2, 3, 4, 5]
pos = 0
result = []

while pos < len(nums):
    if nums[pos] % 2 == 0:
        result.append(nums[pos])
    pos += 1

print(result)

# 결과
[2, 4]
[2, 4]

 

# Count the X's in a matrix

matrix = [["X", "O", "O"], ["O", "X", "O"], ["O", "O", "X"]]
flat = [item for sublist in matrix for item in sublist]
count_of_x = flat.count("X")
print(f"{count_of_x=}")

# 결과
count_of_x=3

 

data = [4, 5, 104, 105, 110, 120, 130, 130, 150,
        160, 170, 183, 185, 187, 188, 191, 350, 360]

min_valid = 100
max_valid = 200
result = [d for d in data if min_valid < d < max_valid]
print(result)

# 또 다른 방법: 인덱스를 얻어 원 데이터에서 삭제하는 방법
# 그러나, 이렇게 하면 안 된다. 의도한 결과가 나오지 않음
# 즉, target 데이터를 조회하며 제거할 때는 원본을 건드리지 말고
# 또 다른 리스트를 생성하는 것이 올바른 방법이다.

for idx, d in enumerate(data):
    if (d < min_valid) or (d > max_valid):
        del data[idx]
print(data)

# Output:
[104, 105, 110, 120, 130, 130, 150, 160, 170, 183, 185, 187, 188, 191]
[5, 104, 105, 110, 120, 130, 130, 150, 160, 170, 183, 185, 187, 188, 191, 360]

 

# Removing Items from a List Backwards (Safety Solution)
data = [104, 101, 4, 105, 308, 103, 5,
        107, 100, 306, 106, 102, 108]

min_valid = 100
max_valid = 200

print("Original:                    ", end='')
print(data)

for idx in range(len(data) - 1, -1, -1):
    if (data[idx] < min_valid) or (data[idx] > max_valid):
        del data[idx]

print("Safety removing of list item:", end='')
print(data)

# Output:
Original:                    [104, 101, 4, 105, 308, 103, 5, 107, 100, 306, 106, 102, 108]
Safety removing of list item:[104, 101, 105, 103, 107, 100, 106, 102, 108]