반응형

클린코드 작성하기 

public class Main {
    public static void main(String[] args) {
        System.out.println("숫자를 입력하세요 : ");
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        
        int r1 = 0, r2 = 0, r3=0, r4=0, r5 = 0, r6 = 0;
        
        for(int i = 0; i < a; i++){
            double b = Math.random() * 6;
            if(b >=0 && b <1){
                r1 ++;
            }else if(b >= 1 && b < 2){
                r2 ++;
            }else if(b >= 2 && b < 3){
                r2 ++;
            }else if(b >= 3 && b < 4){
                r2 ++;
            }else if(b >= 4 && b < 5){
                r2 ++;
            }else if(b >= 5 && b < 6){
                r2 ++;
            }
        }

        System.out.printf("1은 %d번 나왔습니다.\n",r1);
        System.out.printf("2은 %d번 나왔습니다.\n",r2);
        System.out.printf("3은 %d번 나왔습니다.\n",r3);
        System.out.printf("4은 %d번 나왔습니다.\n",r4);
        System.out.printf("5은 %d번 나왔습니다.\n",r5);
        System.out.printf("6은 %d번 나왔습니다.\n",r6);
    }
}

 

이 코드를 리팩토링 하는게 5일차 미션이다. 

 

코드에서 역활을 분리해서 메서드를 추출.

public class TestClass {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = getA(scanner);

        int r1 = 0, r2 = 0, r3 = 0, r4 = 0, r5 = 0, r6 = 0;

        condition(a, r1, r2, r3, r4, r5, r6);
        print(r1, r2, r3, r4, r5, r6);
    }
	
    //주사위를 던질횟수를 입력받는다
    private static int getA(Scanner scanner) {
        System.out.println("숫자를 입력하세요 : ");
        return scanner.nextInt();
    }
	
    //주사위를 던져 1~6까지의 숫자가 몇번나왔는지 증가
    private static void condition(int a, int r1, int r2, int r3, int r4, int r5, int r6) {
        for (int i = 0; i < a; i++) {
            double b = Math.random() * 6;

            switch ((int) b) {
                case 0:
                    r1++;
                    break;
                case 1:
                    r2++;
                    break;
                case 2:
                    r3++;
                    break;
                case 3:
                    r4++;
                    break;
                case 4:
                    r5++;
                    break;
                case 5:
                    r6++;
                    break;
                default:
                    // 기본값 처리
                    break;
            }
        }
    }
	
    //주사위 결과 출력
    private static void print(int r1, int r2, int r3, int r4, int r5, int r6) {
        System.out.printf("1은 %d번 나왔습니다.\n", r1);
        System.out.printf("2은 %d번 나왔습니다.\n", r2);
        System.out.printf("3은 %d번 나왔습니다.\n", r3);
        System.out.printf("4은 %d번 나왔습니다.\n", r4);
        System.out.printf("5은 %d번 나왔습니다.\n", r5);
        System.out.printf("6은 %d번 나왔습니다.\n", r6);
    }
}

 

전체적인 코드는 길어졌지만 메인 메서드만 보면 이전보다는 가독성이 좋아지고

메서드의 이름을 통해 어떤동작을 하는지 간단하게 파악이 가능해졌다. 

 

이제 중복되는 과정들은 조건문과 반복문으로 줄이고 주사위의 횟수를 저장할값도 더 쉽게 만들어보자.

public class TestClass {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Map<Integer, Integer> dice = createDice(6);

        int count = getCount(scanner);
        play(dice,count);
        print(dice);
    }

    private static Map<Integer, Integer> createDice(int a) {
        Map<Integer, Integer> dice = new HashMap<>();
        for (int i = 0; i < a; i++) {
            dice.put(i + 1, 0); // key(주사위번호) : value(해당번호가 나온 횟수)
        }
        return dice;
    }

    private static int getCount(Scanner scanner) {
        System.out.println("숫자를 입력하세요 : ");
        return scanner.nextInt();
    }

    private static void condition(Map<Integer, Integer> dice,int count) {
        for (int i = 0; i < count; i++) {
            int b = (int) (Math.random() * dice.size()) + 1;

            dice.put(b, dice.getOrDefault(b, 0) + 1);
        }
    }

    private static void print(Map<Integer, Integer> dice) {
        for (Entry<Integer, Integer> entry : dice.entrySet()) {
            System.out.printf("%d은 %d번 나왔습니다.\n", entry.getKey(),entry.getValue());
        }
    }
}

 

중간과정을 좀 많이 건너뛴 최종 리팩토링 코드이다. 

 

1.  r1 , r2 로 주사위의 눈금을 받아주던 변수를 확장성있게 map으로 변경


int r1 = 0, r2 = 0, r3 = 0, r4 = 0, r5 = 0, r6 = 0; 
//이제 눈금갯수를 수정해도 변수의 갯수가 바뀌지 않고 변수를 여러개 선언하지않아도 된다.
Map<Integer, Integer> dice = createDice(6);

//Array나 배열을 사용하면 이 메서드를 생성하지 않아도 된다.
private static Map<Integer, Integer> createDice(int a) {
        Map<Integer, Integer> dice = new HashMap<>();
        for (int i = 0; i < a; i++) {
            dice.put(i + 1, 0); // key(주사위번호) : value(해당번호가 나온 횟수)
        }
        return dice;
    }

 

