tuple, list, dict 간단 설명

# random, zip, dict 사용해 숫자가 몇 번 나왔는지 카운트 하기

import random

def main():
    i = random.randint(1, 5)
    keys, values = [], [0] * i

    for key in range(i):
        keys.append(random.randint(1, i))

    ds = dict(zip(keys, values))

    for key in keys:
        ds[key] += 1

    print('key generated:', keys)
    print('key count:', ds)

    pass

if __name__ == '__main__':
    main()

# 결과 1
key generated: [2, 1]
key count: {2: 1, 1: 1}

# 결과 2
key generated: [3, 4, 2, 4]
key count: {3: 1, 4: 2, 2: 1}

# 결과 3
key generated: [2, 3, 2]
key count: {2: 2, 3: 1}

 

# tuple, list, dictionary 간단 설명

 

def main():

tup = tuple(range(3, 7))

print(tup)

 

lst = list(range(3, 7))

print(lst)

lst.append(7)

print(lst)

 

# key:value 형식

dict1 = {"one":1, "two":2, "three":3}

 

for k, v in dict1.items():

print(k, v)

 

# dict 객체 생성자 형식

dict2= dict(four = 4, five = 5, six = 6)

for k, v in dict2.items():

print(k, v)

 

if __name__ == "__main__": main()

 

# 결과

(3, 4, 5, 6)

[3, 4, 5, 6]

[3, 4, 5, 6, 7]

one 1

two 2

three 3

five 5

six 6

four 4

 

# list의 용법

 

def main():
    vals = list(range(1, 5))
    for v in vals:
        print(v, end=' ')

    print("\n")

    strs = "hi! hello"
    for s in strs:
        print(s, end=' ')

    print("\n")

    chars = "abc"
    for i, c in enumerate(chars):
        print(f'[{i}]' + c, end=' ') # python 3.6 이상

    print("\n")

# 결과

1 2 3 4 

h i !   h e l l o 

[0]a [1]b [2]c

 

 

# list flattening

 

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

flat = [x for row in matrix for x in row]

print(flat)

 

# 결과

[1, 2, 3, 4, 5, 6, 7, 8, 9]

 

 

# tuple flattening

 

mtx = ('1'), ('2', '3'), ('4', '5', '6')

flat = tuple(x for row in mtx for x in row)

print(flat)

 

# 결과

('1', '2', '3', '4', '5', '6')

 

 

# remain original grouping

 

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

squared = [[x**2 for x in row] for row in matrix]

print(squared)

 

# 결과

[[1, 4, 9], [16, 25, 36], [49, 64, 81]]

 

 

# list comprehension with if condition

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

filtered = [[x for x in row if x % 3 ==0]

for row in matrix if sum(row) >= 10]

 

print(filtered)

 

# 결과

[[6], [9]]

 

 

# list comprehension with simple loop, two conditions

 

x = list(range(100))

y = [n for n in x if n % 2 ==0 if n % 3 ==0]

 

print(y)

 

# 결과

[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]

 

 

# two levels of looping and expression

 

x = [[1, 2], [3, 4], [5]]

squard_flat = [n ** 2 for row in x for n in row]

 

print(squard_flat)

 

# 결과

[1, 4, 9, 16, 25]

 

 

# unpacking with python3

 

items = ['a', 'b', 'c']

 

first_i, *remaining_items = items

print(first_i)

print(remaining_items)

 

# 결과

a

['b', 'c']

 

 

# 초기값을 가진 리스트 간단 생성 (값은 주소를 가리킴)

 

counters = ['default'] * 3

 

print(counters)

 

print(id(counters[0]))

print(id(counters[1]))

print(id(counters[2]))

 

# 결과

['default', 'default', 'default']

7374176

7374176

7374176

 

# 키에서 dict 생성하기

 

ds = dict.fromkeys(range(1, 11))

 

for key in ds: ds[key] = 0

 

print(ds)

 

# 결과

{1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0}

 

 

# 모듈의 키로 dict 생성, 초기값 지정

from string import ascii_lowercase

 

ds = dict.fromkeys(ascii_lowercase, 0)

 

print(ds)

 

# 결과

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

 

 

# dict 순회에서 삭제하기

 

deleted_keys = set()

 

d = dict(one=1, two=2, three=3, four=4)

 

for key in d:

if key == "four":

deleted_keys.add(key)

 

for key in deleted_keys:

del d[key]

 

print(d)

 

# 결과

{'one': 1, 'two': 2, 'three': 3}

 

# dict subclassing

