이런 경우엔 보통 의존성 문제가 대부분이다. 이럴때는 옵션을 주어서 모듈을 받아와야 한다.

--fore : 충돌을 우회
--legacy-peer-deps : 무시하고 설치

• 해결방법

1. ERR나는 모듈의 버전을 맞춘다.

2. 무시하고 설치한다.

    npm install --save --legacy-peer-deps

react의 기초적이고 중요한 이론만 정리되어 있는 요약집 입니다.

리엑트이란?

react는 javascript 라이브러리 중 하나로 UI(User Interface)를 만들기 위해 사용된다.

• react는 다른 프레임워크와 달리 view만 담당하는 라이브러리이다. 하여 third-party 라이브러리 (react-router-dom, redux)를 추가하여 함께 사용한다.

리엑트 특징

1. Data Flow
2. Props 와 State
3. Component 구조
4. Virtual Dom
5. JSX

1. Data Flow

react는 데이터의 방향이 양방향 구조가 아닌 단반향 구조이다.

2. Props 와 State

• props(properties) 는 상위 컴포넌트가 하위 컴포넌트에 값을 전달할때 사용함. 쉽게 말해서 매개변수를 전달한다고 볼 수 있다. 단방향 구조로 하위 컴포넌트는 상위 컴포넌트의 데이터를 읽기만 가능하다.

기초적이고 중요한 이론만 정리되어 있는 요약집 입니다.

1. 파이썬이란?

- 특징

1. 스크립트 언어 (컴파일 과정 X)
2. 동적 타이핑 (자료형 선언 X)
3. 플랫폼 독립적 (컴파일이 필요없어 3OS 전부 구동 O)
4. 모든 요소가 객체 (객체지향 프로그래밍)

- 사용되는 분야

1. GUI 프로그래밍
2. DB 연동 프로그래밍
3. 연산, 통계
4. 소프트웨어 제작
5. 빅데이터 프로그래밍
6. 네트워크 장비제어

- 파이썬 인터프리터 종류

- Python(CPython) : C로 작성된 인터프리터(Default)
- Jython : 자바 가상머신용 인터프리터
- IronPython : .NET 플랫폼용 인터프리터
- PyPy : 파이썬으로 작성된 인터프리터로 속도 개선 목적
- IPython : 파이썬 + 리눅스, 병렬 컴퓨팅 등을 지원하는 인터프리터

2. 객체 (type, dir, help)

• type() : 객체타입 확인

    n = 10
    type(n)

• dir() : 속성값 확인

    n = 10
    dir(n)

• help() ： 속성정보 확인

    n = 10
    help(10)

3. 타입과 연산자

• 타입

  int / float / str / bool

  
  

• 연산자

| Description | Operator |
| --- | --- |
| 산술 연산자 | +, -, *, /, **, //, % |
| 비교  | ==, !=, <, <=, >, >= |
| 논리 | and, or, not |
| 멤버쉽 | in |
| 식별 | is |

4. 변수와 입출력 (print, input)

• 변수

  • 변수이름 규칙

    1. 문자, 숫자, _ 로 구성된 이름 O
    2. 처음 시작으로 숫자 X
    3. 파이썬 keyword 사용 X
       

  • del 키워드 (변수와 객체 연결을 끊을 수 있다.)

      var = 123
      del var

• 입출력

  • 출력

    print("123") // 123
    print("1", "2", "3", sep=",") // 1,2,3
    print("Hello", end="~ ") // Hello~ >>
    
    “{}는 {}입니다.”.format(’저’, ‘개발자’)
    
    “저는 {job}입니다. {job}는 항상 {mean} 해야합니다.”
    .format(job = ”개발자”, mean = “공부”)

  • 입력

    name = input('이름을 입력 : ')

5. 조건문과 반복문 (if, while)

• 조건문

  • default

      if 표현식1:
          코드 블록
      elif 표현식2:
          코드 블록
      else:
          코드 블록

  
  

  • pass (아무것도 작성 X)

      if False:
          pass
      else:
          코드블록

  
  

  • 3항 연산자

      표현식1 if 표현식2 else 표현식3

• 반복문

• for 문

  for 변수 in 객체:
    코드블록

• range 함수

  range(start, end, step)

• while 문

  while 조건식:
    코드블록