맵말고 Array나 그냥 일반배열로 해도 index를 통해서 눈금을 나타낼수있어서 그쪽이 더 간단할것같다. 

이번에는 그냥 Map타입을 사용해보고싶어서 Map으로 주사위를 지정했지만

이후 다른 기능이 추가될때 특성에따라 타입을 수정해야 할수도 있을것같다.

 

2.조건 부분을 반복문과 조건문으로 수정

private static void condition(int a, int r1, int r2, int r3, int r4, int r5, int r6) {
        for (int i = 0; i < a; i++) {
            double b = Math.random() * 6;

            switch ((int) b) {
                case 0:
                    r1++;
                    break;
                case 1:
                    r2++;
                    break;
                case 2:
                    r3++;
                    break;
                case 3:
                    r4++;
                    break;
                case 4:
                    r5++;
                    break;
                case 5:
                    r6++;
                    break;
                default:
                    // 기본값 처리
                    break;
            }
        }
    }
// if else조건문을 switch문으로 변경했을때 가독성은 더 좋아졌지만 반복되고 코드가 길어지는 문제가있었다
// 이를 반복과 조건문으로 변경하고 r1,r2같이 파라미터가 여러개이던 문제도 dice를 Map타입으로 만들면서 해결되었다.
// a라는 이름으로 들어오던 파라미터도 의미를 알기쉽게 count라는 이름으로 변경해주었다.
private static void play(Map<Integer, Integer> dice,int count) {
        for (int i = 0; i < count; i++) {
            int b = (int) (Math.random() * dice.size()) + 1;

            dice.put(b, dice.getOrDefault(b, 0) + 1);
        }
    }

이제 누가봐도 파라미터로 받는 count만큼 주사위를 굴려서 dice에 매칭 시켜주는 함수라는 걸 알기 쉬워졌다.

메서드이름은 condition보다는 주사위를 굴린다는 의미로 바꾸어주는게 좋을것같다. condition => play

 

3.출력부분을 반복문으로 수정

//주사위 결과 출력
    private static void print(int r1, int r2, int r3, int r4, int r5, int r6) {
        System.out.printf("1은 %d번 나왔습니다.\n", r1);
        System.out.printf("2은 %d번 나왔습니다.\n", r2);
        System.out.printf("3은 %d번 나왔습니다.\n", r3);
        System.out.printf("4은 %d번 나왔습니다.\n", r4);
        System.out.printf("5은 %d번 나왔습니다.\n", r5);
        System.out.printf("6은 %d번 나왔습니다.\n", r6);
    }
    
    private static void print(Map<Integer, Integer> dice) {
        for (Entry<Integer, Integer> entry : dice.entrySet()) {
            System.out.printf("%d은 %d번 나왔습니다.\n", entry.getKey(),entry.getValue());
        }
    }

 

이전에는 출력해주던 메서드도 반복되고 파라미터가 많아서 주사위의 눈금이 늘어나면 그만큼 파라미터도 늘어나야하고 코드도 길어져야 하는 문제가 있었다. 이것 또한 dice로 타입이 변경되면서 반복문이 사용가능해면서 해결되었다.

 

이 부분은 주사위를 map, 배열 , Array로 변경하면서 해결했다.

주사위 자체를 따로 Dice클래스로 만들고 그 안에 주사위의 눈금과 몇번나왔는지 지정해주는 필드를 생성해도 될것같고 

더 다양한 방법도 있을것같다.

 

<클린코드>

이 개념에 대해서 배워보았는데 이전에 우테코를 하면서 코드 컨벤션이라는 개념을 배워본적이있었다.

코드를 작성하기위한 약속이었는데 코드 컨벤션만 준수하면서 작성해도 어느정도 가독성이 좋고

모두가 이해하기 쉬운 코드를 작성할수있다고 생각한다. 가장 좋은 코드는 책 처럼 읽어지는 코드가 아닐까?

반응형
반응형

4일차 과제는 API를 직접만들어보는 과제였다.

 

문제1

우리는 작은 과일 가게를 운영하고있습니다. 과일 가게에 입고된 "과일 정보"를 저장하는 API를 만들어 봅시다.

 

API 스펙

 

위의 요구사항을 보고 우선 값을 저장할수있는 테이블을 생성해주고 

요청값을 파라미터로 받아줄 객체를 생성했다. 

 

테이블 생성

CREATE TABLE fruitshop (
                           id int PRIMARY KEY AUTO_INCREMENT,
                           name VARCHAR(50),
                           warehousedate DATETIME,
                           price INT
);

//이후 필드 추가 , 과일의 판매여부를 체크할 필드
ALTER TABLE fruitshop
    ADD sell BOOLEAN DEFAULT false;

 

파라미터를 전달해줄 DTO객체

public class FruitSaveRequest {

    private String name;
    private Long price;
    private String warehousingDate;

    public String getName() {
        return name;
    }

    public Long getPrice() {
        return price;
    }

    public String getWarehousingDate() {
        return warehousingDate;
    }
}

 

아직 DAO와 DTO의 기준이 모호하다 . 해당객체는 파라미터를받아서 insert 쿼리에 넣어주기위한 용도로만 사용하므로  DTO라고 생각한다.

 

컨트롤러 코드 

