brew가 터미널에 설치되어 있어야합니다.

1. brew tap 명령어로 패키지 저장소를 확보

brew tap mongodb/brew

2. 몽고db 최신 버전 찾기

brew search mongodb

3. 설치

brew install mongodb-community@4.4

4. 실행

brew services start mongodb-community@4.4

5. 프로세스 확인

ps aux | grep -v grep | grep mongod

6. 버전 확인

mongo --version

위와 같이 입력하면 버전 정보가 나오는 사람도 있지만, 아래와 같이 찾을 수 없다는 명령어가 나올 수도 있습니다. 아래의 명령어가 나온다면 zsh, bash_shell 등 본인이 쓰고 있는 터미널 환경에 맞춰서 환경변수를 추가해주면 됩니다.

zsh: command not found mongo

7. 환경변수 설정

아래의 예는 zsh 기준입니다.

1. 편집기 열고, 
vi ~/.zshrc

2. 아래와 같이 mongodb 환경변수 명령어 입력하고,
export PATH="$PATH:/usr/local/opt/mongodb-community@4.4/bin"

3. 환경변수 적용
source ~./zshrc

local 뒤의 경로는 설치 경로에 따라서 다를 수가 있습니다. 해당 경로는 ps aux | grep -v grep | grep mongod 를 입력했을 때 나오는 경로에서 usr/local ~ /bin << 이 경로를 입력하면 됩니다.

8. 로컬에서 접속하기

 mongo "mongodb://<username>:<usrepassword>@IP:PORT"

9. 유저 비밀번호 변경하기

> use admin
switched to db admin
admin> db.changeUserPassword('username', passwordPrompt())
Enter password
*************

1) aws > iam > 엑세스 관리 > 사용자 > 사용자 추가 2) 사용자 이름 입력 / 프로그래밍 방식 엑세스 클릭 3) 기존 정책 직접연결

AmazonEC2FullAccess
AmazonS3FullAccess
AmazonESFullAccess

4) 다음 > 사용자 만들기 > csv 파일 다운받

2. EB CLI 설치

$ brew install awsebcli

pip 으로 설치해도 되는데, 나는 pip 으로 설치했을 때 잘 안됐다.
brew 로 설치하면 따로 환경변수 설정을 안해줘도 된다.

# 설치 확인
$ eb --version

3. django 프로젝트 만들기

# 프로젝트 폴더에서 가상환경 끈 상태로 진행!! 
$ eb init 

리전 선택하기. 나의 경우 서울 10번 선택

1 에서 만든 aws id pw 입력하기 

애플리케이션 이름 입력하기

4. requirements.txt 만들기

$ pip freeze > requirements.txt

5. .ebextensions 설정

manage.py 파일 있는 경로에서

$ mkdir .ebextensions
$ cd .ebextensions

위 파일 경로에서 아래 파일 추가 및 내용 추가

$ vi django.config

아래 내용 추가! 

option_settings:
aws:elasticbeanstalk:container:python:
WSGIPath: test_project/wsgi.py

test_project 이 부분은 본인 프로젝트 넣기
나같은 경우 처음에 두번째줄이랑 세번째줄을 들여쓰기 했더니 계속 json 에러가 났다


:wq 로 파일 저장 및 나오기

6. eb-create 로 환경 생성하기

$ eb-create 만들려는 환경 이름

safe to Ctrl+C 가 중간중간 나오는데 누르지 말고 다 설치 될 때까지 기다리기
설치가 완료되면 터미널 화면 마지막에

Successfully launched environment: 환경이름

위와 같이 들 것이다.

7. eb-status

$ eb-status 

위 명령어로 도메인 명 확인
CNAME 부분에 있다.

해당 부분을 복사 후
프로젝트 파일 > settings.py 에 
ALLOWED_HOSTS = ['이 안에 넣어준다.']

8. 배포

$ eb deploy 로 배포하기

9. 배포 확인

$ eb open 

출처 출처1 출처2

반올림 ( 소수점 n째 자리까지 남기고 반환 )

ROUND(8.765, 2) 
 > 8.77

2. TRUNCATE(칼럼명/값, n)

n 자리수까지 남기고 다 버리기

TRUNCATE(8.765, 2)
 > 8.76

3. POWER(칼럼명/값, n)

값을 n 제곱해서 반환

power(칼럼명/값, n)
 = pow(칼럼명/값, n)

ex. power(2,3) = 8

4. SQRT

값의 제곱근을 반환 (어떤 수를 제곱했을 때 그 수가 나오냐)

SQRT(4) = 2

5. MOD(칼럼명/값, n)

값을 n으로 나누었을 때 나머지를 반환

MOD(칼럼명/값, n)
값을 n으로 나누었을 때의 나머지를 반환
 = 칼럼명 % n >> 이것도 나머지 구하는 거 !

ex. mod(4,2) = 0
    mod(5,2) = 1

