설계

1번의 하위 항목이 2번의 조건문 아래로 겹치는 것은 구현 할 때, 값이 1이 아니라면 continue로 바꿔서 코드를 조금 더 깔끔하게 바꿨습니다.

1. 전체를 순회
   • 1의 값이 나온다면, queue 인덱스 삽입, 자신 0으로 치환, dfs시작
2. dfs
   • 아파트 개수는 1부터 시작
   • 동서남북 조회
     • 조건문 row 좌표, col 좌표 각각 0이상 N미만
     • 1의 값이 나온다면 아파트 개수 +1, 자신 0 치환
     • queue에 현재 인덱스(다음) 삽입
   • 끝난다면 아파트 개수 삽입
3. 출력

코드

from collections import deque

queue = deque()
N = int(input())
next_rows = [0, 0, 1, -1]
next_cols = [1, -1, 0, -0]
apts = [list(map(int, input())) for _ in range(N)]
results = []


for row in range(N):
    for col in range(N):
        if apts[row][col] != 1:
            continue

        apts[row][col] = 0
        queue.append([row, col])
        count = 1

        while queue:
            r, c = queue.popleft()
            for i in range(4):
                nr, nc = r + next_rows[i], c + next_cols[i]
                if 0 <= nr < N and 0 <= nc < N and apts[nr][nc] == 1:
                    count += 1
                    apts[nr][nc] = 0
                    queue.append([nr, nc])

        results.append(count)

print(len(results))
print('\n'.join(map(str, sorted(results))))

• 회고 처음 설계한 그대로 작성해 보기 위해 노력하는데 역시 적다보면 생각하지 못 했던 부분이나 더 좋은 방법이 생각이나는 빈도가 코드를 작성할 때 보다 높은 것 같다. 코드를 적을 때 설계 부분에서 조금씩 고치지만 큰 틀은 바뀌지 않아 좋았다. 어제 처음으로 시도해봤던 그래프 문제는 3시간이 걸려도 시간 초과를 해결하지 못했는데, 두 번째(지금) 문제는 1시간 안 걸렸다^^ 66%이상 줄여버리기(내일은 아마 30분이면 풀 듯?~~) 답을 적고 보면 참 쉬운데 시간이 꽤 걸린게 웃기다 ㅋㅋ

나의 초기 설계 (안 좋은 예시)

1. 어제 배운 그래프 형태를 이용해 보려고 했다.

   1. 행, 열의 값들을 순서대로 0번 부터 행*열-1 까지의 번호를 매김
   2. 동서남북 좌표에 조건문을 단다 (-1있거나 행이 행 크기보다 크거나, 열도 마찬가지 등)
   3. 통과한 좌표에 행좌표*열 + 열의 값을 넣는다

2. 깊이 우선이냐 너비 우선이냐 고민

   1. 깊이 우선
   • 도착점에 도달했을 때의 count를 넣어주면 되나
   • 그럼 각 노드에 도달했을 때 count값을 넣어줘야하나
   • 하지만 다른 경로가 더 짧을 수 있는데 조건문 처리를 해줘야해?
   • 너무 별론데? 안 틀릴 자신이 없다
   2. 너비 우선
   • 제일 먼저 도달한 경우의 count를 보내면 간단하겠는데?
   • count는 어떻게 셀까?
   • 도달한 노드의 라인, 그 노드의 level을 파악하면 되겠다.
   • level은 어떻게 파악하나?
   • level이 바뀌기 전 임의 값을 끼워 넣어서 세자

3. 너비 우선으로 결정

   나의 부끄러운 코드

• 프로그래머스는 시간 초과!
• 백준에서는 3초라는 놀라운 결과로 통과..사실 상 시간 초과

  height, width = map(int, input().split())
  maps = [list(map(int, input())) for _ in range(height)]
  

