'분류 전체보기'에 해당되는 글 112건

저는 1번 방법으로 깔끔하게 설치했습니다.

버전은 4.0 이고 터미널에서 octave-cli 으로 사용할 수 있습니다. 

.m 확장자를 가진 파일을 실행시킬 수 있습니다.

출처 

http://unix.stackexchange.com/questions/280195/how-to-install-octave-without-gui-in-ubuntu-16-04

멀티쓰레딩을 이용하여 여러 개의 클라이언트를 받을 수 있는 소켓 서버를 파이썬으로 구현해 보았습니다. 

server.py

# -*- coding: utf-8 -*-

import threading
import SocketServer
import socket
import sys


class CustomException(Exception):
    """
    Exception 클래스를 상속한 클래스를 만든다
    """
    def __init__(self, value):
        """
        생성할때 value 값을 입력 받음
        """
        self.value = value

    def __str__(self):
        """
        생성할때 받은 value 값을 확인
        """
        return self.value


def raise_exception(err_msg, ip_addr=None):
    """
    예외를 발생하는 함수
    """
    raise CustomException(err_msg)


def print_delimiter():
    print("="*20)


class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):

    def handle(self):
        """
        클라이언트와 연결될 때 호출되는 함수
        상위 클래스에는 handle() 메서드가 정의되어 있지 않기 때문에
        여기서 오버라이딩을 해야함
        """
        cur_thread = threading.current_thread()
        print("{} was started for {}"
              .format(cur_thread.getName(), self.client_address[0]))

        while True:
            try:
                self.recv_data = self.request.recv(1024).strip()

                # :/quit 를 입력하거나 데이터가 없다면 루프를 종료
                if self.recv_data == ":/quit" or not self.recv_data:
                    print_delimiter()
                    raise_exception("{} was gone".format(self.client_address[0]))

            except NameError as e:
                print "{0} got an error : {1}".format(self.client_address[0], e)
                self.request.send("Bye")
                break

            except CustomException as e:
                print e
                self.request.send("Bye")
                break

            print "{} wrote:".format(self.client_address[0]),
            print self.recv_data

            # 영어의 소문자 데이터를 receive 하면 대문자로 변환해 send
            self.request.sendall(self.recv_data.upper())

        print("{} was ended for {}"
              .format(cur_thread.getName(), self.client_address[0]))
        print_delimiter()


class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    pass


if __name__ == "__main__":
    # Port 0 means to select an arbitrary unused port
    HOST, PORT = "0.0.0.0", 3000

    # 소켓 객체 생성
    try:
        server = ThreadedTCPServer((socket.gethostbyname(HOST), PORT), ThreadedTCPRequestHandler)

    except socket.error, msg:
        print "Bind failed. Closing..."
        print "Error code: %s \nError Message: %s"\
          % (str(msg[0]), msg[1])
        sys.exit()

    print "Socket bound on {}".format(PORT)
    ip, port = server.server_address

    # Start a thread with the server -- that thread will then start one
    # more thread for each request
    server_thread = threading.Thread(target=server.serve_forever)
    # Exit the server thread when the main thread terminates
    server_thread.daemon = True
    server_thread.start()
    print "Server loop running in thread:", server_thread.name

    server.serve_forever()

    server.shutdown()
    server.server_close()

client.py

# -*- coding: utf-8 -*-

import socket
import sys

HOST, PORT = "192.168.228.128", 8080
# data = "This will be nickname"  # 실제 서비스에는 닉네임을 전송하자

try:
    # 소켓을 생성 (SOCK_STREAM 은 TCP 소켓을 의미)
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect((HOST, PORT))

except socket.error, msg:
    print "Failed to create socket. Error code: %s \nError Message: %s"\
          % (str(msg[0]), msg[1])
    sys.exit(0)
print "Socket created"

# input 값이 :/quit 일 때까지 데이터 입력 및 전송 반복
# :/quit 를 입력하면 socket 종료
while True:

    try:
        data = raw_input("Input : ")

        if data == ":/quit" or not data:
            sock.close()
            break

        try:
            # 서버에 연결하고 데이터를 전송
            sock.sendall(data + "\n")

            # 데이터를 수신하고 소켓 연결을 닫음
            received = sock.recv(1024)

        finally:
            print "Sent:     {}".format(data)
            print "Received: {}".format(received)

    except KeyboardInterrupt as e:
        print e
        data = ":/quit"