ex. ID 컬럼이 홀수 인 것만 찾고 싶다

select *
from ex_table
where ID % 2 = 1;

6. ABS(칼럼명/값)

값의 절대값을 반환

7. LOWER / UPPER

LOWER : 모든 문자를 소문자로 UPPER : 모든 문자를 대문자로

SELECT lower(memberID)
FROM sample_table;

SELECT UPPER(memberID)
FROM sample_table;

8. REPLACE(칼럼명/문자열, 패턴1, 패턴2)

문자열에 포함된 패턴1을 패턴2로 대체해 반환

SELECT REPLACE(MemberID, 'A', 'B')
FROM sample_table;

9. CONCAT(칼럼명/문자열1, 칼럼명/문자열2....)

여러개의 문자열을 차례대로 연결해 하나의 문자열로 반환

SELECT REPLACE(ID, ':', MemberID) AS MEMBER
FROM sample_table;

ID   MemberID
1     A
2     B
3     C


result

MEMBER
1:A
2:B
3:C

SELECT COUNT (*)
FROM 테이블 이름;

 > Products 테이블에 있는 레코드의 갯수를 세라


특정 칼럼만 세고 싶다면?
SELECT COUNT(세고 싶은 칼럼)
FROM 테이블 이름


중복제거 하고 센다면?
SELECT COUNT(DISTINCT 칼럼)
FROM 테이블 이름

2. SUM / AVG

합계
SELECT SUM(칼럼)
FROM 테이블 이름

평균
SELECT AVG(칼럼)
FROM 테이블 이름

만약 평균 내려는 값에 NULL 값이 있을 때
  1) NULL 을 데이터가 없다고 해석하고 평균 낸다면

  SELECT AVG(칼럼)
  FROM 테이블 이름


  2) NULL 을 0으로 해석한다면,

  SELECT SUM(칼럼)/count(*)
  FROM 테이블 이름

3. 최대 / 최소

SELECT min(price)
SELECT max(price)

4. 그룹 - GROUP BY

ex. 공급자별 평균 가격

SELECT SupperlierID, AVG(Price)
FROM Products
GROUP BY SupperlierID

5. 그 외

평균 낸 결과에 대해 필터링을 걸고 싶으면

SELECT SupperlierID, AVG(Price)
FROM Products
GROUP BY SupperlierID
HAVING AVG(Price) >= 100 

 > WHERE 절 쓰면 안됨 !! HAVING 써야 함

------------------------------------------------------------
select SupperlierID, 
       AVG(Price) AS avg_price
      # as 는 별명 붙이기

출처_인프런 인강

🖥 mac 기준 🖥

1. redis 설치

터미널에서 

$ brew install redis

위의 명령어로 redis 설치하기

2. redis 셋팅

설치 후

$ cd /usr/local/etc

위의 경로에 들어가서

$ vi redis.conf

파일 열기

3. 비밀번호와 외부 접속 설정

requirepass foobared
라고 되어 있는 부분 찾아서

requirepass 내가 설정하려는 비밀번호로
ex. requirepass abcde

-------------------------------------

bind 127.0.0.1 로 되어 있는 부분 찾아서

bind 0.0.0.0 으로 수정해주기

:wq!   <- 명령어로 파일 저장 후 나오기

4. 레디스 실행해보기

$ redis-server

위의 그림처럼 나오면 성공!

터미널 하나 더 키고,

$ redis-cli 

입력하면 아래와 같이 나온다.

레디스 키에 저장된 값이 없어서 조회해보면 empty array로 나온다.

5. django 세팅

# project파일/settings.py

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    }
}

위의 내용 넣어주기

6. views 테스트

# 앱/views.py

import redis
from django.core.cache import cache

class ServiceType(APIView):
    def get(self,request):
        types = request.GET.get("type", None)

        start = time.time()

        today = datetime.datetime.now().date()
        if types == 'E' or types == 'N':

            get_redis = cache.get('test')

            if not get_redis:

                eventlist = Event.objects.filter( type=types)
                contentslist = []
                for contents in eventlist:
                    if contents.active == 'Y':
                        if types == 'E':
                            if contents.end_date > today:
                                badge = f'{contents.end_date.month}/{contents.end_date.day}까지'
                            else:
                                badge  = '종료'

                        elif types == 'N':
                            badge = contents.badge

                        contentslist.append ( {
                            'id' : str(contents.id),
                            'title' : contents.title,
                            'badge' : badge,
                            'startDate' : contents.start_date
                        } )

                data = {
                    'contentsList' : contentslist
                }

                cache.set('test', data)

                end = time.time()
                print('레디스에 키 없을 때 조회 시간 : ', end-start)

                return BaseResponse(resultcode=int('00'), data=data, status=200)

            end = time.time()
            print('레디스에 키 있을 때 조회 시간 : ', end-start)
            return BaseResponse(resultcode=int('00'), data=get_redis, status=200)

        return BaseResponse(resultcode=int('01'), status=400)

