728x90
Machine Language

Machine Language

  • 어셈블러 : Symbolic한 코드(어셈블리어)를 기계어로 바꿔줌
    • ex. 1 ADD 56 > 1 000 0000 0011 1000
  • 컴파일러 : 고급 언어(C, Java, ...)를 기계어로 바꿔줌

Assembly Language

  • 어셈블러 : Symbolic Program을 기계어로 변환
  • 기계마다 기계어가 다르므로, 어셈블러 역시 기계마다 다르게 동작
  • 어셈블리 명렁어의 구성요소
    • Lable : 공백 or Symbolic Address
      • Symbolic Address
        • 알파벳 형태로 주소 지정
        • 첫 글자는 반드시 대문자로 써야 하며, 콤마(,)로 종료
    • Instruction : machine / pseudo Instruction
      • pseudo instruction
        • ORG(Origin of Program), DEC(Decimal), END(END of program) 등
        • 실제 동작에는 관여하지 않고, 어셈블러 동작에 필요한 정보 지정
      • MRI(Memory Reference Instruction)의 경우 공백으로 구분되는 Symbol 명령어
        • 명령어 + 주소 (+ Indirect)로 구성
        • ex. ADD OPR / ADD OPR I (Indirect MRI)
      • non-MRI : 1개 Symbol ex. CLA(Clear ACC)
    • Comment : 코드 주석
  • Code Example : subtract code
    • ORG 100 : 100번 주소에서 코드 시작
    • LDA SUB : SUB 명령어를 Load
      • SUB 명령어는 107에 저장되어 있음
      • SUB의 Opcode가 010이므로 Hex Code 2107로 표현됨
      • MIN : 계산할 값
      • SUB : 뺄 값
      • DIF : 차이
    • CMA - INC - ADD MIN
      • 2진수 빼기는 2의 보수(1의 보수 + 1)을 더하는 방식으로 진행
    • STA DIF : DIF 주소(108)에 결과 저장
    • HLT : 컴퓨터 종료
    • END : 코드의 끝
728x90
728x90
2020 국제 인공지능대전
  • 코로나19로 인해 유명 박람회들이 죄다 연기, 혹은 취소되는 상황에 올해가 끝나가는 이제야 참가할만한 기술 박람회를 맞이할 수 있게 되었다. 한국전자전은 내년으로 연기되었지만, 반도체대전은 올해 개최된다는 것을 보고 거리는 다소 있지만 참관을 결정하게 되었다. 이와 함께 마침 일정이 겹치게 되어 2020 국제인공지능대전도 같이 둘러보기로 했다.

  • 다만 경제 상황이 악화되었던게 문제인지, 작년에 비해서 규모나 분위기가 많이 위축되었다는 점이 많이 느껴져 아쉬움이 남았다. 보통은 전시 마지막날 참관을 하곤 했는데, 올해는 어쩌다 보니 개최 첫날 오전 타임이어서 그럴지도 모른다는 생각이 들었지만, 사회적 거리두기와 맞물려 박람회에 방문한 사람 수가 줄었다는 느낌은 어쩔 수 없는 것 같았다.


2020 국제 인공지능대전

  • 국제인공지능대전에서는 AI와 관련된 HW 및 SW 등 다양한 서비스를 제공하는 기업들을 만나볼 수 있었다. 크게 AI 학습용 GPU서버(Nvidia와 협력 관계를 맺는 회사들이 종종 보였다.), 데이터 학습 및 가공, 그리고 AI모델을 서비스로 제공하는 회사로 크게 분류할 수 있었을 것 같다.
  • 특이했던 점은 기업 대부분이 소규모 혹은 스타트업에 가까웠다는 점이다. 그만큼 AI의 힘을 빌어 핀포인트로 제공 가능한 서비스가 많아졌고, 그와 더불어 AI로 창출 가능한 사업 가능성이 다변화되었음을 의미하는 것 같았다.
  • 기억에 남는 기업이 두 곳 있었는데, 하나는 인피닉이라는 기업이었다. 기존에는 임베디드 및 QA서비스 제공을 하다가, 최근 데이터 관리 사업을 시작한 것으로 보인다. 데이터 수집부터 QA까지 전반적인 전반적인 구축 시스템을 제공하며, 박람회에서는 그 결과물로 영상처리를 기반으로 상품 목록을 자동 인식하는 무인 점포 시스템을 시연 중이었다.

  • 또하나의 기업은 코어닷투데이라는 기업이었다. 이곳의 컨셉은 데이터 스토리텔링이라는 개념이었는데, 내가 어떠한 데이터를 분석한 방식을 Jupyter Notebook을 이용해 업로드하여 사람들에게 공유하는 사이트였다. 어쩌면 Kaggle과 유사한 형태인데, 차이점이라면 Kaggle은 기업이 제시한 내용을 해결하는 곳이라면, 이곳은 이용자들이 자신의 주제로 분석하는 과정을 업로드하는 곳이었다. 자기 이론에 맞게 데이터를 분석할 수 있기 때문에 정보의 자유도가 더 높아질 수 있을 것 같고, 좀 더 사용자 중심적일 수 있다는 장점이 돋보이는 서비스라고 생각했다.

2020 반도체대전

  • SEDEX에서 가장 기억에 남았던 기업은 파스텍이라는 기업으로, 모터 및 컨트롤러 전문 개발 업체였다. 반도체 장비는 극한의 정밀도를 필요로 하는 만큼 로봇에 사용되는 모터 등의 정밀한 제어가 필수적이다. 모터 토크 유지, 3축 등 다양한 방향으로의 정밀 제어를 시연하는 기업이었다.

  • 반도체대전 역시 작년에 비해 아쉬움이 좀 있었는데, 장비나 기술 시연의 규모가 상당히 줄었다는 느낌이 들었다. 그나마 하이닉스/삼성이 자리했고, 램리서치의 경우 간단한 기업 소개 정도만 남아 있는 모습이었다. 거의 기업 시연보다는 해당 박람회에서 기업 간 미팅을 위한 자리를 마련한 곳이 대부분이었던 것 같다.
728x90
728x90
SQL 문법 정리하기

SQL 문법 정리하기

  • SELECT : 테이블에서 데이터를 불러옴
    • 여러개를 불러올 수 있음
    • column명 뒤에 이름을 붙여 결과 table의 column 이름 겸 SQL문 내의 변수로 쓸 수 있음
    • *을 쓸 경우 table의 모든 변수를 불러옴
