one Book a Day

[Git][Error] LF will be replaced by CRLF in 해결

findTheValue — Sun, 2 Oct 2022 18:22:25 +0900

git add .

git add 시

warning: LF will be replaced by CRLF in 파일명

에러가 뜰 수 있다.

이는 OS마다 줄바꿈을 바라보는 문자열이 다르기 때문에 Git 이 볼때 어떤 방식을 선택할지 몰라 경고를 내린 것

LF : Mac, Linux(Unix) 줄바꿈 문자열 = \n : 다음 줄 같은위치
CR : Mac 초기 줄바꿈 문자열 = \r : 같은 줄 맨앞
CRLF : Window, DOX 줄바꿈 문자열 = \r\n : 다음줄 맨앞

해결방법은 autoarlf를 사용해 바꿔주면 된다.

윈도우 즉 LF -> CRLF는

git config --global core.autocrlf true

Linux, Mac 즉 CRLF -> LF는

git config --global core.autocrlf input

로 해당 설정을 바꿔주면 된다.

[Git] Git Rebase로 Conflict 해결

findTheValue — Sun, 2 Oct 2022 18:14:42 +0900

협업을 진행하다보면 conflct가 당연히 발생합니다.

PR을 밀어 넣었을 때 기존 코드와 내 코드가 비교되는 과정에서 다른 코드가 원본에 Merge되면 비교과정이 올바르지 않게 되기 때문에 conflict가 발생하는데 이는 3-way-merge 방법 또는 rebase를 이용해 해결이 가능하다.

3-way-merge : base + 내 branch + upstrem의 최신버전
rebase : 내 branch + rebase 한 내용

rebase는 말 그대로 re + base로 내가 머지하려는 브랜치가 갈라져 나온 branch의 base를 바꾸겠다는 것이다.

이 과정을 통해 내 코드는 새로이 만들어진 base와 코드 대사과정을 하게되므로 Merge하는데 문제가 없게된다.

원리는 내 branch가 지속적으로 기록한 commit에 대한 diff를 기존의 base가 아닌 새로이 rebase하고 싶은 브랜치와 비교하게되고 rebse는 기존에 존재하는 commit이 아닌 새로운 commit(new commit hash)을 만들어 base 브랜치에 붙이게 됩니다.

주의할 점은 develop - branch A - branch B 의 분기에서 branch A에 rebase를 하게되면 branch B에서 더 큰 conflict가 일어날 수 있습니다.

내 PR에 해당 메세지가 뜨며 Merge 버튼이 막힌다면 다음과 같은 순서를 따릅니다.

git fetch upstream/develop

git rebase develop

git rebase upstream/develop

develop은 base branch입니다.

git status

를 통해 문제가 있는 파일을 찾은 후 conflict를 직접 해결해줍니다.

직접 코드를 수정해도 되고 vscode는 해당 지점을 스크롤부분에 표시해주고 해결도구도 제시해줍니다.

코드 수정 후에는 git add, git rebase --continue를 통해 지속적으로 발생하는 conflict를 해결해줍니다.

(rebase는 아까 말했다시피 commit이므로 추가 commit이 필요하지 x)

이후

git push origin HEAD --force-with-lease

를 통해 강제로 밀어넣으면 conflict가 해결된다.

--force-with-lease

는 작업 도중 새로운 commit 이 있어 기대한 값과 다르면 force push를 막는다.

[Java] Java의 main() 메서드

findTheValue — Thu, 28 Jul 2022 17:14:16 +0900

자바의 main() 메서드

Java 프로그램은 특정 순서로 실행되는 Java 명령의 시퀀스기 때문에 시작과 끝이 있다.

Java 프로그램을 실행하려면 JVM에 프로그램 실행을 시작할 위치를 신호해야한다.
Java의 모든 명령어(코드)는 Java 클래스 내에 위치해야한다.
클래스는 함께 속한 데이터와 명령어를 그룹화하는 방법이다. 따라서 클래스는 변수와 메서드를 모두 포함 할 수 있다. 변수는 데이터를 포함할 수 있으며, 메서드는 데이터에 대한 작업 집합(명령어)을 함께 그룹화한다.

자바 클래스 선언

Java 코드는 클래스와 동일한 파일 이름을 가진 파일에 있어야하며 파일 접미사로 끝나야한다.
즉 파일이 클래스 이름과 일치하는 파일에 있어야 Java SDK의 Java 컴파일러 또는 Java IDE 내부에서 컴파일 할 수 있다.

Java 패키지는 단순히 하나 이상의 Java 파일을 포함할 수 있는 파일 시스템의 디렉토리다. 디렉토리가 정상적으로 할 수있는 것처럼 패키지를 중첩 할 수 있다. 예를 들어, 이름을 가진 하드 드라이브의 디렉토리에 해당하는 패키지를 만들 수 있다.

package myjavacode;

public class MyClass {

}

Java 파일이 올바른 디렉토리에 있거나 Java 파일 안에 패키지 선언을 하는 것만으로는 충분하지 않다. 두 요구 사항을 모두 충족해야 한다. `MyClass.javamyjavacodepackage myjavacode;`

main()