@RestController
@RequestMapping("/api/v1/fruit")
public class FruitShopController {
    private final JdbcTemplate template;

    public FruitShopController(JdbcTemplate template) {
        this.template = template;
    }

    @PostMapping
    public void saveFruit(@RequestBody FruitSaveRequest request){
        String sql = "insert into fruitshop (name,warehousedate,price) values (?,?,?)";
        template.update(sql,request.getName(),request.getWarehousingDate(),request.getPrice());
    }
}

 

 

json으로 들어오는 파라미터가 FruitSaveRequest에 매칭되어서 saveFruit메서드에 파라미터로 들어가게되고 

template.update 에서 sql의 파라미터로 사용된다.

 

*자바에서 정수를 다루는 가장 대표적인 두 가지 방법은 int 와 long 이다. 

이 두가지 방법 중 위 API에서 long을 사용한 이유는 무엇일까?

 

값이나 id값은 int자료형으로는 커버할수있는 범위가 작기때문에 값이 얼마나 들어올지 예측할수없는 db의 경우에 커버리지를 넓게 잡기위해 long타입으로 지정해주는듯 하다.

 

문제2

과일이 팔리게 되면, 우리 시스템에 팔린 과일 정보를 기록해야 합니다.

 

API스펙

 

id를 파라미터로 받아서 조건에 맞는 필드를 업데이트 해주면 될것같다.

@PutMapping
    public void sellFruit(@RequestBody Map<String, Object> requestJson){
        long id = Long.parseLong(requestJson.get("id").toString()); //id값
        String readSql = "select id from fruitshop where id = ?";  // 값이 있는지 확인하기위한 쿼리
        Boolean isUserNotExist = template.query(readSql, (rs, rowNum) -> 0, id).isEmpty(); //(rs, rowNum) -> 0 결과값이 있는 경우 0을 반환  
        if(isUserNotExist){
            throw new IllegalArgumentException("수정할 자료가 없습니다.");
        }

        String sql = "update fruitshop set sell = true where id = ?";
        template.update(sql,id);
    }

 

해당하는 아이디의 값이있는지 검증하고 값이 있으면 해당 값의 sell을 true로 변경해준다. (판매되었다는 의미)

 

여기에서는 값을 받기위해서 객체를 생성하지않고 Map을통해서 들어오는 Json을 받아서 long타입의 id로 변경해주었다.

 

 

문제3

우리는 특정 괴일을 기준으로 팔린 금액, 팔리지 않은 금액을 조회하고 싶습니다.

 

API스펙

@GetMapping("/stat")
    public FruitShopAmoutResponse getAmount(@RequestParam String name){
        String sql = "SELECT id,name,warehousedate,price,sell FROM fruitshop where name = ? ";

        List<FruitShopResponse> query = template.query(sql,new Object[]{name}, (rs, rowNum) -> {
            System.out.println("rs = " + rs);
            long id = rs.getLong("id");
            String fruitname = rs.getString("name");
            String warehouseDate = rs.getString("warehouseDate");
            long price = rs.getLong("price");
            boolean sell = rs.getBoolean("sell");
            return new FruitShopResponse(id, fruitname, warehouseDate, price, sell);
        });

        FruitShopAmoutResponse fruitShopAmoutResponse = getFruitShopAmoutResponse(query);
        return fruitShopAmoutResponse;
    }
    
    private static FruitShopAmoutResponse getFruitShopAmoutResponse(List<FruitShopResponse> result) {
        long salesAmount = result.stream()
                .filter(rs -> rs.getSell())
                .mapToLong(rs -> rs.getPrice())
                .sum();

        long notSalesAmount = result.stream()
                .filter(rs -> !rs.getSell())
                .mapToLong(rs -> rs.getPrice())
                .sum();
        FruitShopAmoutResponse response = new FruitShopAmoutResponse(salesAmount, notSalesAmount);
        return response;
    }
반응형
반응형

[질문]

  • 자바의 람다식은 왜 등장했을까?
  • 람다식과 익명 클래스는 어떤 관계가 있을까? - 람다식의 문법은 어떻게 될까?


1. 자바의 람다식은 왜 등장했을까?

함수형 언어

람다식의 도입으로 인해 자바는 객체지향언어인 동시에 함수형 언어가 된다.

객체 지향언어에서는 주로 메서드를 사용하게되는데 메서드는 특정 객체에 종속되어야하지만

람다식을 통해서 메서드가 하나의 독립적인 기능을 할수있게되어 함수라는 용어를 사용한다.

 

익명함수

메서드의 이름과 반환값이 없어지므로 람다식을 익명 함수라고도 한다.

int[] arr = new int[5];
Arrays.setAll(arr , (i) -> (int)(Math.random() * 5) + 1);

// (i) -> (int)(Math.random() * 5) + 1; // 메서드로 변경
int method(){
	return (int) (Math.random() * 5) + 1
}

기존의 메서드는 클래스에 포함되어야 하므로 클래스도 새로 만들어야하고

객체도 생성해야만 메서드를 호출할수가있었다.

람다식은 오직 람다식 자체만으로 이 메서드의 역할을 대신할수가 있다

 

2. 람다식과 익명 클래스는 어떤 관계가 있을까? - 람다식의 문법은 어떻게 될까?

람다식은 익명 클래스의 객체와 동등하다.

 

(int a, int b) -> a > b ? a : b;