• 재귀 함수

  def a():
    코드블록...
    a()
  
    // ex) 등차수열
    def a(n):
        if n == 1:
            return 0
        return a(n-1) + 2
  
    // ex) 피보나치 수열
    def a(n):
        if n < 2:
            return n
        return a(n-1) + a(n-2)

• 반복문 키워드

  • continue
  • break

6. 시퀀스 데이터 (list, tuple, set, dict)

1. list - 대괄호 []

• 여러개의 데이터를 저장하고 대괄호로 감싸진 mutable 타입

- default

```python
# 생성
list1 = [] # 빈리스트 생성 방법1
list1 = list() #빈리스트 생성 방법2

list1 = [1,2,3] # 생성, 초기화 방법1
list1 = list(1,2,3) # 생성, 초기화 방법2
```

1. 인덱싱

```python
s1 = list('abcd')

print(s1[1]) # b
print(s1[-1]) # d
```

2. 슬라이싱

```python
s1 = list('abcd')

print(s1[1:3]) # bc
```

3. unpacking

```python
s1 = list('abc')

e1, e2, e3 = s1 #unpacking
print(e1, e2, e3) # a b c
```

4. 주요 메소드

• len() : 리스트 길이

    s1 = list('abcde')
  
    print(len(s1)) # 5

• del() : 리스트 요소 삭제

    s1 = list('abcde')
  
    del s1[0]
    print(s1) # [bcde]

• append() : 맨뒤 추가

    s1 = list('abcde')
  
    s1.append(f) # abcdef

• insert() : 특정 인텍스에 추가

    s1 = list('abcde')
  
    s1.insert(1, A) # aAbcde

• remove : 먼저만나는 요소 삭제

    s1 = list('abcabc')
  
    s1.remove('b') # acabc

• pop : 리스트 맨마지막 리턴 및 삭제

    s1 = list('abcde')
  
    res = s1.pop() # e

• extend (+연산자동일)

    s1 = [1,2,3]
    s2 = [4,5]
  
    s1.extend(s2) # [1, 2, 3, 4, 5]

• count : 개수 리턴

    s1 = [1, 2, 3, 2, 3]
  
    s1.count(2) # 2

• index : 가장 처음만나는 요소 인덱스 리턴

    s1 = [1, 2, 3, 2, 3]
  
    s1.index(2) # 1

• reverse : 반대로

    s1 = [1, 2, 3, 4, 5]
  
    s1.reverse() # [5, 4, 3, 2, 1]

• sort, sorted : 오름차순 정렬

    s1 = [2, 4, 2, 5, 1]
  
    s2 = sorted(s1) # s1의 값는 변하지않음
    s1.sort() # s1 의 값이 변함 [1, 2, 3, 4, 5]

• 얕은복사, 깊은복사

  • 얕은복사

      s1 = [1, 2, [3, 4]]
      s2 = s1
      s3 = copy(s1)
    
      s1[0] = 'a'
      print(s1) # ['a', 2, [3, 4]]
      print(s2) # ['a', 2, [3, 4]]
      print(s3) # [1, 2, [3, 4]]
    
      s1[2].append(5)
      print(s1) # ['a', 2, [3, 4, 5]]
      print(s2) # ['a', 2, [3, 4, 5]]
      print(s3) # [1, 2, [3, 4, 5]]

  • 얕은복사시 복사본 요소중 객체가 있을 경우 의도치 않은 변경이 생길 수 있음

• 깊은복사

  ```python
  s1 = [1, 2, [3, 4]]
  s2 = s1
  s3 = copy.deepcopy(s1)
  
  s1[2].append(5)
  print(s1) # [1, 2, [3, 4, 5]]
  print(s2) # [1, 2, [3, 4, 5]]
  print(s3) # [1, 2, [3, 4]]
  ```

• 주요 메소드 정리

  function	Description
  cmp(list1, list2)	두 리스트의 요소 비교
  len(list)	리스트 전체 길이
  max(list)	최대값 반환
  min(list)	최소값 반환
  list(seq)	튜플 → 리스트 변환
  list.append(obj)	obj를 list에 추가
  list.count(obj)	list에 있는 obj의 개수 반환
  list.extend(seq)	+ 연산과 동일
  list.index(obj)	list에 있는 obj index반환 (가장적은 index)
  list.insert(index, obj)	list의 해당 index에 obj 추가
  list.pop()	맨끝 삭제 및 반환
  list.remove(obj)	해당 obj 제거
  list.reverse()	반전
  list.sort()	정렬