9번째 & 10번째 줄에

get_redis = cache.get('event4')
if not get_redis:

를 추가해서, 레디스에 내가 저장해 놓은 키값이 있는지 찾은 후 (get 이 조회하는 명령어) 있다면 get_redis 그대로 return 없다면, DB에서 조회 후, 해당 키 값으로 레디스에 저장하기 (set이 저장)

6-1. 레디스에 저장 안 됐을 때

레디스에 키가 없는 상태기 때문에 데이터 조회하는 코드로 데이터 조회 후, 레디스에 키 저장한 후, 데이터 리턴

redis-cli 에서 keys * 로 조회해보면 위의 실행으로 키가 저장된 걸 알 수 있다.

그리고 다시 조회 해보면,

레디스에 저장된 키 값으로 데이터를 찾아서 리턴하면서 시간이 단축된 걸 알 수 있다.

개발자 도구로 확인해보니, not found.... nginx 를 붙이면서, static 파일들을 한 곳으로 모아줬어야 했는데 모아주지 않아서 ec2 서버로 swagger에 접속하니 ui를 찾지 못한 채 blank page 가 나왔습니다.

1. django에서 static 은?

django에서 _static 파일_을 보통 아래 3가지의 경우로 설정합니다.

1. STATICFILES_DIRS
2. STATIC_URL
3. STATIC_ROOT

1) STATICFILES_DIRS

개발 단계에서 사용하는 정적 파일들의 경로를 지정하는 설정입니다. 특정 django app 에만 사용하는 정적 파일이 있거나 여러 경로에 정적 파일들을 배치했다면, 해당 경로들을 list, tuple 로 담으면 됩니다,

STATICFILES_DIRS = (
    os.path.join(BASE_DIR, 'static'),
)

2) STATIC_URL

웹 페이지에서 사용할 정적 파일의 최상위 URL 경로입니다. 이 경로는 디렉터리는 아니며 URL로 존재하는 단위입니다.

처음 django project를 생성하면 settings.py에 아래와 같이 기본값으로 설정되어 있습니다.

STATIC_URL = '/static/'

2) STATIC_ROOT

django 프로젝트에서 사용하는 모든 정적 파일을 한 곳에 모아넣는 경로입니다. python manage.py collectstatic 이라는 명령어를 입력하여 한 곳에 모아줍니다.

개발 과정에선, settings.py에서 DEBUG=True로 설정되어 있으면 STATIC_ROOT 설정은 작용하지 않으며, STATIC_ROOT는 실 서비스 환경을 위한 설정 항목입니다.

django가 접근하여 다루는 곳은 STATICFILES_DIRS 이고, STATIC_ROOT 는 웹 서버가 접근 합니다.

2) django static 파일 모아주기

로컬이나 ec2 우분투 서버에서 장고 프로젝트 settings.py로 이동
저는 ec2 우분투 서버에 클론 받은 프로젝트 파일에서 수정했습니다.


# settings.py

STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR,'static')

STATIC_URL 밑에, STATIC_ROOT 추가하기

# 프로젝트 urls.py

urlpatterns = [
   """내가 추가한 url 들 """
] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)



# 아래 명령어로 정적 파일 모아주기
python manage.py collectstatic

그럼 manage.py 있는 경로에 static 폴더가 생기면서 안에 swagger 관련 js,css 등 정적 파일들이 모아져 있는 것을 볼 수 있습니다.

3) nginx 설정

# cd /etc/nginx/sites-enabled 경로로 이동
# nginx 설정 시 만들었던 프로젝트명.py 파일 열기

sudo vi 프로젝트명.py

server {
        listen 80;
        server_name ec2퍼블릭 주소;

        charset utf-8;

        location / {
        include proxy_params;
        proxy_pass http://127.0.0.1:8000;
        }

        location /static/ {
                alias /home/ubuntu/프로젝트 경로/static/;
        }
}


>>> static 경로 지정 : alias /home/ubuntu/프로젝트 경로/static/

4) 재실행

sudo systemctl daemon-reload
sudo systemctl restart gunicorn
sudo systemctl restart nginx

참고!

1. swagger 설치

pip install -U drf-yasg
pip install flex

스웨거 공식문서에는 pip install django-rest-swagger 를 install 하라고 해서 찾아보니, django-rest-swagger 은 패키지 관리가 잘 안되고 있는 것 같습니다. 그래서 drf-yasg 를 install 해줍니다.
flex : JSON schema를 체크하는 패키지

2. settings.py 에 설정하기

# settings.py
INSTALLED_APPS = [
    'drf_yasg',  # 추가하기 
]

여기서 오전 시간을 다 썼는데, 모든 설정을 다 했는데도 런타임에러가 났었습니다.
'django.contrib.auth' 부분을 제가 주석 처리 해놨었어서 이 부분이 주석이 되어 있다면 꼭! 풀어주셔야 합니다.