li = [(0, 1), (1, 0), (0, -1), (-1, 0)] graph = {x : [] for x in range(widthheight)} for i in range(widthheight): 좌표 = (i//width, i%width) if maps[좌표[0]][좌표[1]] == 0: continue for j in li: next_좌표 = (좌표[0]+j[0] , 좌표[1]+j[1]) if -1 in next_좌표 or width <= next_좌표[1] or height <= next_좌표[0] or maps[next_좌표[0]][next_좌표[1]] == 0: continue graph[i].append(next_좌표[0]*width + next_좌표[1])

def bfs(): visited, need_visit = list(), list([0,'x']) count = 1

while (len(need_visit) != 1 or need_visit[0] != 'x'):
    x = need_visit.pop(0)
    if x == "x":
        count += 1
        need_visit.append('x')
        continue
    if x in visited:
        continue
    if x == width*height-1:
        break
    visited.append(x)
    need_visit.extend(graph[x])
return count

print(bfs())

### 오답 노트
- 그래프 형태에 묶인 편협한 생각은 이 문제로 끝(~~개념만 배우고 문제를 처음 접해서 그런걸로 ㅎㅎ..~~)
- 아니다 싶은 로직 위에 덧붙이지 말자

### 옳바른 정답 발상 (사견)
- 방문이 필요한 노드의 동서남북 값을 각각 확인하여 1인 경우에만 (자기자신 값 + 1) 값을 대입하고 방문이 필요한 노드로 append
    - 숫자가 대입된 곳은 무조건 최단거리이다.
    - 0은 막힌 곳이며 1초과의 값이면 이미 방문했던 곳이다.
- 도착지점의 값을 출력

#### 수정 코드
```python
from collections import deque

n, m = map(int, input().split())
maps = [ list(map(int, input())) for _ in range(n) ]
dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]

queue = deque()
count = 0

def bfs(x,y):
    queue.append([x,y])
    while queue:
        x, y = queue.popleft()

        for i in range(4):
            nx, ny = x + dx[i], y + dy[i]
            if 0 <= nx < n and 0 <= ny < m and maps[nx][ny] == 1:
                maps[nx][ny] = maps[x][y] + 1
                queue.append([nx, ny])
    return maps[n-1][m-1]

print(dfs(0,0))

• CPU : 명령어를 해석하고 실행하는 장치
• 프로그램 : 명령어들의 집합체
• 메모리
  • 주메모리 : 램
  • 보조메모리 : HDD SSD
• 운영 체제 : 컴퓨터 시스템을 운영하고 관리하는 소프트웨어
• 시스템 버스 : 요소들을 연결해주는 역할

프로세스와 스레드

프로세스는 운영체제로부터 자원을 할당받는 작업의 단위이고 스레드는 프로세스 내에서 실행되는 여러 작업의 단위이다.

• 예를 들어서 컴퓨터에게 주어지는 처리 방법과 순서를 기술한 일련의 명령문 집합체인 프로그램을 실행 했을 때, 보조 메모리에 있던 것이 주메모리에 올라와서 작업이 진행되는 것이다. => 프로세스가 생성된다는 의미는 프로그램이 실행된 동적인 상태가 된다는 것이다.

• 그렇게 된다면 CPU는 프로세스가 해야할 작업을 수행하고, 작업을 수행하는 단위가 스레드인 것이다.

• 만약 작업을 해야할 작업이 하나이면 싱글 스레드, 여러개면 멀티 스레드이다.

  멀티 스레드의 장단점

• 장점 : 멀티 스레드에서 스레드끼리 메모리 공유와 통신이 가능하다; 자원의 낭비를 막고 효율성을 향상할 수 있다.

• 단점 : 한 스레드에 문제가 생기면 전체 프로세스에 영향을 미친다.

동시성(병행성) vs 병렬성

동시성(concurrency)

• 한 번에 여러 작업을 동시에 다루는 것을 의미한다(스위칭을 한다)
• 논리적 개념이다. 싱글 스레드(asyncio), 멀티 스레드 적용이 가능하다.

  병렬성(Parallelism)

• 한 번에 여러 작업을 병렬적으로 처리하는 것을 의미한다(at the same time)
• 멀티 코어, 멀티 스레딩
• 파이썬에서는 스레드가 병렬성으로 구현될 수 없다. GIL(Global Interpreter Lock), 동시성으로 구현이 돼야한다.

• 대표적인 그래프 탐색 알고리즘
  • 너비 우선 탐색 (Breadth First Search): 정점들과 같은 레벨에 있는 노드들 (형제 노드들)을 먼저 탐색하는 방식
  • 깊이 우선 탐색 (Depth First Search): 정점의 자식들을 먼저 탐색하는 방식

출처 : https://iq.opengenus.org/dfs-vs-bfs/

파이썬으로 그래프를 표현하는 방법

• 딕셔너리와 리스트 자료 구조를 활용해서 그래프를 표현할 수 있다. 출처 : https://www.fun-coding.org ```python graph = dict()

graph['A'] = ['B', 'C'] graph['B'] = ['A', 'D'] graph['C'] = ['A', 'G', 'H', 'I'] graph['D'] = ['B', 'E', 'F'] graph['E'] = ['D'] graph['F'] = ['D'] graph['G'] = ['C'] graph['H'] = ['C'] graph['I'] = ['C', 'J'] graph['J'] = ['I']

### BFS
```python
def bfs(graph, start_node):
    visited, need_visit = list(), list()
    need_visit.append(start_node)

    while need_visit:
        node = need_visit.pop(0)
        if node not in visited:
            visited.append(node)
            need_visit.extend(graph[node])
    return visited

DFS

def dfs(graph, start_node):
    visited, need_visit = list(), list()
    need_visit.append(start_node)

    while need_visit:
        node = need_visit.pop()
        if node not in visited:
            visited.append(node)
            need_visit.extend(graph[node])
    return visited

• 회고 BFS와 DFS의 구현은 친절한 파이썬 덕분에 어렵지 않지만 오늘 알고리즘 친구를 만나서 사투를 벌이고는 휴전 상태이다. 게임맵 최단거리 30분만 잡아보고 안되면 정답을 보고자 했지만 내 힘으로 풀고 싶어서 20분만 20분만 하다가 2시간 이상이 지났고, 제출 후 정확성은 맞았으나 시간초과가 나서 일단 휴전 협정 후 내일 다시 싸울 예정이당. 부끄러운 나의 코드와 생각은 해결 후 내일 업로드 예정

getattr : 속성값, 메서드 가져오기

getattr(객체, 속성 이름 [, 속성이 없을 때 반환 값])

getattr(...)
    getattr(object, name[, default]) -> value

    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
    When a default argument is given, it is returned when the attribute doesn't exist; without it, an exception is raised in that case.

예제

class 통장:
    def __init__(self, 개설_축하_금액):
        """통장 개설!!ㅊㅊ"""
        self.통장액수 = 개설_축하_금액

    def 입금(self, 입금액):
        self.통장액수 += 입금액

    def 출금(self, 출금액):
        self.통장액수 -= 출금액

• 사용자에게서 입금 출금의 행위를 입력 받고 금액도 입력 받아보겠다.

몸이 힘들어질 수도 있는 방법

테스트_통장 = 통장(5000)
x = input('입금 or 출금?') # 입금
y = input('얼마나?')
테스트_통장.x(int(y)) # SyntaxError, 테스트_통장."입금"(int(5000))

• x는 "입금" 혹은 "출금"으로 들어온다고 했을 때, if문을 사용한다면 아래와 같이 할 수 있을 것이다.

if x == '입금':
    return 테스트_통장.입금(int(y))
elif x == '출금':
    return 테스트_통장.출금(int(y))

• 하지만 입금, 출금만 있는게 아니라 입입금과 출출금 등 새로운 메서드들을 추가한다고 생각하면 if문이 계속 늘어날 것이다.
• 이렇게 나누는 분기가 명확하다면 getattr을 사용해 보자

확장하기 편해지는 방법

x = input('입금 or 출금?') # 입금
y = input('얼마나?')
func = getattr(테스트_통장, x) # 테스트_통장."입금" >>> 테스트_통장.입금
func(int(y))

setattr()

getattr(객체, 속성 이름, 지정 값)

setattr(obj, name, value, /)
    Sets the named attribute on the given object to the specified value.

    setattr(x, 'y', v) is equivalent to ``x.y = v''

• object에 새로운 속성을 추가하고 값은 value로 줍니다.

hasattr()

hasattr(객체, 속성 이름)

hasattr(obj, name, /)
    Return whether the object has an attribute with the given name.

    This is done by calling getattr(obj, name) and catching AttributeError.

• 속성이 있는지 True False로 반환합니다. getattr 혹은 setattr 시에 유효성 검사를 할 수도 있겠죵?
• if not hasattr(테스트_통장, x): return "입력 제대로!";

delattr()

delattr(객체, 속성 이름)

delattr(obj, name, /)
    Deletes the named attribute from the given object.

    delattr(x, 'y') is equivalent to ``del x.y''

• 객체의 속성을 지웁니다.

활용하기(까리하고 편리하게, 개인용)

페이히어 기업과제로 가계부를 만들기를 받았다. django를 사용했고,

지출에 해당하는 것만 구현하면 됐지만, 상세 내용에 수입/지출의 값을 넣고 싶었다. 또한 일별 총 수입/지출의 값을 넣으려 설계했다.

그러기 위해서 상세 내용의 수입/지출 내역을 쓰면 일별 수입/지출 또한 바뀌어야했다.

그래서 생성/삭제 시에 변경되는 값을 바꾸기 위해 아래와 같이 만들었는데 getattr과 setattr을 사용하면 확장성 있게 바뀔 수 있겠다.

바꾸기 전

def add_income_expense(self, instance):
    money_type = instance.money_type
    is_expense = True if money_type == '0' else False

    if is_expense:
        instance.day_log.expense += instance.money
    else:
        instance.day_log.income += instance.money

def sub_income_expense(self, instance):
    money_type = instance.money_type
    is_expense = True if money_type == '0' else False

    if is_expense:
        instance.day_log.expense -= instance.money
    else:
        instance.day_log.income -= instance.money

바꾼 후

func_dict = {
    "add" : lambda x,y : x+y,
    "sub" : lambda x,y : x-y,
}
money_type = {
    "0" : "expense",
    "1" : "income"
}

def add_or_sub_income_expense(self, instance, op):

    money_type = instance.money_type
    func = func_dict[op]
    x = getattr(instance.day_log, money_type[money_type])
    money = func(x, instance.money)

    setattr(instance.day_log, income_or_expoense[money_type], money)

• 눈에 한번에 잘 들어오는 것은 바꾸기 전이긴 하다. 하지만 상황에 따라 다르겠지만 확장성은 아래가 더 좋을지도?

나아가서..

• django를 사용하고 있는데 model이나 serializer에서 저장 시 자동적으로 업데이트가 될 수 있게 만들 수 있을건데 뭐가 더 괜찮을지는 생각을 해봐야겠당

바운드와 블로킹

블로킹 : 바운드에 의해 코드가 멈추게 되는 현상

CPU 바운드

• 프로그램이 실행될 때 실행 속도가 CPU속도에 의해 제한 됨을 의미
• 복잡한 수학 수식을 계산할 때(연산을 많이할 때)

I/O 바운드

• Input/Output 바운드
• 프로그램이 실행될 때 실행 속도가 I/O에 의해 제한됨을 의미
• 사용자가 키보드로 숫자를 입력하는 경우 뿐만 아니라, 컴퓨터와 컴퓨터끼리 통신을 할 대에도 I/O 바운드가 발생한다.

동기 vs 비동기

동기(Sync)

• 코드가 동기적으로 동작한다. => 코드가 반드시 작성된 순서 그대로 실행된다.

비동기(Async)

• 코드가 작성된 순서대로 실행되지 않는다.

코루틴은 비동기로 처리된다.

코루틴의 이해

루틴

• 하나의 진입점과 하나의 탈출점이 있는 루틴이다.
• 루틴이란? 일련의 명령 (코드의 흐름)
  • 메인 루틴 : 프로그램의 메인 코드의 흐름
  • 서브 루틴 : 보통의 함수나 메소드(메인 루틴을 보조함)

코루틴

• 서브 루틴의 일반화된 형태
• 다양한 진입점과 다양한 탈출점이 있는 루틴이다.(간단하게 다양한 출/입 함수이다)
• 파이썬에서는 비동기 함수는 코루틴 함수로 만들 수 있다.

async/await

• 코루틴 함수는 async 키워드를 함수 앞에 붙여 사용이 가능하다.
• 원하는 진입/탈출점에 await 키워드를 붙여 사용한다.
• async 함수 밖에서 await 키워드를 사용하고 싶은 경우에는 ayncio 내장 라이브러리를 사용한다.
• asyncio.run(함수())
• 또한 await 키워드 뒤에는 어웨이터블 객체(coroutine, task, future)가 와야한다.

task

• 코루틴을 동시에 예약하는 데 사용된다.
• asyncio.create_task()와 같은 함수를 사용해 테스크로 싸일 때 코루틴은 곧 실행 되도록 자동으로 예약됩니다.

예제는 좀 더 숙지 후 올릴 예정

• 지정한 IP주소에 데이터 전달
• 패킷(Packet)이라는 통신 단위로 데이터 전달 프로토콜이란? 사람과 사람이 통신할때 서로 이해할 수 있는 언어, 공용된 언어를 사용해 전세계 모든 사람과 대화 할수 있다라고 하면, 컴퓨터와 컴퓨터도 서로 이해 할 수 있는 언어, 공용된 언어를 사용 해야 한다는 것인데 이 것이 바로 프로토콜(Protocol) 입니다.

IP 패킷 정보

• 출발 IP, 목적지 Ip, 기타 & 데이터

• 단점(IP 프로토콜의 한계)

• 1. 비연결성 : 패킷을 받을 대상이 없거나 서비스 불능 상태여도 패킷 전송한다
• 2. 비신뢰성 : 중간에 패킷이 사라지거나 순서대로 안올 수 있다.
• 3. 프로그램 구분 : 같은 IP를 사용하는 서버에서 통신하는 애플리케이션이 둘 이상일 때 구분 지을 수 없다

인터넷 프로토콜 스택의 4계층

• 애플리케이션 계층 - HTTP, FTP
• 전송 계층 - TCP, UDP
• 인터넷 계층 - IP
• 네트워크 인터페이스 계층 - 이더넷,

TCP 특징

• 전송 제어 프로토콜 (Transmission Control Protocol)

• 연결 지향 - TCP 3 way handshake(가상연결)

• 데이터 전달 보증

• 순서 보장

• 신뢰할 수 있는 프로토콜

• 대부분 TCP 사용

연결 지향 (씬 씬엨 엨)

1. 클라이언트에서 먼저 syn 접속 요청을 보내면
2. 서버에서는 ack요청 수락과 함께 syn를 클라이언트에게 보낸다.
3. 클라이언트는 서버에게 ack를 보내고
4. 데이터를 전송할 수 있게된다. (3에서 데이터 전송 가능)

데이터 전달 보증

1. 데이터 전송
2. 데이터 잘 받았음

순서 보장

1. 123 순서로 전송
2. 132 순서로 도착
3. 다시보내 (수정 가능)

UDP 특징

• 사용자 데이터그램 프로토콜(User Datagram Protocol)

• 기능이 거의 없고 데이터 전달 및 순서가 보장되지 않지만, 단순하고 빠르다.

• IP와 거의 같으나 Port와 체크섬 정도만 추가됐다

• 애플리케이션에서 추가 작업이 필요하다.

뒤풀이 사진!

팀원분들이 화염병이냐고 놀림ㅋㅋ 다들 술 한 잔.. 그리고 롤링페이퍼를 할까 하다가 오글거리니까 하지 말자로 변경ㅋㅋㅋㅋ

미우나 고우나 우리팀..ㅠㅠ

처음 준호님 원채님 나, 3명으로 팀 구성이 되고 차례로 민수님, 기훈님, 상훈님이 들어오셨다. 4개월 동안 팀을 변경할 기회는 매우 많았지만 유지하는 쪽으로 항상 마음이 기울었다. 잘하시는 다른 분들과 팀을 해볼 기회도 분명 있었지만 그렇게 하지 않은 이유는 사람이 좋고 책임감도 있었기 때문이다.

항상 좋을 순 없었고 책임감이고 뭐고 내 살길 가버려?!라는 심정이 들 때도 있었다(물론 다들 엄청 잘 하시겠지만 다른 팀에 아련히 있을 팀원들을 생각하니 가슴이 저려서 그건 차마..ㅋㅋㅋ) 그럴 때는 서로 솔직하게 털어 놓음으로써 풀어갈 수 있었다.

기술적으로나 경험으로나 제일 부족한 팀이었을 수 있지만, 우리 팀이 항상 최고라 생각하였습니다. 팀장으로서의 자질이나 실력적으로 부족한 저를 믿고 지지해 주신 팀원분들께 너무나 감사했고 더 도움을 못 드려서 죄송하다는 생각이 들었다.

모두 좋은 분들이기에 어딜 가시던 잘 하실 분이라는 것을 알기에 낸중에 같은 곳에서 근무하며 커피 마시면서 회상하시리라 믿는다. 그전에 내가 회사 차려서 스카웃 ㅋㅋ

4개월간의 힘들고 재밌었던 동거동락, 막을 내렸다. 하지만 새로운 막이 열리고 이제 진짜 시작인 것 같아 무섭기도 설레기도 한다.

나 또한 잘할 거고 팀원분들도 매우 매우 잘하시리라 믿는다.

ps. 오늘 모든 포스팅을 velog에 옮겨야하네ㅠ 오히려 좋아~

• settings.py에 DP_MODE를 설정하여 개발 환경과 배포환경에 맞게 설정해줌.
• ec2 postgresql의 볼륨에 media의 default사진이 들어가지 않아서 cp 명령어를 이용하여 복사함.

[TIL/115일차/12.20] 알림 기능 세팅 ft. 내배캠

async_to_sync를 활용하여 channels_layer를 가져오고 group_send를 통하여 알람 기능도 만들 예정이다.

async_to_sync(layer.group_send)(f'alram_{goods.buyer.id}', {'type': 'chat_message', 'response': json.dumps({'response_type': 'alram', 'message': '낙찰됨'})})

[TIL/116일차/12.21] 리팩토링 ft. 내배캠

팀원 분이 맡아서 하는 부분을 내가 맡게 되면서 기존의 APIView를 ModelViewSet으로 바꾸면서 쿼리를 줄이고 Restfull하게 짜려고 노력해 보았다.

from django.db.models import Prefetch

class IsTrader(permissions.BasePermission):

    def has_object_permission(self, request, view, obj):
        return request.user in [obj.goods.seller, obj.goods.buyer]

class ChatViewSet(ModelViewSet):
    """
    리스트 'list' 요청이 오면 채팅방 리스트를 보내줍니다.
    특정 방의 요청이 'retrive' 오면 채팅방의 채팅들을 보내줍니다.
    """
    permission_classes = [IsTrader,]

    def get_permissions(self):
        if self.action == 'list':
            return [permissions.IsAuthenticated(),]
        return super(ChatViewSet, self).get_permissions()

    def get_serializer_class(self):
        if self.action == 'list':
            return TradeInfoSerializer
        elif self.action == 'retrive':
            return TradeMessageSerializer
        else:
            return None
    def get_serializer_context(self):
        # print(self.request.data)
        return {
            'request': self.request,
            'format': self.format_kwarg,
            'view': self,
            'action' : self.action
        }
    def get_queryset(self):
        print(dir(Goods.objects.first()))
        user_id = self.request.user.id
        if self.action == 'list':
            goods = Goods.objects.filter(status = False, buyer__isnull=False).filter( Q(buyer_id = user_id) | Q(seller_id = user_id)).select_related('seller', 'buyer', 'trade_room').prefetch_related('trade_room__trademessage')
            return goods
        elif self.action == 'retrive':
            return TradeChatRoom.objects.all()
        else:
            return None

[TIL/117일차/12.22] 채팅 view 리팩토링 생각 정리 ft. 내배캠

• 설계 로직

채팅방 리스트 큰 틀 : 내가 구매 혹은 판매 물품의 거래 채팅방을 최근 업데이트 된 날짜로 나열하여 보여준다.

1. 물풀의 객체들에서 상태 값은 False(경매가 끝남), 구매자는 있어야한다.

2. 물품의 구매자 혹은 판매자가 자신이어여야만 한다.

3. 쿼리 수를 줄이기 위해,prefetch 와 select를 사용한다.

4. Goods의 trade_room은 TradeCahtRoom을 외래키로 참조한다(원래는 oto이 맞다).

   • annotate를 사용하여 trade_room의 업데이트 날짜 trade_room__updated_at을 가져와
   • updated_at의 임의의 컬럼을 만들어 정렬해 준다.

5. 선택된 Goods의 객체들을 TradeInfoSerializer에 넣어서 보낸다.

   • wait_cnt : 쿼리 요청을 한 번 더 보내지 않기 위해 반복문을 통하여 길이를 구함
   • image : 첫 번째 사진의 url만 필요함. first()를 쓰지 않은 것은 위와 같이 쿼리 요청을 안하기 위하여
   • last_message : 인덱싱을 통하여 마지막 요소를 가져오나, Negative인덱싱은 불가능하여 (전체 길이 -1)을 try except 구문을 사용하여 담아

개별 채팅 방 틀 : 요청자의 권한을 파악, 메시지 읽음 처리

1. 특정 Goods 객체의 판매자 혹은 구매자를 판별
2. 해당 객체의 메시지들을 가져와 내가 작성한 것들을 제외한 메시지를 읽음 처리함. 줌

[TIL/118일차/12.23] 참여자 피드백 ft. 내배캠

참여자 피드백

• 입찰 내역, 채팅 내역, 참여자들 정보들
• 경매 시작 알람, 낙찰 알람, 입찰 경쟁 알람

[WIL] 17주차 ft. 내배캠

회고

• 프로젝트 리팩토링 기간이기도 하며 다음 주면 캠프가 끝난다.
• 재밌기도 하고 힘들기도 했다.
• 돌이켜 보면 4개월 동안 필수적인 일을 제외하면 밖으로 나갔던 날은 손으로 꼽는 것 같다. ㅋㅋㅋ
• 운동도 안 해버려서 피폐해진 감이 없잖아 있는데 곧 끝나니 운동도 다시 시작하며 힘차게 취업 전선에 뛰어들자!

initial_data

• 유효성 검사를 하기 전에 필드에 접근할 수 있습니다.

  serializer = serializer_class(data = request.data)
  serializer.initial_data['필드'] = 값 or 필드 값을 이용할 수 있음

validated_data

• 유효성 검사를 통과한 필드에 접근 할 수 있다.

  serializer = serializer_class(data = request.data)
  if serializer.is_valid():
    serializer.validated_data['필드'] = 값
    serializer.save()

data

• 유효성 검사를 통과하고 save된 필드에 접근할 수 있다.

  serializer = serializer_class(data=request.data)
  if serializer.is_valid():
    serializer.save()
    serializer.data['필드']

게시글에 포함 된 여러장의 이미지 serializer로 저장하기

models.py

class Goods(models.Model):
    class Meta:
        db_table = 'Goods'

    seller = models.ForeignKey(User, on_delete=models.CASCADE, related_name='sell_goods')
    title = models.CharField(max_length=256)
    content = models.TextField()



class GoodsImage(models.Model):
    goods = models.ForeignKey(Goods, on_delete=models.CASCADE)
    image = models.ImageField(upload_to='goods/')

예시로 상품 모델이 있고 상품 이미지 모델을 만들었다. 상품에는 여러개의 이미지를 포함시키기 위해 상품이미지 모델을 분리 시켜서 상품을 참조하도록 하였다.

serializers.py

class GoodsImageSerializer(serializers.ModelSerializer):
    class Meta:
        model = GoodsImage
        fields = ['image',]


class GoodsDetailSerializer(serializers.ModelSerializer):
    seller = serializers.SerializerMethodField()
    goodsimage_set = GoodsImageSerializer(many=True, read_only = True)

    # images = serializers.SerializerMethodField()
    # def get_images(self, obj):
        # return GoodsImageSerializer(obj.goodsimage_set.all(), many = True).data

    def get_seller(self, obj):
        return obj.seller.username

    class Meta:
         model = Goods
         fields = '__all__'

상품 이미지 모델에서 상품을 참조하기 때문에 상품에서 역참조 시 related_name이 설정되어 있지 않다면 모델_set 필드로 사용하면 되고, 상품 이미지 시리얼 라이저를 통하여 many=True, read_only=True값을 주어서 이미지의 주소 값을 가져올 수 있다.

(주석처럼 SerializerMethodField를 사용해 주어도 된다.)

views.py

class GoodsView(ModelViewSet):

    queryset = Goods.objects.prefetch_related('goodsimage_set').select_related('seller').all()
    serializer_class = GoodsDetailSerializer
    permission_classes = [IsAuthorOrReadOnly,]

    def get_permissions(self):
        if self.action == 'create':
            return [permissions.IsAuthenticated(),]
        return super(GoodsView, self).get_permissions()


    def create(self, request, *args, **kwargs):

        serializer = self.get_serializer(data=request.data)

        images = serializer.initial_data.pop('goodsimage_set')  [1]
        images = [{'image' : image} for image in images]        [2]

        serializer.is_valid(raise_exception=True)
        obj = self.perform_create(serializer)               [3]

        image_serializer = GoodsImageSerializer(data = images, many = True) [4]
        image_serializer.is_valid(raise_exception=True) [4]
        image_serializer.save(goods = obj)  [5]

        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)


    def perform_create(self, serializer):
        return serializer.save(seller_id = self.request.user.id) # save()메서드는 생성된 object를 반환해 주기 때문에 오버라이딩하였다

모델 뷰셋을 사용하였는데 여기에서 중요한 것만 짚겠다.

post요청이 왔을 때 create메서드를 오바라이딩 하였다

• [1] 유효성 검사를 통하기 전 데이터(initial_data)에서 이미지 필드의 값들을 빼온다
• [2] 1번에서 빼온 이미지 데이터를 {'필드값' : 이미지값} serializer양식에 맞춰준다
• [3] 글 양식에서 이미지를 제외한 데이터를 serializer를 통해서 저장하고 객체를 가져온다.
• [4] 2번에서 양식을 맞춰준 이미지 데이터들을 시리얼 라이저에 넣어 유효성 검사를 한다.
• [5] 어떤 상품을 바라보는지 3번에서의 값을 저장시켜준다.

request.data에서 빼와서 사용을 해도 되지만 serializer에서 접근을 하고 싶은 마음에 검색하여 사용했다.

serializer클래서 내부에서 가공되지 않은 상태의 데이터를 사용하기 위해서 initial_data를 사용하는 것으로 판단을 하였다. context에 데이터를 넘겨주어도 되지만 여기서는 굳이 그렇게 안 하고 view에서 처리하였다.

프로젝트 마무리 단계에 있어서 스타일이나 자잘한 수정을 보고 있다. 디자인에 감각이 없기도하고 JS를 검색을 통해서 바로바로 적용을 하면서 하다보니 코드가 정갈하지 않은 점과 백엔드에 집중하지 못하는 점이 아쉽지만, 출시할 생각에 모든 재미있다.

• 오늘 실수한 것은 pr을 보낼 때 개인 정보가 담겨있는 것을 보내 지울 수는 없다는 것을 알았다.
• 비밀키를 서비스에서 지우면 되지만 나의 번호가 남아있어 조금은 찝찝하긴 하다.
• 심지어 내가 팀원분께 그거 보내지 말라고 했는데도 없이 보냈다고 착각을 하여서 머지를 해버렸당 ㅎㅎ.. 잘 확인하자!

[TIL/107일차/12.13] Q객체 ft. 내배캠

Q객체 장고 orm 쿼리문처럼 쓰고 싶을 때 사용할 수 있다. and의 경우에는 &가 있다. &=는 where의 and조건이고 |=는 wherer의 or조건이다.

q = Q(status = True) | Q(status = None)
recommend_goods = self.get_queryset().filter(q).annotate(participants_count = Count('auctionparticipant')).order_by('-participants_count')[:10]
serializer = GoodsListSerializer(recommend_goods, many = True, context = self.get_serializer_context())

[TIL/108일차/12.14] 프로젝트 발표 준비 백엔드 배포 시작 ft. 내배캠

회고

• docker와 nginx를 미리 공부하지 않고 배포를 시작하는 단계다 보니 꽤 힘들었다. 기본적인 백엔들 배포는 가능하더라도 다른 컨테이너 간의 연결이라던가 기본적인 것이 많이 안들어왔다. 그래서 여기에 조금 더 공부를 해보면 좋고 재밌을 것 같다는 생각을 했다. 또한 발표를 위해서 준비할 것이 꽤 많아 집중을 하느라 TIL에 조금 소홀하긴하다.

[TIL/109일차/12.15] 프로젝트 중간 발표 & 회고 ft. 내배캠

프로젝트 중간 발표가 끝나고 이제 배포와 피드백을 받고 프로젝트를 보완하고 발전하려는 작업을 남기고 있었고 더 나은 협업을 위해서 깃허브의 프로젝트를 활용하자고 하였다. 서로의 이슈에 대해서 논의할 수 있고 얼마나 진행됐는지와 어떤 방식으로하면 좋을 지에 대해서 논의 할 수 있는 것이 마음에 들어서 제안을 하였고 다행스럽게도 좋게 봐주셨다.

[TIL/110일차/12.16] annotate ft. 내배캠

annotate를 활용한다면 기존에 있던 컬럼에 내가 원하는 컬럼을 추가하여 볼 수 있다. 나는 두개의 테이블에서 다른 하나를 참조하는 개수에 대해서 알아내기 위해서 사용하였고 좀 더 자게한 것은 추후에 포스팅할 계획이다.

q = Q(status = True) | Q(status = None)
recommend_goods = self.get_queryset().filter(q).annotate(participants_count = Count('auctionparticipant')).order_by('-participants_count')[:10]
serializer = GoodsListSerializer(recommend_goods, many = True, context = self.get_serializer_context())

return Response(data = serializer.data, status=status.HTTP_200_OK)

이것을 사용함으로써 원래 Goods query_set에는 참여자 수라는 컬럼이 없었지만 annotate를 사용하여 참여자 수를 가져올 수 있었다.

[WIL] 내일 배움 캠프 16주차

주간 회고

나는 코딩을 처음 했을 때 너무너무 못 한것을 알기에 지금 처음 하시는 분들에 대해서 존경하는 부분들이 꽤 많다. 그래서 존중하고 더 알려드리려고 하는 부분들이 있다. 하지만 시간이 갈 수록 내가 배려하는 부분에 대해서 당연하게 생각하시고 더 바라시게 되는 것 같다. 이것 또한 내가 잘 못한 것이라고 생각한다. 이를 바로 잡아야하고 이런 일이 다시 생기게 되면 안될 것 같다는 생각을 한다. 배우는 인생.. 재밌다. 이래서 협업을 해봐야 하는 것 같다.

bulk_create() 시 유의사항

이미 정해져있는 인스턴스를 저장해야하기 때문에 Model() 인스턴스를 직접 만들어주어 pk값이 지정되게 한다

기존

instance = Goods.objects.create(**validated_data)
image_set = self.context['request'].FILES.getlist('goodsimage_set')
image_list = [{'goods' : instance, 'image' : image}  for image in image_set]
GoodsImage.objects.bulk_create(image_list)

변경 후

instance = Goods.objects.create(**validated_data)
image_set = self.context['request'].FILES.getlist('goodsimage_set')
image_list = [GoodsImage(goods = instance, image = image) for image in image_set]
GoodsImage.objects.bulk_create(image_list)

'dict' object has no attribute 'pk' when using Django bulk_create() function

[TIL/101일차/12.06] CSS/JS 타이머 만들기, Django image validate ft. 내배캠

타이머 만들기

<div class="pie-timer" style="box-shadow: 0 2px 5px 0px;">
    <div id="center-timer"></div>
</div>

.pie-timer {
            position: relative;
            display: inline-block;
            width: 200px;
            height: 200px;
            border-radius: 50%;
            transition: 0.3s;
        }

        #center-timer {
            background: #fff;
            display: block;
            position: absolute;
            top: 50%;
            left: 50%;
            width: 190px;
            height: 190px;
            border-radius: 50%;
            text-align: center;
            line-height: 100px;
            font-size: 20px;
            transform: translate(-50%, -50%);
        }

async function startTimer(time) {

    let totalSecond = time

    let x = setInterval(function () {
        let min = parseInt(totalSecond / 60)
        let sec = totalSecond % 60
        let perTime = totalSecond / (60 * 20) * 100
        let percolor = perTime <= 10 ? 'red' : ['blue', 'blue', 'purple'] [parseInt(perTime / 40)] // 테두리 색상 설정

        document.getElementById('center-timer').innerHTML = min + "분" + sec + "초";
        $('.pie-timer').css({
            "background": "conic-gradient(" + percolor + " 0% " + perTime + "%, #ffffff " + perTime + "% 100%)"
        });
        totalSecond--;

        if (totalSecond < 0) {
            clearInterval(x);
            document.getElementById('center-timer').innerHTML = '종료';
        }
    }, 1000);
}

Django 이미지 확장자 유효성 검사

from django.core.validators import validate_image_file_extension

class GoodsImage(models.Model):
    goods = models.ForeignKey(Goods, on_delete=models.CASCADE)
    image = models.ImageField(upload_to='goods/',validators=[validate_image_file_extension])

[TIL/102일차/12.07] 프로젝트 프론트엔드 로직 & UI, 백엔드 개인 경고 메시지, 경매 참여 인원 저장 로직 ft. 내배캠

• 오늘 한 일

  • 프로젝트 프론트엔드 로직 & UI
  • 백엔드 개인 경고 메시지
  • 경매 참여 인원 저장 로직
  • 전 기수 취업자 면담
  • 팀원 코드 병합

• 회고

  • 시중에 내놓았을 때, 사용자들이 편하고 올바르게 사용을 할 수 있게끔. 로직을 세세하게
  • 짜는 것이 재밌지만 전반적인 진행률도 신경을 써야한다.
  • 백엔드에 집중하면 좋긴하지만 프론트엔드를 통해 리프레쉬도 돼서 낫밷이기도 하다.(좀 많이 시간이 걸리는 것은 함정)
  • 힘들지만 재밌다. 배포할 생각에 설레버려 ㅋㅋ 파이팅

[TIL/103일차/12.08] 백엔드 리팩토링 & 회원 프론트 로직 & UI ft. 내배캠

• 오늘 한 일
  • 백엔드 리팩토링 : APIView에서 ViewSet으로 바꿔 코드를 줄임
  • 회원 인증과 관련된 프론트 UI와 로직 구현

[TIL/104일차/12.09] channels ASGI import error, Js confirm true/false ft. 내배캠

• ASGI import error가 난 경우에는 경로가 확실하고 설정이 잘 된 경우 웹소켓을 다루는 파일에서(consumer.py 등) import한 라이브러리를 잘 확인해 보아야합니다.

<script>
    if (!confirm("확인(예) 또는 취소(아니오)를 선택해주세요.")) {
        // 취소(아니오) 버튼 클릭 시 이벤트
    } else {
        // 확인(예) 버튼 클릭 시 이벤트
    }
</script>

[WIL] 내일 배움 캠프 15주차 ft. 내배캠

• 회고
  • 마지막 최종 프로젝트를 진행하고 있는게 신기하면서도, 불안, 기쁨, 힘듦 여러가지의 감정이 느껴진다. 백엔드를 더 딥하게 파고 싶지만 프론트 없이 프로젝트를 하다보니 그 부분은 어려운 점은 아쉽지만 캠프가 끝나고도 이력서를 넣으면서 공부할 생각에 뭔가 설레기도 한다. 프로젝트 파이팅!

블로그를 야무지게 채울 생각에 셀렘 가득 ㅎㅋ

• 서버를 실행하고 주기적으로 함수를 실행해야할 경우 필요한 라이브러리이다.

1. django-crontab 설치

pip install django-crontab

2. settings.py 앱 추가 settings.py

   INSTALLED_APPS = [
    .
    .
    'django_crontab',
    .
    .
   ]

3. 앱 하위에 cron.py 생성 후 원하는 함수 구현

   def crontab_hello():
    print('hello')

4. settings.py 설정하기

   CRONJOBS = [
    ('* * * * *', 'study_group.cron.crontab_penalty_student', '>> '+os.path.join(BASE_DIR, 'stady/log/cron.log')),
   ]

• 매분 실행하고 프로젝트/폴드/로그파일 경로를 설정하여 로그를 확인할 수 있다. crontab 시간 설정 웹 사이트

5. 명령어

• 보기 python manage.py crontab show
• 추가 python manage.py crontab add
• 삭제 python manage.py crontab remove

팀 회고

• 느낀점:

  • 원채님 : 팀원 모두가 맡을 역할을 잘 소화함
  • 민수님 : 팀이 좋은 방향으로 가고있다는 것을 느낌
  • 기훈님 : 아직 많이 부족하지만 방향성을 찾을 것 같다.
  • 준호님 : 딥러닝 torch를 너무 몰라서 아쉽고 백엔드에 집중을 못 한 것이 조금 아쉽다.
  • 나 : 이전부터 생각해야할 것들이 꽤 많아 조금 지치는 프로젝트였지만 극복하는 것도 꽤 좋았다.

• Keep:

  • 기훈님 : 회의시간을 서로 잘 조율하여 누락없이 소통
  • 민수님 : 오전 오후 회의가 유지하기
  • 준호님 : 오늘의 공부 내용 및 문제 출제 발표 시간 갖기
  • 원채님 : 프로젝트의 연계성 유연성
  • 나 : 문제 내고 풀기

• 문제점:

  • 준호님 : 코드 정리를 시기를 찾기 힘든 것
  • 기훈님 : 식사를 제때 하지 못 하는 것
  • 원채님 : 개인적인 목표를 완벽히 이루지는 못 함
  • 민수님 : 회의 때 참여가 좀 더 필요하다. 의견을 잘 내자.
  • 나 : 진행상황을 좀 더 나누자

• 시도점 :

  • 민수님 : 커밋 많이 남기기, 이슈 적기
  • 준호님 : 모두 깃 잘 활용하기
  • 원채님 : 변수 이름 잘 쓰기, 진행상황 잘 소통하기
  • 나 : 문서 작성과 설계를 꼼꼼하게 정하고 이행하기

[TIL/94일차/11.29] 깃허브 리드미 정리, 포트폴리오 이력서 특강 ft. 내배캠

이력서에서 중요한 것

• 문제 해결 능력,,,추가 예정

[TIL/95일차/11.30] 프로젝트(핸즈업) 프로젝트 컨셉 구상, 와이어 프레임, ERD, API 구상 ft. 내배캠

[TIL/96일차/12.01] django-channels ft. 내배캠

한 것

• 프로젝트 뼈대 작업, 팀 관련 작업, 티맥스 채용 설명회
• channels-channels 장고 채널스를 통해 웹 소캣을 사용하여 채팅기능을 구현했다. 자세한 내용은 주말에 쓰도록 해야지

django-channels 공식문서

[TIL/97일차/12.02] serializer 객체 접근 ft. 내배캠

initial_data

• 유효성 검사를 하기 전에 필드에 접근할 수 있습니다.

  serializer = serializer_class(data = request.data)
  serializer.initial_data['필드'] = 값 or 필드 값을 이용할 수 있음

validated_data

• 유효성 검사를 통과한 필드에 접근 할 수 있다.

  serializer = serializer_class(data = request.data)
  if serializer.is_valid():
    serializer.validated_data['필드'] = 값
    serializer.save()

data

• 유효성 검사를 통과하고 save된 필드에 접근할 수 있다.

  serializer = serializer_class(data=request.data)
  if serializer.is_valid():
    serializer.save()
    serializer.data['필드']

[WIL] 14주차

이번 주에 대표적으로 한것

• 최종 프로젝트 구상 (아이디어, 컨셉, 와이어 프레임, api 등)
• Channels를 통한 채팅 구현
• viewset활용한 백엔드 구현

회고

• 새로운 주제의 흥미로운 프로젝트를 시작하니 너무나 재밌다. 백엔드를 파면 팔수록 알아야할 것은 쌓여가지만 알아가는 재미가 쏠쏠하지 싶다.

다음 주에 할 것

알고리즘, 프로젝트 백, 프론트, 사용자 인증 구현

bulk_update & bulk_create

• .save()요청 시 쿼리요청을 보내게 되는데, 한꺼번에 많은 양의 쿼리를 요청하면 느려지게 된다. 그럴 때는 bulk_를 사용하여 효율적으로 저장을 할 수 있다.

모델.objects.bulk_update(배열, [컬럼들])

stuies = []
.
.
.
Study.objects.bulk_update(stuies, ["week_money"])

[TIL/87일차/11.22] sting을 json으로 , json을 string으로 변환하기 ft. 내배캠

json을 string으로 변환하기

JSON.stringify(딕셔너리)

string을 json으로 변환하기

JSON.parse(json형태인문자열)

[TIL/88일차/11.23] js 상대 날짜 똑똑하게 표현하기 ft. timeago

• timeago CDN 받기

  <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-timeago/1.6.7/jquery.timeago.min.js"></script>

• 한국 시간으로 원한다면?

  <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-timeago/1.6.5/locales/jquery.timeago.ko.js"></script>

• 날짜 시간을 로딩 후 .timeago() 실행하여 나타내 주기!

<time class="timeago" datetime="${time}"></time>

$("time.timeago").timeago();

참조-깃헙

[TIL/89일차/11.24] Mac git 에러 xcrun: error: invalid active developer path ft. 내배캠

맥업데이트 후 명령어 에러 해결하기

xcode-select --install

[TIL/90일차/11.25] JS 삼항 연산자 ft. 내배캠

자바스크립트 삼항 연산자

condition ? exprIfTrue : exprIfFalse

조건? 참일 때 : 거짓일 때

function example(…) {
    return condition1 ? value1
         : condition2 ? value2
         : condition3 ? value3
         : value4;
}

[WIL] 13주차

이번 주에 대표적으로 한것

• Docker
• 프로젝트

회고

• 아직 도커에 익숙하지 않아서 배포를 원활하게 못 한 느낌이 있다. 최종 프로젝트에는 좀 더 공부를 하고 잘 적용할 것이다.

다음 주에 할 것

프로젝트 구상과 진행

ImportError: libGL.so.1: cannot open shared object file: No such file or directory

ubuntu22.04.1에서 파이썬 3.10.8 이미지에 opencv를 설치하고 실행을 하는데 아래와 같은 에러가 났다.

ImportError: libGL.so.1: cannot open shared object file: No such file or directory

찾아보니 libgl1-mesa-glx라는 것이 설치가 안됐기 때문이고

해결 방법은

이미지 빌드하는 파일인 Dockerfile에 설치하는 구문을 추가해 주면 된다.

RUN apt-get update
RUN apt-get -y install libgl1-mesa-glx

ubuntu 버전 확인

$ lsb_release -a

[TIL/80일차/11.15] 프로젝트 구상, drf살짝 ft. 내배캠

프로젝트 기능에 대한 회의, 아이디어 구상과 와이어 프레임, 정책을 생각하는 하루였고 drf에 대하여 약간 공부하는 하루였습니다.

[TIL/81일차/11.16] Generics RetrieveAPIView ft. 내배캠

url 파라미터 두 개 이상 사용하기

• 파라미터의 이름이 pk이가(미확) 아니거나 두 개 이상일 경우 특정 인스턴스를 가져올 수 있는 방법에 대해 고민해 보고 찾아봤습니다.

결론은 self.kwargs에 저장된 것을 활용하면 됨

예시, 특정 모델의 인스턴스를 가져오고 싶을 때 get_object를 오버라이딩하여 가져오는 경우

def get_object(self):
    return MyModel.objects.get(foo = self.kwargs["foo"], bar = self.kwargs["bar"])

[TIL/82일차/11.17] Algorithm, DRF ListCreateView ft. 내배캠

python len()함수는 어떻게 O(1)의 시간 복잡도를 가질까?

• len()은 __ len __()을 호출한다. (마크다운 언어로 __ 띄움)
• __ len __()은 카운터로 작동하며 데이터가 정의되고 저장되면 자동적으로 증가한다. 결과적으로 길이를 가져오라는 것 대신 이미 저장된 value값을 가지고 오는 것이다.

algorithm 회고

토끼반 알고리즘 10문제

• 짧게 생각하고 오만함이 차고 넘쳐 까불다가 오히려 시간을 더 써버렸다.
• 하지만 맞왜틀이 아닌 틀왜맞을 찾았다. 반례를 등록하고 싶은데 프로그래머스에는 있지는 않는 것 같다.
• 쉬운 풀이가 있음에도 돌아가서 나자신에게 아쉬웠다(성능은 좀 나으니까 정신 승리, 아무나 그렇다고 해줘ㅠ)
• 화나지만 그래도 뿌듯하고 짜증나지만 재밌다. 나 자신에게 화가나

[TIL/83일차/11.18] Django 쿼리셋 로깅하기 ft. 내배캠

로깅이란?

• 정보를 제공하는 일련의 기록인 로그(log)를 생성하도록 시스템을 작성하는 활동.

settings.py

LOGGING = {
    'version': 1,    #logging 버젼
    'disable_existing_loggers': False, # 원래 있던 로깅들을 그래도 냅둠 # 만약 True면 못쓴다는 거겠죠? ㅎ
    'handlers': {                    # 로깅 메세지에서 일어나는 일을 결정하는 녀석이라고 장고공식문서에 나와있는데, 아직 무슨말인지는 저도 모르겠네요 ㅎㅎ 
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
        }
    },
    'loggers': {                # 로깅을 console에 띄울지 ... 다른데 띄울지 그냥 DEBUG용으로 레벨을 설정할 수 도있고, 
        'django.db.backends': {
            'handlers': ['console'],
            'level': 'DEBUG',
        },
    }
}

[TIL/84일차/11.19] django-crontab ft. 내배캠

django-crontab이란?

• 서버를 실행하고 주기적으로 함수를 실행해야할 경우 필요한 라이브러리이다.

1. django-crontab pip install django-crontab

2. settings.py 앱 추가 settings.py

   INSTALLED_APPS = [
    .
    .
    'django_crontab',
    .
    .
   ]

3. 앱 하위에 cron.py 생성 후 원하는 함수 구현

   def crontab_hello():
    print('hello')

4. settings.py 설정하기

   CRONJOBS = [
    ('* * * * *', 'study_group.cron.crontab_penalty_student', '>> '+os.path.join(BASE_DIR, 'stady/log/cron.log')),
   ]

• 매분 실행하고 프로젝트/폴드/로그파일 경로를 설정하여 로그를 확인할 수 있다. (crontab 시간 설정 웹 사이트)[https://crontab.guru/#*_*_*_*_*]

[WIL/ 12주차] 내일 배움 캠프 12주차 ft. 내배캠

이번 주에 대표적으로 한것

• Docker
• 프로젝트 구상
• drf generics viewset(살짝)
• 알고리즘

  회고

느낌적으로 새롭게 배우는 것이 많은 한 주였다. 무언가를 많이 만들기보다는 조금씩 만들며 개념을 다지는 주였다. 알고리즘을 하면서 정답으로 가는 길을 돌아가곤 하는데 잘 짠 코드를 보면 감탄도 나오고 나에 대한 분노도 조금 느끼나 좌절하지 않고 더 잘쓰기 위해서 노력하자는 마음이 든다. DRX의 꺾이지 않는 마음 ㅋ

다음 주에 할 것

프로젝트 진행, 배포, 리팩토링, 보완

알고리즘

read_csv()를 이용하여 csv파일을 편리하게 DataFrame으로 로딩합니다. read_csv()의 sep인자를 콤마(,)가 아닌 다른 분리자로 변경하여 다른 유형의 파일도 로드가 가능합니다.

import pandas as pd
titanic_df = pd.read_csv('titanic_train.csv')

head() tail() 맨 앞 또는 맨 뒤부터 데이터를 가져올 수 있다. 기본 값은 5

titanic_df.head()

set_option()

pd.set_option('display.max_rows', 1000) # 행 개수
pd.set_option('display.max_colwidth', 100) # 컬럼 글자 너비
pd.set_option('display.max_columns', 100) # 컬럼 개수

DataFrame의 생성

dic1 = {'Name': ['Chulmin', 'Eunkyung','Jinwoong','Soobeom'],
        'Year': [2011, 2016, 2015, 2015],
        'Gender': ['Male', 'Female', 'Male', 'Male']
       }
# 딕셔너리를 DataFrame으로 변환
data_df = pd.DataFrame(dic1)
print(data_df)
print("#"*30)

# 새로운 컬럼명을 추가
data_df = pd.DataFrame(dic1, columns=["Name", "Year", "Gender", "Age"])
print(data_df)
print("#"*30)

# 인덱스를 새로운 값으로 할당. 
data_df = pd.DataFrame(dic1, index=['one','two','three','four'])
print(data_df)
print("#"*30)

       Name  Year  Gender
0   Chulmin  2011    Male
1  Eunkyung  2016  Female
2  Jinwoong  2015    Male
3   Soobeom  2015    Male
##############################
       Name  Year  Gender  Age
0   Chulmin  2011    Male  NaN
1  Eunkyung  2016  Female  NaN
2  Jinwoong  2015    Male  NaN
3   Soobeom  2015    Male  NaN
##############################
           Name  Year  Gender
one     Chulmin  2011    Male
two    Eunkyung  2016  Female
three  Jinwoong  2015    Male
four    Soobeom  2015    Male
##############################

columns, index, values

print("columns:",titanic_df.columns)
print("index:",titanic_df.index)
print("index value:", titanic_df.head().index.values)

columns: Index(['PassengerId', 'Survived', 'Pclass', 'Name', 'Sex', 'Age', 'SibSp',
       'Parch', 'Ticket', 'Fare', 'Cabin', 'Embarked'],
      dtype='object')
index: RangeIndex(start=0, stop=891, step=1)
index value: [0 1 2 3 4]

info()

DataFrame내의 컬럼명, 데이터 타입, Null건수, 데이터 건수 정보를 제공합니다.

titanic_df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   PassengerId  891 non-null    int64  
 1   Survived     891 non-null    int64  
 2   Pclass       891 non-null    int64  
 3   Name         891 non-null    object 
 4   Sex          891 non-null    object 
 5   Age          714 non-null    float64
 6   SibSp        891 non-null    int64  
 7   Parch        891 non-null    int64  
 8   Ticket       891 non-null    object 
 9   Fare         891 non-null    float64
 10  Cabin        204 non-null    object 
 11  Embarked     889 non-null    object 
dtypes: float64(2), int64(5), object(5)
memory usage: 83.7+ KB

describe()

데이터값들의 평균,표준편차,4분위 분포도를 제공합니다. 숫자형 컬럼들에 대해서 해당 정보를 제공합니다.

titanic_df.describe()

value_counts()

동일한 개별 데이터 값이 몇건이 있는지 정보를 제공합니다. 즉 개별 데이터값의 분포도를 제공합니다.

value_counts() 메소드를 사용할 때는 Null 값을 무시하고 결과값을 내놓기 쉽습니다. value_counts()는 Null값을 포함하여 개별 데이터 값의 건수를 계산할지 여부를 dropna 인자로 판단합니다.

value_counts = titanic_df['Pclass'].value_counts()
print(value_counts)
print(titanic_df['Embarked'].value_counts(dropna=False)) # Null 값 포함한 분포도

3    491
1    216
2    184
Name: Pclass, dtype: int64
S      644
C      168
Q       77
NaN      2
Name: Embarked, dtype: int64

# DataFrame에서도 value_counts() 적용 가능. 
titanic_df[['Pclass', 'Embarked']].value_counts()

Pclass  Embarked
3       S           353
2       S           164
1       S           127
        C            85
3       Q            72
        C            66
2       C            17
        Q             3
1       Q             2
dtype: int64

DataFrame과 리스트, 딕셔너리, 넘파이 ndarray 상호 변환

• 넘파이 ndarray, 리스트, 딕셔너리를 DataFrame으로 변환하기

import numpy as np

col_name1=['컬럼']
list1 = [1, 2, 3]
array1 = np.array(list1)

print('리스트로 만든 DataFrame \n', pd.DataFrame(list1, columns=col_name1))
print('ndarray로 만든 DataFrame \n', pd.DataFrame(array1, columns=col_name1))

리스트로 만든 DataFrame 
    컬럼
0   1
1   2
2   3
ndarray로 만든 DataFrame 
    컬럼
0   1
1   2
2   3

col_name = ['이름', '나이', '성별']
list1 = [
    ['김경민', '25', '남'],
    ['김윤민', '27', '남'],
    ['이효리', '22', '여'],
]
array1 = np.array(list1)
print('2차원 리스트로 만든 DataFrame \n', pd.DataFrame(list1, columns=col_name))
print('2차원 ndarray로 만든 DataFrame \n', pd.DataFrame(array1, columns=col_name))

2차원 리스트로 만든 DataFrame 
     이름  나이 성별
0  김경민  25  남
1  김윤민  27  남
2  이효리  22  여
2차원 리스트로 만든 DataFrame 
     이름  나이 성별
0  김경민  25  남
1  김윤민  27  남
2  이효리  22  여

dic1 = {
    '이름' : ['김경민', '김윤민', '이효리'],
    '나이' : [25, 27, 22],
    '성별' : ['남', '남', '여'],
}
df_user = pd.DataFrame(dic1)
print('딕셔너리로 만든 DataFrame \n', df_user)

딕셔너리로 만든 DataFrame 
     이름  나이 성별
0  김경민  25  남
1  김윤민  27  남
2  이효리  22  여

DataFrame을 ndarray, 리스트, 딕셔너리로 변환하기

col_name = ['col1', 'col2', 'col3']
list1 = [
    [1,2,3],
    [2,3,4]
] 
df_list = pd.DataFrame(list1, columns = col_name)
print('DataFrame : \n',df_list)
print('DataFrame\'s values \n', df_list.values, 'type?', type(df_list.values))
print('DataFrame to list \n',df_list.values.tolist(), 'type?', type(df_list.values.tolist()))

DataFrame : 
    col1  col2  col3
0     1     2     3
1     2     3     4
DataFrame's values 
 [[1 2 3]
 [2 3 4]] type? <class 'numpy.ndarray'>
DataFrame to list 
 [[1, 2, 3], [2, 3, 4]] type? <class 'list'>

print('DataFrame to dict \n', df_list.to_dict('list'), 'type?', type(df_list.to_dict()))

DataFrame to dict 
 {'col1': [1, 2], 'col2': [2, 3], 'col3': [3, 4]} type? <class 'dict'>

DataFrame의 칼럼 데이터 세트 생성과 수정, 삭제

df_user['address'] = 'Seoul'
df_user

df_user['10년후'] = df_user['나이'] + 10
df_user

df_user['나이/10후나이'] = df_user['나이']/df_user['10년후']
df_user

df_user = df_user.drop('address', axis=1) # 열을 지울 때는 label과 axis 1
df_user = df_user.drop(index = 0, axis=0) # 행을 지울 때는 index과 axis 0

index 객체

print(titanic_df.head().index)
col_name = ['이름', '나이', '성별']
list1 = [
    ['김경민', '25', '남'],
    ['김윤민', '27', '남'],
    ['이효리', '22', '여'],
]
df_user=pd.DataFrame(list1,index=['1짱','2짱','3짱'], columns=col_name)
print(df_user.index)

RangeIndex(start=0, stop=5, step=1)
Index(['1짱', '2짱', '3짱'], dtype='object')

indexes = df_user.index
print(indexes,type(indexes.values))
print(indexes[0])

Index(['1짱', '2짱', '3짱'], dtype='object') <class 'numpy.ndarray'>
1짱

indexes[0] = '5짱' # 변경불가

Cell In [83], line 1
----> 1 indexes[0] = '5짱'

TypeError: Index does not support mutable operations

출처 : kakao developers doc

참고하면 괜찮을 블로그

해야할 리스트(사전 준비)

1. 카카오 developers에서 애플리케이션 추가하기

2. 추가한 애플리케이션에 들어가서 앱키 받아놓기(앱키는 노출되지 않게 주의해 주세요!)

3. 앱 설정의 플랫폼에 들어가 Web URL에 내 사이트 등록하기

4. 필요한 정보를 동의항목에서 설정하기

5. 카카오 로그인 활성화와 redirect URI 설정하기

5-1) 백 엔드에서 redierct uri를 받을 url설정하기 - 처리를 원하는 url을 설정해 줍니다.

# urls.py
from django.urls import path
from user.views import kakao_social_login, kakao_social_login_callback

urlpatterns = [
    #로그인 요청을 보낼 url
    path('account/login/kakao/', kakao_social_login, name='kakao_login'),
    #받은 인가 코드로 접근 토근을 받아 유저의 정보를 가져올 url
    path('account/login/kakao/callback/', kakao_social_login_callback, name='kakao_login_callback'),
]


# views.py
def kakao_social_login(request):
    pass

def kakao_social_login_callback(request):
    pass

5-2) 프론트 엔드에서 버튼을 만들기!

<!--  로그인 버튼과 백엔드에서 설정해준 URL로 설정하기    -->
<a id="kakao-login-btn" href="/account/login/kakao">
    <img src="https://k.kakaocdn.net/14/dn/btroDszwNrM/I6efHub1SN5KCJqLm1Ovx1/o.jpg" width="222" alt="카카오 로그인 버튼"/>
</a>

5-3) 카카오 developers에서 로그인 활성화 & redirect uri 등록하기

REST API로 인증 요청 및 접근 코드 받아서 사용자 정보 활용하기

저희가 처리해야할 부분은 4개가 되겠습니다.

1번 - /oauth/authorize 에 요청 보내기

def kakao_social_login(request):
    """
    카카오톧에 나의 애플리케이션의 정보를 담아 사용자에게 카카오 로그인 요청
    """
    if request.method == 'GET':
        client_id = CLIENT_ID # 앱키 ex) b923j1i23k4io1l2k3ji1uaq2
        redirect_uri = 'http://127.0.0.1:8000/account/login/kakao/callback' # 인가 코드를 받을 uri
        return redirect(
            f'https://kauth.kakao.com/oauth/authorize?client_id={client_id}&redirect_uri={redirect_uri}&response_type=code'
        )

2번 Redirect URI로 전달된 인가 코드를 받기

pip install requests

def kakao_social_login_callback(request):
    """
    받은 인가 코드, 애플리케이션 정보를 담아 /oath/token/에 post요청하여 접근코드를 받아 처리하는 함수
    """
    try:
        code = request.GET.get('code')
#         client_id = CLIENT_ID
#         redirect_uri = 'http://127.0.0.1:8000/account/login/kakao/callback' # 인가 코드를 받은 URI
#         token_request = requests.post(
#             'https://kauth.kakao.com/oauth/token', {'grant_type': 'authorization_code',
#                                                     'client_id': client_id, 'redierect_uri': redirect_uri, 'code': code}
#         )

#         token_json = token_request.json()

#         error = token_json.get('error', None)

#         if error is not None:
#             print(error)
#             return JsonResponse({"message": "INVALID_CODE"}, status=400)

#         access_token = token_json.get("access_token")

#     except KeyError:
#         return JsonResponse({"message": "INVALID_TOKEN"}, status=400)

#     except access_token.DoesNotExist:
#         return JsonResponse({"message": "INVALID_TOKEN"}, status=400)

#         #------get kakaotalk profile info------#

#     profile_request = requests.get(
#         "https://kapi.kakao.com/v2/user/me", headers={"Authorization": f"Bearer {access_token}"},
#     )
#     profile_json = profile_request.json()
#     kakao_id = profile_json.get('id')
#     username = profile_json['properties']['nickname']

3번 /oauth/token에 인가 코드를 담아 접근 토큰 받기

def kakao_social_login_callback(request):
    """
    받은 인가 코드, 애플리케이션 정보를 담아 /oath/token/에 post요청하여 접근코드를 받아 처리하는 함수
    """
    try:
        code = request.GET.get('code')
        client_id = CLIENT_ID # 앱 키
        redirect_uri = 'http://127.0.0.1:8000/account/login/kakao/callback' # 인가 코드를 받은 URI, 이 부분은 크게 상관이 없어보입니다.
        token_request = requests.post(
            # grant_type은 authorization_code로 고정입니다.
            'https://kauth.kakao.com/oauth/token', {'grant_type': 'authorization_code',
                                                    'client_id': client_id, 'redierect_uri': redirect_uri, 'code': code}
        )

        token_json = token_request.json()

#         error = token_json.get('error', None)

#         if error is not None:
#             print(error)
#             return JsonResponse({"message": "INVALID_CODE"}, status=400)

#         access_token = token_json.get("access_token")

#     except KeyError:
#         return JsonResponse({"message": "INVALID_TOKEN"}, status=400)

#     except access_token.DoesNotExist:
#         return JsonResponse({"message": "INVALID_TOKEN"}, status=400)

#         #------get kakaotalk profile info------#

#     profile_request = requests.get(
#         "https://kapi.kakao.com/v2/user/me", headers={"Authorization": f"Bearer {access_token}"},
#     )
#     profile_json = profile_request.json()
#     kakao_id = profile_json.get('id')
#     username = profile_json['properties']['nickname']

4번 토큰 유효성 검증 후 토큰으로 사용자의 정보 조회와 서비스 내에서 처리

def kakao_social_login_callback(request):
    """
    받은 인가 코드, 애플리케이션 정보를 담아 /oath/token/에 post요청하여 접근코드를 받아 처리하는 함수
    """
    try:
        code = request.GET.get('code')
        client_id = CLIENT_ID # 앱 키
        redirect_uri = 'http://127.0.0.1:8000/account/login/kakao/callback' # 인가 코드를 받은 URI
        token_request = requests.post(
            'https://kauth.kakao.com/oauth/token', {'grant_type': 'authorization_code',
                                                    'client_id': client_id, 'redierect_uri': redirect_uri, 'code': code}
        )

        token_json = token_request.json()
        #------------유효성 검증 --------------#
        error = token_json.get('error', None)

        if error is not None:
            print(error)
            return JsonResponse({"message": "INVALID_CODE"}, status=400)
        #-------------받은 토큰---------------#
        access_token = token_json.get("access_token")

    except KeyError:
        return JsonResponse({"message": "INVALID_TOKEN"}, status=400)

    except access_token.DoesNotExist:
        return JsonResponse({"message": "INVALID_TOKEN"}, status=400)

    #------토큰을 이용하여 사용자 정보 조회------#
    profile_request = requests.get(
        "https://kapi.kakao.com/v2/user/me", headers={"Authorization": f"Bearer {access_token}"},
    )
    #------사용자 정보를 활용---------------#
    profile_json = profile_request.json()
    print(profile_json)
    kakao_id = profile_json.get('id')
    username = profile_json['properties']['nickname']

[Python/numpy] 기초_attr_2 (reshape(), 인덱싱, sort(), argsort(), dot(), transpose())

reshape()

• ndarray의 차원과 크기를 변경하는 method

array1 = np.arange(8)
print(array1)
array2 = array1.reshape(2,4)
print(array2)
array3 = array2.reshape(2,2,2)
print(array3)

[0 1 2 3 4 5 6 7]
[[0 1 2 3]
 [4 5 6 7]]

[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]

알 수 없는(계산하기 귀찮은) 차원의 자리에 -1을 넣는다면 알아서 계산해 준다.

array2 = array1.reshape(-1, 2)
print(array2) # (4,2) 2차원 4행 2열

[[0 1]
 [2 3]
 [4 5]
 [6 7]]

만약 둘 이상의 인자에 -1을 넣는다면? ValueError : can only specify one unknown dimension 알 수 없는 차원(-1)을 하나만 지정할 수 있습니다.

인덱싱 - 데이터 세트 선택하기

1. 단일 인덱싱

array1 = np.arange(1,11)
print('#-----1차원-----#')
print(array1)
print('1번 인덱스 데이터 >>>',array1[1])
print('[-1]마지막 데이터 >>>',array1[-1])
print('#-----2차원-----#')
array2 = array1.reshape(-1,5)
print(array2)
print('[1,4] 2행 5열의 데이터 >>>',array2[1,4])

#-----1차원-----#
[ 1  2  3  4  5  6  7  8  9 10]
1번 인덱스 데이터 >>> 2
마지막 데이터 >>> 10

#-----2차원-----#
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]]
2행 5열의 데이터 >>> 10

2. 슬라이싱

array1 = np.arange(1,11)
print('#-----1차원-----#')
print(array1[:5])
print(array1[:5:-1])
print(array1[10:5:-1])
print(array1[::2])
print('#-----2차원-----#')
array2 = array2.reshape(5,-1)
print(array2)
print('2차원nd배열[0:1,2:4] \n', array2[0:1, 2:4])
print('2차원nd배열[2:4,0:1] \n', array2[2:4, 0:1])
print('2차원nd배열[:4,:] \n', array2[:4, :])
print('#-----2차원에서 단일 인덱싱 실행 시 차원의 변화-----#')
print('2차원nd배열[0], 2차원nd배열[0].shape \n', array2[0], '차원은?', array2[0].shape)

#-----1차원-----#
[1 2 3 4 5]
[10  9  8  7]
[10  9  8  7]
[1 3 5 7 9]

#-----2차원-----#
[[ 1  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]]
2차원nd배열[0:1,2:4] 
 []
2차원nd배열[2:4,0:1] 
 [[5]
 [7]]
2차원nd배열[:4,:] 
 [[1 2]
 [3 4]
 [5 6]
 [7 8]]

#-----2차원에서 단일 인덱싱 실행 시 차원의 변화-----#

2차원nd배열[0], 2차원nd배열[0].shape 
 [1 2] 차원은? (2,)

3. 팬시 인덱싱!

• 일정한 인덱싱 집합을 리스트 또는 ndarray 형태로 지정해 해당 위치에 있는 ndarray를 반환한다.

array1 = np.arange(1,11)
array2 = array1.reshape(2,5)
print(array2)
print('2차원nd배열[1, 2:3] \n', array2[[1], 2:3])
print('2차원nd배열[:, [0,2,4]] \n', array2[:, [0,2,4]])
print('2차원nd배열[:, [0,2,4]].tolist() 리스트로 변환해보기 \n', array2[:, [0,2,4]].tolist())

[[ 1  2  3  4  5]
 [ 6  7  8  9 10]]
2차원nd배열[1, 2:3] 
 [[8]]

2차원nd배열[:, [0,2,4]] 
 [[ 1  3  5]
 [ 6  8 10]]

2차원nd배열[:, [0,2,4]].tolist() 리스트로 변환해보기 
 [[1, 3, 5], [6, 8, 10]]

4. 불린 인덱싱!!

• 특정 조건에 해당 여부로 ndarray를 반환한다.

array1 = np.arange(1,11)

print('#-----1차원-----#')
짝수판별_nd배열 = array1 % 2 == 0
print('짝수판별 1차원 ndarray \n',짝수판별_nd배열)
print('타입은?', type(짝수판별_nd배열), '차원은?', 짝수판별_nd배열.shape)

print('#-----1차원에 불린 인덱싱 정룔 후 변화-----#')
print(array1[짝수판별_nd배열])
print('차원은?', array1[짝수판별_nd배열].shape)

print('#-----2차원-----#')
array2 = array1.reshape(-1,5)
짝수판별_2차원_nd배열 = array2 % 2 == 0
print('짝수판별 2차원 ndarray \n',짝수판별_2차원_nd배열)
print('타입은?', type(짝수판별_2차원_nd배열), '차원은?', 짝수판별_2차원_nd배열.shape)

print('#-----2차원에 불린 인덱싱 적용 후 변화-----#')
print(array2[짝수판별_2차원_nd배열])
print('차원은?', array2[짝수판별_2차원_nd배열].shape)

#-----1차원-----#
짝수판별 1차원 ndarray 
 [False  True False  True False  True False  True False  True]

타입은? <class 'numpy.ndarray'> 차원은? (10,)

#-----1차원에 불린 인덱싱 정룔 후 변화-----#
[ 2  4  6  8 10]

차원은? (5,)

#-----2차원-----#
짝수판별 2차원 ndarray 
 [[False  True False  True False]
 [ True False  True False  True]]

타입은? <class 'numpy.ndarray'> 차원은? (2, 5)

#-----2차원에 불린 인덱싱 적용 후 변화-----#
[ 2  4  6  8 10]

차원은? (5,)

불린 인덱싱 사용법을 파이썬으로 이해하기

print(array1[array1%2 == 0])

[ 2  4  6  8 10]

파이썬 문법으로 바꿔보기

print(list(x for x in array1 if x%2 == 0))

[2, 4, 6, 8, 10]

sort()

• np.sort() : 원본 배열을 참조하여 새로 정렬된 배열을 반환한다. (Like 파이썬의 sorted() )
• ndarray.sort() : 원본 배열 자체를 정렬한다. 반환 값은 None (Like 파이썬의 .sort() )

원본배열 = np.array([3,1,5,7,4,9])
np.sort사용배열 = np.sort(원본배열)
print('np.sort사용배열', np.sort사용배열, '원본배열', 원본배열)
원본배열.sort()
print('원본배열.sort()실행 후 원본 배열', 원본배열)

np.sort사용배열 [1 3 4 5 7 9] 원본배열 [3 1 5 7 4 9]
원본배열.sort()실행 후 원본 배열 [1 3 4 5 7 9]

원본배열 = np.array([[2,1],[0,3],[9,6],[6,2]])
디폴트이차원정렬배열 = np.sort(원본배열) # 디폴트로 axis = -1 열을 기준으로 정렬해 준다.
행기준이차원정렬배열 = np.sort(원본배열, axis = 0)
print('원본배열\n', 원본배열)
print('기본이차원정렬배열\n', 디폴트이차원정렬배열)
print('행기준이차원정렬배열 \n', 행기준이차원정렬배열)

원본배열
 [[2 1]
 [0 3]
 [9 6]
 [6 2]]
기본이차원정렬배열
 [[1 2]
 [0 3]
 [6 9]
 [2 6]]
행기준이차원정렬배열 
 [[0 1]
 [2 2]
 [6 3]
 [9 6]]

argsort()

• 정렬된 행렬의 인덱스를 반환하는 메서드

array1 = np.array([100,10,1000,10000])
array1_argsort = np.argsort(array1)
print('오름 차순으로 정렬하려면 어떻게 기존 배열에서 어떤 인덱스가 차례로 들어와야 하나요??', array1_argsort)
print(array1[1], array1[0], array1[2], array1[3])

오름 차순으로 정렬하려면 어떻게 기존 배열에서 어떤 인덱스가 차례로 들어와야 하나요?? [1 0 2 3]
10 100 1000 10000

이건 언제 필요하나요?

name_list = np.array(['kim', 'lee', 'park', 'han'])# 우리 팀원들 5명의 리스트
score_list = np.array([25, 99, 12, 39])# 우리 팀원들의 점수 리스트

상황) 우리 팀원들을 점수 순(오름차순과 내림차순)으로 나열해 주세요!

score_argsort = np.argsort(score_list)
print(score_argsort)
print('오름차순',name_list[score_argsort])
print('내림차순',name_list[score_argsort][::-1])

[2 0 3 1]
오름차순 ['park' 'kim' 'han' 'lee']
내림차순 ['lee' 'han' 'kim' 'park']

선형대수 연산 - 행렬 내적(곱셈)과 전치 행렬 구하기!

행렬 내적

행렬의 내적 구하기 유튜브(강추)

A = np.array([[1, 2, 3],
              [4, 5, 6]])
B = np.array([[7, 8],
              [9, 10],
              [11, 12]])

내적 = np.dot(A, B)
print('행렬 내적 결과 :\n', 내적)

행렬 내적 결과 :
 [[ 58  64]
 [139 154]]

transpose() 전치 행렬

print(np.transpose(A))

[[1 4]
 [2 5]
 [3 6]]