// 두개는 동일하다.

new Object(){
	int max(int a, int b){
    	return a> b ? a : b; 
    }
}

 

더 구체적인 예시는 

interface MyFunction{
	public abstract int max(int a, int b);
}

//인터페이스를 구현한 익명객체

MyFunction f = new MyFunction(){
	public int max(int a, int b) {
    	return a > b? a : b;
    }
}
int big = f.max(5, 3); // 익명 객체의 메서드를 호출

//람다식으로 대체

MyFunction f = (int a, int b) -> a> b? a : b; // 익명객체를 람다식으로 ㅂ대체
int big = f.max(5, 3); // 익명 객체의 메서드를 호출

 

익명객체를 람다식으로 대체가 가능한 이유는 람다식도 실제로는 익명 객체이고

MyFunction인터페이스를 구현한 익명 객체의 메서드 max( )

람다식의 매개변수의 타입과 개수 반환값이 일치하기 때문이다.

 

 

반응형
반응형

이번에는 파이썬이 이미 가지고있는 내장함수에 대해 배워보자

 

abs( ) 절대값을 반환해주는 함수

# abs(x) 절대값을 반환
result1 = abs(-100)
print(result1) # 100

 

all( ) 리스트,튜플,문자열 전체가 True일때만 True를 리턴 나머지는 False를 리턴

any( ) 하나라도 True면 True리턴

print(all([1,"A",""])) # False
print(any([1,"A"," "])) # True

파이썬에서는 아무것도없는 공백도 False로 취급한다.

 

divmod( a , b ) 몫과 나머지를 tuple로 반환

print(divmod( 10 , 3 )) # (3,1) 몫,나머지

 

enumerate( ) 열거형타입 배열의 인덱스와 요소를 열거해준다.

list = ["a","b","c","d","e"]

for i in range(len(list)): #이렇게 출력하는걸 enumerate를 사용해서 똑같이 출력가능
    print(i,list[i])
    
for i, v in enumerate(list): #인덱스와 밸류값을 가지고있음 
    print(i,v)

#결과 두 함수가 같음
0 a
1 b
2 c
3 d
4 e

 

max( ) 최대값을 리턴

min( ) 최소값을 리턴

print(max([80,90,60,70,50])) # 90
print(min([10,30,20,50])) # 10

응용

scores = [10,20,30,60,25,90]
maxscore = max(scores) # scores에서 가장 큰 값을 찾음
maxindex = scores.index(maxscore) # 가장 큰 값의 인덱스번호를 찾음
print('최대값은 %d 이고 %d번째 값입니다.' %(maxscore,maxindex)) #큰값과 큰값의 인덱스번호를 넣어서 출력

# 최대값은 90 이고 5번째 값입니다.

 

round( 반올림할수, 소수점자릿수)  수를 반올림 해서 반환

print(round(12.6789,2)) #12.68

 

sum( ) 리스트나 튜플을 입력받아 모든 요소의 합을 반환

numTuple = (2,3,4,5,6)
print(sum(numTuple)) # 20

 

이렇게 내장함수들과 파이썬의 자료형 제어문들을 모두 배워보았다 다른 라이브러리를 사용해보지는 않았지만 이것만 가지고 간단하게 로또 번호를 만들수있는 구문을 짜 보았다.

 

# 랜덤모듈 불러오기
import random
# 로또번호 출력
# 1~45 겹치지 않게 랜덤한 숫자로 6개 출력
# lottolist  = [range(1,46)] ,resultlost = []
count = input("로또를 얼마나 구입하시겠습니끼?:") #입력받은 값만큼 번호를 뽑음

for i in range(int(count)):
    lottolist = list(range(1,46)) #1~45까지 들어간 리스트 정의
    resultlist = [] # 결과가 들어갈 빈 리스트 
    for i in range(6): #로또번호가 6개이기때문에 배열에서 번호를 6번 뽑아내야함
        randnum = random.randint(1,len(lottolist))-1 # 1~45중 랜덤숫자
        resultlist.append(lottolist[randnum]) # 뽑은 랜덤숫자를 인덱스로 값에접근해서 빈리스트에 추가
        lottolist.remove(lottolist[randnum]) # 결과리스트에 추가한값 배열에서 제거
        #다르게 만드는방법
        # lottol = lottolist.pop(randomNum) #랜덤숫자를 넣어서 pop을 돌리면 값을지우면서 지운값을 리턴 
        # result.append(lottol) #리턴받은값을 결과 배열에 추가
    resultlist.sort() #만들어진 결과배열 정렬
    print(resultlist)

 

이거보고 누구든 로또사셔서 돈을 많이버시고 들숨에 체력 날숨에 재력을 얻으셨으면 좋겠습니다.

그리고 나도 좀 나눠주세요 ㅎ

반응형

'백엔드 > 파이썬' 카테고리의 다른 글

파이썬) 제어문  (0) 2023.03.08
파이썬) 파이썬 자료형  (0) 2023.03.07
파이썬) 문자열 메소드  (0) 2023.03.06
파이썬) 변수만들기,문자열  (0) 2023.03.06
파이썬 (설치방법,vscode사용법)  (0) 2023.03.06
반응형

조건문 

if(조건):
	#참일때 실행될구문
else:
	#거짓일때 실행될 구문