# 프로젝트 > urls.py

from django.urls import path, include, re_path
from drf_yasg.views import get_schema_view
from drf_yasg import openapi
from django.conf import settings
from rest_framework.permissions import AllowAny
from rest_framework import routers, permissions


schema_view = get_schema_view(
    openapi.Info(
        title="project A title", # 타이틀
        default_version='v1', # 버전
        description="프로젝트 API 문서", # 설명
        terms_of_service="https://www.google.com/policies/terms/",
        contact=openapi.Contact(email="이메일"),
        license=openapi.License(name=""),
    ),
    validators=['flex'],
    public=True,
    permission_classes=(AllowAny,)
)


urlpatterns = [
    path(r'swagger(?P<format>\.json|\.yaml)', schema_view.without_ui(cache_timeout=0), name='schema-json'),
    path(r'swagger', schema_view.with_ui('swagger', cache_timeout=0), name='schema-swagger-ui'),
    path(r'redoc', schema_view.with_ui('redoc', cache_timeout=0), name='schema-redoc-v1'),
    # django 앱 
    path('scooter', include('scooter.urls')),
    path('bus', include('bus.urls'))
]

프로젝트 urls.py에서 위와 같이 설정해주고 나서 런서버 > http://localhost:8000/swagger 에 접속해도 내가 짠 api들이 나오지 않았습니다.

3. views.py 에 데코레이터 작성하기

저는 get해오는 과정에서 파라미터가 있는 상황이었기 때문에 아래와 같이 스키마를 작성해주었습니다. 만약, 파마리터가 따로 없다면, class 와 def 사이에 있는 두 줄은 안 적으셔도 됩니다.

from rest_framework.views import APIView
from drf_yasg.utils import swagger_auto_schema
from drf_yasg import openapi


class Test(APIView):
    bstopId = openapi.Parameter('stationId', openapi.IN_QUERY, description='정류소 고유번호', required=True, default=165000381, type=openapi.TYPE_NUMBER)

    @swagger_auto_schema(manual_parameters=[bstopId], responses={200: "Success"})
    def get(self, request):
        bstopId = request.GET.get("stationId", None)

클래스형 뷰를 사용했기 때문에, class 와 함수 사이에 swagger_auto_schema 데코레이터 를 작성해주면 된다.

4. View vs APIview

처음에는 위와 같이 설정하고 나서도, api들이 나오지 않았습니다. 확인해보니 ,

class Test(View):

그냥 View 로 했을 때는 스웨거에 api가 나오지 않았고,

class Test(APIView):

APIView로 바꿔주니 스웨거에 api가 나왔습니다.

Schemas

• API schema는 참조 문서를 생성하거나 API와 상호 작용 할 수 있는 동적 클라이언트 라이브러리를 구동하는 등 다양한 사용 사례를 허용하는 유용한 도구입니다.
• REST 프레임워크의 스키마 생성은 docstring을 사용하여 스키마 문서의 설명을 자동으로 채웁니다.
• 명시적인 메서드 docstring이 있는 APIView입니다. 참고

결과적으로 그냥 View가 아닌 APIView로 바꿔줘야 api문서가 완성 됩니다.

내가 하고 싶었던 것

1. 계속 외부 사이트에 콜 날려서 데이터를 가져옴
2. 로컬 DB에는 아무것도 없고, 저장도 안 할 거임
3. 가져온 데이터에 필드가 여러개인데, 그 중 내가 원하는 필드만 뽑아서 프론트로 반환

기존에 알던 방식

data = [{
    'fare'     : i['fare'],
    'baseFare' : i['baseFare'],
    'latitude' : i['latitude'],
    'fareTime' : i['fareTime'],
    'longitude' : i['longitude'],
    }for i in all_list]

return JsonResponse({'data': data }, status=200)

가져오고자 하는 필드를 변수로 지정해서, 리프트 컴프리헨션으로 for문을 돌리고, 변수에 지정해주는 방법이다. 하지만, 변수 하나하나 지정하는 방법 말고 시리얼라이저를 적용해서 원하는 필드만 빼오고 싶었다.

시리얼라이저 적용

1. models.py 에 가져오고자 하는 필드 지정

class Location(models.Model):
    fare = models.IntegerField()
    baseFare = models.IntegerField()
    latitude = models.FloatField()
    fareTime = models.IntegerField()
    longitude = models.FloatField()

2. seriailizers.py 에 모델쓰에 있는 필드 전부 가져오겠다 명시

from rest_framework import serializers
from scooter.models import Location


class LocationSerialzer(serializers.ModelSerializer):
    class Meta:
        model = Location
        fields = '__all__'

3. views.py 에 외부에서 가져온 데이터 중에 
   내가 시리얼라이저로 지정한 필드만 가져오겠다 작성하기

serializer = LocationSerialzer(data = location['data'], many=True)
serializer.is_valid(raise_exception=True)
data = json.dumps(serializer.data)

