[Data Mining] Crash_Course in Python Part.2

The Not-So-Basics

Sorting

x = [4,1,2,3]
y = sorted(x)    # is [1,2,3,4], x is unchanged
x.sort()         # now x is [1,2,3,4]

# sort the list by absolute value from largest to smallest
x = sorted([-4,1,-2,3], key=abs, reverse=True) # is [-4,3,-2,1]
# sort the words and counts from highest count to lowest
wc = sorted(word_counts.items(),
            key=lambda x: x[1], # x[1] 두번째 값을 기준으로 정렬
            reverse=True)

wc
# [('I', 2), ('am', 1), ('a', 1), ('boy', 1), ('love', 1), ('you', 1)]

• x 리스트는 절댓값에 따라 내림차순으로 정렬됩니다.
  • sorted() 함수는 입력 리스트를 정렬합니다.
  • key=abs 인자는 정렬 키를 절댓값으로 설정합니다.
  • reverse=True 인자는 내림차순으로 정렬됨을 나타냅니다.
• wc는 단어 및 해당 카운트를 가진 딕셔너리를 가장 많은 카운트부터 가장 적은 카운트로 정렬됩니다.
  • sorted() 함수의 key 매개변수는 각 요소에 대해 적용되는 함수를 지정합니다.
  • 여기서는 람다 함수를 사용하여 요소의 두 번째 값(카운트), 단어의 출연 빈도를 기준으로 정렬합니다.
  • reverse=True 인자는 내림차순으로 정렬됨을 나타냅니다.

word_counts.items()는 딕셔너리의 각 항목을 튜플로 반환합니다.
예를 들어, { 'I': 2, 'am': 1, 'a': 1 }이라는 딕셔너리가 있다면, items() 메소드는 ('I', 2), ('am', 1), ('a', 1)과 같은 튜플들의 리스트를 반환합니다.
sorted() 함수에 의해 두 번째 요소(즉, 튜플의 두 번째 값)를 기준으로 내림차순으로 정렬됩니다.
따라서 word_counts.items()가 튜플들의 리스트를 반환하므로 두 번째 값은 해당 단어의 출현 빈도를 나타냅니다.
x[0]: ‘단어’, x[1]: ‘숫자’

• 단어와 해당 카운트를 가장 많은 카운트부터 가장 적은 카운트로 정렬합니다.

---

List Comprehensions

• 특정 요소만을 선택하거나 요소를 변환하거나 둘 다를 선택하여 목록을 다른 목록으로 변환하고자 할 것입니다.
• 목록의 포괄성은 파이토닉 방식에 의해 결정됩니다.
• 가능하면 항상 List Comprehensions를 사용합니다.

even_numbers = [x for x in range(5) if x % 2 == 0]  # [0, 2, 4], 0 ~ 4 사이중
squares      = [x * x for x in range(5)]            # [0, 1, 4, 9, 16]
even_squares = [x * x for x in even_numbers]        # [0, 4, 16]

• 마찬가지로 List을 Dictionary 또는 Set으로 변환할 수 있습니다.

square_dict = { x : x * x for x in range(5) }  # { 0:0, 1:1, 2:4, 3:9, 4:16 }
square_set = { x * x for x in [1, -1] }        # { 1 } # set은 중복 요소 포함 X

• 변수로 밑줄을 사용하는 것이 일반적입니다.
  • ‘_’은 값이 필요하지 않을때 사용. even_numbers = [0, 2, 4] → Zeros List: [0, 0, 0]'

zeroes = [0 for _ in even_numbers]    # has the same length as even_numbers

• List Comprehension 다음과 같은 여러 가지 이유가 포함될 수 있습니다.

pairs = [(x, y)
         for x in range(10)
         for y in range(10)] # 100 pairs (0,0) (0,1) ... (9,8), (9,9)

• 컴퓨터 사용이 쉬운 거리 행렬, 나중에는 이전의 결과를 사용할 수 있습니다.

increasing_pairs = [(x, y)
                    for x in range(10)
                    for y in range(x + 1, 10)]
                    
# [(0,1), (0,2), (0,3) ... (8, 9)]

• 0부터 9까지인 모든 숫자 쌍을 생성합니다.
• 이 쌍들은 첫 번째 요소가 두 번째 요소보다 작은 증가하는 순서쌍입니다.

---

Generators & Iterators

• List의 문제점은 List가 쉽게 매우 커질 수 있다는 것입니다.
• range(1000000)는 실제 100만 개의 원소 목록을 만듭니다.
• 만약 당신이 한 번에 하나씩만 다루면 된다면, 이것은 엄청난 비효율성의 원천(또는 메모리 부족의 원인)이 될 수 있습니다.
• 만약 당신이 잠재적으로 처음 몇 개의 값만 필요하다면, 그것들을 모두 계산하는 것은 낭비입니다.
• Generator는 사용자가 반복할 수 있지만(우리의 경우, 일반적으로 에 사용합니다) 필요에 따라 값이 생성되는 것(lazily)입니다.
• Generator를 만드는 한 가지 방법은 함수와 yield 연산자를 사용하는 것입니다:

def lazy_range(n):
    """a lazy version of range"""
    i = 0
    while i < n:
        yield i
        i += 1

# The following loop will consume the yield ed values one at a time until none are left:
for i in lazy_range(10):
    print(i)

0
1
2
3
4
5
6
7
8
9

# The following loop will consume the yield ed values one at a time until none are left:
for i in lazy_range(10000):
    if i == 3: break
    print(i)

0
1
2

t = lazy_range(3)
next(t)
next(t)
next(t)
#next(t)

# 2

def lazy_inf_range():
    i = 0
    while True:
        yield i
        i += 1

t = lazy_inf_range()
next(t)
next(t)
next(t)

# 2

• Generator를 만드는 두 번째 방법은 괄호 안으로 포장된 comprehension에 사용하는 것입니다:

lazy_evens_below_20 = (i for i in lazy_range(20) if i % 2 == 0)
lazy_evens_below_20

# <generator object <genexpr> at 0x7cce6849c4a0>

---

Randomness

• 난수를 생성하기 위해, 우리는 난수 모듈을 사용할 수 있습니다.
• random.random()는 0에서 1 사이의 숫자를 균일하게 생성합니다.

import random

four_uniform_randoms = [random.random() for _ in range(4)]
four_uniform_randoms

[0.15001730378211198,
 0.047689363188983425,
 0.4438845111618783,
 0.8064273339306516]

• reproducible 가능한 결과를 얻으려는 경우.

random.seed(10)
print(random.random())
random.seed(10)
print(random.random())

0.5714025946899135
0.5714025946899135

• random.randrange는 1 또는 2개의 인수를 사용하고 해당 범위 ()에서 임의로 선택한 요소를 반환합니다.

random.randrange(10)      # choose randomly from range(10) = [0, 1, ..., 9]
random.randrange(3, 6)    # choose randomly from range(3, 6) = [3, 4, 5]

• random.shuffle는 목록의 요소를 임의로 재정렬합니다:

up_to_ten = list(range(10))
random.shuffle(up_to_ten)
print(up_to_ten)

# 4, 5, 8, 1, 2, 6, 7, 3, 0, 9]

• 목록에서 한 요소를 임의로 선택하는 방법입니다.

my_best_friend = random.choice(["Alice", "Bob", "Charlie"])

• 대체하지 않고 원소 표본을 임의로 선택하는 방법입니다. (즉, 중복되지 않습니다)

lottery_numbers = range(60)
winning_numbers = random.sample(lottery_numbers, 6)

• 대체 요소 표본을 선택하는 방법입니다.(즉, 중복을 허용합니다)

four_with_replacement = [random.choice(range(10)) for _ in range(4)]
four_with_replacement

# [2, 9, 5, 6]

• random.choice(range(10))는 0부터 9까지의 숫자 중에서 하나를 무작위로 선택하는 함수입니다.
• 이를 리스트 컴프리헨션 으로 4번 반복하여 리스트를 생성. 중복을 허용합니다. 무작위로 선택된 0부터 9까지의 숫자가 4개 포함.

---

Regular Expressions

• 정규 표현식은 텍스트를 검색하는 방법을 제공합니다.
• 그것들은 믿을 수 없을 정도로 유용하지만 또한 꽤 복잡해서 그것들에 대한 전체 책이 있습니다.

import re

# 정규 표현식을 사용하여 다양한 문자열 작업을 수행하고, 각 작업의 결과를 검사합니다.
# 모든 조건이 참일 경우 True를 출력합니다.

print(all([
    not re.match("a", "cat"),                # "cat" 문자열은 "a"로 시작하지 않음
    re.search("a", "cat"),                    # "cat" 문자열에 "a"가 포함되어 있음
    not re.search("c", "dog"),                # "dog" 문자열에 "c"가 포함되어 있지 않음
    3 == len(re.split("[ab]", "carbs")),    # "carbs" 문자열을 "[ab]"를 기준으로 분할하면 ['c', 'r', 's']가 되며, 길이가 3임
    "R-D-" == re.sub("[0-9]", "-", "R2D2")    # "R2D2" 문자열에서 숫자를 "-"로 대체하면 "R-D-"가 됨
]))    # 출력 결과는 True

---

Object-Oriented Programming

# 관례적으로, 클래스는 PascalCase 이름을 사용합니다.
class Set:
    # 이것들은 멤버 함수입니다.
    # 각 함수는 "self"라는 첫 번째 매개변수를 가져야 합니다(또 다른 관례입니다).
    # 이 "self"는 사용되는 특정 Set 객체를 가리킵니다.

    def __init__(self, values=None):
        """이것은 생성자입니다.
        새로운 Set을 만들 때 호출됩니다.
        다음과 같이 사용할 수 있습니다.
        s1 = Set()          # 빈 집합
        s2 = Set([1,2,2,3]) # 값으로 초기화"""

        self.dict = {}  # 각 Set 인스턴스마다 고유한 dict 속성이 있습니다.
                        # 이 속성은 멤버십을 추적하는 데 사용됩니다.
        if values is not None:
            for value in values:
                self.add(value)

    def __repr__(self):
        """이것은 Set 객체의 문자열 표현입니다.
        Python 프롬프트에서 입력하거나 str()에 전달하면 사용됩니다."""
        return "Set: " + str(self.dict.keys())

    # 각 요소의 멤버십은 self.dict의 키로 표시됩니다.
    def add(self, value):
        self.dict[value] = True

    # 값이 집합에 있는지 여부는 사전의 키로 판별됩니다.
    def contains(self, value):
        return value in self.dict

    def remove(self, value):
        del self.dict[value]