sock.close()

오래된 글이지만 join을 이해할 때 많은 도움이 되어서 링크를 올립니다.

http://blog.naver.com/tyboss/70008713640

(아래 정리한 내용은 아직 완성되지 않은 글입니다. 자료 보충도 필요합니다. 정확하게 공부하고 싶으시다면 위의 링크에서 보시거나 다른 글을 보는 것이 좋을 듯 합니다.)

JOIN이란 2개의 테이블의 데이터들을 하나의 테이블에 나타내는 것입니다.

1. FULL JOIN

각 테이블의 튜플들을 모두 매치시키는 JOIN입니다.

2. INNER JOIN

THETA JOIN에서 WHERE 문을 이용하여 조건을 제시했다면 INNER JOIN에서는 on test1.a = test2.b와 같이 조건을 지정할 수 있습니다.

3. LEFT OUTER JOIN

가장 많이 사용하는 JOIN 중 하나입니다. 

JOIN할 때의 조건이 ON test1.a = test2.b 일 때, INNER JOIN 같은 경우에는 test1과 test2 테이블에서 서로 조건에 맞는 데이터들만 조인됩니다.

하지만 LEFT OUTER JOIN을 사용하면 기본적으로 모든 test1의 데이터들이 조인 테이블에 들어가고 거기에 조건에 매치되는 test2의 데이터들이 들어갑니다.

이 때 test2가 매치되는 데이터가 없다면 NULL로 표시됩니다.

JOIN문을 사용할 때 OUTER는 옵션이므로 명시하지 않아도 된다고 합니다.

4. RIGHT OUTER JOIN

LEFT OUTER JOIN의 반대라고 생각하시면 됩니다.

test2의 모든 데이터가 JOIN됩니다.

5. SELF JOIN

참고

http://rapapa.net/?p=311

이번에는 클라이언트가 특정 단어를 입력하기 전까지 계속해서 데이터를 보낼 수 있는 코드를 짜보았습니다.

server.py

# -*- coding: utf-8 -*-

import SocketServer


def quit_server(client_addr):
    print("{} was gone".format(client_addr))


class MyTCPHandler(SocketServer.BaseRequestHandler):
    """
    The request handler class for our server.

    It is instantiated once per connection to the server, and must
    override the handle() method to implement communication to the
    client.
    """

    def handle(self):
        """
        클라이언트와 연결될 때 호출되는 함수
        상위 클래스에는 handle() 메서드가 정의되어 있지 않기 때문에
        여기서 오버라이딩을 해야함
        """
        self.recv_data = ''

        while True:
            try:
                self.recv_data = self.request.recv(1024).strip()

                # :/quit 를 입력하면 루프를 종료
                if self.recv_data == ":/quit":
                    quit_server(self.client_address[0])
                    break

            except NameError as e:
                print "{0} got an error : {1}".format(self.client_address[0], e)

            finally:
                print "{} wrote:".format(self.client_address[0]),
                print self.recv_data

                # 영어의 소문자 데이터를 receive 하면 대문자로 변환해 send
                self.request.sendall(self.recv_data.upper())


if __name__ == "__main__":
    HOST, PORT = "localhost", 3000

    # 서버를 생성합니다. 호스트는 localhost, 포트 번호는 3000
    server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)

    print("waiting for connection...")

    # Ctrl - C 로 종료하기 전까지는 서버는 멈추지 않고 작동
    server.serve_forever()

clinet.py

# -*- coding: utf-8 -*-

import socket

HOST, PORT = "localhost", 3000
# data = "This will be nickname"  # 실제 서비스에는 닉네임을 전송하자
data = ''

# 소켓을 생성 (SOCK_STREAM 은 TCP 소켓을 의미)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((HOST, PORT))

# input 값이 :/quit 일 때까지 데이터 입력 및 전송 반복
# :/quit 를 입력하면 socket 종료
while data != ":/quit":
    data = raw_input("Input : ")
    try:
        # 서버에 연결하고 데이터를 전송
        sock.sendall(data + "\n")

        # 데이터를 수신하고 소켓 연결을 닫음
        received = sock.recv(1024)
    finally:
        print "Sent:     {}".format(data)
        print "Received: {}".format(received)

sock.close()

다음에는 멀티쓰레드를 이용하여 한 서버에 여러 클라이언트가 접속할 수 있도록 하는 코드를 올리겠습니다.