Java 프로그램은 어딘가에서 실행을 시작해야한다.
Java 프로그램은 일부 클래스의 main 메소드를 실행하여 시작한다. 실행할 클래스의 이름은 선택할 수 있지만 main 메서드 이름은 선택할 수 없다. main 메서드는 항상 호출되어야 한다.

package myjavacode;

public class MyClass {

    public static void main(String[] args) {

    }
}

main 메소드 선언에는 세 가지 키워드가 필요하다. public static void main()

세 개의 키워드 뒤에 메서드 이름이 있다. 요약하자면, 메소드는 단일 작업인 것처럼 실행될 수 있는 명령어 세트다. 메서드를 "호출"(실행)하면 해당 메서드 내의 모든 명령이 실행된다.

다음에 매개 변수 목록이 나타난다. 매개 변수는 변수 (데이터 / 값)로, 메서드의 명령을 사용해 동작을 사용자 정의하는 데 사용할 수있는 메서드에 전달할 수 있다. 메서드는 항상 객체 배열을 가져와야한다.

String[] stringArray

매개 변수를 제공하는 이름은 중요하지 않다. 이름은 자유롭게 선택할 수 있다. `main()StringargsstringArray`

메서드의 매개 변수 목록 다음 왼쪽 중괄호 {가 나오면 빈 공백이 있고 오른쪽 중괄호 }가 나타난다. 중괄호 안에는 메소드가 실행될 때 실행될 Java 명령어가 있다. (=메서드 본문)

메서드 본문에 단일 명령을 삽입해보면

package myjavacode;

public class MyClass {

  public static void main(String[] args) {
    System.out.println("Hello World, Java app");
  }
}

System.out.println("Hello World, Java Program");

이 명령은 텍스트를 *콘솔*에 인쇄한다. 명령 줄에서 Java 프로그램을 실행하면 명령 줄 콘솔 (컴퓨터에 대한 텍스트 인터페이스)에 출력이 표시된다. IDE 내부에서 Java 프로그램을 실행하면 IDE는 일반적으로 콘솔에 대한 모든 출력을 포착하여 IDE 내부의 어딘가에서 볼 수 있다.

main() 실행

Java 프로그램을 시작할 때 일반적으로 명령 줄 (콘솔)을 통해 한다. JRE와 함께 제공되는 명령을 호출하고 실행할 Java 클래스와 메소드에 전달할 인수를 알려준다. 그 후 Java 프로그램은 JVM 내에서 실행된다.