여기서 포인트!! *serializer.is_valid(raise_exception=True) *를 꼭 써줘야 한다.

나는 처음에 내가 가져오려는 필드만 DB에 넣고, 시리얼라이저에 fields = 'all'

라고 선언했기 때문에 가져오는 외부 데이터에서 내가 원하는 필드만 알아서 가져온다고 생각했다. 하지만, serializer.is_valid(raise_exception=True) 를 입력해서 꼭 벨리데이션 체크를 해줘야지 원하는 값만 걸러서 들어온다.

body에 이메일, 비밀번호, 토큰을 넣고 외부 사이트로 로그인해서 토큰 및 그 외 여러 데이터를 받아와야했다.

기존 코드

def post(self,request):
        data = json.loads(request.body)
        try:
            login_url = "https://로그인하려는 사이트 주소"
            header = {"Content-Type": "application/json; charset=utf-8"}
            response = requests.post(login_url, data=data, headers=header)

위와 같이 body에 데이터를 담고, request.post로 요청하는데 url, data, headers를 담아서 print(response)를 하면! 안나온다....

한참 찾아본 결과 문제는 data=data 이 부분이었다. 나는 당연히 data = json.loads(request.body) 로, body에 담아져서 온 데이터 자체가 json이기 때문에 data=data 라고 선언만 해주면 되는 줄 알았다.

보여지는 건 json이지만, json object일 뿐 실제 json 데이터는 아니었다. 그래서 data=json.dumps(data) 코드로 수정했고, data=json.dumps(data) 는 json=data 와 같았다. 즉, json 은 단순한 변수가 아니고, json뒤에 있는 걸 json화 시켜주는 문법이었다!

수정 코드

def post(self,request):
        data = json.loads(request.body)
        try:
            login_url = "https://로그인하려는 사이트 주소"
            header = {"Content-Type": "application/json; charset=utf-8"}
            response = requests.post(login_url, json=data, headers=header)

수많은 에러 ㅠㅠ,,가 발생했습니다. gcc error, no moduled django, psycopg2, command '/usr/bin/clang' failed with exit code 등등 어떤 에러라고 특정 지을 수도 없었습니다.

결과적으로,

1) 기존 requirements.txt 파일에 cffi 와 psycopg2 와 psycopg2-binary 의 버전 문제 2) psycopg2 가 posgresql을 연결해주는 라이브러리이기 때문에 postgresql 도 설치

cffi : 파이썬과 c언어를 이어붙을 수 있게 도와 주는 라이브러리 psycopg2 / psycopg2-binary : Python과 PosgreSQL을 연결하는 라이브러리

처음엔 psycopg2 을 requirements 파일에 있는 버전 그대로 pip install 을 했습니다. 그랬더니 당연히 fail..........🤣

1. PostgreSql 설치하기

pip install -r requirements.txt 하기 전에 postgresql 먼저 설치하기!!!

brew install postgresql

2. cffi , psycopg2 버전 바꾸기

• requirements.txt 파일에 있는 cffi 1.11.5 를 cffi 1.13.2 로 수정
• requirements.txt 파일에 있는 psycopg2==2.7.5 / psycopg2-binary==2.7.5 를 psycopg2==2.8.5 / psycopg2-binary==2.8.5 로 바꾸기

3. 재시도

pip install -r requirements.txt

를 다시 하면 나의 가상환경에 라이브러리 내용이 전부 들어갑니다.

출처 : Two Soops of Django

가장 긴 이름을 찾는 코드를 작성한다면,

names = ['computer','book', 'abc']
letters = [len(n) for n in names]

longest_name = None
max_letters = 0

for i in range(len(names)):
    count = letters[i]
    if count > max_letters:
        longest_name = names[i]
        max_letters = count

print(longest_name)
> computer

로 찾을 수 있습니다. 하지만, 인덱스 i로 루프에 접근하는 과정이 두 번 일어납니다. 위의 코드를 좀 더 명료하게 하기 위해 내장 함수 zip을 사용할 수 있습니다.

파이썬에서 zip은 이터레이터 두개 이상을 감쌉니다. 또한 각 이터레이터로부터 다음 값을 담은 튜플을 얻어옵니다.

zip 함수 사용한 코드

names = ['computer','book', 'abc']
letters = [len(n) for n in names]
longest_name = None
max_letters = 0
for name, count in zip(names, letters):
    if count > max_letters:
        longest_name = name
        max_letters = count

📌 내장함수 zip을 사용할 때는 문제가 있습니다.

이터레이터들의 길이가 다르면 zip이 제대로 작동하지 않는다는 것입니다. 만약, names 리스트에 새로운 단어를 추가하고, letters 의 카운터를 업데이트하지 못했다면 결과가 정상적으로 나오지 않습니다.

names = ['computer','book', 'abc']
letters = [len(n) for n in names]
longest_name = None
max_letters = 0

