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. 옵저버 : 일대다 관계 ( 다수의 상태를 바꿔야 할때 )의 객체간 의존성을 낮출 때 

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

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

'뇌세포덩어리"" > 리팩토링&객체지향' 카테고리의 다른 글

디자인패턴  (0) 2019.06.02
sonarQube 정적 코드 분석 (기초편)  (0) 2019.05.26

WRITTEN BY
No.190
세계정복의 시작점

트랙백  0 , 댓글  0개가 달렸습니다.
secret

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에서 볼수 있습니다. 

coverage에 커버리지 %를 볼수 있게 되었습니다. 
어느 부분에서 테스트코드가 작성되지 않았는지 볼수 있습니다. 

 

진짜 끝!

'뇌세포덩어리"" > 리팩토링&객체지향' 카테고리의 다른 글

디자인패턴  (0) 2019.06.02
sonarQube 정적 코드 분석 (기초편)  (0) 2019.05.26

WRITTEN BY
No.190
세계정복의 시작점

트랙백  0 , 댓글  0개가 달렸습니다.
secret

'뇌세포덩어리""' 카테고리의 다른 글

트렌지스터의 동작 원리  (0) 2018.12.08
.NET Framework 2.0 설치  (4) 2011.06.27
솔라리스 디스크 사용량 알아내기 - df -h 명령어  (0) 2011.06.15
UX라.....  (0) 2010.05.21
mysql 백업, 복구  (0) 2010.05.13
mfc71.dll msvcp71.dll msvcr71.dll  (0) 2009.12.27

WRITTEN BY
No.190
세계정복의 시작점

트랙백  0 , 댓글  0개가 달렸습니다.
secret

WRITTEN BY
No.190
세계정복의 시작점

트랙백  0 , 댓글  0개가 달렸습니다.
secret

#!/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[ ]:





'뇌세포덩어리"" > tensorflow' 카테고리의 다른 글

1. word2Vec  (0) 2018.10.08

WRITTEN BY
No.190
세계정복의 시작점

트랙백  0 , 댓글  0개가 달렸습니다.
secret
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))


이진트리는 트리 형식으로 만들어야 함으로 쪼금 길다.



선형 탐색 O(n)

이진 탐색 O( logn) 단 정렬이 되 있어야 함

이진 트리 O( logn) 


WRITTEN BY
No.190
세계정복의 시작점

트랙백  0 , 댓글  0개가 달렸습니다.
secret

파이썬을 간단하게 짠 정렬들... 원리만 알면 구하기 쉬움.





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))


버블   O(n^2)

선택   O(n^2)

삽입  O(n^2) but 버블/선택 보단 빠르고 메모리를 적게 먹음

퀵     최적 O(nlogn)     최악 O(n^2)

머지  O(nlogn)


WRITTEN BY
No.190
세계정복의 시작점

트랙백  0 , 댓글  0개가 달렸습니다.
secret



- 이 세상에서 이십년 동안 존 재하면서 습득한 상식을 알고 싶다면 그 일에 이십년을 들여야 한다. 이에 상응하는 자기발견적방법론을 그 보다더 짧은 시간내에 조립할 방도는 없다. 경험은 알고림적으로 압축할 수 없기 때문이다.


sf소설로 유명한 테드창의 작품

우리가 AI를 어떻게 발전시키고 이용해 나가는가에 대해서 상상한 작품이다. 꽤나 현실적으로 다가오는 부분이 많은데 AI를 꼭 좋은 일에만 쓰진 않는다는 것이다. 


마지막까지 인간이 되지 못하는 AI들을 주인공이 위와 같이 한 말이 너무나 맘에 와 닿는다. 

한 인간이 되기 위해선 그 한인간만큼의 삶을 살아야 한다는것.

그리고 그만큼의 삶동안은 어떤 생물이든 존경받아야 한다는것.


'뇌세포덩어리"" > ' 카테고리의 다른 글

소프트웨어 객체의 생애주기  (0) 2015.06.21
까칠하게 힐링  (0) 2015.06.08
나무를 심은 사람  (0) 2014.09.12
죽음이란 무엇인가  (0) 2014.09.12
읽기 좋은 코드가 좋은 코드다  (0) 2014.09.11
공룡은 살아있다.  (0) 2014.07.12

WRITTEN BY
No.190
세계정복의 시작점

트랙백  0 , 댓글  0개가 달렸습니다.
secret




까칠하게 힐링!

'뇌세포덩어리"" > ' 카테고리의 다른 글

소프트웨어 객체의 생애주기  (0) 2015.06.21
까칠하게 힐링  (0) 2015.06.08
나무를 심은 사람  (0) 2014.09.12
죽음이란 무엇인가  (0) 2014.09.12
읽기 좋은 코드가 좋은 코드다  (0) 2014.09.11
공룡은 살아있다.  (0) 2014.07.12

WRITTEN BY
No.190
세계정복의 시작점

트랙백  0 , 댓글  0개가 달렸습니다.
secret




내용은 정말 짧은데...이게 실화라는게 더욱 당혹스럽게 하는책.

한사람이 자연을/ 사람들의 인생을 바꿀수 있다는게 가능하다는걸.

한사람의 조금만한 생각이 많은것을 변화시킬수 있다는것을 깨닫게 된다.

'뇌세포덩어리"" > ' 카테고리의 다른 글

소프트웨어 객체의 생애주기  (0) 2015.06.21
까칠하게 힐링  (0) 2015.06.08
나무를 심은 사람  (0) 2014.09.12
죽음이란 무엇인가  (0) 2014.09.12
읽기 좋은 코드가 좋은 코드다  (0) 2014.09.11
공룡은 살아있다.  (0) 2014.07.12

WRITTEN BY
No.190
세계정복의 시작점

트랙백  0 , 댓글  0개가 달렸습니다.
secret