No.190
세계정복의 시작점

1. 싱글톤 : 객체 하나를 통한 이벤트 

                - 클래식싱글톤 : 상속을 해도 오직 상위객체의 데이터/함수만 사용가능

                - borg 싱글톤 : 상속을 해서 하위단의 데이터를 사용가능/함수만 상위단의 것을 사용

2. 팩토리 : 변수에 따른 객체를 리턴

                - 여러개의 공통된 클래스의 집합을 통해 하나의 클래스에서 변수를 통해 해당 클래스를 리턴 

                - 사용자는 상위단을 알 필요 없이 선택에 따라 객체를 받을수 있음

                                         - ex : Connect() ------> httpConnect()

                                                                   |

                                                                   ------->ftpConnect()

                                           - 사용자의 입력에 따라 http or ftp 객체를 리턴 

                    - 상위단에서는 하위단에서 구현되여야 할 함수를 선언(abstract)

3. 파사드 : 인터페이스를 통해 사용자의 편의성 제공 목적

                 - 사용자가 인터페이스를 통해 원하는 액션을 받을수 있도록 하나의 인터페이스로 여러개의 클래스를 집약시킴

                 - 팩토리와 다른점은 팩토리는 사용자의 선택에 따라 객체를 선택해서 받음, 파사드는 오직 하나의 동작만을 수행하지만 인터페이스를 통한 간소화가 목적

4. 프록시 : 다른 객체의 기능을 확장할때 사용 (중간에서 어떠한 행위를 할때 사용)

               - 보안상의 필요성을 위해 몇몇의 변수/함수만을 허락할때 

               - subject의 모든 호출 및 파라미터를 기록할때 

               - 값을 반환하기 전에 임시로 저장하기 위해 

               - 객체에 대한 참조를 세기 위해 

                - ex :                                       client --------------------->   proxy   ------------------->    subject(interface)

                                                                                                                      |                                                       ^

                                                                                                                     %                                                      |

                                                                                                                  realSubject--------------------------| 

                    - realSubject에 모든 구현이 되어 있지만 client는 proxy를 통해 사용

                   -  proxy에서 중간에서 수행할 기능 구현 

5. 옵저버 : 일대다 관계 ( 다수의 상태를 바꿔야 할때 )의 객체간 의존성을 낮출 때 

                - 모든 사용자들에게 알림요청

                - 특정 상태를 다수의 객체에 전달할때

No.190
세계정복의 시작점

1. docker kitematic를 통한 sonarqube 다운로드 및 설치

2.  http://localhost:32768/about 로 접속 로그인  (아이디 /  패스워드  :  admin / admin )

3. create new project ( 이름은 아무거나 )

4. 토큰 생성 클릭