파이썬의 조건문은 자바스크립트와 달리 중괄호를 쓰지않고 들여쓰기로 실행될구문을 넣어준다

 

조건이 여러개인경우

if(조건1):
	#조건1이 참일때 실행될 구문
elif(조건2):
	#조건2가 참일때 실행될 구문
else:
	#조건이 모두 거짓일때 실행될구문

elif 로 다른조건을 추가할수있다.

 

반복문

while

while 조건:
	실행문
    # break:반복을 탈출
    # continue:반복 건너띄기

while문은 반복문 안에 증감식이나 조건문을 넣어서 조건을 빠져나올수있게 해줘야한다.

 

ex)  예제

treeHit = 0
while treeHit < 10:
    print("나무를 %d번 찍었습니다." %treeHit)
    treeHit += 1

#결과 
# 나무를 0번 찍었습니다.
# 나무를 1번 찍었습니다.
# 나무를 2번 찍었습니다.
...

 

for

for 변수 in 리스트(또는 튜플,문자열) :
    수행할 문장...

 

range메서드

range()함수
range(stop) # 0 ~ stop-1 까지 숫자를 생성
range(start,stop) #start ~ stop-1 까지 숫자를 생성
range(start, stop, step) start ~ stop -1 까지의 숫자를 step간격으로 생성.

 

ex) 구구단만들기 

for i in range(1,10): # 1~9
    for j in range(1,10): # 1~9
        print('%d * %d = %d' %(i,j,i*j))

#결과
# 1 * 1 = 1
# 1 * 2 = 2
# 1 * 3 = 3
... 9단까지반복
반응형

'백엔드 > 파이썬' 카테고리의 다른 글

파이썬) 내장함수  (0) 2023.03.08
파이썬) 파이썬 자료형  (0) 2023.03.07
파이썬) 문자열 메소드  (0) 2023.03.06
파이썬) 변수만들기,문자열  (0) 2023.03.06
파이썬 (설치방법,vscode사용법)  (0) 2023.03.06
반응형

이전에 팀프로젝트로 만든 파일을  로컬에서만 쓰다가 오늘 호스팅 하는 방법을 배워서

호스팅 하는 방법을 올려보려고 한다.

 

리액트파일과 서버파일이 있어서 두곳에 따로따로 호스팅 해줘야 한다. 

 

Node.js 서버 호스팅

HEROKU

https://dashboard.heroku.com/apps

 

Heroku

 

dashboard.heroku.com

위의 사이트에 들어가서 가입을 해줘야한다.

가입을 하면 로그인을 하고 create new app으로 들어가 준다

 

이제 여기서 이름을 설정해 주고 Create app을 누르면 깃허브리포지터리 같은 게 만들어진다.

 

만들고 나면 이런 창으로 이동하게 되는데 깃허브처럼 파일을 여기로 보내주면 된다

heroku로 push 하기 위해서는 heroku를 설치해줘야 한다. 

https://devcenter.heroku.com/articles/heroku-cli

 

The Heroku CLI | Heroku Dev Center

Last updated January 17, 2023 The Heroku Command Line Interface (CLI) lets you create and manage Heroku apps directly from the terminal. It’s an essential part of using Heroku. Install the Heroku CLI Pre-requisites The Heroku CLI requires Git, the popula

devcenter.heroku.com

링크로 들어가서 해당하는 운영체제와 옵션에 따라 설치해주면 된다.

 

설치하면 이제 호스팅 할준비가 끝났다 호스팅할 파일들도 준비를 좀 해줘 야한다

 

1. 호스팅 할 서버 파일이름을 index.js로 변경 

2. 호스팅 하는 파일의 port번호 변경

const port = process.env.PORT || 8080;
//지정해주는 포트번호가있다면 지정번호를사용하고 없다면 8080포트 사용

3.package.json 변경

 

 "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node index.js"
  },

 

이렇게 해준 뒤에 이제 깃허브에 push 하는 것과 똑같이 해주면 된다 

cmd 나 터미널을 이용해 주자

서버폴더위치에서 입력해줘야 한다.

 

주의사항*

서버를 깃허브에서 클론 해온 경우 node.module이 설치되어 있는지 확인 

없다면 npm install로 설치

 

. git 폴더를 지우고 처음부터 git init 하기 

 

업로드 전 서버를 실행시켜 보고 잘 실행되는지 확인!

 

json의 scripts.start 부분이 서버의 파일이름과 일치하는지 확인!!!

 

 

터미널에 입력

$ cd 프로젝트 위치
$ git init
$ git add .
$ git commit -m "heroku deploy" //커밋은 넣고싶은메모를 넣으면된다
$ heroku git:remote -a app name //이부분은 deploy에 쓰여있으니 복붙!
 --> 예시 $ heroku git:remote -a zzang9ha

$ git push heroku main //현재브랜치이름을 넣어주자 브랜치변경을 하지않았다면 master일수도 있다

 

push 까지 해 주고 오른쪽상단에 있는 open App을 눌러서 이런 창이 뜨면 성공이다 다른 에러창이 뜬다면 

json파일과 포트번호 그리고 모듈들이 잘 설치되어 있는지 다시 확인해 보고 리포지터리를 삭제한 다음 다시 만들어서 호스팅을 시도해야 한다..

 

서버의 데이터를 요청하는 주소로 이동하니 데이터를 잘 보내주는 걸 볼 수 있다! 이제 서버 끝 

 

 