names.append('helloworld')
for name, count in zip(names, letters):
    if count > max_letters:
        longest_name = name
        max_letters = count

print(longest_name)
> computer


helloworld 를 append 했지만, letters에 반영이 되지 않았기 때문에, 
computer가 제일 긴 단어로 프린트됩니다.

만약 zip으로 실행할 리스트의 길이가 같다고 확신 할 수 없다면, 내장 모듈 itertools의 zip_longest를 고려하는 것이 좋습니다.

출처 : 파이썬 코딩의 기술 도서

매직 메서드 : 클래스를 다채롭게 사용할 수 있게 만들어 주는 방법입니다.

객체가 실행되거나 종료 될 때

객체를 표현하는 방법

데이터 참조 시

다른 객체를 변경하는데 사용하는 클래스에서 사용

연산자들을 재정의하기 위해 사용

출처 : "컴퓨팅사고를 위한 파이썬" 도서

힙

최댓값과 최솟값을 빠르게 찾기 위해 고안된 자료구조입니다. 그래서, 리스트에서 가장 작거나 큰 요소에 반복적으로 접근하는 프로그램에 유용합니다. 시간복잡도 : O(log n)

• 힙을 사용하는 이유
  • 배열에 데이터를 넣고 최대/최소값을 찾으면 시간 복잡도는 O(n)
  • 힙에 데이터를 넣고 최대/최소값을 구하면 O(log n) 이 걸림

1-1. heapq 모듈

리스트를 힙으로 변환하기

import heapq
list1 = [4, 6, 8, 1]
heapq.heapify(list1)

print(list1)
> [1, 4, 8, 6]

항목에 힙 삽입하기 > heapq.heappush(heap, item)

import heapq
h = []
heapq.heappush(h, (1, 'food'))
heapq.heappush(h, (2, 'fruit'))
heapq.heappush(h, (1, 'drink'))

print(h)
> [(1, 'drink'), (2, 'fruit'), (1, 'food')]

힙에서 가장 작은 항목 제거하고 결과 리턴

import heapq

list1 = [1,3,4,6]
heapq.heappop(list1)

print(list1)
> [3, 4, 6]

여러 리스트의 값을 이터레이터로 반환하기

for x in heapq.merge([1,4,7],[2,9,10]):
    print(x)
    > 1
    > 2
    > 4
    > 7
    > 9
    > 10

우선순위 큐

우선순위가 가장 높은 자료를 가장 먼저 꺼낼 수 있는 자료 구조입니다.

import heapq

hq = []
heapq.heappush(hq, (30,'red'))
heapq.heappush(hq, (15,'blue'))
heapq.heappush(hq, (19,'white'))

print(hq)
> [(15, 'blue'), (30, 'red'), (19, 'white')]

first = heapq.heappop(hq)
print(first)
 > (15, 'blue')
print(hq)
 > [(19, 'white'), (30, 'red')]

second = heapq.heappop(hq)
print(second)
 > (19, 'white')

O(1) < O(log n) < O(n) < O(n log n) < O(n^2) < O(2^n) < O(n!)

1. O(1)

입력 데이터의 양과 상관없이 실행 시간이 일정합니다. ex. 해시 테이블의 조회 및 삽입

2. O(log n)

데이터 양이 많아져도 시간은 조금씩만 증가합니다. 시간에 비례하여 탐색 가능한 데이터양이 2의 n승이 됩니다. 이는 주로 큰 문제를 일정한 크기를 갖는 작은 문제로 쪼갤 때 나타나는 유형입니다. ex. 이진 검색 ( 가운데에 위치한 값과 찾고자 하는 값 비교하면서 가운데 값을 바꿔가는 방법)

3. O(n)

데이터양과 시간이 정비례합니다. ex. for 문을 통한 탐색, 리스트 순회 등

4. O(n log n)

데이터 양이 n만큼 많아지면 실행 시간은 n배 보다 조금 더 많아집니다. 큰 문제를 독립적인 작은 문제로 쪼개어, 독립적으로 해결 후 다시 하나로 모으는 경우에 나타납니다. ex. 퀵 정렬, 병합 정렬 등

5. O(N^k)

데이터 양에 따라 걸리는 시간은 제곱에 비례합니다.(효율이 좋지 않음) ex. n번 순회하는 반복문을 k번 중첩

스케일아웃

서버를 여러 대 추가하여 시스템을 확장하는 것입니다. 서버가 여러 대가 되면, 각 서버에 걸리는 부하를 균등하게 분할 해주는 로드밸런싱이 필요합니다.

장점 : 서버 한 대가 다운되면, 다른 서버로 서비스 제공이 가능합니다. 단점 : 모든 서버가 동일한 데이터를 가지고 있어야하므로, 데이터변화가 적은 웹서버에 적합한 방식입니다.

스케일업

서버에 CPU나 RAM 등을 추가하거나, 고성능의 부품, 서버로 교환하는 등 서버의 성능 자체를 증가시키는 것입니다.