select (column name) from table
  • WHERE : 조건 부여
    • AND, OR, NOT을 이용해 여러개의 조건을 한번에 사용 가능
    • IN : 조건을 부여하는 COLUMN에서 여러 개의 값을 찾고 싶을 때 사용
      • where col is a or col is b or ... 대신
      • where col in (a,b, ...)
    • BETWEEN A AND B : column이 A와 B에 해당하는 범위를 갖는 경우
    • NULL : SQL 테이블의 NULL값은 별도로 탐색해주어야 함 / COUNT되지 않는 값으로 처리
    • LIKE : 문자열 패턴 검색
      • "%" : 와일드카드(임의 길이의 문자)
      • "_" : 1자리를 차지하는 문자
      • ex. where col like "_5%" : 2번째 글자가 5인 col 데이터
    • HAVING : WHERE 사용이 불가한 경우(COUNT 등의 집계함수에 사용)
  • DISTINCT : 중복 제거
  • JOIN : 두 테이블을 결함
    • INNER JOIN : 교집합
    • LEFT/RIGHT JOIN : 먼저/나중에 호출하는 테이블을 메인으로 집합
    • FULL OUTER JOIN : 합집합
[INNER/LEFT/RIGHT/FULL OUTER] JOIN table1 on table1.col == table2.col
  • MIN/MAX(col) : 해당 col의 최소/최댓값
  • LIMIT : 제한된 개수만 리턴
    • LIMIT n : n개 리턴
    • LIMIT a, n : a번째부터 n개만 리턴
  • GROUP BY col : col 기준으로 묶음
  • ORDER BY col [ASC/DESC] : col 기준으로 오름/내림차순 정렬
728x90
728x90
Numpy

Numpy

  • 과학 계산의 경우 행렬 연산의 비중이 높으며, 이를 효율적으로 처리하기 위해 사용되는 라이브러리
import numpy as np np.arange(10) # array([0,1,2,3,4,5,6,7,8,9])

Scalar

  • 단일 값으로 표현
    • pi, 온도, x, y 등등...
  • 스칼라값은 소문자 알파벳으로 표현 (a,b,c,d,...)

Vector

  • 값으로 이루어진 array
  • column vector : x=[x1x2x3...]x = \begin{bmatrix} x_1\\ x_2\\ x_3\\ ... \end{bmatrix}
  • row vector : x=[x1,x2,x3,...]x = \begin{bmatrix} x_1, x_2, x_3, ... \end{bmatrix}

Matrice

  • 값으로 이루어진 2차원 배열
  • x=[x11,x12,...,x1mx21,x22,...,x2m...xm1,xm2,...,xmm]x=\begin{bmatrix} x_{11},x_{12}, ..., x_{1m}\\ x_{21},x_{22}, ..., x_{2m}\\ ...\\ x_{m1},x_{m2}, ..., x_{mm}\\ \end{bmatrix}
  • 머신러닝에 있어서 많은 데이터는 벡터나 행렬로 표현
  • matrix 생성 함수
    • np.array([list]) : list를 numpy 배열로 변환
    • np.arange(n) : 0~n-1의 배열 생성
    • np.reshape(r,c) : r x c 크기로 배열 재생성
    • np.zeros(size) : 0행렬 생성
    • np.ones(size) : 모든 원소가 1인 행렬 생성
    • np.full(size, element) : 해당 행렬을 element로 채움
    • np.random.random(size) : 0 ~ 1 사이의 값을 원소로 갖는 행렬 생성
    • Transepose(행렬) or 행렬.T : 행렬의 행-열을 바꿈
    • np.shape() : (행, 열) 반환
    • len(arr.shape) : 몇차원 행렬인지를 반환

Tensor

  • 2개 이상의 축을 갖는 행렬
    • ex. RGB image(가로, 세로 x 3 (R, G, B))
  • tensor 연산 : 일반 연산과 동일하게 작성
    • 곱셈, 나눗셈은 행렬곱이 아닌 원소 간의 곱으로 계산
  • reduction
    • 원소들의 합을 계산하고, 1개 축을 제거
    • tensor.sum()
      • axis 미지정시 전체 원소의 합
      • axis : 0인 경우 세로 방향의 합을, 1인 경우 가로 방향의 합 계산
      • keepdims : 합을 계산 후 배열 크기를 유지
  • np.identity : 단위행렬 반환
  • np.diag : 대각행렬 반환
  • np.dot(vec1, vec2) : 행렬의 합성곱(x1×x2\sum x_1 \times x2) 계산

Norm

  • 벡터를 스칼라를 연결
    • 벡터의 크기에 대한 표현
  • norm f의 특징
    • f(ax)=af(x)f(ax)=|a|f(x) : vector에 상수를 곱한 만큼 증가
    • f(x+y)f(x)+f(y)f(x+y)\leq f(x)+f(y)
    • f(x)0f(x)\geq 0 : norm은 항상 0 이상
  • LpnormL_p-norm : xp=[i=1nxip]1/p||x||_p=[\sum^n_{i=1}|x_i|^p]^{1/p}
    • L1 norm : manhattan distance ( 절대값의 합 )
    • L2 norm : Euclidian distance
728x90
728x90
파이썬 프로그램의 실행

파이썬 프로그램의 실행

  • 파이썬은 인터프리터 언어이므로, 기본적으로는 맨 처음부터 시작하게 됨
  • 프로그램 시작점이 필요한 경우(main), 다음과 같이 정의
def main(): # 수행할 main함수 내용 if __name__ == '__main__' : main()

파이썬 모듈

  • import 이름 형태로 불러옴
  • from package import 모듈 : 패키지(모듈) 내의 구성요소를 바로 불러올 수 있음
    • 사용자 함수와 동일한 모듈을 불러온 경우 오류 위험
import math # a from math import cos # b # a의 경우 math.cos(0) # b의 경우 cos(0)
  • 모듈을 import해도 하위 모듈까지 같이 import되지는 않으므로 호출해주어야 함
import A ''' module A ㄴmodule B ㄴmodule D ㄴmodule C 일때, A를 import한다고 B,C,D를 바로 쓸수 없다 ''' A.B #(o) B #(x) A.B.D #(o) B.D #x
  • absolute import
    • 파이썬의 환경변수(sys.path)에 속하는 경로 모듈에 접근
  • reletive import
    • 작성된 프로젝트에 속하는 모듈에 접근
  • init.py : 패키지의 초기화
    • 패키지 import 시 가장 먼저 실행됨
    • __all__변수 : from ... import * 명령(패키지 내 모든 구성요소 import) 실행 시 가져오는 내용

  • sys 모듈
    • 인터프리터에 의해 사용되는 정보, 변수
    • sys.argv : 커맨드라인으로 실행 시 매개변수 호출
    • ex. pyhon foo.py file.txt
      • argv[0] == "foo.py"
      • argv[1] == "file.txt"
728x90
728x90
Background