5. 언어와 실행할 os 선택 ( python // macos 선택 )

download를 클릭하여 sonar-scanner 실행 파일 다운로드

"soanr-scanner는 정적 분석 후 sonarqube에 전송하는 역활"

하단의 커맨드 부분을 copy 후 실행 하면 정적분석 시작!!

파라미터를 보면  "sonar.sources=. " 부분이 어떤 폴더를 실행할지를 결정하므로 

커맨드를 실행하는 해당 폴더의 파일들을 분석하게됨 (각자 알아서 폴더 경로를 넣어주면 됨  " . " 일 경우 현재 폴더를 의미)

6. 명령어 실행시 정적 분석을 시작  / 완료 후 클릭해 보면 분석 데이터를 볼수 있음

7. 버그와 중복 코드가 많은것을 볼수 있음......

8. 나의 경우 pytest를 통한 분석용페이지에서 중복 코드가 대부분 나왔다. 해당 폴더를 제외 시키자

9. 메뉴 Administration -> Analysis Scope -> Files -> Source File Exclusions 에 제외시키고 싶은 경로를 쓰면 된다. ( 특정 폴더의 모든 파일들을 제외 시킨다면 다음과 같이 쓴다. ex : 폴더명/*.* ) 

저장을 하고 5번에서의  sonar-scanner 명령어를 다시 실행하면 해당 폴더가 제외된 실행 결과를 볼수 있다. 

10. 해당 폴더가 제외된 결과 상황 ( *.py만 나왔다.. 중복 코드가 너무 많다.. )

11. 리포팅을 통해 버그와 중복을 제거하자. 끝! 

추가 부분 

12.  현재  pytest를 통해 테스트코드 작성과 커버리지를 하고 있었음.

pytest의 리포트 기능을 통해 sonarqube에 coverage와 test를 보여줄수 있음

먼저 pytest 실행시 두개의 옵션 추가 

$ pytest --cov-report=xml:coverage.xml --junitxml=./pytest-report.xml

--cov-report 는 커버리지 내용을 다음에 저장하라는 명령어. 

--junitxml 은 테스트 코드가 어디곳에 작성되어 돌아가는지 저장하는 명령어

해당 명령어를 돌리면 두개의 파일 coverage.xml / pytest-report.xml 이 생성 됩니다. 

13. sonar-sanner 실행시 옵션을 추가 합니다. 

sonar-scanner \
-Dsonar.projectKey=test_sonarqube \
-Dsonar.sources=. \
-Dsonar.host.url=http://localhost:32768 \
-Dsonar.login=80a2d40fd130938312a5a776c0e406f205ca9d5a \
-Dsonar.python.xunit.reportPath=./pytest-report.xml \
-Dsonar.python.coverage.reportPaths=./coverage.xml

unit과 coverage 파일의 경로를 추가 해주면 아래와 같이 리포팅된 값을  sonarqube에서 볼수 있습니다. 

진짜 끝!

No.190
세계정복의 시작점

No.190
세계정복의 시작점

No.190
세계정복의 시작점

#!/usr/bin/env python

# coding: utf-8

# In[1]:

corpus = ['king is a strong man', 

          'queen is a wise woman', 

          'boy is a young man',

          'girl is a young woman',

          'prince is a young king',

          'princess is a young queen',

          'man is strong', 

          'woman is pretty',

          'prince is a boy will be king',

          'princess is a girl will be queen']

# In[2]:

print corpus

# In[7]:

def remove_stop_words(corpus):

    stop_words = ['is', 'a', 'will', 'be']

    results = []

    for text in corpus:

        tmp = text.split(' ')

        for stop_word in stop_words:

            if stop_word in tmp:

                tmp.remove(stop_word)

        results.append(" ".join(tmp))

    return results

# In[8]:

corpus = remove_stop_words(corpus)

print corpus

# In[10]:

words = []

for text in corpus:

    for word in text.split(' '):

        words.append(word)

words = set(words)

words

# In[12]:

word2int = {}

for i,word in enumerate(words):

    word2int[word] = i

sentences = []

for sentence in corpus:

    sentences.append(sentence.split())

WINDOW_SIZE = 2

data = []

for sentence in sentences:

    for idx, word in enumerate(sentence):

        for neighbor in sentence[max(idx - WINDOW_SIZE, 0) : min(idx + WINDOW_SIZE, len(sentence)) + 1]:

            if neighbor != word:

                data.append([word, neighbor])

# In[14]:

import pandas as pd

for text in corpus:

    print(text)

df = pd.DataFrame(data, columns = ['input', 'label'])

# In[15]:

df.head(10)

# In[16]:

df.shape

# In[17]:

word2int

# In[19]:

import tensorflow as tf

import numpy as np

ONE_HOT_DIM = len(words)

def to_one_hot_encoding(data_point_index):

    one_hot_encoding = np.zeros(ONE_HOT_DIM)

    one_hot_encoding[data_point_index] = 1

    return one_hot_encoding

X = []

Y = []

for x,y in zip(df['input'], df['label']):

    X.append(to_one_hot_encoding(word2int[x]))

    Y.append(to_one_hot_encoding(word2int[y]))

X_train = np.asarray(X)

Y_train = np.asarray(Y)

x = tf.placeholder(tf.float32, shape = (None, ONE_HOT_DIM))

y_label = tf.placeholder(tf.float32, shape = (None, ONE_HOT_DIM))

EMBEDDING_DIM = 2 

# hidden layer: which represents word vector eventually

W1 = tf.Variable(tf.random_normal([ONE_HOT_DIM, EMBEDDING_DIM]))

b1 = tf.Variable(tf.random_normal([1])) #bias

hidden_layer = tf.add(tf.matmul(x,W1), b1)

# output layer

W2 = tf.Variable(tf.random_normal([EMBEDDING_DIM, ONE_HOT_DIM]))

b2 = tf.Variable(tf.random_normal([1]))

prediction = tf.nn.softmax(tf.add( tf.matmul(hidden_layer, W2), b2))

# loss function: cross entropy

loss = tf.reduce_mean(-tf.reduce_sum(y_label * tf.log(prediction), axis=[1]))

# training operation

train_op = tf.train.GradientDescentOptimizer(0.05).minimize(loss)

# In[20]:

sess = tf.Session()

init = tf.global_variables_initializer()

sess.run(init) 

iteration = 20000

for i in range(iteration):

    # input is X_train which is one hot encoded word

    # label is Y_train which is one hot encoded neighbor word

    sess.run(train_op, feed_dict={x: X_train, y_label: Y_train})

    if i % 3000 == 0:

        print('iteration '+str(i)+' loss is : ', sess.run(loss, feed_dict={x: X_train, y_label: Y_train}))

# In[21]:

vectors = sess.run(W1 + b1)

print(vectors)

# In[22]:

w2v_df = pd.DataFrame(vectors, columns = ['x1', 'x2'])

w2v_df['word'] = words

w2v_df = w2v_df[['word', 'x1', 'x2']]

w2v_df

# In[25]:

import matplotlib.pyplot as plt

fig, ax = plt.subplots()

for word, x1, x2 in zip(w2v_df['word'], w2v_df['x1'], w2v_df['x2']):

    ax.annotate(word, (x1,x2 ))

PADDING = 1.0

x_axis_min = np.amin(vectors, axis=0)[0] - PADDING

y_axis_min = np.amin(vectors, axis=0)[1] - PADDING

x_axis_max = np.amax(vectors, axis=0)[0] + PADDING

y_axis_max = np.amax(vectors, axis=0)[1] + PADDING

plt.xlim(x_axis_min,x_axis_max)

plt.ylim(y_axis_min,y_axis_max)

plt.rcParams["figure.figsize"] = (10,10)

plt.show()

# In[24]:

# In[ ]:

No.190
세계정복의 시작점

def linear_search(list, find_key):
    for i in range(len(list)):
        if list[i] == find_key:
            return i
    return "not find"


def binary_search(list, find_key):
    mid = len(list)//2
    while True:
        if list[mid] == find_key:
            return mid
        elif list[mid] < find_key:
            mid += mid/2
            if mid >= len(list):
                mid = len(list)-1
        else:
            mid -= mid/2
            if mid/2 == 0:
                mid = 0


class binary_tree:
    value = 0
    left = None
    right = None

    def __init__(self, value):
        self.value = value

    def get_value(self):
        return self.value

    def get_left(self):
        return self.left

    def get_right(self):
        return self.right

    def input_value(self, value):
        if self.value > value:
            if self.left is None:
                new_binary_tree = binary_tree(value)
                self.left = new_binary_tree
                return self.left
            else:
                return True
        else:
            if self.right is None:
                new_binary_tree = binary_tree(value)
                self.right = new_binary_tree
                return self.right
            else:
                return False


def binary_tree_create(list):
    root = binary_tree(list[0])
    for i in range(len(list)):
        if list[i] != root.get_value():
            now_obj = root
            while True:
                temp_obj = now_obj.input_value(list[i])
                if isinstance(temp_obj, binary_tree):
                    break
                else:
                    if temp_obj is True:
                        now_obj = now_obj.get_left()
                    else:
                        now_obj = now_obj.get_right()

    return root


def binary_tree_search(node, value, depth):

    temp_value = node.get_value()
    if temp_value == value:
        return temp_value, depth
    elif temp_value > value:
        if isinstance(node.get_left(), binary_tree) is False:
            return "not find"
        return binary_tree_search(node.get_left(), value, depth+1)
    else:
        if isinstance(node.get_right(), binary_tree) is False:
            return "not find"
        return binary_tree_search(node.get_right(), value, depth+1)


temp_list = [33, 11, 99, 1, 22, 88, 55, 44, 66, 77]


print(linear_search(temp_list, 77))
print(binary_search(temp_list, 77))
root = binary_tree_create(temp_list)
print(binary_tree_search(root, 77, 0))

No.190
세계정복의 시작점

def bubble(list):
    for i in range(len(list)):
        for j in range(len(list)):
            if list[i] < list[j]:
                list[i], list[j] = list[j], list[i]

    return list


def selection(list):
    for i in range(len(list)):
        min_temp = i
        for j in range(i, len(list)):
            if list[min_temp] > list[j]:
                min_temp = j
        list[i], list[min_temp] = list[min_temp], list[i]

    return list


def insertion(list):
    for i in range(len(list)):
        if i+1 < len(list):
            pin = i+1
            for j in reversed(range(0, pin)):
                if list[j] > list[pin]:
                    list[pin], list[j] = list[j], list[pin]
                    pin = j
                else:
                    break
    return list


def quicksort(list):
    if len(list) <= 1:
        return list

    pivot = list[len(list)//2]
    small = []
    many = []
    equal = []
    for x in list:
        if x < pivot:
            small.append(x)
        elif x > pivot:
            many.append(x)
        else:
            equal.append(x)

    return quicksort(small)+equal+quicksort(many)


def mergesort(list):
    if len(list) <= 1:
        return list

    helf = len(list)/2
    left = mergesort(list[:helf])
    right = mergesort(list[helf:])

    return_list = []
    left_x = 0
    right_x = 0
    while left_x < len(left) and right_x < len(right):
        if left[left_x] < right[right_x]:
            return_list.append(left[left_x])
            left_x += 1
        else:
            return_list.append(right[right_x])
            right_x += 1

    return_list += left[left_x:]
    return_list += right[right_x:]

    return return_list


temp_list = [33, 11, 99, 1, 22, 88, 55, 44, 66, 77]


print(bubble(temp_list))
print(selection(temp_list))
print(insertion(temp_list))
print(quicksort(temp_list))
print(mergesort(temp_list))

No.190
세계정복의 시작점

No.190
세계정복의 시작점

No.190
세계정복의 시작점