단점: 서버 한 대에 모든 부하가 집중되기 때문에 장애 시 영향을 크게 받을 수 있습니다. 용량 확장 제한이 다다르면 새 시스템에 추가해야하는데 이때 마이그레이션 비용이 발생할 수 있습니다. 데이터 갱신이 번번히 일어나는 경우에 적합한방식입니다.

제너레이터

제너레이터 : 이터레이터를 생성해주는 함수이며, 파이썬의 시퀀스를 생성하는 객체입니다.(제너레이터는 yield 문을 사용합니다) 이터레이터 : 반복문을 활용해서 데이터를 순회하면서 처리하는 것 (리스트, 딕셔너리, 튜플 등) 시퀀스 : 앞뒤가 꼭 지켜져야 하는 시/공간적 순서

1. 제너레이터 없는 for문

def square_numbers(nums):
    result = []
    for i in nums:
        result.append(i * i)
    return result

my_nums = square_numbers([1, 2, 3, 4, 5])

print(my_nums)
>> [1, 4, 9, 16, 25]

print를 실행해보면 위의 함수가 전부 실행되어 값이 반환된 것을 볼 수 있습니다.

2. 제너레이터를 사용한 for문 

def square_numbers(nums):
    for i in nums:
        yield i * i

my_nums = square_numbers([1, 2, 3, 4, 5])  #1

print(my_nums)
>> <generator object gensquare_numbers at 0x7fc5fe928f90>

위의 내용을 프린트해보면 값이 나오는 것이 아닌, 제너레이터 오브젝트가 리턴이 됩니다. 자신이 리턴할 모든 값을 메모리에 저장하는 것이 아닌 호출 될 때마다 하나씩 값을 전달하기 때문에 기다리는 상태입니다.

def square_numbers(nums):
    for i in nums:
        yield i * i

my_nums = square_numbers([1, 2, 3, 4, 5])  #1

# 그냥 프린트가 아닌 next로 감싸서 프린트 해보면 1이 찍혀서 나옵니다.
print(next(my_nums))
>> 1
print(next(my_nums))
>> 4
print(next(my_nums))
>> 9
print(next(my_nums))
>> 16
print(next(my_nums))
>> 25

프린트를 계속 반복해보면 값이 나오는 것을 알 수 있습니다.
값이 전부 반환된 상태에서 한번 더 next 를 프린트 하면,

print(next(my_nums))
>> Traceback (most recent call last):
  File "generator.py", line 22, in 
    print(next(my_nums))
StopIteration

StopIteration 예외가 발생합니다.

제너레이터는 일반적으로 for문을 통해서 호출합니다.

def square_numbers(nums):
    for i in nums:
        yield i * i

my_nums = square_numbers([1, 2, 3, 4, 5])

for num in my_nums:
    print(num)

위의 코드를 실행해보면 예외처리가 발생하지 않고, 알아서 멈춥니다.

데이터의 양이 많아지고 메모리 사용량을 최적화 해야하는 상황이 온다면 제너레이터를 사용해야합니다.

yield 를 사용하지 않고, 제너레이터를 만들 수 있습니다.

result = (i*i for i in range(0,10))
for num in result:
    print(num)