![java 명령을 실행하는 명령행으로, Java 기본 프로그램을 실행합니다.](https://jenkov.com/images/java/main-program.png)

**java 명령을 실행하는 명령행으로, Java 기본 프로그램을 실행한다.**

java -cp classes myjavacode.MyClass

이 명령의 첫 번째 명령은 JVM을 시작한다. 경우에 따라 명령이 컴퓨터에 있는 전체 경로(일반적으로 Java 설치 dir의 하위 디렉토리 내부)를 지정해야 할 수도 있다.

두 번째 및 세 번째 인수는 컴파일 된 Java 클래스가 위치한 디렉토리의 JVM에 알려준다. (cp는 클래스 경로를 의미). 이 경우 컴파일된 Java 클래스는 myjavacode라는 디렉토리에 있습니다.

네 번째 인수는 JVM이 실행할 Java 클래스의 이름입니다. 클래스 이름에 있는 패키지 이름("정규화된 클래스 이름")도 어떻게 포함되는지 확인한다.

main() 메서드에 인수 전달

명령줄에서 메서드로 인수를 전달할 수 있다.

java -cp classes myjavacode.MyClass Hello World

JVM이 메소드를 실행할 때 매개 변수로 전달 된 배열에는 "Hello"와 "World"라는 두 개의 문자열이 포함된다.

package myjavacode;

public class MyClass {

    public static void main(String[] args) {
        System.out.println( args[0] );
        System.out.println( args[1] );
    }
}

자바 메인 클래스

Java 프로그램의 단일 Java 클래스에만 main이 포함되어 있는 경우, 메소드를 포함하는 클래스를 종종 *메인 클래스*라고 한다. JVM은 한 번에 하나만 실행하도록 지시 할 수 있다. JVM이 실행하는 메서드 내부에서 다른 메소드를 호출 할 수 있으며 각각 단일 메소드를 실행하는 여러 가상 머신을 시작할 수도 있다. (중첩)

[MarkDown] 특수문자를 특수문자로 입력하기

findTheValue — Mon, 25 Jul 2022 16:21:35 +0900

Symbol 뒤에 HTML Number를 붙혀주면 특수문자를 입력할 수 있다.

Symbol	HTML Number	HTML Name	Description
!	!		exclamation point
"	"	&quot\;	double quotes
#	#		number sign
$	$		dollar sign
%	%		percent sign
&	&	&amp\;	ampersand
'	'		single quote
(	(		opening parenthesis
)	)		closing parenthesis
*	*		asterisk
+	+		plus sign
,	,		comma
-	-		minus sign - hyphen
.	.		period
/	/		slash
:	:		colon
;	;		semicolon
<	<	<	less than sign
=	=		equal sign
>	>	>	greater than sign
?	?		question mark
@	@		at symbol
[	[		opening bracket
\	\		back slash
]	]		closing bracket
^	^		caret - circumflex
_	_		underscore
`	`		grave accent
{	{		opening brace
\|	\|		vertical bar - pipe
}	}		closing brace
~	~		equivalency sign - tilde
–	–		en dash

출처: https://4urdev.tistory.com/62 [Simplify:티스토리]

[Java] 정규표현식

findTheValue — Mon, 25 Jul 2022 16:18:58 +0900

Regular Expression

컴퓨터 과학의 정규 언어로 부터 유래
특정한 규칙을 가진 문자열의 집합을 표현, 형식언어
정해진 형식을 사용자가 제대로 입력했는지 검증
즉 입력값이 형식에 맞는지 검증할 때 자주 사용함.
java.util.regex 패키지 안의 Pattern Class와 Matcher Class 사용

문법

^	문자열 시작
$	문자열 종료
.	임의의 한 문자(단 \은 넣을 수 없음). (SQL Like에서 _)
*	앞 문자가 없을 수도 무한정 많을 수도 있음 (SQL Like에서 %)
+	앞 문자가 하나 이상
?	앞 문자가 없거나 하나 있음
[ ]	문자의 집합이나 범위를 나타내며 두 문자 사이는 - 기호로 범위를 나타냅니다. [] 내에서 ^ 가 선행하여 존재하면 not을 나타냄
{ }	횟수 또는 범위 ({2}는 2번, {2, 3}은 2~3번)
( )	소괄호 안의 문자를 하나의 문자로 인식
\\|	패턴 안에서 or 연산을 수행할 때 사용
\	정규 표현식 역슬래시(\)는 확장문자 (역슬래시 다음에 일반 문자가 오면 특수문자로 취급하고 역슬래시 다음에 특수문자가 오면 그 문자 자체를 의미)
\b	단어의 경계
\B	단어가 아닌것에 대한 경계
\A	입력의 시작 부분
\G	이전 매치의 끝
\Z	입력의 끝이지만 종결자가 있는 경우
\z	입력의 끝
\s	공백 문자
\S	공백 문자가 아닌 나머지 문자
\w	알파벳이나 숫자
\W	알파벳이나 숫자를 제외한 문자
\d	숫자 [0-9]와 동일
\D	숫자를 제외한 모든 문자[^0-9]
(?i)	앞 부분에 (?!)라는 옵션을 넣어주게 되면 대소문자는 구분하지 않음

Pattern 클래스의 matches

import java.util.regex.Pattern;

public class Example {
	public static void main(String[] args)  {
    
            String pattern = "^[0-9]*$"; //정규식
            String val = "123456789"; //검증대상문자열
        
            boolean regex = Pattern.matches(pattern, val);
            System.out.println(regex);
    }
}

Pattern 클래스 주요 메서드

compile(String regex) : 주어진 정규표현식으로부터 패턴을 만듭니다.

matcher(CharSequence input) : 대상 문자열이 패턴과 일치할 경우 true를 반환합니다.

asPredicate() : 문자열을 일치시키는 데 사용할 수있는 술어를 작성합니다.

pattern() : 컴파일된 정규표현식을 String 형태로 반환합니다.

split(CharSequence input) : 문자열을 주어진 인자값

CharSequence 패턴에 따라 분리합니다

.

Parttern 플래그 값 사용(상수)

Pattern.CANON_EQ : None표준화된 매칭 모드를 활성화합니다.

Pattern.CASE_INSENSITIVE : 대소문자를 구분하지 않습니다.

Pattern.COMMENTS : 공백과 #으로 시작하는 주석이 무시됩니다. (라인의 끝까지).

Pattern.MULTILINE : 수식 ‘^’ 는 라인의 시작과, ‘$’ 는 라인의 끝과 match 됩니다.

Pattern.DOTALL : 수식 ‘.’과 모든 문자와 match 되고 ‘\n’ 도 match 에 포함됩니다.

Pattern.UNICODE_CASE : 유니코드를 기준으로 대소문자 구분 없이 match 시킵니다.

Pattert.UNIX_LINES : 수식 ‘.’ 과 ‘^’ 및 ‘$’의 match시에 한 라인의 끝을 의미하는 ‘\n’만 인식됩니다.

Matcher의 find()

대상 문자열 패턴 해석, 주어진 패턴과 일치 판별
CharSequence 인터페이스를 입력값으로 받아 다양한 문자 단위 매칭이 가능

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Example {
	public static void main(String[] args)  {
            Pattern pattern = Pattern.compile("^[a-zA-Z]*$"); //영문자만
            String val = "abcdef"; //대상문자열
	
            Matcher matcher = pattern.matcher(val);
            System.out.println(matcher.find());
	}
}

Matcher 클래스 주요 메서드

matches() : 대상 문자열과 패턴이 일치할 경우 true 반환합니다.

find() : 대상 문자열과 패턴이 일치하는 경우 true를 반환하고, 그 위치로 이동합니다.

find(int start) : start위치 이후부터 매칭검색을 수행합니다.

start() : 매칭되는 문자열 시작위치 반환합니다.

start(int group) : 지정된 그룹이 매칭되는 시작위치 반환합니다.

end() : 매칭되는 문자열 끝 다음 문자위치 반환합니다.

end(int group) : 지정되 그룹이 매칭되는 끝 다음 문자위치 반환합니다.

group() : 매칭된 부분을 반환합니다.

group(int group) : 매칭된 부분중 group번 그룹핑 매칭부분 반환합니다.

groupCount() : 패턴내 그룹핑한(괄호지정) 전체 갯수를 반환합니다.

자주 사용하는 표현

^[0-9]*$ 								// 숫자
^[a-zA-Z]*$ 							// 영문자
^[가-힣]*$	 			  			   // 한글
\\w+@\\w+\\.\\w+(\\.\\w+)? 				// 이메일
^\d{2,3}-\d{3,4}-\d{4}$					// 전화번호
^01(?:0|1|[6-9])-(?:\d{3}|\d{4})-\d{4}$ // 휴대전화번호
\d{6} \- [1-4]\d{6}						// 주민등록번호
^\d{3}-\d{2}$							// 우편번호

Reference

[Java] 자바 거듭 제곱 구하기 Math.pow() (tistory.com)

[자료구조] 파이썬으로 LRU cache O(1) 구현하기

findTheValue — Mon, 25 Jul 2022 14:09:38 +0900

LRU cache O(1)

캐시는 불필요한 통신을 줄이고 기민한 UX를 제공
DB과부하를 막음.(query결과 저장)
Proxy, CDN(유저와 가까운 CDN node)
메모이제이션

OrderedDict이용

from collections import OrderedDict

MAX_SIZE = 2
cache = OrderedDict()

def get_user(user_id):
    if user_id in cache:
        cache.move_to_end(user_id) 
        return cache[user_id]

    if len(cache) == MAX_SIZE:
        cache.popitem(last=False) 

    cache[user_id] = fetch_user(user_id)
    return cache[user_id]

last=False는 맨앞.

from collections import OrderedDict
 
class LRUCache:
 
    def __init__(self, capacity: int):
        self.cache = OrderedDict()
        self.capacity = capacity
 

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        else:
            self.cache.move_to_end(key)
            return self.cache[key]
 

    def put(self, key: int, value: int) -> None:
        self.cache[key] = value
        self.cache.move_to_end(key)
        if len(self.cache) > self.capacity:
            self.cache.popitem(last = False)
 
cache = LRUCache(2)

move_to_end

def move_to_end(self, key, last=True):
    '''Move an existing element to the end (or beginning if last is false).
    Raise KeyError if the element does not exist.
    '''
    link = self.__map[key]
    link_prev = link.prev
    link_next = link.next
    soft_link = link_next.prev
    link_prev.next = link_next
    link_next.prev = link_prev
    root = self.__root
    if last:
        last = root.prev
        link.prev = last
        link.next = root
        root.prev = soft_link
        last.next = link
    else:
        first = root.next
        link.prev = root
        link.next = first
        first.prev = soft_link
        root.next = link

functools 모듈 cache 데코레이터(3.9추가)

from functools import cache

def fetch_user(user_id):
    print(f"DB에서 아이디가 {user_id}인 사용자 정보를 읽어오고 있습니다...")
    return {
        "userId": user_id,
        "email": f"{user_id}@test.com",
        "password": "test1234"
    }

@cache
def get_user(user_id):
    return fetch_user(user_id)

if __name__ == "__main__":
    from random import choice

    for i in range(10):
        get_user(user_id = choice(["A01", "B02", "C03"]))
        
10번 호출해도 3번만 갔다옴.

동일모듈 lru_cache 데코레이터

from functools import lru_cache

def fetch_user(user_id):
    print(f"DB에서 아이디가 {user_id}인 사용자 정보를 읽어오고 있습니다...")
    return {
        "userId": user_id,
        "email": f"{user_id}@test.com",
        "password": "test1234"
    }

@lru_cache
def get_user(user_id):
    return fetch_user(user_id)

if __name__ == "__main__":
    from random import choice

    for i in range(10):
        get_user(user_id = choice(["A01", "B02", "C03"]))
    print(get_user.cache_info())

출력 결과

DB에서 아이디가 B02인 사용자 정보를 읽어오고 있습니다...
DB에서 아이디가 A01인 사용자 정보를 읽어오고 있습니다...
DB에서 아이디가 C03인 사용자 정보를 읽어오고 있습니다...
CacheInfo(hits=7, misses=3, maxsize=128, currsize=3)

@lru_cache(maxsize=2)

이런식으로 캐시 크기 제어 가능

OrderedDict x

class Node(object):
    __slots__ = ['prev', 'next', 'me']
    def __init__(self, prev, me):
        self.prev = prev
        self.me = me
        self.next = None

class LRU:
    """
    Implementation of a length-limited O(1) LRU queue.
    Built for and used by PyPE:
    http://pype.sourceforge.net
    Copyright 2003 Josiah Carlson.
    """
    def __init__(self, count, pairs=[]):
        self.count = max(count, 1)
        self.d = {}
        self.first = None
        self.last = None
        for key, value in pairs:
            self[key] = value
    def __contains__(self, obj):
        return obj in self.d
    def __getitem__(self, obj):
        a = self.d[obj].me
        self[a[0]] = a[1]
        return a[1]
    def __setitem__(self, obj, val):
        if obj in self.d:
            del self[obj]
        nobj = Node(self.last, (obj, val))
        if self.first is None:
            self.first = nobj
        if self.last:
            self.last.next = nobj
        self.last = nobj
        self.d[obj] = nobj
        if len(self.d) > self.count:
            if self.first == self.last:
                self.first = None
                self.last = None
                return
            a = self.first
            a.next.prev = None
            self.first = a.next
            a.next = None
            del self.d[a.me[0]]
            del a
    def __delitem__(self, obj):
        nobj = self.d[obj]
        if nobj.prev:
            nobj.prev.next = nobj.next
        else:
            self.first = nobj.next
        if nobj.next:
            nobj.next.prev = nobj.prev
        else:
            self.last = nobj.prev
        del self.d[obj]
    def __iter__(self):
        cur = self.first
        while cur != None:
            cur2 = cur.next
            yield cur.me[1]
            cur = cur2
    def iteritems(self):
        cur = self.first
        while cur != None:
            cur2 = cur.next
            yield cur.me
            cur = cur2
    def iterkeys(self):
        return iter(self.d)
    def itervalues(self):
        for i,j in self.iteritems():
            yield j
    def keys(self):
        return self.d.keys()

java

public class LRUCacheImpl {

	private class ListNode {
		private int key;
		private int val;
		private ListNode prev;
		private ListNode next;

		public ListNode(int key, int val) {
			this.key = key;
			this.val = val;
			this.prev = null;
			this.next = null;
		}
	}

	private Map<Integer, ListNode> nodeMap;
	private int capacity;
	private ListNode head;
	private ListNode tail;

	public LRUCacheImpl(int capacity) {
		this.nodeMap = new HashMap<>();
		this.capacity = capacity;
		head = new ListNode(0, 0);
		tail = new ListNode(0, 0);
		head.next = tail;
		tail.prev = head;
	}

	private void remove(ListNode node) {
		node.prev.next = node.next;
		node.next.prev = node.prev;
		nodeMap.remove(node.key);
	}

	private void insertToHead(ListNode node) {
		this.head.next.prev = node;
		node.next = this.head.next;
		node.prev = this.head;
		this.head.next = node;
		nodeMap.put(node.key, node);
	}

	public int get(int key) {
		if (!nodeMap.containsKey(key)) {
			return -1;
		}
		ListNode node = nodeMap.get(key);
		remove(node);
		insertToHead(node);
		return node.val;
	}

	public void put(int key, int value) {
		ListNode newNode = new ListNode(key, value);
		if (nodeMap.containsKey(key)) {
			ListNode oldNode = nodeMap.get(key);
			remove(oldNode);
		} else {
			if (nodeMap.size() >= capacity) {
				ListNode tailNode = tail.prev;
				remove(tailNode);
			}
		}
		insertToHead(newNode);
	}
}

OrderedDick

# Located in Lib/collections/__init__.py

################################################################################
### OrderedDict
################################################################################

class _OrderedDictKeysView(KeysView):

    def __reversed__(self):
        yield from reversed(self._mapping)

class _OrderedDictItemsView(ItemsView):

    def __reversed__(self):
        for key in reversed(self._mapping):
            yield (key, self._mapping[key])

class _OrderedDictValuesView(ValuesView):

    def __reversed__(self):
        for key in reversed(self._mapping):
            yield self._mapping[key]

class _Link(object):
    __slots__ = 'prev', 'next', 'key', '__weakref__'

class OrderedDict(dict):
    'Dictionary that remembers insertion order'
    # An inherited dict maps keys to values.
    # The inherited dict provides __getitem__, __len__, __contains__, and get.
    # The remaining methods are order-aware.
    # Big-O running times for all methods are the same as regular dictionaries.

    # The internal self.__map dict maps keys to links in a doubly linked list.
    # The circular doubly linked list starts and ends with a sentinel element.
    # The sentinel element never gets deleted (this simplifies the algorithm).
    # The sentinel is in self.__hardroot with a weakref proxy in self.__root.
    # The prev links are weakref proxies (to prevent circular references).
    # Individual links are kept alive by the hard reference in self.__map.
    # Those hard references disappear when a key is deleted from an OrderedDict.

    def __init__(*args, **kwds):
        '''Initialize an ordered dictionary.  The signature is the same as
        regular dictionaries, but keyword arguments are not recommended because
        their insertion order is arbitrary.
        '''
        if not args:
            raise TypeError("descriptor '__init__' of 'OrderedDict' object "
                            "needs an argument")
        self, *args = args
        if len(args) > 1:
            raise TypeError('expected at most 1 arguments, got %d' % len(args))
        try:
            self.__root
        except AttributeError:
            self.__hardroot = _Link()
            self.__root = root = _proxy(self.__hardroot)
            root.prev = root.next = root
            self.__map = {}
        self.__update(*args, **kwds)
        
    def __setitem__(self, key, value,
                    dict_setitem=dict.__setitem__, proxy=_proxy, Link=_Link):
        'od.__setitem__(i, y) <==> od[i]=y'
        # Setting a new item creates a new link at the end of the linked list,
        # and the inherited dictionary is updated with the new key/value pair.
        if key not in self:
            self.__map[key] = link = Link()
            root = self.__root
            last = root.prev
            link.prev, link.next, link.key = last, root, key
            last.next = link
            root.prev = proxy(link)
        dict_setitem(self, key, value)

    def __delitem__(self, key, dict_delitem=dict.__delitem__):
        'od.__delitem__(y) <==> del od[y]'
        # Deleting an existing item uses self.__map to find the link which gets
        # removed by updating the links in the predecessor and successor nodes.
        dict_delitem(self, key)
        link = self.__map.pop(key)
        link_prev = link.prev
        link_next = link.next
        link_prev.next = link_next
        link_next.prev = link_prev
        link.prev = None
        link.next = None

    def __iter__(self):
        'od.__iter__() <==> iter(od)'
        # Traverse the linked list in order.
        root = self.__root
        curr = root.next
        while curr is not root:
            yield curr.key
            curr = curr.next

    def __reversed__(self):
        'od.__reversed__() <==> reversed(od)'
        # Traverse the linked list in reverse order.
        root = self.__root
        curr = root.prev
        while curr is not root:
            yield curr.key
            curr = curr.prev

    def clear(self):
        'od.clear() -> None.  Remove all items from od.'
        root = self.__root
        root.prev = root.next = root
        self.__map.clear()
        dict.clear(self)

    def popitem(self, last=True):
        '''od.popitem() -> (k, v), return and remove a (key, value) pair.
        Pairs are returned in LIFO order if last is true or FIFO order if false.
        '''
        if not self:
            raise KeyError('dictionary is empty')
        root = self.__root
        if last:
            link = root.prev
            link_prev = link.prev
            link_prev.next = root
            root.prev = link_prev
        else:
            link = root.next
            link_next = link.next
            root.next = link_next
            link_next.prev = root
        key = link.key
        del self.__map[key]
        value = dict.pop(self, key)
        return key, value

    def move_to_end(self, key, last=True):
        '''Move an existing element to the end (or beginning if last==False).
        Raises KeyError if the element does not exist.
        When last=True, acts like a fast version of self[key]=self.pop(key).
        '''
        link = self.__map[key]
        link_prev = link.prev
        link_next = link.next
        link_prev.next = link_next
        link_next.prev = link_prev
        root = self.__root
        if last:
            last = root.prev
            link.prev = last
            link.next = root
            last.next = root.prev = link
        else:
            first = root.next
            link.prev = root
            link.next = first
            root.next = first.prev = link

    def __sizeof__(self):
        sizeof = _sys.getsizeof
        n = len(self) + 1                       # number of links including root
        size = sizeof(self.__dict__)            # instance dictionary
        size += sizeof(self.__map) * 2          # internal dict and inherited dict
        size += sizeof(self.__hardroot) * n     # link objects
        size += sizeof(self.__root) * n         # proxy objects
        return size

    update = __update = MutableMapping.update

    def keys(self):
        "D.keys() -> a set-like object providing a view on D's keys"
        return _OrderedDictKeysView(self)

    def items(self):
        "D.items() -> a set-like object providing a view on D's items"
        return _OrderedDictItemsView(self)

    def values(self):
        "D.values() -> an object providing a view on D's values"
        return _OrderedDictValuesView(self)

    __ne__ = MutableMapping.__ne__

    __marker = object()

    def pop(self, key, default=__marker):
        '''od.pop(k[,d]) -> v, remove specified key and return the corresponding
        value.  If key is not found, d is returned if given, otherwise KeyError
        is raised.
        '''
        if key in self:
            result = self[key]
            del self[key]
            return result
        if default is self.__marker:
            raise KeyError(key)
        return default

    def setdefault(self, key, default=None):
        'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
        if key in self:
            return self[key]
        self[key] = default
        return default

    @_recursive_repr()
    def __repr__(self):
        'od.__repr__() <==> repr(od)'
        if not self:
            return '%s()' % (self.__class__.__name__,)
        return '%s(%r)' % (self.__class__.__name__, list(self.items()))

    def __reduce__(self):
        'Return state information for pickling'
        inst_dict = vars(self).copy()
        for k in vars(OrderedDict()):
            inst_dict.pop(k, None)
        return self.__class__, (), inst_dict or None, None, iter(self.items())

    def copy(self):
        'od.copy() -> a shallow copy of od'
        return self.__class__(self)

    @classmethod
    def fromkeys(cls, iterable, value=None):
        '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
        If not specified, the value defaults to None.
        '''
        self = cls()
        for key in iterable:
            self[key] = value
        return self
        
    def __eq__(self, other):
        '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
        while comparison to a regular mapping is order-insensitive.
        '''
        if isinstance(other, OrderedDict):
            return dict.__eq__(self, other) and all(map(_eq, self, other))
        return dict.__eq__(self, other)

Reference

[collections — Container datatypes — Python 3.10.5 documentation](https://docs.python.org/3/library/collections.html#collections.OrderedDict)

[Taking input in Python - GeeksforGeeks](https://www.geeksforgeeks.org/taking-input-in-python/?ref=lbp)

[파이썬 - LRU 캐시 - GeeksforGeeks](

[Python] Python List, Dictionary, Set등 참조형 자료구조 복사

findTheValue — Sun, 24 Jul 2022 21:51:32 +0900

Python의 List와 Set, Dictionary등은 call by reference한다.

즉

a = [1, 2, 3]
b = a
b.append(4)
print(a)

# [1, 2, 3, 4]

할당 된 주소가 공유된다.

때문에

자료형 a 와 동일한 자료형 b를 만들기 위해 다음과 같은 방법을 사용할 수 있다.

from copy import copy, deepcopy

l = [1, 2, 3]
s = {1, 2, 3}
d = {1:1, 2:2, 3:3}

# use copy(얕은복사)
l_copy = copy(l)
s_copy = copy(s)
d_copy = copy(d)

# use deepcopy(깊은 복사)
l_deepcopy = deepcopy(l)
s_deepcopy = deepcopy(s)
d_deepcopy = deepcopy(d)

# slicing(새로운 주소 할당)
l_slicing = l[:]

# comprehension(새로 만들기)
l_comprehension = [i for i in l]
s_comprehension = {i for i in s}
d_comprehension = [i:j for i, j in d.items()]

보통 이중으로 리스트나 dictionary에 call by reference하는 자료형이 중첩되었을 경우 깊은 복사가 필요한데

이때 deepcopy는 무겁고 느리기 때문에 comprehension을 사용하면 좋습니다.

[D3] D3.js 튜토리얼 정리

findTheValue — Sun, 24 Jul 2022 21:06:10 +0900

D3.js

D3은 데이터 기반 문서(Data-Driven Documents)
SVG, HTML, CSS를 이용해 웹 브라우저에 맞춤형 데이터 시각화를 생성하기 위한 오픈소스
Protovis는 정적 시각화, D3은 상호작용, 전환 및 변환에 중점.
전역 JavaScript 개체 d3을 정의

D3의 기능

웹 표준 사용
데이터 기반
DOM 조작
데이터 기반 elements
동적 속성
시각화 유형
맞춤형 시각화
전환(transition)
상호작용 및 애니메이션(duration, delay, easy)

D3의 장점

모든 JS 프레임워크와 함께 사용 가능.
D3는 데이터에 중점을 두고 있으므로 데이터 시각화에 유리.
D3는 오픈 소스기 때문에 소스 코드로 작업하고 고유한 기능 추가가 가능
웹 표준과 함께 작동하므로 D3를 사용하기 위해 브라우저 이외의 다른 기술이나 플러그인이 필요하지 않음.
마찬가지 이유로 D3이 작동하는 데 필요한 새로운 학습 또는 디버깅 도구가 필요 없음.
D3는 시각화를 제어하여 원하는 방식의 사용자 정의가 가능해 Tableau 또는 QlikView와 같은 도구보다 유리함.
D3는 가벼우며 웹 표준과 직접 작동하기 때문에 매우 빠르고 대규모 데이터 세트에서 잘 작동.

DOM 선택

d3.select(css 선택기) 지정된 css-selector를 기반으로 HTML 문서에서 첫 번째로 일치하는 요소를 반환
d3.selectAll(css 선택기) 지정된 css-selector를 기반으로 HTML 문서에서 일치하는 모든 요소를 반환

DOM 조작

text("content") 선택한 요소의 텍스트를 가져오거나 설정
append("element name") 선택한 요소 내부에 있지만 선택한 요소의 끝 바로 앞에 요소를 추가
insert("element name") 선택한 요소에 새 요소를 삽입
remove() DOM에서 지정된 요소를 제거
html("content") 선택한 요소의 내부 HTML을 가져오거나 설정
attr("name", "value") 선택한 요소의 특성을 가져오거나 설정
property("name", "value") 선택한 요소의 특성을 가져오거나 설정
style("name", "value") 선택한 요소의 스타일을 가져오거나 설정
classed("css class", bool) 선택 항목에서 CSS 클래스를 가져오거나 추가하거나 제거

Data Function

각 DOM 조작 메서드는 상수값 뿐 아니라 함수를 메개변수로 쓸 수 있음.

.text(function (d, i) {
    console.log(d); // the data element
    console.log(i); // the index element
    console.log(this); // the current DOM object

    return d;
});

Event

이벤트 리스너

d3.selection.on(유형[, 리스너[, 캡처]]);

on메서드는 선택된 모든 DOM elements에 eventListener를 추가.

Event handlers

selection.on() : click, mouseover, mpouseout 과 같은 이벤트 유형을 캡처하기 위해 이벤트 리스너를 추가하거나 제거
selection.dispatch() : 클릭, 마우스오버, 마우스아웃과 같은 이벤트 유형을 캡처합니다. Typenames는 이벤트 이름이고 listener는 이벤트 리스너
d3.event : 타임스탬프와 같은 표준 이벤트 필드 또는 preventDefault와 같은 메서드에 액세스하기 위한 이벤트 객체
d3.mouse(container) : 지정된 DOM 요소에서 현재 마우스 위치의 x 및 y 좌표를 가져옵니다.
d3.touch() : 컨테이너에 대한 터치 좌표를 가져옵니다.

Animation

Animation은 한 형태에서 다른 형태로의 전환
selection.transition() 선택한 요소에 대한 전환을 예약
transition.duration() 지속 시간은 각 요소의 애니메이션 지속 시간을 밀리초 단위로 지정
transition.ease() easy는 여유 함수를 지정(예: 선형, 탄성, 바운스).
transition.delay() 지연은 각 요소의 애니메이션 지연을 밀리초 단위로 지정

Data Binding

Data를 DOM에 Binding
data() 선택한 요소에 데이터를 결합(1:1매핑)
enter() 누락된 요소에 대한 자리 표시자 참조가 있는 선택 항목을 만듦(data가 더 많을 시 append와 묶어 새로운 태그를 생성.)
exit() 노드를 제거하고 나중에 DOM에서 제거할 수 있는 이탈 선택에 추가
datum() 인을 계산하지 않고 선택한 요소에 데이터를 주입

Data Loading

위에서 우리가 지정한 지역변수가 아닌 다양한 유형의 파일에서 data를 로드하고 DOM요소에 바인딩 가능.
d3.csv() .csv 파일 또는 데이터를 로드하기 위해 지정된 URL에 http 요청을 보내고 파싱된 csv 데이터 개체로 콜백 함수를 실행
d3.json() .json 파일 또는 데이터를 로드하기 위해 지정된 URL에 http 요청을 보내고 파싱된 json 데이터 객체로 콜백 함수를 실행
d3.tsv() .tsv 파일 또는 데이터를 로드하기 위해 지정된 URL에 http 요청을 보내고 파싱된 tsv 데이터 개체로 콜백 함수를 실행
d3.xml() .xml 파일 또는 데이터를 로드하기 위해 지정된 URL에 http 요청을 보내고 파싱된 xml 데이터 개체로 콜백 기능을 실행

SVG elements

Fill : 요소의 채우기 색상. 색상 이름, 16진수 값 또는 RGB 또는 RGBA 값
stroke : 획 색상. 요소의 색상을 지정할 수 있음
stroke-width : 획 너비는 선 또는 경계의 너비를 지정. 픽셀 단위
opacity : 불투명도는 불투명도/투명도 숫자를 지정. 0은 투명, 1은 불투명
font-family : 텍스트 요소의 경우 font-family 지정 가능
font-size : 텍스트 요소의 글꼴 크기 지정

chart

예제 참고

chart scales

눈금과 축
Continuous
- d3.scaleLinear() 입력 데이터(도메인)가 지정된 출력 범위에 매핑되는 연속 선형 스케일을 구성
- d3.scaleIdentity() 입력 데이터가 출력과 동일한 선형 스케일을 구성
- d3.scaleTime() 입력 데이터가 날짜이고 출력이 숫자인 선형 척도를 구성
- d3.scaleLog() 로그 스케일을 구성
- d3.scaleSqrt() 제곱근 척도를 구성
- d3.scalePow() 지수 규모를 구성
Sequential
- d3.scaleSequential() 보간 기능에 의해 출력 범위가 고정된 순차 스케일을 구성
Quantize
- d3.scaleQuantize() 이산 출력 범위로 양자화 스케일을 구성
Quantile
- d3.scaleQuantile() 입력 샘플 데이터가 이산 출력 범위에 매핑되는 분위수 척도를 구성
Threshold
- d3.scaleThreshold() 임의의 입력 데이터가 이산 출력 범위에 매핑되는 축척을 구성
Band
- d3.scaleBand() 밴드 스케일은 출력 범위가 연속적이고 숫자라는 점을 제외하고 서수 스케일과 유사
Point
- d3.scalePoint() 포인트 스케일을 구성
Ordinal
- d3.scaleOrdinal() 입력 데이터가 알파벳을 포함하고 이산 숫자 출력 범위에 매핑되는 순서 척도를 구성

chart axes

사람이 읽을 수 있는 눈금
d3.axisTop() 상단 수평 축을 만듦
d3.axisRight() 수직 오른쪽 방향 축을 만듦
d3.axisBottom() 아래쪽 수평 축을 만듦
d3.axisLeft() 왼쪽 세로 축을 만듦

Reference & To-Be

[PL/SQL Developer] Recall Statement

findTheValue — Tue, 12 Jul 2022 17:29:09 +0900

Tools - Preference - Recall Statement에서 갯수, 저장위치 설정

Edit - Recall Statement

Ctrl + E

로 부르면 이전에 실행한 Query Log를 확인 가능

[Oracle] Like 용법 정리

findTheValue — Tue, 12 Jul 2022 17:15:24 +0900

시작

WHERE A LIKE 'B%'

끝

WHERE A LIKE '%B'

포함

WHERE A LIKE '%B%'

여러개 포함

WHERE A LIKE '%B%C%'

대소문자 구분 x

WHERE LOWER(A) LIKE '%B%C%'

제외

WHERE A NOT LIKE '%B%'

자리수

WHERE A LIKE '__'

2번째가 B

WHERE A LIKE '_B%'

언더바를 문자로 쓰기

WHERE A LIKE '%\_%' ESCAPE '\'

LIKE 여러개

WHERE REGEXP_LIKE(A, 'B|C|D', i)

i는 있으면 대소문자 구분 x 없으면 인자 2개만 받음