React.js 호스팅

 

Vercel 가입하기

 

https://vercel.com/

 

Vercel: Develop. Preview. Ship. For the best frontend teams

Vercel is the platform for frontend developers, providing the speed and reliability innovators need to create at the moment of inspiration.

vercel.com

위 사이트를 통해서 github를 연결해서 바로 호스팅 할 수 있다.

깃허브로 회원가입이 가능하니 깃허브로 가입하고 빠르게 진행할 수 있다.

 

vercel에 리액트 파일을 호스팅 하기 전에 리액트 파일의 서버주소를

호스팅 된 노드서버주소로 변경해 준 다음 npm start로 실행해 보자.

리액트프로젝트의 서버주소 변경

나는 서버주소를 apiurl.js에서 변수로 선언해서 사용하고 있어서 여기 주소만 변경해 주겠다. 뒤에 / 가 필요하면 붙여주고 필요 없으면 때 주면 된다 서버에 요청을 어떻게 하는지 확인하자.

 

이제 다시 vecel로 돌아가서 

 

Add new에 project를 클릭하고 들어가서

깃허브를 연결해 주고 호스팅 하고 싶은 파일을 import 해주면 된다.

이제 이 화면에서 Deploy 해주고 기다리면 호스팅이 끝난다.

 

여기서는 수정할 부분이 있으면 로컬파일을 수정해서 다시 깃허브에 push 해주면

vercel에서 다시 호스팅 해준다.

 

https://team-project-thenadlee.vercel.app/

 

React App

 

team-project-thenadlee.vercel.app

호스팅 된 팀프로젝트.

반응형
반응형

숫자형)

숫자형태로 이루어진 자료형(정수,실수,8진수,16진수)

 

문자열)

문자나 문자들의; 집합 " " , ' ' , """ """,''' '''

 

리스트)

여러가지 자료의 묶음(배열) num = [1, 2, 3, 4, 5, 6] 인덱스로 값에 접근가능

 

리스트메소드

append( ) 리스트의 마지막 요소를 추가

리스트.append(추가할요소)

students = ["stu1","stu2","stu3","stu4"]

# 리스트에 요소추가 append
students.append("stu5") # students = ["stu1","stu2","stu3","stu4","stu5"]

sort( ) 리스트의 요소를 순서대로 정렬

리스트.sort( )

numberList = [5,2,1,6,7,8,2,10]
numberList.sort()
# numberList = [1,2,5,6,7,8,10]

 

reverse( ) 리스트 뒤집기

리스트.reverse( )

students = ["stu1","stu2","stu3","stu4","stu5"]
# 뒤집기 reverse
students.reverse()
# ["stu5","stu4","stu3","stu2","stu1"]

 

 

index( ) 리스트에 해당 값이 있으면 그 값의 index 값을 리턴 없으면 오류발생

리스트.index(찾는값)

students = ["stu1","stu2","stu3","stu4","stu5"]
num = students.index("stu3") # 2

 

insert(start,value) 리스트에 요소 삽입 start번째 위치에 value를 삽입

리스트.insert(2,20)

students = ["stu1","stu2","stu3","stu4","stu5"]
# 리스트에 요소추가 (원하는 위치에) insert(start,value)
students.insert(1,"newStu") # ["stu1","newStu","stu2","stu3","stu4","stu5"]

 

remove(value) 리스트에서 첫번째로 나오는 value를 삭제 

같은  값이 여러개이면 첫번째로나오는 value만 삭제된다.

students = ["stu1","stu2","stu3","stu4","stu5"]
# 리스트 요소제거 remove(value)
students.remove("stu3") # ["stu1","stu2","stu4","stu5"]

 

pop( ) 리스트의 맨 마지막요소를 리턴하고 그 요소는 삭제

리스트.pop( )

students = ["stu1","stu2","stu3","stu4","stu5"]
# 리스트 마지막요소 리턴후 삭제 pop()
lastlist = students.pop()
print(lastlist) # stu5

 

count(value) 리스트안에 value 가 몇개 있는지 개수를 리턴

ex)list = [1,2,3,1,2,3] , list.count(3) // 2 

fruits = ["사과","딸기","사과","바나나","사과","귤"]
applenum = fruits.count("사과")
print(applenum) # 3

 

튜플 자료형)

요소의 값을 변경할수없다. ( )안에 값을 넣음 ( ) 를 생략할수도있다.

t1 = ( )

t2 = (1 , )  // 1개일때 쉼표를 찍어줘야 튜플형이라는것을 알수있다

t3 = (1,2,3)

t4 = 1,2,3,4

인덱싱,슬라이싱, + , * , len() 사용가능

t1 = (1,2,3)
t2 = (1,) # 콤마필수
t3 = 1,2,3

# 인덱싱 ,슬라이싱, + , * ,len() 만 가능
print(t3[0:2]) # (1,2)
print(t1+t3) # (1,2,3,1,2,3)
print(t1*3) # (1,2,3,1,2,3,1,2,3)
print(len(t1)) # 3

 

딕셔너리 자료형)

{key : value) 

d1 = {'name' : 'green' , 'age' : 30}

d1 = {'name':'green','age':30,'name':'blue'}  // 뒤에 같은키로 만들면 뒤의값으로 덮어쓰기됨