2. tuple - 소괄호 ()

• 여러개의 데이터를 저장하고 소괄호로 감싸진 immutable 타입.
• 리스트와 동일하지만 차이점은 한번 생성되면 읽기만 가능하고 수정이 불가.

• default

    # 생성
    t1 = () # 빈 튜플 생성 방법1
    t1  = tuple() # 빈 튜플 생성 방법2
  
    t1 = (1, 2, 3) # 생성, 초기화 방법 1
    t1 = tuple([1,2,3]) # 생성, 초기화 방법2

1. 인덱싱

    t1 = (1, 2, 3, [4, 5, 6])
   
    print(t1[0]) # 1
    print(t1[-1]) # [4, 5, 6]

2. 슬라이싱

    t1 = (1, 2, 3, 4, 5)
   
    print(t1[1:3]) # (2, 3)

3. unpacking

    t1 = (1, 2, 3)
   
    e1, e2, e3 = t1 # 1 2 3

4. 주요 메소드

   • len() : 튜플 전체 길이 반환

       t1 = (1, 2, 3)
     
       print(len(t1)) # 3

   • count : 개수 리턴

       t1 = (1, 2, 3, 2, 3)
     
       t1.count(2) # 2

   • index : 가장 처음만나는 요소 인덱스 리턴

       t1 = (1, 2, 3, 2, 3)
     
       t1.index(2) # 1

3. set - 중괄호 {}

• 여러개의 데이터를 저장한다.

• 순서를 유지하지 않는다.

• 같은데이터는 1개로 처리한다.

• 중괄호를 사용한다.

• default

    # 생성
    s1 = {'hello'} # 생성방법 1
    s1 = set('hello') # 생성방법 2
  
    print(s1) # {'l', 'o', 'e', 'h'}

1. 인덱싱

    s1 = {'hello'}
   
    print(s1[0]) # error 접근불가

2. 주요메소드 (len, add, update, remove)

    s1 = {1, 2, 3, 2, 3}
   
    # len (요소개수) - 중복된 요소는 count 되지 않는다.
    print(len(s1)) # 3 
   
    # add (단일요소추가)
    s1.add(4)
   
    # update (다중요소추가)
    s2 = {7,8}
    s1.update(s2)
   
    # remove (요소 제거)
    s1.remove(3)

3. set은 집합 연산이 가능

   • 교집합 - &
   • 합집합 = |
   • 차집합 = -
   • 대칭 차집합 = ^

4. dict - 중괄호 {}

• 딕셔너리는 사전으로 고유한(key), 변경되는(value)로 맵핑되어 있는 집합.

• 각 키와 값은 콜론(:)으로 구분.

• value를 가져오려면 대괄호를 사용함.

• 중복키는 허용하지 않음.

• 수정이 가능한 mutable 타입.

• default

    # 생성
    d1 = {'Name' : 'SM', 'Age' : 30}
  
    # get (방법2가지)
    print(d1['Name']) # SM
    print(d1.get('Age')) # 30
  
    # insert
    d1['weight'] = 60
  
    # del
    del d1['weight']

• 주요 메소드

  • keys() : 모든 key 가져오기

      d1 = {'Name' : 'SM', 'Age' : 30}
    
      keys = d1.keys() # (['Name', 'Age'])

- values() : 모든 value 가져오기

    ```python
    d1 = {'Name' : 'SM', 'Age' : 30}

    keys = d1.keys() # (['SM', 30])
    ```


- items() : 모든 key와 모든 value 가져오기

    ```python
    d1 = {'Name' : 'SM', 'Age' : 30}

    items = d1.items() # ([('Name', 'SM'), ('Age', 30)])
    ```


- value in array : key 존재 판단

    ```python
    d1 = {'Name' : 'SM', 'Age' : 30}

    print('Age' in d1) # True
    ```


- clear() : 모든 요소 지우기

    ```python
    d1 = {'Name' : 'SM', 'Age' : 30}

    d1.clear()
    ```

7. 함수