# __missing__()을 재정의해서 대소문자 구문없이 사전 조회 가능하게

 

class smart_dict(dict):

def __missing__(self, key):

return self[key.lower()]

 

d = smart_dict(dict(one=1, two=2))

 

print(d['ONE'])

 

# 결과

1

 

 

# dict.update

xs = {1:1, 2:4, 3:9}

ys = {1:0}

 

ys.update(xs)

print(ys)

 

# 결과

{1: 1, 2: 4, 3: 9}

 

 

# dict - value adding

ds = {

'a': {1, 2},

'b': {3}

}

 

ds.setdefault('c', 4)

ds['b'].add(5)

print(ds)

 

# 결과

{'a': {1, 2}, 'b': {3, 5}, 'c': 4}

 

 

# dict - __getitem__, __call__

ds = {1: 2, 3: 4}

print(ds.__getitem__(3))

 

class D():

def __getitem__(self, key):

return key**2

 

d = D()

o = d[10]

print(o)

 

class F():

def __call__(self, val):

return val**2

 

f = F()

o = f(10)

print(o)

 

# 결과

4

100

100

 

 

# Tuple의 n번째를 참조해서 소팅하기

 

fruits = ['one', 'two', 'three']

 

indexes = []

for i, f in enumerate(fruits):

# 리스트 내에 튜플로 저장하기

indexes.append(('{} is '.format(f), str(i + 1)))

 

# 튜플의 1번째를 기준으로 정렬하기

indexes.sort(key=lambda item: item[1], reverse = True)

 

for st, nm in indexes:

print('{} {}'.format(st, nm))

 

# 결과

three is  3

two is  2

one is  1

 

# tuple, dict, list 변환하면서 사용하기

 

ls = []

 

ds = dict(three=3, two=2, one=1)

 

for k, v in ds.items():

# dict의 k, v로 tuple 만들기

ls.append((k, v))

 

# tuple의 [1]로 소팅하기

ls.sort(key=lambda i: i[1])

print("sorted tuple: ", ls)

 

# tuple의 요소로 다시 dict 만들기

ds2 = {}

for l in ls:

ds2[l[0]] = l[1]

 

print("dict recreation:", ds2)

 

# 결과

sorted tuple:  [('one', 1), ('two', 2), ('three', 3)]

dict recreation: {'three': 3, 'one': 1, 'two': 2}

 

# tuple comprehension

 

ts = tuple(x ** 2 for x in range(11))

print(ts)

 

# 결과