파이썬의 SocketServer 모듈은 네트워크 서버의 작성 작업을 간단하게 해줍니다.

(파이썬 3.x 버전에서는 socketserver로 사용할 수 있습니다.)

server.py

# -*- coding: utf-8 -*-

import SocketServer


class MyTCPHandler(SocketServer.BaseRequestHandler):
    """
    The request handler class for our server.

    It is instantiated once per connection to the server, and must
    override the handle() method to implement communication to the
    client.
    """

    def handle(self):
        """
        클라이언트와 연결될 때 호출되는 함수
        상위 클래스에는 handle() 메서드가 정의되어 있지 않기 때문에
        여기서 오버라이딩을 해야함
        """
        self.data = self.request.recv(1024).strip()
        print "{} wrote:".format(self.client_address[0]),
        print self.data
        # 영어의 소문자 데이터를 receive 하면 대문자로 변환해 send
        self.request.sendall(self.data.upper())

if __name__ == "__main__":
    HOST, PORT = "localhost", 3000

    # 서버를 생성합니다. 호스트는 localhost, 포트 번호는 3000
    server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)

    print("waiting for connection...")

    # Ctrl - C 로 종료하기 전까지는 서버는 멈추지 않고 작동
    server.serve_forever()

clinet.py

# -*- coding: utf-8 -*-

import socket
import sys

HOST, PORT = "localhost", 3000
data = " ".join(sys.argv[1:])

# 소켓을 생성 (SOCK_STREAM 은 TCP 소켓을 의미)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

try:
    # 서버에 연결하고 데이터를 전송
    sock.connect((HOST, PORT))
    sock.sendall(data + "\n")

    # 데이터를 수신하고 소켓 연결을 닫음
    received = sock.recv(1024)
finally:
    sock.close()

print "Sent:     {}".format(data)
print "Received: {}".format(received)

[Errno 10048] 에러는 이미 해당 포트가 사용 중이기 때문에 에러가 발생하는 것입니다. 사용 중인 포트 번호를 바꾸거나 사용 중인 프로세스를 중지해서 해결할 수 있습니다.

출처

https://docs.python.org/2.7/library/socketserver.html#socketserver-tcpserver-example

df : 남은 디스크의 용량을 확인

-h 단위를 사용하여 보여줌(KB, MB, GB 등)

du : 현재 디렉터리에서 사용중인 용량 확인

-h 단위를 사용하여 보여줌(KB, MB, GB 등)

# -*- coding: utf-8 -*-

li = map(int, raw_input().split(' '))

여러 개의 정수를 문자열로 받아서 공백 단위로 끊은 후에 int형으로 변환시킵니다. 

리스트 자료형에 저장할 수도 있고 a, b = ~~ 처럼 할 수도 있습니다. 다만 변수의 개수가 일치해야겠지만 말입니다.

이전에 트랜잭션과 회복 기법에 대해 조사해봤었는데 이제와서 다시보니 헷갈려서 회복에 대해 다시 정리하기로 하였습니다.

1. 즉시 갱신 회복 기법

  이 기법을 사용하면 트랜잭션 도중 데이터가 변경되면 그 내용을 DB에 즉시 반영하고 로그에 기록합니다. 트랜잭션 완료(Commit) 이전에 수행한 갱신 연산을 미완료 갱신(Uncommitted Update)라고 합니다.

  만약 트랜잭션 수행 도중 에러가 발생하면 로그에 있는 내용을 기반으로 UNDO 합니다. 

  따라서 회복을 진행하고 나면 DB는 해당 트랜잭션이 실행되기 이전으로 돌아갑니다. 이 때 로그를 참조하여 이전 상태로 돌아가는 것을 UNDO라고 합니다.

  만약 트랜잭션에서 오류가 발생하기 이전에 이미 COMMIT 된 다른 트랜잭션이 있다면 그 트랜잭션을 REDO 합니다. (이유는?) 

  그리고 트랜잭션을 다시 실행하여 DB를 변경하는데 이를 REDO 라고 합니다.