s = Set([1,2,3])
s.add(4)
print(s.contains(4))    # True
s.remove(3)
print(s.contains(3))    # False

---

Function Tools

• 함수를 전달할 때 새 함수를 만들기 위해 부분적으로 (또는 카레) 함수를 적용하고 싶을 때가 있습니다

def exp(base, power):
    return base ** power

def two_to_the(power):
    return exp(2, power)
    
two_to_the(3)

# 8

• functools.partial을 사용하는 것은 다른 접근 방식

from functools import partial

two_to_the = partial(exp, 2)     # is now a function of one variable
print(two_to_the(3))             # 8

square_of = partial(exp, power=2)
print(square_of(3))    # 9

• 또한 map, reduce 및 filter를 사용하여 이해를 나열하는 기능적 대안을 제공하기도 합니다:
• 항상 map 사용하고 가능하면 reduce하고 filtering합니다.

---

Map

def double(x):
    return 2 * x

xs = [1, 2, 3, 4]

# 리스트 컴프리헨션을 사용하여 각 요소를 두 배로 만듭니다.
twice_xs = [double(x) for x in xs]

# map 함수를 사용하여 각 요소를 두 배로 만듭니다.
twice_xs = map(double, xs)

# partial 함수를 사용하여 map 함수에 double 함수를 적용합니다.
list_doubler = partial(map, double)
# list_doubler를 사용하여 xs의 각 요소를 두 배로 만듭니다.
twice_xs = list_doubler(xs)

def multiply(x, y): return x * y

products = map(multiply, [1, 2], [4, 5])    # [1 * 4, 2 * 5] = [4, 10]
list(products)

# [4,10]

def multiply(x, y, z): return x * y * z

products = map(multiply, [1, 2], [4, 5], [10, 20])    # [1 * 4 * 10, 2 * 5 * 20]
list(products)

# [40, 200]

---

Filter

def is_even(x):
    """x가 짝수이면 True, 홀수이면 False를 반환합니다."""
    return x % 2 == 0

xs = [1, 2, 3, 4]

# 리스트 컴프리헨션을 사용하여 짝수만 필터링합니다.
x_evens = [x for x in xs if is_even(x)]
print(x_evens)

# filter 함수를 사용하여 짝수만 필터링합니다.
x_evens = filter(is_even, xs)
print(list(x_evens))

# partial 함수를 사용하여 filter 함수에 is_even 함수를 적용합니다.
list_evener = partial(filter, is_even)
# list_evener를 사용하여 xs에서 짝수만 필터링합니다.
x_evens = list_evener(xs)
print(list(x_evens))

[2, 4]
[2, 4]

---

Reduce

def multiply(x, y): return x * y

xs = [1,2,3]
x_product = reduce(multiply, xs)
print(x_product)
list_product = partial(reduce, multiply)
x_product = list_product(xs)
print(x_product)

6
6

---

Enumerate

• 목록에서 반복하고 해당 요소와 인덱스를 모두 사용하려면 다음과 같이 하면 됩니다.

documents = ["I", "am", "a", "boy"]
# not Pythonic
for i in range(len(documents)):
    document = documents[i]
    print(i, document)

# also not Pythonic
i = 0
for document in documents:
    print(i, document)
    i += 1

0 I
1 am
2 a
3 boy
0 I
1 am
2 a
3 boy

• Pythonic solution은 열거형으로 튜플(인덱스, 요소)을 생성합니다:

for i, document in enumerate(documents):
    print(i, document)

0 I
1 am
2 a
3 boy

for i in range(len(documents)): print(i)    # not Pythonic

for i, _ in enumerate(documents): print(i)  # Pythonic

0
1
2
3
0
1
2
3

---

Zip & Unzip

• 둘 이상의 목록을 함께 압축합니다.
• zip은 여러 목록을 해당 요소의 튜플 단일 목록으로 변환합니다:

list1 = ['a', 'b', 'c']
list2 = [1, 2, 3]
list(zip(list1, list2))        # is [('a', 1), ('b', 2), ('c', 3)]

• 이상한 속임수를 사용하여 List를 "Unzip"할 수도 있습니다:

pairs = [('a', 1), ('b', 2), ('c', 3)]
letters, numbers = zip(*pairs)
print(letters, numbers)

# ('a', 'b', 'c') (1, 2, 3)

pairs = [('a', 1), ('b', 2), ('c', 3)]
letters, numbers = zip(('a', 1), ('b', 2), ('c', 3))
print(letters, numbers)

# ('a', 'b', 'c') (1, 2, 3)