(0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

 

# list, dict comprehension 으로 다시 작성

 

ds = dict(three=3, two=2, one=1)

 

ls = [(k, v) for k, v in ds.items()]

 

ls.sort(key=lambda i: i[1])

print("sorted tuple: ", ls)

 

ds2 = {l[0]: l[1] for l in ls}

print("dict recreation:", ds2)

 

# 결과

sorted tuple:  [('one', 1), ('two', 2), ('three', 3)]

dict recreation: {'three': 3, 'two': 2, 'one': 1}

 

# anagram solution #1

 

def anagram(s1, s2):

s1 = s1.replace(' ', '').lower()

s2 = s2.replace(' ', '').lower()

 

# Edge case check

if len(s1) != len(s2):

return False

 

count = {}

 

for letter in s1:

if letter in count:

count[letter] += 1

else:

count[letter] = 1

 

for letter in s2:

if letter in count:

count[letter] -= 1

else:

count[letter] = 1

 

for k in count:

if count[k] != 0:

return False

 

return True

 

print(anagram('god', 'dog'))

 

# 결과

True

 

 

# anagram solution #2

 

def anagram(s1, s2):

s1 = s1.replace(' ', '').lower()

s2 = s2.replace(' ', '').lower()

 

return sorted(s1) == sorted(s2)

 

print(anagram('happy', 'yppah'))

 

# 결과

True

 

# Array Pair Sum

 

def pair_sum(arr, n):

if len(arr) < 2:

return

 

seen = set()

output = set()

 

for num in arr:

 

target = n - num

 

if target not in seen:

seen.add(num)

else:

output.add( (min(num, target), max(num, target)) )

 

return ('\n'.join(map(str, list(output))))

 

o = pair_sum([1, 3, 2, 2], 4)

print(o)

 

# 결과

(1, 3)

(2, 2)

 

# Find the Missing 

 

def missing_finder(arr1, arr2):

arr1.sort()

arr2.sort()

 

for num1, num2 in zip(arr1, arr2):

if num1 != num2:

return num1

 

return arr1[-1]

 

arr1 = [1, 2, 3, 4, 5, 6, 7, 8]

arr2 = [1, 2, 3, 4, 6, 7]

 

o = missing_finder(arr1, arr2)

print(o)

 

# 결과

5

 

 

# Find the Missing - my version

 

def missing_finder(arr1, arr2):

diff = []

 

if len(arr1) == len(arr2):

return None

 

if len(arr1) > len(arr2):

big = sorted(arr1)

small = sorted(arr2)

else:

big = sorted(arr2)

small = sorted(arr1)

 

for n in range(len(big)-len(small)):

small.append(0)

 

for num1, num2 in zip(big, small):

if num1 != num2:

diff.append(num1)

 

if len(diff) == 0: return arr1[-1]

 

return diff

 

arr1 = [1, 2, 3, 4, 5]

arr2 = [1, 2, 3, 4, 5, 6, 7]

 

o = missing_finder(arr1, arr2)

print(o)

 

# 결과

[6, 7]

 

 

# list와 tuple의 차이

 

# tuple - immutable
""" 같은 객체를 재사용하지 않기 때문에 내용이 바뀌지 않는다. """
t = (1, 2)
print(id(t))
t = (1, 2, 3)
print(id(t))
t = (1, 2)
print(id(t))

 

# 결과

7477608

6712696

7477568

 

# list - mutable

t = [1, 2]
print(id(t))
t = [1, 2, 3]
print(id(t))
t = [1, 2]
print(id(t))

 

# 결과
14424024

14424064

14424024

 

 

# list slicing - reverse slicing

""" 시작위치는 포함이고, 끝위치는 미포함이다. """

ls = [1, 2, 3, 4, 5]

print(ls[3:0:-1])

 

# 결과

[4, 3, 2]

 

 

# list insertion with list slicing

ls = [1, 5]

 

ls[1:1] = [2, 3, 4]

 

print(ls)

 

# 결과

[1, 2, 3, 4, 5]

 

 

# 리스트 요소 사이를 스트링으로 연결한다.

ad = '+'

seq = ['1', '2']

 

o = str1.join(str2)

print(o)

 

# 결과

1+2

 

# join 메써드로 리스트를 스트링으로 변환한다.

ls = ['1', '2']

k = ''.join(ls)

print("type k: {}, value k: {}".format(type(k), k))

 

# 결과

type k: <class 'str'>, value k: 12

 

 

# dict unpacking

infos = {'name': 'mike', 'age': '34'}

print("%(name)s, %(age)s" % infos)

 

# 결과

mike, 34

 

 

# Generate dict from key list

d = {}.fromkeys(['name', 'age'])

print(d)

 

# 결과

{'age': None, 'name': None}

 

# Generate dict from key list 2

d = dict.fromkeys(['height', 'age'], 0)

print(d)

 

# 결과

{'height': 0, 'age': 0}

 

 

# dict로 문자 출현 빈도 카운트하기

msg = "Hello, World!"

 

count = {}

 

for c in msg:

count.setdefault(c, 0)

count[c] = count[c] + 1

 

print(count)

 

# 결과

{' ': 1, 'l': 3, ',': 1, '!': 1, 'H': 1, 'W': 1, 'e': 1, 'd': 1, 'o': 2, 'r': 1}

 

 

# dict subclassing으로 None key는 그대로 key 출력

# Exist key는 value를 출력

class passThruDict(dict):

def __missing__(self, key):

return key

 

censor = passThruDict({'hell': 'h***', 'darn': 'd*rn'})

sentence = "That darn cat!"

o = ' '.join(censor[w] for w in sentence.split())

print(o)

 

# 결과

That d*rn cat!

 

 

# attribute 접근 방법들

class C():

def __init__(self, x):

self._x = x

 

def __getitem__(self, key):

if key == 'x':

self._x += 1

return self._x

 

c = C(10)

print(c['x'])

 

class D():

def __init__(self, x):

self._x = x

 

@property

def x(self):

self._x += 1

return self._x

 

d = D(10)

print(d.x)

 

# 결과

11

11

 

 

# dict - sorted()

datas = {(1, 2): 0, (1, 3): 1}

 

o = [{k: v} for k, v in datas.items() if k[1] == 3]

sorted_o1 = sorted(datas, key = datas.__getitem__, reverse=True)

sorted_o2 = sorted(datas, key = lambda x: x[1], reverse=True)

 

print(o)

print(sorted_o1)

print(sorted_o2)

 

# 결과

[{(1, 3): 1}]

[(1, 3), (1, 2)]

[(1, 3), (1, 2)]