Background

  • Data consistency
    • 멀티프로세싱/스레딩 시에 다수 작업이 동시에 시행
    • 인터럽트 발생 시 이전에 동작하던 작업이 일시 중단되고 새로 실행
    • 여러 작업이 데이터를 공유할 경우 문제 발생
      • 데이터 업데이트 중 다른 프로세스가 읽어들이거나
      • 여러 프로세스가 동시에 쓰는 경우
    • 일정 루틴에 맞는 프로세스 실행 순서를 정의할 필요가 존재
  • Producer - Consumer Problem
    • 데이터 생산 프로세스(Producer)는 큐가 차있지 않은 동안 데이터를 입력
    • 데이터를 쓰는 프로세스(Consumer)는 큐가 비어있지 않으면 데이터 사용
    • Counter 변수를 같이 접근하는 문제 존재
      • ++, --명령어 실행 시 변수값을 각 레지스터로 이동하여 처리
    • race condition : 초기값이 5일 때, 동시에 접근 시 Producer는 5 > 6, Consumer는 5 > 4로 Counter 값을 바꾸므로 결과적으로 카운터값이 6>4로 변경될 가능성 존재
    • fork()의 race condition
      • fork 실행 시 반환값은 PID
      • 두 프로세스가 동시에 fork 호출 시 같은 PID를 갖는 두 프로세스가 생성될 수 있음
/* Producer Process */ while (true) { /* produce an item in next produced */ while (counter == BUFFER_SIZE) ; /* do nothing */ buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE; counter++; } /* Consumer Process */ while (true) { while (counter == 0) ; /* do nothing */ next_consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; counter--; /* consume the item in next consumed */ }

Critical-Section Problem

  • 다수의 프로세스/스레드 생성 시 한 번에 하나의 작업만 실행될 수 있는 구간
    • 공용 데이터 접근시의 충돌 방지
do { /* Ask Permission to enter critical section */ /* Critical Section */ /* Exit Critical Section */ ... }while(...);
  • Critical Section 문제의 해결 조건
    • Mutual Exclusion : 프로세스 P가 Critical Section에 접근 시 다른 프로세스는 해당 구간을 실행하면 안됨(Critical Section의 정의)
    • Progress : Critical Section에 실행 중인 프로세스가 없을 경우, 이 구간에 진입하고자 하는 프로세스를 지연 없이 진입시켜야 함
    • Bounded Waiting : 프로세스 A가 Critical Section에 있을 때, 새 프로세스가 진입하고자 할 경우 A가 끝나는 것을 대기해야 하나, 무한정 대기해서는 안됨 (Critical Section 진입 시 우선순위의 조정 필요)
  • OS의 Critical-Section Handling : Non-Preemptive
    • 인터럽트 없이 커널 설계
    • 구현이 쉽고, 오류를 신경쓸 필요성이 낮아짐
    • 공유 데이터 접근 시 우선한 작업이 처리되어야 나머지 처리가 가능하므로 시스템 반응성, 성능이 떨어지게 됨

Peterson's Solution

  • SW 기반으로 HW 영역의 문제를 해결하고자 하는 접근법
  • 2개 프로세스/스레드를 가정
    • load/store 명령어는 순서대로 실행된다고 가정(각 명령어 중에는 인터럽트가 없음)
    • 두 프로세스에는 변수가 존재 : int turn ; bool flag[2]
    • turn : critical section에 접근 가능한 프로세스
    • flag[i]가 true면 i번째 process가 Critical section에 접근하고자 함
  • Entry Section
    • 자신의 flag를 true로 만듦 : critical section에 접근할 준비
    • turn을 상대 프로세스 값으로 대입
    • while : 상대 프로세스가 준비가 되었고(flag), 실행할 순서인 경우(turn), 완료할 때까지 무한루프로 대기
      • 그렇지 않은 경우 자신의 코드 실행
    • critical section 실행 후 자신의 flag를 false로 설정
  • 위 예시의 검증
    • Mutual Section : while문 조건에서 turn이 상대방 값으로 대입되므로 critical section에 동시 접근이 불가
    • Progress : Entry section에 진입하지 않은 경우 해당 프로세스의 flag는 false이므로 다른 프로세스는 바로 critical section에 접근 가능
    • Bounded Waiting : turn이 상대 값으로 대입되었기 때문에 프로세스가 while문 재진입 시 다른 프로세스에 우선권을 넘겨주므로 무한 대기 없이 두 프로세스가 순차 실행

  • Peterson's Soultion의 문제 : 현대 컴퓨터에서 실행을 보증하지 않음
    • 프로세서나 컴파일러가 성능을 위해 독립적으로 실행되는 명령어 순서를 변경할 수 있음
    • 독립적인(서로 다른 곳에 접근하는) 명령어의 경우 순서를 바꾸어도 결과는 동일
    • 멀티코어 / 멀티프로세서 구조에서 심각한 문제가 될 수 있음
      • 원래의 알고리즘
        • (Process i) flag i = true, turn = j
        • (Process j) flag j = true, turn = i
        • (Process j가 먼저 접근한 경우) j는 critical section 처리, i는 while 대기
        • flag j = false : Process i가 critical section 처리
      • 현대 아키텍처의 경우
        • (Process i) turn = j : flag를 나중에 대입
        • (Process j) turn = i, flag j = true
        • turn i=false이므로 Process j가 Critical section 처리
        • (Process i) flag i = true
        • turn이 i이므로 Process i도 Critical Section에 접근 가능 : Mutual Section 위반

HW Support for Synchronization

  • Critical Section Code를 위한 별도 명령어 제공
    • Memory Barrier
    • HW Instruction
    • Atomic Variable
  • Memory Barrier
    • 명령어의 실행 순서를 명시
    • Strongly Ordered : 각 프로세서가 구현 명령어대로 접근
    • Weakly Ordered : 명령어 접근 순서가 바뀔 수 있음
    • Memory barrier : 배리어 전후로는 명령어 순서 변경이 불가
  • HW Instruction
    • Test-and-Set

      boolean test_and_set (boolean *target) {
      boolean rv = *target;
      *target = true;
      return rv:
      }

      • 다른 명령어와 독립적으로 실행(execute atomically)
      • target값을 읽어들인 후, target에 새 값 대입
      • 읽어들인 값 rv 반환
    • Compare-and-Swap

      int compare_and_swap(int *value, int expected, int new_value) {
      int temp = *value;
      if (*value == expected)
      *value = new_value;
      return temp;
      }

      • 이전값(value)가 예측값(expected)와 동일하면 새 값(new_value)로 치환
// criticals section with test_and_set do { while (test_and_set(&lock)) ; /* do nothing */ /* critical section */ lock = false; /* remainder section */ } while (true);
  • test_and_set이 처음에는 false
    • 먼저 접근한 프로세스가 lock을 true로 바꿈
    • 나머지 프로세스들은 test_and_set이 true를 반환하게 되므로 mutual section이 성립