d1[key] 키를 이용해서 값에 접근한다.

 

딕셔너리 메서드

keys( ) key값들을 리스트로만들기

딕셔너리.keys( ) // 파이썬 2.7까지는 리스트로 돌려주고 이후버전에서는 dict_keys객체로 돌려준다

dic3 = {'name':"G",'age':30,'name':'b'}
# key리스트 만들기
dic3key = dic3.keys()
print(dic3key) # dict_keys(['name', 'age']) 
dic3keylist = list(dic3key)
print(dic3keylist) ['name', 'age']

 

values( ) value값들을 리스트로 만들기

딕셔너리.values( )  // 파이썬 2.7까지는 리스트로 돌려주고 이후버전에서는 dict_keys객체로 돌려준다

dic3 = {'name':"G",'age':30,'name':'b'}
#value 리스트 만들기 values()
dic3value = dic3.values()
print(list(dic3value)) # ['b', 30]

 

items( ) key,value쌍으로 리스트만들기

딕셔너리.items( ) key와 value쌍을 튜플로 묶은 값을 dict_items 객체로 돌려준다

dic3 = {'name':"G",'age':30,'name':'b'}
#key,value 쌍 얻기 items()
dic3item = dic3.items()
print(list(dic3item)) # [('name', 'b'), ('age', 30)]

 

clear( ) key와 value쌍 모두 지우기 clear( )

딕셔너리.clear()

dic3 = {'name':"G",'age':30,'name':'b'}
# key,value 쌍 모두 지우기 clear()
dic3.clear()
print(dic3) # {}

 

 

get( ) key로 value값 구하기

딕셔너리.get(key) // 존재허지 않는키에 접근시 None을 리턴

딕셔너리[key] // 존재하지 않는 키로 접근시 오류 발생

# key로 value값 얻기 get(key)
dic4 = {'name': '구름','age':3,'color':'white'}
print(dic4.get('name')) # 구름
print(dic4.get('age')) # 3
print(dic4.get('a','aaaaa')) #없는 키로 호출시 none을 반환 default지정가능 // default 인 aaaaa출력

 

in 해당 key가 딕셔너리 안에 있는지 조사

'key' in 딕셔너리  있으면 True 없으면 False를 리턴

dic4 = {'name': '구름','age':3,'color':'white'}
# 해당 key가 있는지 in 
print('name' in dic4) # True
print('a' in dic4) # False

 

집합 자료형)

파이썬 2.3부터 지원 집합에 관련된 것을 쉽게 처리하기 위해서 만든 자료형

*중복을 허용하지 않는다, 순서가 없다

s1 = set([1,2,3])

s2 = set("Hello")

s3 = set([1,2,3,4,5,1,2,3])

li = list(s3) //[1,2,3,4,5]

 

집합 메서드       

값 추가하기 add

집합.add(value)

numberset1 = set([1,2,3,4,5,6])
# 값 한개 추가하기
numberset1.add(20)
print(numberset1) # {1, 2, 3, 4, 5, 6, 20}

 

값 여러개 추가하기 update

집합.update([4,5,6])

numberset1 = set([1,2,3,4,5,6,20])
# 값 여러개 추가하기 update()
numberset1.update([100,200,300])
print(numberset1) # {1, 2, 3, 4, 5, 6, 100, 200, 300, 20}


       

특정 값 제거하기 remove()
집합.remove(value)

numberset1 = set([1, 2, 3, 4, 5, 6, 100, 200, 300, 20])
# 특정 값 제거하기 remove(value)
numberset1.remove(100)
print(numberset1) #{1, 2, 3, 4, 5, 6, 200, 300, 20}


       

교집합 집합1 & 집합2 ,집합1.intersection(집합2)
 s1 = set([1,2,3,4,5,6])
 s2 = set([4,5,6,7,8,9])
 s1 & s2 {4,5,6}
 s1.intersection(s2) // {4,5,6}

numberset1 = set([1,2,3,4,5,6])
numberset2 = set([4,5,6,7,8,9])
# 교집합
print(numberset1 & numberset2) # {4, 5, 6}
print(numberset1.intersection(numberset2)) # {4, 5, 6}

 

합집합 집합1 | 집합2 , 집합1.union(집합2)

두개의 집합을 더해준다 중복값은 하나만들어감
s1 | s2 {1,2,3,4,5,6,7,8,9} 

s1.union(s2)

numberset1 = set([1,2,3,4,5,6])
numberset2 = set([4,5,6,7,8,9])
# 합집합
print(numberset1 | numberset2) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
print(numberset1.union(numberset2)) # {1, 2, 3, 4, 5, 6, 7, 8, 9}


       

차집합 집합1 - 집합2 , 집합1.difference(집합2)
 s1 = set([1,2,3,4,5,6])
 s2 = set([4,5,6,7,8,9])
 s1 - s2    // {1,2,3}
 s1.difference(s2) {1,2,3}

numberset1 = set([1,2,3,4,5,6])
numberset2 = set([4,5,6,7,8,9])
# 차집합
print(numberset1 - numberset2) #{1, 2, 3}
print(numberset1.difference(numberset2)) #{1, 2, 3}

 

부울 자료형) 불 자료형 참과 거짓을 나타내는 자료형 True 참 False 거짓

 

 

 