2. 지연 갱신 회복 기법

  트랜잭션이 부분 완료 상태가 되기 전까지 모든 변경 내용을 로그에만 저장합니다. 데이터베이스에는 COMMIT 할 때 반영을 합니다. 

  이 때 부분 완료란 데이터베이스가 COMMIT 되기 직전의 상태 즉, 트랜잭션에서 모든 데이터의 변경이 끝난 이후를 말합니다.

  트랜잭션 도중 에러가 발생했을 때 로그 파일을 무시한다.  COMMIT 이전이므로 DB는 트랜잭션을 실행하기 이전 상태와 같습니다.

  즉시 갱신 회복 기법에서는 UNDO를 통해 데이터베이스를 복구했어야 했던 반면에 지연 갱신 회복 기법은 UNDO가 필요없습니다.

  그리고 트랜잭션을 다시 실행하는 REDO를 합니다.

라고 알고 있었는데 아무래도 부정확한 부분들이 몇몇 있는 것 같습니다. 먼저, 지연 갱신 회복 기법과 즉시 갱신 회복 기법의 COMMIT 시점은 상황에 따라 달라집니다.

기법은 말 그대로 기법입니다. 즉, 이것들은 코드로 구현되어야 비로소 의미가 있는 것입니다. 때문에 정책 또는 개발자에 따라 COMMIT 시점이 변경되는 것입니다.

Checkcpoint는 redo를 할 때 모든 트랜잭션을 하면 효율이 떨어지기 때문에 사용합니다. 그리고 트랜잭션이 진행 중이더라도 그 시점까지 변경된 데이터를 강제로 DB에 반영합니다. 

그리고 Check Point 회복기법을 지연 갱신 회복 기법과 함께 사용합니다. 

===================================

선생님께서 즉시 갱신, 지연 갱신에 대해 다음에 다시 가르쳐주신다고 한다.

즉시 갱신, 지연 갱신 기법은 말 그대로 기법이다. 즉, 코드로 구현하는 것.

즉시 갱신은 checkpoint처럼 DB에 즉시 반영됨(확실 X)

일단 코드를 직접 봐야할 듯

지연 갱신은 보통 백그라운드에서 트리거를 통해 commit

checkpoint란, 사용하는 이유(redo할 때 효율 때문에)

checkpoint는 트랜잭션이 진행 중이더라도 그 때까지의 변경된 데이터를 바로 DB에 반영(강제출력과 비슷)

===================================

http://altibase.com/product/in-memory-database/

http://www.mcobject.com/in_memory_database

https://en.wikibooks.org/wiki/Design_of_Main_Memory_Database_System/Overview_of_DBMS

지난 11월 22일부터 25일, 4일 동안 대전정보문화산업진흥원에서 진행하는 <SW테스트 전문가 양성교육 및 ISTQB 자격검증교육>에 참석하였습니다.

4일 동안 교육을 받고 마지막 날인 11월 25일에 ISTQB FL(Foundation Level) 시험에 응시하였습니다.

학교 수업을 빠지고 교육을 받았던만큼 배운 내용을 헛되이 날릴 수 없다고 생각합니다.

그래서 블로그에 배웠던 내용을 요약해서 가끔 올리려고 합니다.

중첩함수(nested function)

함수 안에 함수를 정의한 것을 말합니다.

중첩함수를 통해 default로 enclosing function local scope 변수를 참조할 수 있습니다.

내부 함수와 외부 함수

# -*- coding: utf-8 -*-


def outer_func(msg):

    def inner_func():
        print msg

    return inner_func

inner_func을 내부함수, outer_func를 외부함수라고 합니다.

inner_func 입장에서 outer_func 함수의 지역변수 영역을 enclosing function local scope(바깥 함수 지역 변수 영역) 라고 부릅니다.

클로저(closure)란

# -*- coding: utf-8 -*-


def outer_func(msg):

    def inner_func():
        print msg

    return inner_func

my_func = outer_func("Megumin is so cute!!")
my_func()

Megumin is so cute!!

내부함수가 외부함수의 맥락(context)에 접근할 수 있는 것을 가리킵니다.

inner_func가 outer_func의 지역변수인 msg를 참조하여 출력하는 것을 볼 수 있습니다.

함수를 변수에 저장할 수 있는 이유는 파이썬에서는 함수가 일급 객체(first-class object)이기 때문입니다.

# -*- coding: utf-8 -*-


def outer_func(msg):

    def inner_func():
        print msg

    return inner_func

first_func = outer_func("Megumin is so cute!!")
first_func()

second_func = outer_func("It's true")
second_func()

print
print "outer_func : ", id(outer_func), "\n"
del outer_func