//critical section with comp_and_swap while (true){ while (compare_and_swap(&lock, 0, 1) != 0) ; /* do nothing */ /* critical section */ lock = 0; /* remainder section */ }
  • 초기값 lock이 0이면 해당 프로세스는 Critical section 진입하면서 lock을 1로 바꿈
    • 나머지 프로세스는 lock이 1이므로 while 대기
    • 이때 value와 expect가 다르므로(1, 0) swap이 되지 않게 됨
while (true) { waiting[i] = true; key = 1; while (waiting[i] && key == 1) key = compare_and_swap(&lock,0,1); waiting[i] = false; /* critical section */ j = (i + 1) % n; while ((j != i) && !waiting[j]) j = (j + 1) % n; if (j == i) lock = 0; else waiting[j] = false; /* remainder section */ }
  • Bounded waiting and Mutual section
    • i번째 프로세스가 실행된 경우
    • i+1부터 순회하면서 대기중인 프로세스 탐색
    • 대기중인 프로세스가 있을 경우 해당 프로세스의 waiting 상태를 풀어줌
    • 특정 프로세스가 계속해서 점유하는 것을 방지
  • Atomic Variable
    • 변수 하나만을 보호해야 할 경우
    • 동시 접근 시 데이터의 일관성 보장

Mutex Locks

  • acquire/release 명령어로 atomic variable 선언
    • busy wait : Critical Section에 접근하지 못한 나머지 변수들은 while loop를 돌면서 대기
    • spin lock : 무한루프를 돌면서 대기하는 형태(busy wait)

Semaphores

  • Mutex Lock의 경우 한 번에 하나의 프로세스만 Critical Section 진입
  • Semaphore의 경우 정수 변수 S 값의 설정에 따라 진입 가능한 프로세스 수 설정 가능
    • wait(S) : 대기 중인 프로세스 조정
    • signal(S) : 실행이 완료된 프로세스 release
  • 자원 관리에 주로 사용
  • Busy wait이 없는 Semaphore
    • 프로세스 sleep(), wakeup() 확인
    • wait : 프로세스 실행이 불가능한 경우 프로세스를 sleep queue에 추가 후 sleep
    • signal : 프로세스가 추가 실행이 불가능하면서 waiting중인 프로세스 존재 시 해당 프로세스 wakeup
    • 프로세스 리스트 접근 시 mutex section 구현 필요