파이썬의 기본자료형과 각 자료형에서 사용할수있는 메소드 들을 알아보았다 다음엔 제어문(반복문,조건문)을 아라보자!

 

반응형

'백엔드 > 파이썬' 카테고리의 다른 글

파이썬) 내장함수  (0) 2023.03.08
파이썬) 제어문  (0) 2023.03.08
파이썬) 문자열 메소드  (0) 2023.03.06
파이썬) 변수만들기,문자열  (0) 2023.03.06
파이썬 (설치방법,vscode사용법)  (0) 2023.03.06
반응형

이번에는 문자열을 이용해서 다양한 문자열메서드를 사용해 보겠다.

 

문자열 더하기 ( + , *)

head = "python "
tail = "is fun"
print(head + tail)
print(head * 2)

#결과
# python is fun
# python python

 

문자열 길이 구하기 len( )

a = "python";
print(len(a))
print(a[5]) 

#결과
# 6
# n

문자열도 일종의 배열로 취급되기 때문에 인덱스를 이용해서 필요한 글자만 출력할 수 있다.

(인덱스는 0부터 시작)

 

문자열 슬라이싱

문자열[문자열 시작번호 : 끝번호] -  

a = "python"

print(a[0:2]) #인덱스0부터 2이전까지
print(a[:3]) #인덱스 시작부터 3이전까지
print(a[2:]) #인덱스 2부터 끝까지

# 결과
# py
# pyt
# thon

p y t h o n   문자열

0 1 2 3 4 5  인덱스

 

포맷팅

문자열 안에 어떤 값을 삽입

포맷코드

%s 문자열  string

%d 정수     decimal

%f  소수      float

number = 18
print("현재 온도는 %d도 입니다."%number) # 현재온도는 18도 입니다.
print("%0.4f"%3.1415923534) # 3.1416
number2 = 3
print("나는 사과 %d개를 먹었다" %number2) # 나는 사과 3개를 먹었다.

문자열의 포맷코드가 들어간부분에 변수를 넣어서 출력할 수 있다. 

%0.4f 는 소수점아래 4개까지 반올림하여 출력하겠다는 키워드이다.

num = 3
str3 = "어제"
print("나는 %s 사과 %d개를 먹었다" % (str3 , num))

변수를 2개 넣을 때는 %( ) 안에 변수이름들을 넣어주면 된다. 

 

format함수 사용하기

str3 = '어제'
num2 = 10

print("나는 {0} 사과 {1}개를 먹었다".format(str3,num2))   
print("나는 {0} 사과 {num2}개를 먹었다".format(str3,num2 = 30)) #여기서 num2는 밖의num2와는 다른변수이다

#결과
# 나는 어제 사과 10개를 먹었다
# 나는 어제 사과 30개를 먹었다

문자열에는 중괄호로 변수가들어갈 순서를 만들어주고 .format함수에 들어갈변수들을 넣어준다

f.string

name = "green"
age = 30
print(f'나의 이름은 {name}이고 나이는 {age}이다.')
print(f'내년이면 내 나이는 {age+1}이 됩니다')

#결과
# 나의 이름은 green이고 나이는 30이다.
# 내년이면 내 나이는 31이 됩니다

앞에 f를 붙여주고 중괄호 안에 변수를 넣어주어서 문자열로 포맷팅 해서 사용할 수 있다 파이썬 3.6부터 지원

 

 

문자개수 count

문자열. count('찾는 문자')

str = "hobbbby"
#문자갯수 문자열.count('찾는문자')
print(str.count('b'))

#결과
# 4

찾는 문자인 b를 문자열 str에서 몇 개인지 찾아줌.

 

위치 찾기 find

문자열. find('찾는 문자')

str = "hobbbby"
print(str.find('z'))

#결과
# -1

찾는 값의 인덱스번호를 반환한다 값이 없으면 -1을 반환해 준다.

 

문자열 삽입 join( )

리스트타입 --> 문자열로 변환

print('*'.join('green'))
print("*".join(['a','b','c','d','e']))

#결과
# g*r*e*e*n
# a*b*c*d*e

문자 사이에 입력한 텍스트가 들어간다.

리스트타입은 아직 안 배웠는데 문자열도 일종의 리스트처럼 사용해서 인덱스나 join 이 사용 가능하다.

 

대문자 upper( )

소문자 lower( ) 

str2 = "abcde"
print(str2.upper())
str3 = "ABCDE"
print(str3.lower())

#결과
# ABCDE
# abcde
 

공백지우기 strip( )

왼쪽 lstrip() 오른쪽 rstrip() 양쪽 strip()
str4 = " 안녕하세요 "
print(str4.rstrip())
print(str4.lstrip())
print(str4.strip())

#결과
# 안녕하세요
#안녕하세요
#안녕하세요
 
 

문자열에서 사용할수있는 메소드를 둘러봤다 다음은 이제 본격적으로 파이썬의 자료형에 대해서 아라보자.

 

반응형

'백엔드 > 파이썬' 카테고리의 다른 글

파이썬) 내장함수  (0) 2023.03.08
파이썬) 제어문  (0) 2023.03.08
파이썬) 파이썬 자료형  (0) 2023.03.07
파이썬) 변수만들기,문자열  (0) 2023.03.06
파이썬 (설치방법,vscode사용법)  (0) 2023.03.06

+ Recent posts