```

리스트 컴프리헨션 구조에서 괄호를 '[]' 가 아닌 '()' 로 바꿔주면 됩니다.

출처

동적 계획법이란?
복잡한 문제를 재귀를 통해 간단한 하위 문제로 분류 및 단순화하여 해결하는 방법 최적 부분 구조 / 중복되는 부분 문제가 있다면 동적 계획법을 사용하면 좋습니다. 최적부분구조 : 답을 구하기 위해 했던 계산을 반복해야하는 구조

최장 증가 부분열 찾기

1. 동적계획법

from bisect import bisect
from itertools import combinations
from functools import wraps

def solution(seq):
    L = [1] * len(seq)
    res = []
    for cur, val in enumerate(seq):
        for i in range(cur):
            if seq[i] <= val:
                L[cur] = max(L[cur], 1 + L[pre])
    return max(L)

애플리케이션에서 의뢰받은 프로토콜 스택이 메세지를 송신하는 방법

1. 소켓 작성
2. 서버 접속
3. 데이터 송 수신
4. 서버에서 연결을 끊고 소켓 말소
5. IP와 이더넷의 패킷 송,수신 동작
6. UDP 프로토콜을 이용한 송 수신 동작

이전에 정리한 1,2번에 이어서 3,4번에 대해서 정리하겠습니다.

3. 데이터 송, 수신

3-1. 프로토콜 스택에 HTTP 리퀘스트 메시지를 넘기기

connect에서 애플리케이션에 제어가 되돌아오면 데이터 송수신 을 할 수 있습니다. 커넥션 : - 데이터를 송/수신 할 수 있도록 파이프와 같은 것으로 소켓이 연결되어 있는데, 이 파이프와 같은 것을 커넥션이라고 함. - 이 커넥션은 close를 호출하여 연결을 끊기 전까지 계속 존재합니다.

데이터 송,수신의 첫 작업은 애플리케이션이 write를 호출하여 송신 데이터를 프로토콜 스택에 건네주는 것입니다.

프로토콜 스택은 받은 데이터를 곧바로 송신하는 것이 아닌 , 자체 내부에 있는 송신용 버퍼 메모리 영역에 저장 하고, 애플리케이션이 다음 데이터를 건네주기를 기다립니다.

📌 받은 데이터를 왜 일단 저장할까?
프로토콜 스택으로 전달하는 데이터의 길이는 애플리케이션의 종류나 만드는 방법에 따라 결정됩니다. 즉, 항상 다르기 때문에 프로토콜 스택에서 제어할 수가 없습니다. 만약, 작은 단위의 데이터를 받을 때마다 데이터를 보내게 되면 네트워크의 효율이 저하되기 때문에, 어느정도 데이터를 쌓고 나서 송수신 동작을 합니다.
📌 프로토콜 스택에 데이터를 저장하지 않고 바로 전송하도록 애플리케이션에서 옵션을 설정할 수도 있습니다. 브라우저와 같은 대화형 애플리케이션이 서버에 메시지를 보내는 경우라면 프로토콜 스택에 저장해놓는 동안 응답 시간이 지연되므로 이와 같은 옵션을 사용하는 경우가 많습니다.

3-2. 패킷이 도착했는지 확인

패킷 : 데이터의 단위 TCP는 송신한 패킷이 상대에게 올바르게 도착했는지 확인하고, 도착하지 않았으면 다시 송신하는 기능이 있기 때문에, 패킷 송신 후 확인 동작으로 넘어갑니다.

📌 확인 과정

1. 서버로 넘기는 데이터를 조각으로 분할
2. 데이터 맨 앞에서부터 따져서 각 조각이 몇 번째 바이트에 해당하는지를 시퀀스 번호라는 항목에 저장 >> TCP 헤더에 기록
3. 데이터의 크기도 같이 전달
4. 데이터의 누락 여부를 확인 할 수 있음

   예를 들어, 1,460바이트까지 수신 완료함. 1,461 패킷이 도착하면 누락이 없는 것임
   근데 시퀀스 번호가 1,461인 패킷이 도착하지 않았는데 
   2,921 패킷이 도착하면 1,461 패킷이 누락된 것임

5. 이렇게 데이터의 누락여부를 확인 후에, 이전에 수신한 데이터를 합쳐서 데이터를 몇 번째 바이트까지 수신한 것인지 계산하고, 그 값을 ACK 번호(아크번호)에 기록해서 송신측에 전달

송신 : 00 번째 바이트부터 시작되는 데이터를 xx바이트만큼 보내세요 수신 : xx번째 바이트까지 수신했습니다.
ACK번호를 되돌려주는 위의 동작을 수신확인 응답이라고 부름

--틈틈히 정리중--

1. finally 블록

예외를 전달하고 싶지만, 예외가 발생해도 정리 코드를 실행하고 싶을 때는 try/finally를 사용하면 됩니다

ex)

file_open = open('/test.txt')
try:
    data = file_open.read()
finally:
    file_open.close()

2. else 블록

어떤 예외를 처리하고, 어떤 예외를 전달할지를 명확하게 하고자 한다면 try/except/else를 사용하면 됩니다.

def load_json_key(data, key):
    try:
        result_dict = json.loads(data)
    except ValueError as e:
        raise KeyError from e
    else:
        return result_dict[key]

except와 else를 나눠서 예외 전달 행위를 명확하게 할 수 있습니다.

1) json.loads 과정에서 ValueError가 일어나면 2) except에서 처리 됨 3) 에러 없으면 else로 넘어가서 벨류값 찾음 4) 3번의 과정에서 에러가 발생한다면, try/except와 구분되는 에러이기 때문에 시각적으로 except와 구분함

3. 모두 사용

복합문 하나로 모든 것을 처리하고자 한다면 try/except/else/finally 를 전부 사용하면 됩니다.

ex. 파일에서 수행할 작업 설명을 읽고, 처리한 후 바로 업데이트 하는 작업 try : 파일을 읽고 처리 except : try블록에서 일어난 예외 처리 else : 파일을 바로 업데이트하고, 관련한 예외가 전달되게 하는데 사용 finally : 파일 핸들을 정리하는데 사용

undefined = object()

def divide_json(path):
    handle = open(paht, 'r+')
    try:
        data = handle.read()
    op = json.loads(data)
        value = (
            op['numerator'] / 
            op['denominator'])
    except ZeroDivisionError as e:
        return undefined
    else:
        op['result'] = value
        result = json.dumps(op)
        handle.seek(0)
        handle.write(result)
        return value
    finally:
        handle.close()

출처 : 도서 [파이썬 코딩의 기술]