wait(semaphore *S) { S->value--; if (S->value < 0) { //add this process to S->list; block(); } } signal(semaphore *S) { S->value++; if (S->value <= 0) { //remove a process P from S->list; wakeup(P); } }

Monitor

  • mutex/semaphor의 고레벨 구현
  • monitor 내에 선언한 함수는 컴파일 단계에서 wait-signal이 구현됨
  • condition variable
    • 변수에 여러 프로세스가 동시 접근 시 signal - wait 구현

Liveness

  • Progress, Bounded Waiting으로 보장
  • 프로세스가 일정 시간 내에 실행되는 것을 보장
    • 보장되지 않을 경우 알 수 없는 이유로 시스템이 멈추는 등의 문제 발생
  • Deadlock
    • 둘 이상의 프로세스가 서로의 자원을 필요로 하는 상황
    • 서로의 wait을 위해 서로의 자원을 필요로 하는 상황
      • P0의 Q wait을 위해서는 P1이 대기하는 Q가 필요
      • P1의 S wait을 위해서는 P0이 대기하는 S가 필요
  • Starvation
    • 프로세스가 공유 자원(Critical Section, Semaphore, ...)을 무한히 대기하는 현상
    • 선점한 프로세스가 무한히 자원을 점유하기 때문에 발생
  • Priority Inversion
    • P1>P2>P3의 우선순위를 갖는 프로세스(P1이 가장 우선)을 가정
    • P1, P3이 공유 자원 R1을 사용하는 상황
    • P3이 사용하는 자원을 release해야 P1을 실행 가능
    • 이때 P2가 실행되면 P2>P3이므로 P2가 우선 실행
    • P1은 R1 자원을 대기중이므로 실행되지 못함
    • 이로 인해 P2가 P1보다 우선 실행되는 우선순위 역전 현상이 발생
    • 해결책 : Priority Inheritance(우선순위 상속) - P3의 우선순위를 P1 수준으로 높여줌

Bounded-Buffer Problem

  • n개의 버퍼마다 데이터 존재
    • 버퍼에는 full, empty, mutex 변수를 갖고 있음
    • full : 버퍼 내 데이터 수
    • empty : 버퍼 내의 공백 수 (full + empty = 버퍼 크기)
    • mutex : 프로세스의 권한 할당 여부 (1 - producer / 0 - consumer)
  • Producer
    • 버퍼가 비었는지 확인(wait(empty))
    • lock acquire - release acquire(wait, signal(mutex))
    • notify consumer(signal(full))
  • Consumer
    • 버퍼가 찼는지 확인(wait(full))
    • lock acquire - relase acquire(wait, signal(mutex))
    • notify producer(signal(empty))

Readers-Writers Preoblem

  • readers : 데이터를 읽기만 하는 프로세스
  • writers : 데이터의 입/출력을 모두 하는 프로세스
  • readers의 경우 동시에 데이터 읽기가 가능하게 설정
    • rw_mutex semaphore를 설정
728x90
728x90
파이썬 연산자

파이썬 연산자

  • 산술 연산자
    • =: 할당
    • +, -, *, / : 사칙연산
    • // : 정수 나누기(5//2 = 2)
    • % : 나머지
    • ** : 거듭제곱
    • >>, << : bit shift left, right
    • &, |, ~, ^ : bit and, or, not, xor
  • 파이썬의 비교 연산자
    • A>B, A>=B : A가 B보다 크다 / 크거나 같다
    • A<B, A<=B : A가 B보다 작다 / 작거나 같다
    • A==B, A!=B : A와 B가 같다 / 다르다
    • not A : A가 아닌 경우
    • A and B, A or B : A 그리고/혹은 B
    • 모든 비교 연산자는 true 혹은 false를 반환

파이썬의 제어문

  • 파이썬 제어문은 들여쓰기(space, tab)으로 해당 영역을 구분함
  • 둘을 혼합해서 사용할 수는 없음
  • if : 조건문
if ''' condition 1 ''': # TODO elif ''' condition 2 ''': # TODO if condition 1 not satisfied ... else : # TODO if all condition not satisfied

while, for : 반복문

while ''' condition ''': # while condition satisfied, TODO for i in [1, 2, 3]: # loop(iterate) all element in list
  • range(start, end, step)
    • start부터 end-1까지를 step 단위로 반복
    • range(5) = [0,1,2,3,4]
    • range(1,5) = [1,2,3,4]
    • range(1, 10, 2) = [1,3,5,7,9]
    • range(10,1,-1) = [10,9,...,3,2]

파이썬 함수

  • 추상화를 위한 도구 : 입력과 출력 사이의 동작 내용은 Blackbox화
  • 특정 기능을 구현하는 코드 영역
  • 프로그램의 기본적인 단위(block)
  • 코드의 재사용이 가능하게 함
  • local scope : 함수 내의 변수는 외부에 영향을 주지 않음
def func1(arg1, arg2): #function header return arg1+arg2 #function body ##### a = 4 def test(): a = 5 print(a) # 5 print(a) #4

  • parameter : 함수 호출 시 전달하는 값
    • positional parameter : 전달 순서에 따른 값 할당
    • default value : 함수 선언 시 매개변수에 값을 대입하면 함수 호출시 값 전달을 하지 않아도 호출 가능
    • variadic positional argument : 정해지지 않은 개수의 파라미터를 튜플 형태로 전달
    • variadic keyword argument : 정해지지 않은 개수의 파라미터를 딕셔너리 형태로 전달
#positional parameter def mul(a,b): return a*b mul(1,2) #a=1, b=2 mul(2,1) #a=2, b=1 # default value def mul(a,b=1): return a*b mul(1,2) #a=1, b=2 mul(1) #a=1, b=1(default) # variadic positional argument def mul(*args): for a in args: print(a) mul(1,2,3,4,5) #variadic keyword argument def mul(**args): for key, value in args: print(key, value) mul(a=1, b=2, c=3, d=4)
  • variable scope
    • 함수 내외의 변수는 독립적으로 취급됨
    • global : 최상위 변수에 접근
    • nonlocal : 자신의 상위 scope에 해당하는 변수에 접근
x = 1 # (a) def A(): x = 2 # (b) def B(): nonlocal x = 3 #(c) global x = 3 #(d) # (c)의 경우, (b)에 접근 # (d)의 경우, (a)에 접근

람다식

  • 파이썬 함수는 일종의 객체
  • 람다식 = 익명 함수
    • lambda arg1, agr2, ... : 계산식
sums = lambda x, y, z : x+y+z

파이썬의 클래스

  • 객체지향 프로그래밍 : 동작을 정의하는 데이터와 코드를 객체 형태로 표현
  • 객체지향의 특징
    • Encapsulation
      • 사용하는 데이터 접근 시 함수를 사용
      • 객체 내부의 동작은 내부에서 접근 불가
      • 디버깅을 용이하게 함
    • Abstraction
      • 디자인 관점의 문제
      • 내부의 복잡한 동작보다 문제의 핵심에 집중
    • Inheritance
      • 각 객체의 공통 특성을 상위의 하나의 객체에서 상속
      • ex. 세단, SUV, 트럭은 모두 차량이라는 공통 특성을 보유
      • 파이썬의 경우 다중 상속을 지원
    • Polymorphism
      • 같은 이름을 갖는 기능이 여러 동작을 하는 것
      • ex. sort - bubble sort, quick sort, ...
  • 파이썬의 클래스 정의
    • constructor : 클래스 생성 시 자동으로 호출되는 함수로 객체를 초기화
    • 객체는 클래스의 인스턴스로 선언됨
class Car: num_of_cars = 0 #class variable def __init__(self, hp): # constructor Car.num_of_cars+=1 self.hp = hp def accelerate(self): # member method ... car = Car(100)
  • getter/setter : 인스턴스 외부에서 접근하기 위한 방법 제공
    • getter는 변수값을 읽을 때, setter는 변수값을 쓸 때 활용
  • 클래스 변수와 인스턴스 변수
    • 인스턴스 변수 : 객체 생성마다 선언되는 변수
    • 클래스 변수 : 해당 클래스가 공유하는 변수
    • 인스턴스 변수 접근 시 존재하지 않는 경우 클래스 변수 탐색
  • @staticmethod : 객체가 아닌 클래스에 작용하는 메소드
  • @classmethod : 클래스와 무관하게 객체에만 작용하는 메소드

Exception

  • 오류를 처리하기 위한 방법
  • Try-Except문을 이용해 처리
  • else : except가 발생하지 않은 경우
  • finally : except와 무관하게 무조건 실행
  • 파이썬 Exception은 계층적으로 구성
    • 최상위에 BaseException으로 구성
    • 가장 많이 쓰는 예외들은 Exception 클래스 내에 존재
  • 사용자 정의 Exception
    • 클래스 상속을 통해 정의
    • class MyError(Exception) - raise MyError("info") - except Myerror as e : print(e)

728x90
728x90
Numerical Integration

Numerical Integration

  • 수치적 적분은 \int대신 \sum을 쓰는 원리

Trapezoidal Rule

  • 적분 구간의 일부인 [a, b]구간의 적분을 가정 (구분구적법과 유사)
    • x0x2f(x)dx(x2x0)[f(x0)+f(x2)]2\int_{x_0}^{x_2}f(x)dx\simeq (x_2-x_0)\frac{[f(x_0)+f(x_2)]}{2}
  • 해당 구간의 Linear Lagrange Polynomial P1(x)=xx1x0x1f(x0)+xx0x1x0f(x1)P_1(x)=\frac{x-x_1}{x_0-x_1}f(x_0)+\frac{x-x_0}{x_1-x_0}f(x_1)
  • Lagrange Method x1, x2x_1,\ x_2를 shifting
    • L0=hxh, L1=xhL_0=\frac{h-x}{h},\ L_1=\frac{x}{h}
    • x0x2f(x)dx(2h)[f(x0)+f(x2)]2\int_{x_0}^{x_2}f(x)dx\simeq (2h)\frac{[f(x_0)+f(x_2)]}{2}
  • three-point rule 적용(x-h, 0, x+h)
    • taylor polynomial : f(x)=f(x1)+f(x1)(xx1)+f(ζ)2(xx1)2f(x)=f(x_1)+f'(x_1)(x-x_1)+\frac{f''(\zeta)}{2}(x-x_1)^2
    • a : x0x2f(x)=f(x1)2h+f(ζx)2(xx1)2\int_{x_0}^{x_2}f(x)=f(x_1)\cdot 2h+\frac{f''(\zeta_x)}{2}(x-x_1)^2
    • b : [f(x0)+f(x2)]h=2hf(x1)+[f(ζ1)+f(ζ2)]h32[f(x_0)+f(x_2)]h=2hf(x_1)+[f''(\zeta_1)+f''(\zeta_2)]\frac{h^3}{2}
    • error = a-b = x0x1f(ζ)2(xx1)2[f(ζ1)+f(ζ2)]2h3\int_{x_0}^{x_1}\frac{f''(\zeta)}{2}(x-x_1)^2-\frac{[f''(\zeta_1)+f''(\zeta_2)]}{2}h^3
      =h3[f(η)3[f(ζ1)+f(ζ2)]2]=h^3[\frac{f''(\eta)}{3}-\frac{[f''(\zeta_1)+f''(\zeta_2)]}{2}]
  • Error 발생 hhf(x)dxh[f(h)+f(h)]2\int^h_{-h} f(x)dx\simeq h\frac{[f(h)+f(-h)]}{2}
    • f(x)=1인 경우 : a=2h, b=2h
    • f(x)=x인 경우 : a=b=0
    • f(x)=x2x^2인 경우 : 23h3h3\frac{2}{3}h^3\not ={h^3}(error 발생)

Simpson's Rule

  • [a, b]구간을 세 점 (x0, x1, x2)로 가정
  • shifting : x0=h, x1=0, x2=hx_0=-h,\ x_1=0,\ x_2=h
    • hhf(x)hf(h)+4f(0)+f(h)3\int_{-h}^hf(x)\simeq h\frac{f(-h)+4f(0)+f(h)}{3}
    • 혹은 x0x2f(x)dx=2hf(x1)+h33f(x1)+f(ζ)60h5\int_{x_0}^{x_2}f(x)dx=2hf(x_1)+\frac{h^3}{3}f''(x_1)+\frac{f''''(\zeta)}{60}h^5
  • Trapizoidal Rule의 degree of precesion은 1이지만, simpson은 4(전자는 2차식, 후자는 5차식부터 오차 발생)
  • Composite Simpson's rule
    • 함수를 일정 구간으로 나누어 Simpson's Rule을 여러번 적용
    • I(f)=abf(x)dx,I(f)=\int^b_af(x)dx,
    • Tn(f)=h[f(x0)+f(x1)2+f(x1)+f(x2)2+...+f(xn2)+f(xn1)2+f(xn1)+f(xn)2T_n(f)=h[\frac{f(x_0)+f(x_1)}{2}+\frac{f(x_1)+f(x_2)}{2}+...+\frac{f(x_{n-2})+f(x_{n-1})}{2}+\frac{f(x_{n-1})+f(x_n)}{2}
      =h[f(x0)2+f(x1)+...+f(xn1)+f(xn)2]=h[\frac{f(x_0)}{2}+f(x_1)+...+f(x_{n-1})+\frac{f(x_n)}{2}]
    • 오차 = nO(h3)nO(h^3) - 간격이 줄어 h가 감소하므로 오차가 대폭 줄어듦

Gaussian Quadratic

  • f(x)dxc1f(x1)+c2f(x2)\int f(x)dx\simeq c_1f(x_1)+c_2f(x_2)
  • Simpson's rule의 변형으로, 양 끝점을 구분부적 하는 대신 구간 내 임의 두개의 점으로 구분구적을 진행
  • 미지수 c1, c2, x1, x2c_1,\ c_2,\ x_1,\ x_2를 알기 위한 4개 방정식 필요
  • 5개 점(a, x1, 0, x2, b)이 대칭형이라 가정
    • x1 = -x2
    • c1 = c2
728x90
728x90
Numeriacal Differenctiation

Numeriacal Differenctiation

  • f(x)=Pn(x)+fn+1(ζ(x))(n+1)!Π(xxn)=Pn(x)+fn+1(ζ(x))(n+1)!Φ(x)f(x)=P_n(x)+\frac{f^{n+1}(\zeta(x))}{(n+1)!}\Pi(x-x_n)=P_n(x)+\frac{f^{n+1}(\zeta(x))}{(n+1)!}\Phi(x)
  • 미분 근사
    • f(x)=limh0f(x+h)f(x)hf(x+h)f(x)hf'(x)=lim_{h\rarr0}\frac{f(x+h)-f(x)}{h}\simeq\frac{f(x+h)-f(x)}{h}
    • 계산이 단순함
    • 수렴이 느림 = 근사 정확도가 낮음
    • h에 정비례로 오차도 작아짐 (1차 수렴)
  • Higher Order method : Lagrange method
    • f(x)=Σf(xk)Lk(x)+fn+1(ζ(x))(n+1)!Π(xxn)f(x)=\Sigma f(x_k)L_k(x)+\frac{f^{n+1}(\zeta(x))}{(n+1)!}\Pi(x-x_n)
    • 앞의 항은 Pn(x)P_n(x), 뒤의 항은 Error
    • 미분값 f(x)=k=0nf(xk)Lk(x)+Dx[Φ(x)]fn+1(ζ(x))+Φ(x)Dx[fn+1(ζ(x))]f'(x)=\sum^n_{k=0}f(x_k)L'_k(x)+D_x[\Phi(x)]f^{n+1}(\zeta(x))+\Phi(x)D_x[f^{n+1}(\zeta(x))]
      • j번째 미분항 f(xj)=k=0nf(xk)Lk(xj)+fn+1(ζ(xj))(n+1)!Πk=0,kjn(xjxk)f'(x_j)=\sum^n_{k=0}f(x_k)L'_k(x_j)+\frac{f^{n+1}(\zeta(x_j))}{(n+1)!}\Pi^n_{k=0, k\not ={j}}(x_j-x_k)
      • 오차를 특정하기보다는 Error Bound를 계산한다.
    • n이 중가할수록 error는 감소

Three-Point Formula

  • Lagrange Polynomial (3 basis) : 3개 점을 이용한 근사식
    • L0=(xx1)(xx2)(x0x1)(x0x2)L_0=\frac{(x-x_1)(x-x_2)}{(x_0-x_1)(x_0-x_2)}
    • L1=(xx0)(xx2)(x1x0)(x1x2)L_1=\frac{(x-x_0)(x-x_2)}{(x_1-x_0)(x_1-x_2)}
    • L2=(xx0)(xx1)(x2x0)(x2x1)L_2=\frac{(x-x_0)(x-x_1)}{(x_2-x_0)(x_2-x_1)}
  • 3-point method : 3개 점이 일정 간격이라 가정 x1=x0+h, x2=x0+2hx_1 = x_0+h,\ x_2=x_0+2h
    • Lagrange method의 분모항은 모두 2h22h^2으로 통일됨
    • shifting : 3개 점 중 하나를 0으로 치환
  • 3-point method를 적용한 미분식
    • f(x0)=1h[32f(x0)+2f(x0+h)12f(x0+2h)]+h23f(ζ0)f'(x_0)=\frac{1}{h}[-\frac{3}{2}f(x_0)+2f(x_0+h)-\frac{1}{2}f(x_0+2h)]+\frac{h^2}{3}f'''(\zeta_0)
    • f(x0+h)=1h[12f(x0)+12f(x0+2h)]+h26f(ζ1)f'(x_0+h)=\frac{1}{h}[-\frac{1}{2}f(x_0)+\frac{1}{2}f(x_0+2h)]+\frac{h^2}{6}f'''(\zeta_1)
    • f(x0+2h)=1h[12f(x0)2f(x0+h)+32f(x0+2h)]+h23f(ζ2)f'(x_0+2h)=\frac{1}{h}[\frac{1}{2}f(x_0)-2f(x_0+h)+\frac{3}{2}f(x_0+2h)]+\frac{h^2}{3}f'''(\zeta_2)
    • h가 절반 >> error항은 2차식이므로 오차는 1/4로 감소
  • 미분식 간소화
    • f(x0)3f(x0)+4f(x1)f(x2)2hf'(x_0)\simeq\frac{-3f(x_0)+4f(x_1)-f(x_2)}{2h} (back-order form)
    • f(x1)f(x0)+f(x2)2hf'(x_1)\simeq\frac{-f(x_0)+f(x_2)}{2h} (central form)
    • f(x2)f(x0)4f(x1)+3f(x2)2hf'(x_2)\simeq\frac{f(x_0)-4f(x_1)+3f(x_2)}{2h} (forward-order form)
    • 세 식이 대칭 구조를 이룸
    • 분자의 계수 합이 0이어야 함

  • x~=xx1 (x1=x+h)\tilde{x}=x-x_1\ (x_1=x+h)로 정의
    • Largrange Polynomial f(x)f(x0)L0(x)+f(x1)L1(x)+f(x2)L2(x)f(x)\simeq f(x_0)L_0(x)+f(x_1)L_1(x)+f(x_2)L_2(x)
    • f(x)f(x0)L0(x~)+f(x1)L1(x~)+f(x2)L2(x~)f(x)\simeq f(x_0)L_0(\tilde{x})+f(x_1)L_1(\tilde{x})+f(x_2)L_2(\tilde{x})로 치환
    • L0(x~)=x~(x~h)2h2L_0(\tilde{x})=\frac{\tilde{x}(\tilde{x}-h)}{2h^2}
  • five point formula
    • f(x0)=112h(f(x02h)8f(x0h)+8f(x0+h)f(x0+2h))+h430f(5)(ζ)f'(x_0)=\frac{1}{12h}(f(x_0-2h)-8f(x_0-h)+8f(x_0+h)-f(x_0+2h))+\frac{h^4}{30}f^{(5)}(\zeta)
      • midpoint formula - 가운데 점의 미분
      • ζ=[x02h,x0+2h]\zeta=[x_0-2h, x_0+2h]
    • f(x0)=112h[25f(x0)+48f(x0+h)36f(x0+2h)+16f(x0+3h)3f(x0+4h)]+h45f(5)(ζ)f'(x_0)=\frac{1}{12h}[-25f(x_0)+48f(x_0+h)-36f(x_0+2h)+16f(x_0+3h)-3f(x_0+4h)]+\frac{h^4}{5}f^{(5)}(\zeta)
      • endpoint formula - 왼쪽 끝점에서 미분
      • ζ=[x0,x0+4h]\zeta=[x_0, x_0+4h]
    • Error식이 4차 - Order of Convergence = 4
  • Order of Convergence 계산
    • Error Eh=ChαE_h=Ch^\alpha라고 할 때 Order of convergence = O(h2)O(h^2)
    • h값이 1/2로 감소한다고 할때 이전 값은 2h이므로 E2h=C(2h)αE_2h=C(2h)^\alpha
    • error의 감소분은 E2hEh=2α\frac{E_2h}{E_h}=2^\alpha
    • α\alpha의 계산은 logE2hEh/log2log\frac{E_2h}{E_h}/log2로 구할 수 있음 (Error Of Convergence)

Application of the Formula

  • ex. f(x)=xexf(x)=xe^x
    • f(1.8) = 10.889365, f(1.9) = 12.703199, f(2.0) = 14.778112, f(2.1) = 17.148957, f(2.2) = 19.855030
    • h=0.1, x=1.9 기준으로 한 3-point endpoint formila
      f(x)=10.2[3f(1.9)+4f(2.0)f(2.1)]f(x)=\frac{1}{0.2}[-3f(1.9)+4f(2.0)-f(2.1)]
728x90
728x90
파이썬의 특징

파이썬의 특징

  • 인터프리터 언어 : 컴파일 과정이 없음
    • 파이썬 코드는 인터프리터를 통해 .pyc라는 binary 파일로 변환
    • Cross-Platform으로 동작 가능
  • Dynamic Typing(Duck Typing) : 타입 명시가 필요 없음
  • 단순한 문법

파이썬의 Value :

  • 프로그램에 의해 사용될 수 있는 객체 표현
    • 숫자 : 정수(Int), 실수(Float), 허수(3+j), Boolean(True, False)
      • 허수는 .real, .imag로 실/허수를 분리해낼 수 있음

문자열

  • "" / '' - 한 줄
  • """ """ - 여러 줄
  • 특수문자는 (키보드 ₩ 표시)뒤의 문자로 입력 가능
  • 문자열 메소드
    • ''.join : 문자열을 인자와 함께 이어 붙임
    • split('') : 문자열을 인자 기준으로 나눔
    • float, int : 문자열을 숫자로 (int의 경우 진수 지정 가능)
    • strip / lstrip / rstrip : 양옆 / 왼쪽 / 오른쪽 공백 제거
    • whitespace : 공백 문자로 처리하는 문자를 확인
    • find, rfind : 시작/끝에서 문자를 찾아 인덱스 반환 (없으면 -1)
    • startswith, endswith : 해당 문자열로 시작/끝나는지 여부

리스트(배열) : [], list()

  • C와 달리 여러 타입의 값이 같이 들어갈 수 있음
  • [ 1, "123", [1,2,3] ]
  • 파이썬의 리스트 인덱스는 음수로도 가능
    • 리스트 처음의 인덱스는 0 혹은 -(리스트 길이)
    • 리스트 마지막 인덱스는 (리스트 길이 - 1) 혹은 -1
  • 슬라이스 : 리스트의 일부분을 추출해낼 수 있음
    • range와 유사하게 동작
    • a = [1,2,3,4,5]
    • a[:] = [1,2,3,4,5]
    • a[:2] = [1,2]
    • a[1:3] = [2,3]
  • 파이썬 리스트 함수
    • x=[1,2,3], y=[4,5,6]
    • len(x) : 리스트의 길이 반환 (3)
    • x[len(x):] = y, x 리스트의 뒤에 y를 연결할 수 있음
      • [1,2,3,4,5,6]
      • x.extend(y), x[2:3] = y로도 가능
      • x+y로도 가능
    • x[:0] = [1,2,3] : x 리스트의 앞에 [1,2,3]으로 연장
      • [4,5,6,1,2,3]
    • x.append(10) : 리스트 끝에 추가
      • [1,2,3,10]
    • x.insert(n, element) : n번째 인덱스 앞에 element 추가
      • x.insert(0,-1) = [-1,1,2,3]
    • del x[] : 리스트 원소를 지울 수 있음
      • del x[1] = [1,3]
      • del x[:] = []
    • x.remove(2) : x리스트 안의 원소 2를 지움
      • [1,3]
    • x.reverse() : 리스트 x를 역순으로 정렬
      • [3,2,1]
    • z = [1,3,2] - z.sort() 리스트를 크기순으로 정렬
      • [1,2,3]
      • z를 변화시키며 리턴값 없음
    • y = sorted(z) : 정렬된 새 리스트를 반환
      • z = [1,3,2], y=[1,2,3]
    • in : 값이 리스트에 있는지 확인
      • 1 in [1,2,3] : True
      • 5 in [1,2,3] : False
      • 5 not in [1,2,3] : True
    • min, max : 리스트 내의 최대/최소값 반환
    • x.index(1) : 해당 원소가 존재할 경우 인덱스 반환
      • 0
    • k = [1,1,1,2,2,3] - k.count(1) : k 리스트 내의 원소 개수 반환
      • 3

튜플 : (), tuple()

  • 수정 불가능한 리스트
  • (1,) : 하나의 원소를 갖는 튜플 - (1)는 정수 1임
  • 튜플의 활용 : 변수 선언의 간소화
  • extend unpacking * : *이 붙은 원소는 길이가 맞지 않는 모든 값을 흡수
x=1 y=2 z=3 w=4 #에서 (x,y,z,w)=(1,2,3,4)#로 # Extend unpacking a, *b, c = (1,2,3,4,5) ''' a=1 b=[2,3,4] c=5 ''' a,b,c,*d=(1,2,3) ''' a=1 b=2 c=3 d=[] : 빈 리스트 '''

딕셔너리 : {}, dict()

  • 키 - 값 관계를 갖는 자료 구조
  • d = {1:"one", 2:"two}일 때, d[1] = "one"을 반환

세트 : set()

  • 중복이 없는 자료 구조
  • set([1,2,3,4,1,2,3,4]) = set([1,2,3,4])
  • |, & : 합집합, 교집합 계산
  • -: 차집합
  • ^ : XOR 연산과 동일
  • frozenset([]) : Immutable한 set
    • set 안의 set을 구현하기 위해 사용
    • seta = {1,2, frozenset([3,4,5])}
      • set은 unique한 값을 갖는 객체를 해쉬로 구현하는데, set은 Mutable하므로 값이 바뀔 수 있어 set 안의 set 구현이 불가능. 이로 인해 set in set을 구현하기 위해 frozenset이 필요

파이썬 객체

  • 프로그램이 조작 가능한 데이터
  • Scala : Int, Float, Bool, None - 분리 불가능한 최소 단위
    • None : 반환값이 없는 함수에 사용(None을 반환)
  • Non-scala ; List, Tuple, Dictionary, defined Class - Scala Type에 기반해서 만들어지는 자료형
  • Type() : 자료형 변환이 가능(C의 type-casting)
  • 값과 변수
    • Value : 값을 표현
    • Variable : 데이터가 저장된 곳을 이름으로 표현
    • 값을 변수에 할당하여 사용 (Variable = Value : pi = 3.14)
      • 만약 x=3으로 할당 후, x=4로 할당하면, x = 3의 연결이 끊어지고, 4와 x가 bind됨
      • 3의 값은 python에서 자체적으로 메모리를 정리해줌
    • del(x) : 변수 x를 삭제
  • 객체 복사
    • 파이썬의 모든 변수는 레퍼런스(포인터)로 동작
      • a=3, b=3의 코드를 가정
      • C의 경우 a, b의 메모리 공간에 각각 3을 저장
      • python의 경우 a, b가 3의 값을 갖는 객체의 주소를 가리킴
      • a=4가 될 경우, c는 a변수의 메모리 공간을 지우고 4를 넣지만, python은 4의 값을 갖는 객체를 만들고, 그 주소를 a가 가리키게 됨
      • 리스트 역시 각 위치가 포인터로 동작
        • [1, 2, 3]은, 리스트의 0, 1, 2번째 인덱스가 각각 1,2,3의 값을 갖는 객체를 가리키는 상태
        • shallow copy : 리스트를 대입한 후 연산을 할 경우, 같은 리스트 변수에도 영향을 줌
li1 = [1,2,3] li2 = li1 #shallow copy li2 = li1 * 2 # li1, li2 모두 [2,4,6] # Deep copy : 분리하여 복사 import copy li2 = copy.deepcopy(li1)

  • 파일 객체
    • open('파일명', '읽기/쓰기 여부')로 호출
    • 존재하는 파일을 쓰기로 호출할 경우, 덮어쓰는 식으로 파일 작성

Immutable / Mutable

  • 파이썬의 객체 분류 기준
  • Immutable : Number, Boolean, Tuple
  • Mutable : List, Set, Dictionary
  • Object ID : id() 함수는 객체의 id를 반환
    • Immutable한 객체들의 id는 모두 동일
    • Mutable 객체(ex. list)의 경우 매번 새로 생성되므로 다른 id 할당
    • is 연산자로 두 객체가 완전히 같은지 확인 가능
      • ==는 두 객체의 값을 비교

주석

  • 코드가 어떻게 동작하는지를 설명
  • 실제 코드에는 영향을 주지 않음
  • # : 한 줄 / ''' ''' : 여러 줄
# comment in one line ''' comment in lines '''

파이썬의 코딩 스타일 - PEP 8

  • 개발 편의를 위한 코딩 규칙
  • 모듈명, 패키지명 : 모두 소문자로, 필요할 때만 _로 구분 (imp, sys)
  • 함수, 변수명 : 모두 소문자로, 가독성을 위해 언더바 사용 (my_func(), my_var)
  • 클래스명 : 각 단어마다 대문자로 시작(MyClass)
  • 상수 : 모두 대문자, 가독성을 위해 언더바(MY_CONSTANT)
  • 들여쓰기 : tab 대신 스페이스 4번으로 사용할 것
  • 비교 : True, False와 직접적인 대조를 하지 말 것
    • if my_var == True >> if my_var
    • if my_var == False >> if not my_var
728x90

+ Recent posts