first_func()
second_func()

print
print "first_func : ", id(first_func)
print "second_func : ", id(second_func)

Megumin is so cute!!
It's true

outer_func :  37766872 

Megumin is so cute!!
It's true

first_func :  37766984
second_func :  37767096

outer_func을 삭제해도 first_func가 정상적으로 호출됨을 알 수 있습니다.

이는 함수를 변수에 저장할 때마다 객체를 새롭게 생성하기 때문입니다.

(outer_func, first_func, second_func 모두 id 값이 다릅니다)

즉, first_func와 second_func는 서로 완전히 독립된 객체인 것입니다.

클로저 내에서 enclosing function local scope 변수 Read/Write

클로저에서 enclosing function local scope 변수에 접근할 수 있다면 modify 하는 것도 가능하지 않을까라고 생각할 수 있습니다. 

하지만 그것은 다음과 같은 오류를 보여줄 뿐입니다. 

# -*- coding: utf-8 -*-


def outer_func(msg):

    def inner_func():
        print msg
        msg = "Awesome!!"
        print msg

    return inner_func

first_func = outer_func("Megumin is so cute!!")
first_func()

UnboundLocalError: local variable 'msg' referenced before assignment

첫 번째 print문에서 inner_func 함수 내에서 msg라는 변수는 선언된 적이 없기 때문에 enclosing function local scope에서 찾게 됩니다. 하지만 이 변수는 전역 변수와 마찬가지로 함수 내에서 수정할 수 없습니다. (파이썬 네임스페이스 참고)

그래서 python 3.x 부터는 nonlocal 이라는 키워드를 통해 외부함수 영역의 변수를 modify할 수 있도록 합니다.(nonlocal은 global과 비슷한 개념이라 할 수 있습니다)

python 3.x

# -*- coding: utf-8 -*-

def outer_func(msg):

    def inner_func():
        print(msg)
        nonlocal msg
        msg = "Awesome!!"
        print(msg)

    return inner_func

first_func = outer_func("Megumin is so cute!!")
first_func()

Megumin is so cute!!
Awesome!!

다만, 별로 추천하지는 않다고 합니다.(보충 필요)

대신, python 2.x 에서는 내부 함수의 local variable에 enclosing scope의 변수를 저장하여 사용할 수 있습니다.

# -*- coding: utf-8 -*-


def outer_func(msg):

    def inner_func():
        _msg = msg
        print _msg
        _msg = "Awesome!!"
        print _msg

    return inner_func

first_func = outer_func("Megumin is so cute!!")
first_func()

Megumin is so cute!!
Awesome!!

또는 함수 속성에 변수를 대입해도 가능합니다.

# -*- coding: utf-8 -*-


def outer_func(msg):

    def inner_func():
        inner_func.msg = msg
        print inner_func.msg
        inner_func.msg = "Awesome!!"
        print inner_func.msg

    return inner_func

first_func = outer_func("Megumin is so cute!!")
first_func()

Megumin is so cute!!
Awesome!!

왜 사용할까

● 전역 변수의 사용을 피할 수 있음

● private 속성이 없는 파이썬에서 내부 데이터의 은닉을 할 수 있음

● 하나의 함수로 여러 가지의 함수를 간단히 만들어 낼 수 있도록 해줌

● 기존에 만들어진 함수나 모듈 등을 수정하지 않고도 wrapper 함수를 이용해 커스터마이징할 수 있게 해줌

(상세 설명 보충 필요)

요약

● 클로저란 내부 함수 영역에서 외부 함수 영역의 변수에 접근하는 것을 말함

● 파이썬에서 클로저가 구현 가능한 이유는 함수를 일급 객체로 취급하기 때문

● 클로저 내에서 외부 함수 영역 변수를 수정하기 위해서는 별도의 방법이 필요함

● 데이터 은닉 등의 목적을 위해 사용함

참고

[중첩함수]

https://www.programiz.com/python-programming/closure

[내부 함수와 외부 함수]

http://blog.naver.com/msyang59/220773717531

[클로저란]

https://slipp.net/questions/249

https://opentutorials.org/course/743/6544

http://jonnung.blogspot.kr/2014/09/python-easy-closure.html

[왜 사용할까]

http://schoolofweb.net/blog/posts/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%ED%81%B4%EB%A1%9C%EC%A0%80-closure/