날짜 2023-10-11 12:05

참고/연관된 기록 =>

• https://wikidocs.net/book/1

ㅡ 행동에 대한 이유 =>

ㅡ
나는 파이썬 웹 개발 취업 캠프를 참여했다. 따라서 첫 커리어의 시작점을 파이썬을 주력으로 활용하는 웹 백엔드 개발직군으로 설정했었다. 하지만 캠프에서 제공했던 다양한 선배 개발자 세미나 참여를 통해 조언을 듣고 생각을 정리하는 과정에서 현재는 금융산업-웹 개발자로 진로의 방향성을 좀 더 구체화시킬 수 있었다.

따라서 현재는 파이썬 개발 역량보다는 자바 개발 역량 향상이 필요하지만 캠프에서 보낸 시간들이 의미 있게 만들고, 다음 새로운 언어 학습에 앞서 배운 파이썬 내용을 끝까지 학습하기로 결정.

ㅡ
특정 직무나 산업 분야를 결정했다면, 해당 분야에서 요구하는 기술 스택-프로그래밍 언어를 학습하는 것이 가장 적절하다. 하지만 만약 아직 구체적인 직무나 산업 분야를 결정하지 못한 상황이라면 파이썬으로 시작하는 것이 좋은 선택지라 생각한다.

파이썬 언어는 직관적인 구조를 가지고 있고, 읽기 쉬운 언어이기 때문에 처음 공부하는 초보자가 다른 언어보다 학습하기 수월하다고 생각한다. 더 나아가 해당 언어로 간단한 프로그램을 개발해 보면서 프로그래밍에 대한 기본적인 이해를 쌓는다면 후에 다른 언어로의 전환 시 좀 더 빠르게 학습할 수 있다.

모든 언어가 문법과 표현 방식의 차이점이 있을 뿐 공통적으로 가지고 있는 기본 개념과 원리가 유사하기 때문에 하나의 프로그래밍 언어를 제대로 배워두면 다른 언어로의 학습이 빨라진다.

Second-Brain

02장 파이썬 프로그래밍의 기초, 자료형

• "문법" 용어

• 비슷한 의미 = 상호 교환적 사용 가능
  • 변수가 가지고 있는 데이터 특징이나 종류/형태를 의미
• ㅡㅡㅡㅡ
• 데이터 타입
• 데이터 자료형
• 데이터 유형
• 데이터 종류
• 데이터 특징

ㅡ 객체복사

• 참조복사, 얕은복사 모두 객체 참조/공유하는 상황 설명 시 사용.
• 참조복사
  • 두 변수(가) 완전히 동일한 객체 참조 상황 = 새로운 객체 발생 x 상황 -- - '특정 객체 다른 변수에 할당하는 상황'
• 얕은 복사
  • 최상위 레벨 객체는 새로운 객체 생성
  • 내부 객체 원본 참조 상황
• 깊은 복사
  • 최상위 객체 + 내부 객체 모두 독립적 존재 > 단일 리스트인 경우 새로운 객체가 반환된다는 사실만으로는 어떤 복사가 발생했는지 구별 x

참조복사상황-객체동일-참조-공유" tabindex="-1">ㅡ 참조복사상황-객체동일-참조-공유

• 키워드/문장 기록 =>
• 예시코드
• 참조 복사 상황
  • 객체 동일
• ㅡㅡㅡㅡ
• 변수 직접 할당 -- '복사 객체 값 변경 시 > 원본 객체 변경'
  • = 메모리상 동일한 객체 가리키고 있는 상황
  • = 동일 객체 참조 상황

ㅡ 얕은복사상황-작동방식-new객체-값공유

• 키워드/문장 기록 =>
• 예시코드
• 독립적 존재 표현 = 참조 x = 값 공유 x = 값 변경 시 영향 x = 메모리 주소 달라 = 새로운 객체 존재
• 얕은 복사 (shallow copy) 상황
• ㅡㅡㅡㅡ
• copy() 함수 = 얕은 복사 작동방식 =>
• 이중 리스트 = 중첩 리스트 상황
  • 가장 밖 위치한 리스트 = 최상위 리스트
  • 새로운 객체 생성 = 새로운 객체(로) 복사 -- '최상위 리스트 원본 객체 <> 복사 객체 메모리 주소 달라'
    • 최상위 리스트 직접 값 변경 > 원본 리스트 값 변경 x
  • 값 공유발생
    • 내부 값(/리스트/다른 가변 객체) 같은 객체 참조/공유 상황 -- '메모리 주소 = id 같음'
    • 복사 리스트 객체 내부 값 수정 > 원본 리스트 객체 값 변경
• 단일 리스트 상황
  • 가장 밖 위치한 리스트 = 최상위 리스트 객체 = 단일 리스트 상황
  • 값 공유 상황 발생 x
  • 리스트 내 요소값 새로운 객체(로) (직접)복사

얕은복사-추가내용" tabindex="-1">ㅡ 얕은복사-추가내용

• 키워드/문장 기록 =>
• 예시코드 -- '얕은복사지만 같은 위치 참조'
  • 리스트 슬라이싱 -- '최상위 레벨 새로운 객체로 복사 <> 중첩된 객체 동일한 값 참조'
• ㅡㅡㅡㅡ
• 최상위 레벨 복사 = 독립적인 객체 = 새로운 객체 = 다른 메모리 위치
• 내부 개별 원소/값/객체 = 불변객체(immutable)
  • 정수-문자열 타입
• 메모리 최적화 발생 > 단 하나의 메모리 위치 공유

ㅡ 깊은복사상황-deep copy

• 키워드/문장 기록 =>
• 깊은 복사(deep-copy) 상황
• ㅡㅡㅡㅡ
• copy모듈 - deepcopy() 사용
• 최상위 객체 + 내부 객체 모두 독립적 존재

리스트슬라이싱-주의" tabindex="-1">ㅡ 리스트슬라이싱-주의

• 키워드/문장 기록 =>
• 리스트 슬라이싱
• ㅡㅡㅡㅡ
• 메모리에 새로운 객체 생성=원본 객체 복사된 상태
• 주의 - "슬라이싱을 했더라도 변수에 할당하는 과정이 없다면 원본 객체를 참조하고 있는 상황 "

ㅡ 객체특징-가변성(Mutability)-불변성(Immutability) 1

• 키워드/문장 기록 =>
• 객체의 특징
• ㅡㅡㅡㅡ
• 객체 가변성(Mutability) = 가변객체 = Mutable 특징 가진 객체 =>
  • 리스트 / 딕셔너리 / 집합
• 가변 객체 특징
  • 객체 생성 후(에도) > 상태( 기존 위치에서 메모리 공간/사이즈) 변경 가능
  • (원본)객체 직접 수정 가능 = 객체 값 수정 시 같은 메모리 주소(에서) 발생 = 객체 식별자 ID 동일
  • 예시 -- '리스트 메서드 호출 > 값 수정/변경 > 원본 객체 값 수정'
• 객체 불변성(Immutability) = 불변 객체(Immutable Objects) = Immutable 특징 가진 객체 =>
• 객체 생성 후 > 상태 변경-수정 x = 새로운 메모리 주소 = 새로운 객체 생성
  • 정수 / 문자열 / 튜플
  • 예시 -- '문자열 메서드 호출 > 새로운 객체 반환출력'

파이썬-연산자" tabindex="-1">ㅡ 파이썬-연산자

• 키워드/문장 기록 =>
  • 산술 연산자 (Arithmetic Operators)
    • 더하기/빼기/곱하기/나누기/몫/나머지/거듭제곱
  • 비교 연산자 = 관계 연산자 (Comparison (i.e., Relational) Operators)
    • >
  • 논리 연산자 (Logical Operators)
    • and/ or/ not
  • 삼항 연산자(Ternary operators)=조건 연산자(ternary operator) - "if와 else 사용 간단한 한 줄로 조건문 표현 작성 시 사용"
  • 비트 연산자 (Bitwise Operators)
  • 할당 연산자 = 복합 대입 연산자 (Assignment Operators)
    • =
  • 구성원 연산자 = 멤버 연산자 (Membership Operators)
    • in/not 0 - "멤버 연산자 + 예약어"
      • 단독사용 - "특정 값이 객체 안에 속해 있는지 여부 확인 기능"
      • for문과 함께 사용 - "해당 객체의 각 요소에 하나씩 접근하도록 하는 기능"
  • 식별 연산자 (Identity Operators) = 아이디 연산자
    • is / is not

예약어-키워드" tabindex="-1">ㅡ 예약어-키워드

• 키워드/문장 기록 =>
  • 이미지-예약어/키워드
  • 이미 특정 목적으로 기능이 정의되어 있는 코드 의미
  • 변수 이름-함수이름 등 사용 x
  • ㅡㅡㅡㅡ
  • del - "메모리 공간에 존재하는 객체 제거하는 기능"
    • del 객체명

ㅡ 02-1 숫자형-int-integers

• 키워드/문장 기록 =>
• 정수형
• 실수형-float-Floating point
  • 소수점 - "메모리에 있는 숫자를 보여주는 방식" | 소수점계산-원리
  • 정확한 표현x > 근사값 표현
    • 실수> 이진수 표현
• ㅡㅡㅡㅡ
• 숫자형 메서드/내장함수 | 05-5 내장함수
  • hex()
  • bin()
  • round()
  • pow()
  • abs()
• int() 내장함수
  • 형변환 기능
  • 소수 입력 시 > 소수의 정수 부분 반환 - "반올림x 단지 소수점부분 기준 절단 반환 느낌"

ㅡ 02-2 문자열 자료형

• 키워드/문장 기록 =>
• 문자열 자료형<>리스트 자료형 연관성 - "메모리 저장 시 리스트 자료구조 형태로 저장 > 따라서 비슷하게 동작."
  • 문자열 인덱싱/슬라이싱
  • 양수 인덱싱 <> 음수 인덱싱(reverse indexing)
    • 마지막 글자 확인 - s[-1]
• str-문자형-Strings
• 문자열 정의 방법
  • 큰/작은 따옴표
• 주석(comments)
  • 세 개 따옴표
  • #
• 문자열끼리 연산 가능
  • 더하기 연산자 - "문자열끼리 더하기 연산자를 사용해 append()를 사용한 것과 같이 이어붙일 수 있음" | 예제코드
    • print("파"+"이"+"썬") - '문자형 공백없이 연결 출력'
    • print("파","이","썬") - '쉼표 사용 시 구분되어/띄어쓰기 출력'
  • 곱하기 연산자

ㅡ 탈출문자-이스케이프-escape

• 키워드/문장 기록 =>
  • 탈출문자-이스케이프 코드(escape) - "역슬래쉬와 문자의 조합으로 특정한 기능이 정의되어 있는 코드"
  • ㅡㅡㅡㅡ
  • 문자열-출력물 보기좋게 포맷하는 기능
  • \n -- '줄 변경 시 사용'
  • \t, \\, \', \"

문자열 포매팅-포맷팅" tabindex="-1">ㅡ 문자열 포매팅-포맷팅

• 키워드/문장 기록 =>
• 문자열 포맷팅 -- '문자열 내 정보를 삽입하는 방법'
• ㅡㅡㅡㅡㅡㅡㅡ
• 1. %기호 사용한 포맷코드
  • 숫자 대입
  • 문자 대입
  • 변수 대입
  • %기호+숫자 > 추가적인 포맷 기능
    • 1. 정렬 표현 가능
      • 왼쪽/오른쪽/가운데 정렬
    • 2. 공백 표현 가능
    • 3. 소수점 표현 가능
• 2. format 메서드 -- '작성된 순서에 따라 인덱스화/설정됨'
  • {} 중괄호 사용 객체 삽입 위치 지정
  • 키워드/변수 할당 후 삽입
• 3. f-string

문자열-메서드-함수" tabindex="-1">ㅡ 문자열-메서드-함수

• 문자열 일반적인 작업

  • 대소문자 변환
  • 문자열 분할, 결합

• 키워드/문장 기록 =>

• 1. split() 메서드
• 2. partition() 메서드
  • 비슷한 기능
    • 문자열 분할 기능
  • 차이점 =>
  • 반환형식 차이
    • 1. 리스트 반환
    • 2. 분리자 기준 세부분 분리 > 튜플 반환
    • (분리자 이전의 부분, 분리자 자체, 분리자 이후의 부분)
  • 분리자(separator) 처리 =>
    • 1. 분리자 결과 리스트 포함x
    • 2. 분리자 결과 튜플 포함o
  • 사용예시 =>
    • 1. 하나의 문자열 > 여러 하위 문자열 나눔
    • 쉼표, 공백 기준 분리 > 텍스트 데이터 토큰화
    • 2. 하나의 문자열 > 분리자 중심 두 부분 나눔
    • 텍스트를 특정 태그, 키워드 기준 앞뒤로만 분리 시

• capitalize() 메서드 - "문자열의 첫 글자를 대문자로 만드는 기능"

  • <> title()

• istitle() -- '문자열 제목형태 여부 확인 기능'

  • 각 단어 대문자 시작 + 나머지 소문자 > True반환

• upper() <> lower() - "문자 대/소문자 바꾸기 기능"

• isupper(), islower() 메서드 - "문자열 모든 문자가 대문자 or 소문자인지 확인 기능 > T or F 반환"

• count() - " 문자 개수 세기 기능"

• find() <> index() - " 위치 알려주기 기능"

• isalnum() -- '모든 문자가 문자 or 숫자 일 때 True 반환 = 특수문자 or 공백 포함 시 False 반환'

  • 영문자, 한글문자
  • <> isalpha() -- '문자로만 이루어지면 True 반환'
  • 사용예시 =>
  • 사용자 입력검증 = 비밀번호 유효성 검사 -- '입력받은 데이터가 특정조건(문자만 포함 or 숫자 포함 등)만족 확인'

• isspace()

  • 오직 공백 문자(whitespace characters)로만 구성 > T반환 -- '문자열이 비어있거나, 공백 문자 이외의 다른 문자를 포함하고 있으면 False를 반환'
  • 사용예시 -- '입력값 검증, 텍스트 처리과정 시 문자열이 공백으로 구성여부 확인 시 사용'

• join() - "특정 구분자-문자열 사용 > 반복 가능한 객체(이터러블 특징 가진 객체) 요소들을 하나의 문자열 반환"

• replace() - " 문자열 바꾸기 기능"

• strip() - "문자열 /공백 제거"

  • 양쪽 공백 지우기
  • rstrip()
  • lstrip()

• isdigit() - "문자열이 숫자 0~9로만 이루어져 있는지 확인 > T or F 반환 기능"

ㅡ 02-3 리스트자료형

• 키워드/문장 기록 =>
• 리스트 자료구조 자료형
• 요소-element 표현
• 리스트 표현 = 배열 표현
• ㅡㅡㅡㅡ
• 리스트 정의/선언
  • 대괄호 []
  • list() 함수
  • 빈 리스트 정의 가능
• 특징
  • 리스트 안 요소 다양한 타입 가능
  • 다중 리스트
  • 값 변경 가능 mutable type
  • 인덱스/인덱싱 - "순서가 존재"
  • 슬라이싱 (slicing)
    • 역순 출력 가능- [: : -1]
    • [start, stop, step] - "~이상~미만"
• 리스트 연산
  • 리스트끼리 더하기 가능 - '리스트끼리 연결'
  • 리스트 반복 가능 - '주의 - 리스트끼리 곱연산자 x'
    • 곱셈 연산자
• 리스트 길이
  • 리스트 확장 - "하나의 리스트에 다른 리스트 연결"

리스트자료형-함수" tabindex="-1">ㅡ 리스트자료형-함수

• 키워드/문장 기록 =>
  • 리스트 자료형 관련 함수/기능
  • ㅡㅡㅡㅡ
  • 리스트 요소 추가 함수
    • • append() - "요소 추가"
    • extend()
    • • remove("값")
  • 리스트 요소 삽입 <> 꺼냄
    • • insert(index, 넣을 값)
  • pop(index)
    • 딕셔너리 자료형 사용 가능
    • 원본 객체/리스트 요소 추출
  • reverse() - "리스트 모든 요소 역순/뒤집기"
  • • sort() - "리스트 함수-정렬기능-원본 리스트 정렬기능"
      • 오름차순 <> 내림차순
      • sorted() - "내장함수-새로운 리스트 반환출력"
  • count()
    • 리스트 포함된 요소 개수 확인
    • 리스트 안에 리스트=중첩 리스트 상황
      • 리스트 순회
  • index() - "인덱스 반환"

ㅡ 02-4 튜플 자료형

• 키워드/문장 기록 =>
• tup-Tuples
• () 소괄호 정의
• 특징
  • 수정-변경-재할당 x - "리스트와 다른점"
  • 언패킹 (Unpacking) 표현식
  • 인덱싱 가능

ㅡ 02-5 딕셔너리 자료형

• 키워드/문장 기록 =>
• {key : value} 중괄호 정의
• 참고기록 : Part3-Javascript-내용기록#ㅡ 추가내용

딕셔너리-메서드-뷰객체" tabindex="-1">ㅡ 딕셔너리-메서드-뷰객체

• 키워드/문장 기록 =>
  • 딕셔너리 메서드
  • ㅡㅡㅡㅡ
  • 딕셔너리 뷰 객체
    • 값 가진 상태 X = 원본 딕셔너리 값 참조 > 특정 부분(키-값-쌍) (보여주는) 인터페이스 역할 수행
  • 특징
    • 실시간 변경사항 반영 = 동기화 상태
    • 메모리 사용량 감소
    • 반복/접근/순회 가능
    • 변경 불가능한(immutable) 특징 뷰 객체
  • keys() 메서드
    • dict_keys객체 반환
    • 원본 딕셔너리 키
  • values() 메서드
    • dict_values객체 반환
    • 원본 딕셔너리 값
  • items() 메서드
    • dict_items객체 반환
    • 원본 키-값 쌍

ㅡ 02-6 집합 자료형

• 키워드/문장 기록 =>
• 집합=세트=set-Sets
• {} 중괄호 정의
• 특징
  • 고유한 값=중복x
    • 리스트 자료형 > 세트 자료형 형변환(캐스팅) > 리스트 자료형
  • 순서 x

ㅡ 집합-세트-set-메서드

• 키워드/문장 기록 =>
• 집합 메서드
  • 집합 자료형은 수학 집합 개념 기반 구현된 자료구조
  • 합집합-교집합-차집합 연산기능 제공
  • 벤다이어그램 생각
  • 메서드 이름 update 존재 > 원본 객체 수정 메서드
• ㅡㅡㅡㅡ
• difference()
  • 차집합 기능
  • 새로운 객체 반환
  • difference_update()
    • 원본 객체 수정 = 직접 수정
• add()
  • 더하기 기능
• clear()
  • 모든 요소 지움 기능

ㅡ 02-7 불 자료형

• 불리언-Boolean=bool

ㅡ
내가 알고 있는 얕은 복사란
원본 객체의 주소값만을 복사한 상태이다. 따라서 같은 주소값을 참조하고 있기 때문에 객체는 동일하다.
깊은 복사란
원본 객체 그 자체를 복사했기 때문에 새로운 객체가 생성된 상태이다.

그렇다면 copy메서드는 얕은 복사본이 아니라 깊은 복사본인거 아닌가??

ㅡ 02-8 자료형의 값을 저장하는 공간, 변수

파이썬-변수의미-명명규칙" tabindex="-1">ㅡ 파이썬-변수의미-명명규칙

• 키워드/문장 기록 =>

• 파이썬 변수 - "값이 직접 들어가 있는 상태가 아닌 대입된 객체를 가리키는 포인터같은 상태" = "변수에 메모리 주소값이 할당" | 객체특징-가변성(Mutability)-불변성(Immutability) 1#코드2

• 변수가 필요한 이유 - "프로그램이 돌아가기 위해선 데이터 필요 > 그러한 데이터는 메모리 공간에 존재 > 메모리 공간에 접근/참조하기 위해선 이름/주소값 필요"

  • 데이터 저장 = 메모리 공간 = 객체
  • 이름 = 주소값

• 파이썬 객체지향-메모리 - "모든 데이터는 클래스로부터 생성됨 (메모리에 생성) > 클래스-인스턴스/객체로부터 생성"

  • 이미지 | JS-프로그래밍언어-객체-의미#이미지-프로그래밍 언어-객체이해
    • !300

• 변수 명명규칙

  • 스네이크 케이스(snake case) - "언더바(_) 사용 정의"
    • 함수, 메서드, 변수 등의 이름을 지을 때 사용 - var snake_case;
  • 영문자/숫자/언더스코어 가능
  • 숫자로 시작 x
  • 대소문자 구분 ㅇ
  • 미리 정의된 예약어(reserved words) x

• 카멜 케이스 (camel case) - "중간 글자들은 대문자로 시작하지만 첫 글자가 소문자인 경우"

  • var camelCase;

ㅡ 유효범위-지역-전역변수

• 키워드/문장 기록 =>
  • 변수-유효범위 (variable scope) - "변수가 선언된 위치에 따라 변수가 영향을 미치는 범위 달라짐" | 네임스페이스-내장변수-name-객체참조탐색순서-LEGB
  • ㅡㅡㅡㅡ
  • 지역 변수(local variable) - "특정 함수에서만 사용되는 값들"
  • 전역 변수(global variable) - "여러 함수에서 함께 사용하는 값들"
    • global 선언o - "함수 내부에서 전역변수값 이어서 사용가능 > 수정된 값이 밖에서도 유지."

ㅡ 네임스페이스-내장변수-name-객체참조탐색순서-LEGB

• 키워드/문장 기록 =>
• 내장변수=전역변수 - "이미 정의되어 있는 변수 = 파이썬 언어가 가지고 있어야 하는 기본 설정값들이 자동-저장되어 있는 느낌"
• ㅡㅡㅡㅡ
• __name__
  • __main__
• 코드파일을 "직접 실행" 표현
  • "인터페이스를 통해 실행"
  • __name__ == "__main__"
• 코드파일을 "모듈로서 사용_실행" 표현
  • import
  • __name__ = 모듈 이름
    • "파이썬 개발자들이 저지를 수 있는 실수를 막아준다"
• 네임스페이스(Namespace) | 네임스페이스-접근제어-객체
  • 코드블럭
• 객체 참조 탐색 순서
  • 존재 이유/배경
    • "이름뿐 아니라 다른 방법으로도 객체를 구분할 수 있는 추가적인 방법 필요"
• LEGB
  • 지역 네임스페이스(Local namespace)
    • 함수/메서드단위 코드블럭-범위
    • 지역변수 | 유효범위-지역-전역변수
  • 글로벌 네임스페이스(Global namespace)
    • 모듈단위 코드블럭-범위
  • 빌트인 네임스페이스(Built-in namespace)
    • 전체코드 - "파이썬 내장함수, 예약어들이 속해있는 공간"
  • 상위 네임스페이스

네임스페이스-접근제어-객체" tabindex="-1">ㅡ 네임스페이스-접근제어-객체

• 키워드/문장 기록 =>
  • 네임스페이스(Namespace)
    • 이름 = 식별자
    • "객체(변수-함수-모듈-클래스)의 이름/식별자를 저장하고 관리하는 공간 = 객체를 구분할 수 있게됨 = 객체마다 행사할 수 있는 범위 제한하여 이름 중복 허용됨 = 객체 유효 범위"
  • 접근 제어(Access Control) (기능 의미) <> 접근 제어자 (public, private, protected 코드 의미)
    • "접근하다" = "참조하다" = "임포트/호출해서 사용하다"
    • "클래스 내 멤버" = 변수, 메서드
    • "클래스 내 멤버에 대한 외부에서의 접근 권한을 관리"

전역상수(변수)-모듈레벨" tabindex="-1">ㅡ 전역상수(변수)-모듈레벨

• 키워드/문장 기록 =>
• 전역 상수(변수) <> 변수
• ㅡㅡㅡㅡ
• 명명 규칙/관례
  • 대문자 작성
• 특징 =>
• 프로그램 실행 중 수정 x
• 모듈 레벨(에서) 정의 -- '전역 상수들 따로 빼서 모듈로 정의'
  • CSS파일 생각
  • constants.py

ㅡ [[네임맹글링(name mangling)-_클래스명__속성명]]

• 키워드/문장 기록 =>
• 네임 맹글링(name mangling)
• 언제 사용?
  • 클래스 속성값을 외부에서 접근하기 힘들게 할 때
    • "클래스의 속성값을 외부에서 접근하고 있다"
    • private한 성격
    • "맹글링이 적용된 속성"
      • _클래스명__속성명
  • 하위 클래스에서 상위 클래스 속성을 오버라이딩 하는 것을 막을 때

ㅡ [[_ 언더바-언더스코어 기능 및 명명규칙]]

• 키워드/문장 기록 =>
  • _ 언더바 - 언더스코어 역할
  • 무시하는 값
    • *(Asterisk_아스테리스크)
    • 언패킹 (Unpacking)
  • 숫자와 함께 사용 > 자릿수 구분
  • _를 사용한 네이밍 (명명규칙) <> 문법적인 요소_규칙
    • 언더바를 이름 앞에 하나 붙은 경우 의미
    • 이름 뒤에 언더바가 하나 붙은 경우 의미
    • 이름 앞에 언더바가 두 개 붙은 경우 의미
      • 네임 맹글링 (name mangling)
    • 이름 앞 뒤로 언더바가 두 개 붙은 경우 의미
      • 매직 메소드(Magic Method) - 던더 메소드(Dunder Method, Double Underscore Method)

ㅡ 시퀀스-컬렉션-타입

• 키워드/문장 기록 =>

• 시퀀스 타입-sequence

• ㅡㅡㅡㅡ

• (값 순서대로 저장) 순서 존재 데이터 타입 | 이터레이터-iterator타입-이터러블-Iterable특징

  • "순서가 있다" = "인덱스가 있다" = "순회가 가능하다." = "반복할 수 있다." = "각 항목/요소들에 접근 가능" = "조작이 가능" = "각 요소 하나씩 리턴할 수 있다."

• 리스트-튜플-문자열

• 컬렉션 타입-Collection

• ㅡㅡㅡㅡ

• 자료구조(데이터구조)구현 데이터 타입 - "여러 요소(객체들..)를 하나의 단위/구조로 저장/관리할 수 있는 특징을 가진 데이터 타입"

  • 컨테이너

• 예시코드 =>

• 리스트 객체 > 하나의 독립적인 메모리 공간 차지

• 리스트 내부 포함 값/원소/객체 > 독립적인 메모리 공간 차지

• 하나의 큰 메모리 컨테이너 공간

  • 여러 개 작은 메모리 공간 차지

• 리스트-튜플-set

• 딕셔너리-dict-dictionaries

• 타입의미 복기 - "데이터 종류, 특징"

  • ex) 리스트는 시퀀스 타입(특징)+ 컬렉션 타입(데이터 종류)

ㅡ 이터레이터-iterator타입-이터러블-Iterable특징

• 키워드/문장 기록 =>
• 이터레이터(iterator) -- '순회 가능한 모든 자료구조의 요소값에 순차적 접근 후 값을 리턴할 수 있는 특징 가진 객체' | 시퀀스-컬렉션-타입
• 이터레이터 <> 데이터 저장하는 자료구조 차이점 -- '값 가지고 있는 상태 x , 이터레이터라는 인터페이스를 통해 값 접근할 수 있는 매커니즘 존재'
• ㅡㅡㅡㅡ
• 이터러블한 객체(여야만) > 이터레이터 객체 - '접근할 수 있어야만 다음 값을 리턴할 수 있음'
• __iter__() 메서드 - "호출 시 이터레이터 객체을/로 반환"
  • iter() 함수
• __next__() 메서드 - "다음 값 반환"
  • next() 함수 - '이터레이터 일 때 생성되고 > 사용가능'
  • StopIteration 예외
• 직접 Iterator 정의 가능
• 리스트 > 이터러블한 객체 O, 이터레이터 객체 X - "위 2개 메서드가 모두 존재해야 이터레이터"
  • __iter__() O ,__next__() X - "아직 스스로 다음 값을 반환할 수 없는 상태 = __iter__ 호출 되기 전이라 아직 이터레이터 객체 x"
• ㅡㅡㅡㅡ
• 접근 후 값 리턴 2가지 방식 =>
• 제너레이터-이터레이터
  • 1. 호출 시 값 생성 > 접근 > 반환출력
• iterable-이터러블한 특징을 가진 객체-이터레이터
  • 리스트 / 튜플 / 문자열 / 딕셔너리
  • 2. 이미 메모리 상 존재 값 접근 > 반환출력
• 1번 특징(핵심특징) =>
• 모든 이터러블 객체 특징
• 객체의 원소(내부 요소-멤버-원소)에 순차적으로 접근할 수 있는 특징을 가진 객체 = (반복문에서 사용할 수 있는 객체)
  • 접근할 수 있다는 건 순회(Iteration)가 가능한 객체
    = 순회가 가능하다는건 인덱스가 있는 객체
    = 인덱스가 있다는 건 순서가 있는 객체
    = 순회가 가능하다는건 반복할 수 있는 객체
    = 반복할 수 있다는 건 하나씩 리턴할 수 있는 객체
• 2번 특징 =>
• 일부 이터러블 객체에만 해당
• 한 번에 모든 값 메모리에 저장 x > 호출 시 생성 - '제너레이터 객체는 1번 특징을 가지고 있기에 이터러블한 객체이면서 동시에 2번 특징도 가진 객체'
• for문 동작원리 - "내부적으로 Iterator 생성(__iter__ 이용)후 동작됨"
  • 이터러블 객체 > for문 실행 > __iter__ 메서드 호출 > 이터레이터 객체 > __next__ 메서드 호출 > 1개씩 접근/리턴/순회

03장 프로그램의 구조를 쌓는다! 제어문

ㅡ 조건문-if-elif-else

• 키워드/문장 기록 =>
  • 파이썬-조건문 - "조건명제/상황에 따라 다른 명령을 수행"
  • ㅡㅡㅡㅡ
  • if문 구조
    • if
    • if-else
    • if-elif-else (else if)
      • 코드블록(block)=콜론(:)=들여쓰기(indentation)
  • pass 키워드
    • indentationError에러

ㅡ else문-추가내용-for문-정상적완료-조기종료

• 키워드/문장 기록 =>
  • else문 - "if문과만 사용되는게 아님."
  • for문, while문, if문
  • ㅡㅡㅡㅡ
  • for ... else 구문
    • "else문은 for루프가 조기종료 되지 않고, 정상적으로 완료되었을 때 실행" = "for루프에 등록된 모든 반복시행/수까지 모두 수행 했을 때"
    • "정상적 완료" 예시 - "range(5)라면 > 5번 반복시행 발생"
  • 문법
    • for 루프 외부 존재=같은 라인 존재
  • 예제코드

ㅡ 반복문

ㅡ for문-구조-range()특징

• 키워드/문장 기록 =>
  • for문 기본구조
  • ㅡㅡㅡㅡ
  • for 변수 in 문자열(or 튜플 or 리스트): - | 시퀀스 자료형
  • for (t1,t2) in list2: - '튜플을 원소로 갖는 리스트'
    • 언패킹(Unpacking) - '하나의 튜플에서 여러 변수로 값을 동시에/분패하는 방법'
      • 두 (요소)값이 연결된 정보를 갖는 경우 해당 표현식 유용
      • 좌표값, 키와 값
  • for _ in range(N)
    • 시퀀스 자료형
      • 리스트-튜플-문자열
    • 딕셔너리 - "key값에 순서대로 접근/반환"
      • values() 메서드
      • items() 메서드
    • 집합(set)
    • range()함수
  • range()함수 - "전달된 인수에 따라 연속된 정수들을 가진 객체 반환 기능"
  • ㅡㅡㅡㅡ
  • range 객체 반환 = 이터러블 객체 | 이터레이터-iterator타입-이터러블-Iterable특징
    • range() 함수 특징
  • list() 형변환 - "이터러블한 특징 > 호출 시 값 생성됨. 따라서 객체 내부의 값을 확인하기 위해선 캐스팅 진행"
    • 형변환(casting)=캐스팅 - "형변환이란 자료형의 종류를 변경하는 것"
  • 문법
    • range(마지막정수) / range(시작정수, 마지막정수)/ range(start, stop, step)
    • "~이상 ~ 미만"
    • step - "숫자 간 간격 (기본값 1)"
      • 역순출력 - "리스트 슬라이싱 문법 같음"
  • for 문과 continue 문

ㅡ while-무한반복문-작성방식

• break 키워드 - "반복문 탈출/중지"
• continue 키워드 - "해당 시행을 끝내고 다음 시행-처음으로 돌아가기"
• 무한 루프(infinite loop)가 되지 않도록 조건명제의 결과가 어느 순간 거짓,참이 되도록 탈줄조건 작성
• 키워드/문장 기록 =>
  • while 무한반복문 작성 주요방식
  • ㅡㅡㅡㅡ
  • 1. 조건명제 사용 방식 =>
  • while some_condition: 형태
  • 특정 조건 참인 동안 반복 지속 - "내부에서 조건이 변경되는 로직/상황 필요"
  • 반복 조건 명확시 사용
  • 2. True 사용 방식 =>
  • while True: 형태
  • 특정 상황/지점 > break , return문 사용 강제종료 방식
  • 다양한 경우 종료조건 설정 시 사용

04장 파이썬의 입출력

ㅡ 04-1 함수란-정의_선언-호출

• 키워드/문장 기록 =>
• 함수란 (function)
• ㅡㅡㅡㅡ
• 매개변수(parameter)
  • 적절한 명명 중요 -- '해당 매개변수에 어떠한 데이터가 들어가는지, 해당 매개변수가 함수에서 어떠한 기능을 수행하는지 대략적으로 알 수 있도록 명명'
• 인수(arguments)
• 함수 선언-정의 및 호출 =>
• 가장 단순한 형태 함수 정의
• 함수 정의 > () 괄호 작성 = 실행/호출/사용
• 주의
  • 함수 직접/자체 출력 = 함수 객체 참조 = () 괄호 x 호출 - '해당 함수 메모리 위치/주소 출력'
    • <function test_fun at 0x000002708BB6A200>
  • 함수 호출=() 사용 - '내부로직 실행'

ㅡ 매개변수 2가지 역할-변수-기본기능조절

• 키워드/문장 기록 =>
• 메서드/함수 매개변수 두 가지 주요 역할 수행
• ㅡㅡㅡㅡ
• 1. 외부 인수를 받는 변수로서 역할
• 2. 다양한 상황에 맞춰 함수의 기능을 조절하는 역할 수행
  • 기본값 설정된 매개변수(옵션매개변수) > 다른 값 설정 > 함수 기본 동작방식 조절=추가설정=흐름제어=결과 변경

ㅡ 매개변수-지정호출-기본값 설정

• 키워드/문장 기록 =>
• 함수 매개변수-parameter - "함수에 전달되는 인수는 함수 정의 시 작성한 매개변수 순서에 따라 할당됨"
• ㅡㅡㅡㅡ
• 매개변수 지정 호출 가능
  • 대입 연산자 = 사용
• 매개변수 기본값 설정 - default parameters
  • 우선순위 - "전달받은 인수 > 기본값"
  • 주의 - "매개변수 기본값 설정 시 목록에서 오른쪽부터 차례대로 명시"

ㅡ 가변매개변수-위치매개변수-키워드매개변수

• 키워드/문장 기록 =>
• (*args, **kwargs) - "함수 매개변수에 어떤 타입, 몇 개 인수가 매개변수에 전달되도 처리 가능"
• 가변 인수-가변 매개변수 (variable-length arguments)
• 예시코드 -- '가변 매개변수에 전달된 값 형태 확인'
• ㅡㅡㅡㅡ
• 함수 인수 전달 2가지 방법
  • 위치 매개변수-인수 (Positional Arguments) - "모든 위치 인수가 튜플에 할당 후 반환됨"
    • *args
  • 키워드 매개변수-인수 (Keyword Arguments) - "모든 키워드 인수 딕셔너리로 묶어 저장됨"
    • **kwargs

함수호출-반환형태에 따른 구분-원본객체-새로운객체" tabindex="-1">ㅡ 함수호출-반환형태에 따른 구분-원본객체-새로운객체

• 키워드/문장 기록 =>
• 1. 원본 객체를 수정하는 메서드/함수=인플레이스(In-Place) 메서드 = 직접수정
  • "원본 객체 직접 수정 후 반환값이 없거나, None 반환하는 메서드들 존재"
  • sort() 메서드, append() 메서드
• 1.2 원본 객체를 수정하지만 반환값이 있는 메서드/함수 - "인플레이스(In-Place) 메서드지만 특이 케이스"
  • pop() - "원본을 수정하면서 수정된/삭제된 값을 반환"
• 2. 새로운 객체 반환 메서드/함수=아웃플레이스 메서드 (Out-Place Method)
  • "반환출력값이 존재하면 (1.2번 특이 케이스 제외) 새로운 객체 반환출력"
  • 원본 객체 변경 x > 새로운 객체 반환 출력
    • 1. 변수 대입 사용 - "함수를 호출한 곳에 결과값 반환됨 > 변수 대입 후 이어서 사용"
    • 2. 대입 x > 바로 사용 - "해당 행에서만 사용가능"
  • sorted() 함수, replace() 메서드
  • 리스트 슬라이싱
• 주의 - "대부분의 메서드/함수는 두 가지 경우 중 하나를 따르지만, 절대적인 규칙은 아님"
  • 1번과 반대인 원본 객체를 수정 후 그 수정된 원본 객체를 바로 반환하는 메서드/함수 거의 x
  • 메서드 체이닝(Chaining) 표현식-기법-작성법 - "여러 메서드/함수 호출 (새로운 객체들 이용해)을 연속해 작성하는 것"
    • 간결 작성 > 가독성 향상
• 3. 새로운 값을 반환하는 메서드/함수 - "단순하게 인수로 들어온 값이 함수 로직을 거쳐 새로운 결과값을 반환하는 함수"
  • 일반적인 함수 형태 표현
  • 결과 반환이 여러 개 경우
    • 언패킹 표현식

ㅡ 람다표현식-익명함수

• 키워드/문장 기록 =>
  • 람다 표현식(Lambda expression) =익명 함수(Anonymous function) = 이름이 없는 함수 - "간단하게 함수 정의 > 사용하는 표현방법"
  • ㅡㅡㅡㅡ
  • 사용법-작성법-표현식
    • (lambda 매개변수 : 매개변수를 활용한 표현식_리턴값)(매개변수에 들어갈 인수_값)
    • lambda (매개변수) : (참일때 매개변수를 활용한 표현식_리턴값) (if 조건) (else 거짓일때 리턴값)
  • 람다 표현식 언제 사용
    • 1. "람다 표현식은 함수-매개변수로서 많이 활용" 표현 = 람다 표현식으로 만들어진 함수 그 자체를 다른 함수의 매개변수로서 사용
      • map() / filter()
    • 2. 재사용하지 않는 간단한(한 줄로 표현 가능) 함수일 때

ㅡ 함수설명(독스트링)-타입힌트(Type Hint)

ㅡ 타입힌트-추가 설명

• 키워드/문장 기록 =>
• 함수 설명(docstring) 작성방법
• ㅡㅡㅡㅡ
• 보통 함수 정의
• 타입 힌트 작성 정의 | 타입힌트-추가 설명 - "사용자가 직접 정의한 클래스 포함 모든 데이터 타입을 매개변수에 들어간 타입 힌트로 작성 가능"
• 작성 이유-장점 - "코드 가독성 향상 + 타입 오류 방지"
• 타입 힌트(Type Hint) 표현식 - "함수에 어떤 입력값과 출력값에 대한 정보 명시적 표현"
  • 함수 이름 / 매개변수 개수 / 매개변수 자료형_타입 / 매개변수 기본값 / 함수 반환값 자료형 (자료형 = 데이터 타입 = 클래스(객체지향))
  • 규칙 x = 강제성 x
• 함수의 독스트링(docstring) -- "함수가 어떻게 정의되어 있는지 설명하다." <> "함수 동작 방식과 사용법을 설명하다"

타입힌트클래스-기호" tabindex="-1">ㅡ 타입힌트클래스-기호

• 키워드/문장 기록 =>
• 타입힌트 클래스
• typing모듈
• ㅡㅡㅡㅡ
• Optional클래스 - "메서드에 전달되는 값이 있거나 or 없는 상황를 설명할 때 사용"
• (length: Optional[int] = None) = (length: Optional[int])
  • None - "입력하지 않아도 됨을 나타냄 = 비어있는 상태 의미하는 데이터 타입"
    • <class 'NoneType'>
  • int타입 할당 or 아무런 값이 입력x=자동 None 할당
  • 입력값 선택적 가능 의미
  • 선택할 수 있는 값의 목표 표현 시 사용=특정한 값 집합 정의 시
• Literal클래스
• antialias: bool | Literal[0, 1] = antialias: bool | 0 | 1
• direction: Literal['north', 'south', 'east', 'west']
• | 기호 - "Optional클래스와 같은 기능. 버전 업되면서 기호로 좀 더 간결하게 표현"
• = 기호 - "매개변수에 기본값이 할당되어 있음 표현"
• [] 괄호 - "매개변수가 가질 수 있는 값을 묶어서 표현"

ㅡ 04-3 파일 읽고 쓰기

• 파이썬 파일 입출력
• 사용자 입출력
• 프로그램 입출력

파일입출력모듈-클래스" tabindex="-1">ㅡ 파일입출력모듈-클래스

• 키워드/문장 기록 =>
• 프로그램/파일 <> 사용자 사이 입출력 작업 수행 | 파일입출력-열고닫기-읽는방법
• ㅡㅡㅡㅡ
• 파일 읽고 쓰기 작업 수행 가능 = 파일 상호작용 시 필요한 메서드-속성 존재
  • 파일 입출력 모듈.클래스
  • _io.TextIOWrapper
• 표준 입출력 함수 사용
  • input(), print()

파일입출력-열고닫기-읽는방법" tabindex="-1">ㅡ 파일입출력-열고닫기-읽는방법

• 키워드/문장 기록 =>
• 파일 생성/열고 닫기 => | 파일입출력모듈-클래스
• ㅡㅡㅡㅡ
• 내장함수 =>
• open()
  • 반환출력 형태 > 파일 객체(file object)
• close()
• 1번 매개변수
  • 파일경로-이름
• 2번 매개변수
  • 파일 모드 = 파일 사용 용도 결정
  • r = read mode
  • w = wirte mode
    • 주의 - '같은 이름 파일 존재 시 내용 제거 후 새로운 파일 열림'
  • a = append mode
• 파일 읽는 방법 =>
• seek(0) 메서드-내부 작동방식
• 역할/기능 - '파일 포인터 위치 재설정/이동 기능'
  • 파일 포인터 = 커서 개념 존재 - '포인터 위치는 처음 > 끝 이동'
• read() 메서드 - '모든 내용 > 하나의 문자열 반환'
  • 호출 = 포인터 끝 위치 이동 - '해당 메서드 다시 호출하더라도 다시 내용 확인 x'
• readline() 메서드 - '파일 내용 한 라인씩 문자열 반환'
  • 반복문 함께 사용
  • 포인터 끝 위치 - '비어있는 문자열 반환'
• readlines() 메서드 - '파일 내용 한 라인씩 리스트 할당 후 반환'
  • 반복문 함께 사용
• 포인터 끝 위치 - '비어있는 리스트 반환'
• with 구문 =>
• 열린 파일 자동 닫음
• 오류 방지

파일입출력-파일모드" tabindex="-1">ㅡ 파일입출력-파일모드

• 키워드/문장 기록 =>
• 파일입출력
• 다양한 파일모드
• ㅡㅡㅡㅡ
• 기본모드 | 파일입출력-열고닫기-읽는방법
  • r / w / a 모드
• 추가모드 =>
• b모드 -- '파일 > 이진-binary 형식으로 다룸'
• 덱스트 x 데이터 = 이미지, 비디오
• 기본모드 결합 사용
  • rb / wb / ab

05장 파이썬 날개 달기 = 객체지향 프로그래밍 (OOP)

• Object-Oriented Programming Language = 객체지향 프로그래밍 언어

  • 파이썬 : 객체(Object)를 기반으로 하는 클래스(Class)와 인스턴스(Instance) 같은 개념을 사용해 코드구성/작성하는 언어

• 클래스 정의 - 상속

• 다형성

• 캡슐화

ㅡ
전자레인지를 사용할 때, 내부의 기계 부품이나 전자적 원리에 대해 자세히 알지 못해도 사용 설명서를 통해 어떤 버튼을 눌러 필요한 기능을 실행할 수 있는지, 온도를 조절할 수 있는지 알 수 있다. 이를 통해 해당 도구를 이용해 음식을 만들 수 있다.

이러한 사실은 프로그래밍 학습에도 해당된다고 생각한다. 프로그래밍 언어 내장함수-모듈-라이브러리-패키지-프레임워크 등 사용할 때, 해당 도구들 각각의 문서/설명서를 읽고 이해함으로써 개발 작업에 활용할 수 있다.

따라서 현재는 강의나 다른 사람들의 설명을 통해 이러한 도구들을 사용하는 방법에 대해 배우고 있지만 궁극적으로는 문서를 스스로 읽고 이해하여, 이 도구들을 효율적으로 사용할 수 있는 능력을 갖추는 것이 중요하다 생각한다.

ㅡ 파이썬-cmd-명령코드

• 다른 기록들에서 나온 cmd 명령코드들을 하나의 기록에 연결
• 키워드/문장 기록 =>
  • 파이썬 공부 > cmd 명령코드
  • 다양한 기능을 명령코드로 실행-사용 | cmd-명령프롬프트-터미널-콘솔-프로그램실행원리
  • cmd 명령코드 이해
    • 프로그램 실행 명령코드
      • 기능 사용 명령코드
        • 추가적인 옵션 설정 명령코드
        • 플래그(Flag)=옵션(Option) 코드 - '대시(-~) 로 시작'
        • 긴 형식 존재 - '`--version'
        • 짧은 형식 존재 - '`-r'
  • ㅡㅡㅡㅡ
  • cmd 코드 =>
  • cd 명령어(코드)-Change Directory - '작업 디렉토리 출력/변경' | 파일경로-절대경로-상대경로-기호표현#cmd-코드
    • 원도우 운영체제 명령코드
    • pwd 명령코드 - '리눅스, 유닉스 기반 운영체제'
  • dir-Directory - "현재 위치 디렉토리에 어떤 파일 폴더 있는지 확인 기능"
  • cls-Clear Screen

  • where - "설치 경로 확인 명령코드"

  • pip 명령코드 =>
  • 파이썬 패키지 관리자 프로그램 존재 - "명령코드로 해당 프로그램을 실행 후 사용 > 가상환경에서 패키지 설치 or 관리 기능"
  • list - '설치된 패키지와 버전을 리스트 형태로 출력'
    • freeze - '~ 텍스트 파일 형식으로 출력'
  • show - "패키지 세부 정보 출력"
    • --version - "패키지 버전 정보 출력"
  • install
    • uninstall
    • --upgrade
  • python 명령코드 =>
  • 프로그래밍 언어 = 프로그램
    • CLI 방식 지원 - "파이썬 언어(프로그램)을 사용하기 위해 cmd를 이용한다."

  • python -m ipykernel install

  • jupyter 명령코드 =>
  • jupyter kernelspec uninstall

ㅡ 파이썬 코드 구조-로직-형태 분석

• 쉬운 코드구조 예시
  • VS코드에서 바로 확인 가능한 구조

import datetime

print(datetime.datetime.now())
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
(module) datetime
	(class) datetime
		(method) def now

• 모듈, 클래스, 함수, (클래스) 메서드 구분 방법

ㅡ
soup = bs4.BeautifulSoup() # 대문자! 클래스 (생성자)호출 > 인스턴스 생성

ㅡ
class MyClass: # 클래스
<class 'builtin_function_or_method'>

ㅡ
def my_function(): # 함수 
<class 'function'> # 사용자 정의함수라면 이렇게 함수 확인 가능
<class 'builtin_function_or_method'> # 내장함수라면 이렇게 확인 가능

ㅡ
def my_function(self): # 메서드 

ㅡ
t = datetime.time(4, 20, 1) # (소문자지만 클래스..)예외적인 상황 존재. 클래스 (생성자)호출
<class 'datetime.time'> # 타입검사 time클래스 인스턴스임을 확인 가능

• =>

클래스-모듈-패키지-라이브러리-프레임워크-용어정리" tabindex="-1">ㅡ 클래스-모듈-패키지-라이브러리-프레임워크-용어정리

• 파이썬 코드블록/덩어리

  • 함수 < 클래스-(메서드) < 모듈 < 라이브러리 <> 패키지 <> 프레임워크

• 함수

  • 특정한 기능 정의한 코드로직/집합/코드블록

• 프레임워크 (Framework) =>

• 사용자가 제어당함 = 정해진 규칙에 따라 코드작성/사용

• Django, Flask 웹 프레임워크 - "규칙 + 도구/기능 제공"

• 서비스 개발 위한 규칙-구조 제공하는 라이브러리들의 집합

  • 규칙 > 특정한 디자인 패턴에 따라 작성
    • 규칙에 따라 작성된 모듈
      • 클래스 생성 시 특정한 메서드-속성 필요
      • 특정 클래스 생성 시 다른 클래스의 인스턴스 인수 필요 | 디자인패턴-용어-작성규칙-템플릿

• 구조

  • 프레임워크 (기능 + 구조 흐름제어)
    • 라이브러리1 (기능제공)
    • 라이브러리2
    • ....

• 키워드/문장 기록 =>

• 클래스-모듈-패키지-라이브러리-프레임워크

  • 용어정리

• ㅡㅡㅡㅡ

• 클래스 =>

• 객체 생성을 위한 템플릿/틀(붕어빵 금형)

• JS-프로그래밍언어-객체-의미#이미지-프로그래밍 언어-객체이해

• 데이터 (변수-속성) + 기능(메서드-함수)를 묶어서 저장하고 있는 큰 코드블록

• 패키지(Package) =>

• 윈도우 폴더 = 파이썬 디렉토리 = 파이썬 패키지 -- '패키지는 파이썬 모듈들을 가지고 있는 폴더'

• 여러 모듈 그룹화(폴더) > 하나의 큰 단위/패키지 정의

• numpy패키지, django패키지

• 구조코드

  • 계층구조-모듈들 관리
  • 큰 폴더
    • 작은 폴더들 존재 = 서브패키지(Subpackage) = 하위패키지
    • 각각 다양한 기능들 제공

• 라이브러리 (Library) =>

• 구조코드 - "이러한 구조를 가지기 때문에 라이브러리 <> 모듈 혼용 사용"

• 작은 규모 모듈 모음 > 라이브러리 용어 사용

  • 사용자가 제어 = 선택적 사용 가능 - "필요한 라이브러리-함수 임포트 사용"
  • 큰 규모 모듈, 여러 기능 모음 > 패키지 용어 사

• math 라이브러리(폴더) - "특정 작업/기능을 위한 코드집합 - 수학연산 기능"

  • 모듈들이 모여 > 하나의 확장된 기능 제공(구조)

• 하나의/독립적인 기능 제공 코드 집합/모듈들 집합

  • 집합 > 특정 작업을 위한 함수, 클래스 집합
  • 집합=폴더=디렉토리

ㅡ 패키지-구성이해-init.py기능

• 키워드/문장 기록 =>
  • 예시코드
    • https://github.com/LeeKunH/NIPA_Seoul_Web/tree/main/package-test
  • 패키지
    • 특정 작업 수행 위한 여러 기능 제공
    • 모듈들의 집합
  • 패키지 어떻게 구성-사용
  • ㅡㅡㅡㅡ
  • 패키지 예시구조 =>
    • a 패키지 = a 폴더(/디렉토리)
    • 내부
      • __init__.py 파일 존재 -- '해당 파일 존재하기에 패키지가 모듈로 인식'
        • 내부 : 여러 모듈 import 상황
  • __init__.py 파일 기능 =>
  • 1. 폴더-패키지인식-init.py
    • a폴더-디렉토리 = a패키지
  • 2. 초기화 기능 -- '패키지를 구성하는 모듈들 사이 관계 정의' =>
    • 패키지 내부 __init__.py 파일 존재 > 하나 인터페이스 역할 수행 중
      • 여러 모듈 조직 > 하나 통합 인터페이스 제공
    • __init__.py 내부 - 패키지가 가지고 있는 기능/모듈 임포트 구문 존재
      • 패키지 단일 임포트 > 해당 패키지 통해 모든 모듈 접근 가능

라이브러리-패키지-이미지-파일경로" tabindex="-1">ㅡ 라이브러리-패키지-이미지-파일경로

• 키워드/문장 기록 =>
  • 이미지
  • ㅡㅡㅡㅡ
  • 실제 파이썬 라이브러리-패키지-구조 존재 확인 =>
  • requests 외부 라이브러리 = requests 폴더
    • __init__.py | 폴더-패키지인식-init.py
  • 해당 라이브러리 다양한 기능 = requests폴더 내부 다양한 모듈 존재
  • 파일경로 =>
  • requests 외부 라이브러리 파일경로
    • anaconda3 폴더내부 존재
  • math 내장 라이브러리 파일경로
    • vscode코드 폴더내부 존재 = 인터프리터(VScode) 내장 > .py 파일형태 저장 x = .pyi 파일형태 저장 o | 타입힌트파일=pyi=stub
    • .pyi 파일형식
      • 타입정보 파일 = 스텁 파일 = 실제 라이브러리 코드파일 x

ㅡ 타입힌트파일=pyi=stub

• 키워드/문장 기록 =>
  • 타입 힌트(type-hints) 파일 = .pyi 확장자명 = stub 파일
  • ㅡㅡㅡㅡ
  • 1. 코드 작성 시 타입 정보 제공 + 자동완성 기능 제공> 오류 사전 방지 도움 | 무제 파일 66
  • 2. 단순 정보 제공 파일 = 실제 로직 정의 x --
    • 예시 | 라이브러리-패키지-이미지-파일경로 =>
    • VS코드에서 math.sqrt() 함수 마우스 클릭 > math.pyi 파일 내용 참조 > 해당 함수 인자 타입, 반환 타입 등 타입힌트 정보 확인 가능
  • 3. 인터페이스 역할 수행 =>
  • 해당 라이브러리-패키지-모듈 제공 기능(에 대한) 명세서(specification)
    • 기능 = 함수-클래스 의미
    • 함수-클래스 어떤 매개변수> 어떤 타입값 반환 정보 가짐

ㅡ 폴더-패키지인식-init.py

• 키워드/문장 기록 =>
  • 파이썬 패키지-라이브러리-폴더 정의
  • 예시구조
  • ㅡㅡㅡㅡ
  • 구버전
    • 폴더 내 __init__.py 파일 정의 = 원도우 폴더 > 파이썬 패키지-라이브러리 인식 -- '패키지로 인식되야 import구문 사용 폴더 내 모듈 접근 가능'
  • 신버전
    • 존재 x > 인식 o -- '여전히 관행적 작성. 해당 파일에 패키지 초기화 코드 주로 존재' | 패키지-구성이해-init.py기능
    • VS코드 구문강조 x
    • 자동완성 x

ㅡ 05-1 클래스

ㅡ 파이썬-클래스(class)의 특징

ㅡ 클래스-생성자-사용이유-예시코드

• 키워드/문장 기록 =>
  • 클래스 정의 이유 - 예시코드
  • 클래스 - 생성자 메서드 정의 이유 - 예시코드
• 키워드/문장 기록 =>
• 클래스 특징 =>
• ㅡㅡㅡㅡ
• 1. object 클래스-최상위 클래스 - "모든 클래스 자동상속된 상태" | 클래스계층구조-최상위-메타-사용자정의
  • class test(): = class test(object):
• 2. 모든 데이터 > 클래스 인스턴스-객체 - "모든 자료형은 클래스다."
• 메서드 =>
• ㅡㅡㅡㅡ
• 인스턴스 메서드(Instance method) - "일반적인 메서드 정의 생각"
  • self 코드 - "클래스 인스턴스/객체 자기 자신 의미"
• 클래스 메서드(Class method) -- '인스턴스 특정 상태/값 무관하게 호출 시 일정한 기능수행/값 출력 시 클래스 메서드로 정의'
  • (정적메서드와 같이) 인스턴스 생성 X > 메서드 직접 참조-호출-사용
  • cls 코드 - "클래스 자체 전달-의미"
  • 직접 값을 초기화 > 인스턴스 생성 <> 생성자 메서드로 값 초기화 > 인스턴스 생성
    • "직접 인스턴스를 생성 가능 = 직접 값을 초기화 가능"
  • @classmethod
• 스태틱 메서드(Static method)=정적메서드 | 정적메서드-직접참조-@staticmethod
  • 코드x
  • 단순 기능적인 역할-유틸리티적인 함수 정의
• 변수 =>
• 예시코드 -- '클래스 인스턴스 생성 시 전달된 인수에 따라 해당 인스턴스 속성값이 결정됨/객체의 초기상태' | 참고기록
• ㅡㅡㅡㅡ
• 클래스 (멤버)변수 - "클래스 전체에서 전역적으로 사용되는 값=모든 인스턴스 동일한 값"
• 인스턴스 변수 - "동일한 속성, 하지만 다른 독립적인-속성값을 가짐"
• 클래스에서 사용되는 용어-표현
  • 속성(attributes)/필드(fields) 용어 <> 변수 용어
  • 클래스 인스턴스 특징-데이터 의미/클래스 데이터 저장 공간 의미 <> 데이터 저장-메모리 위치-이름

ㅡ [[생성자(메서드)-__init__-인스턴스생성과정]]

• 키워드/문장 기록 =>
  • 생성자(메서드)=생성자(__init__)=constructor
  • ㅡㅡㅡㅡ
  • "생성자 메서드를 호출하다 = 인스턴스 초기화하다." <> "생성자 메서드를 직접 호출하다"
  • 생성자 메서드 매개변수 정의 = 인스턴스 생성 시 필요한 초기값 전달 필요
    • 매개변수 x 생성자 가능
  • 클래스 인스턴스 생성과정
    • 클래스 정의 > 클래스 호출 > 생성자 메서드 자동호출 > 특정한 값 할당(초기화) > 인스턴스 생성 > 변수에 주소값 할당
  • 기본 생성자(메서드)
    • 빈 init메서드
    • 내부 어떠한 것도 작성되지 않은 상태
    • 생성자 직접 정의하지 않으면 기본 생성자 자동 정의 > 호출

ㅡ 클래스객체-클래스인스턴스-용어

• 키워드/문장 기록 =>
• 클래스 객체와 인스턴스 생성 과정
• 클래스 객체(Object) 용어 <> 클래스 인스턴스(Instance) 용어
• ㅡㅡㅡㅡ
• 클래스 객체 생성 -- "메모리 상에 객체-공간 생성된 상태 = 아직 특정 값으로 초기화 되지 않은 상태"
  • __new__ 메서드 호출
• 클래스 인스턴스 생성 -- "위에서 생성된 객체에 특정 값이 할당-초기화된 상태"
  • __init__ 메서드
• new메서드 호출=객체 생성 > init메서드 호출=값 초기화=인스턴스 생성

클래스계층구조-최상위-메타-사용자정의" tabindex="-1">ㅡ 클래스계층구조-최상위-메타-사용자정의

• 키워드/문장 기록 =>
  • 파이썬 클래스 계층구조
  • ㅡㅡㅡㅡ
  • 최상위 클래스=object 클래스=모든 메타클래스의 부모 클래스
    • 메타클래스=모든 일반 클래스의 부모 클래스
      • 사용자 정의 클래스=일반 클래스

클래스상속-메서드오버라이딩" tabindex="-1">ㅡ 클래스상속-메서드오버라이딩

• 상속예시 : 파이썬-프로그램 코드-작성-느낀 점#상속
• 키워드/문장 기록 =>
  • 클래스 상속 (inheritance) - "이미 존재하는 클래스 모든 특징 물려받는 새로운 클래스 빠르게 정의"
  • 객체지향프로그래밍 대표적인 특징/개념
  • ㅡㅡㅡㅡ
  • 문법
    • class 자식클래스명(부모클래스명):
  • 부모 클래스(parent class) = 기초 클래스(base class)
  • 자식 클래스(child class) = 파생 클래스(derived class)
    • "부모클래스 상속을 통해 기존 클래스 기능 재사용 + 쉽게 자식클래스에서 새로운 기능 추가 가능=기능 확장"
  • 메서드 오버라이딩(method overriding) - "자식 클래스에서 같은 이름으로 메서드 재정의."

ㅡ 상속-super(현재클래스, self or cls)-작동원리

• 키워드/문장 기록 =>
  • 클래스 상속-super() 함수 - '상속 관계 > 부모클래스 <> 자식클래스 간 메서드 호출 가능하도록 하는 함수'
  • ㅡㅡㅡㅡ
  • 작동원리 - '호출 시 부모클래스에 접근 가능한 프록시 객체 반환 > 이를 통해 자식 클래스는 부모클래스 메서드 접근 가능'
    • 프록시 객체 = 중개 객체
  • 이점 - '부모 클래스 이름 직접 사용하지 않아도 해당 클래스 메서드 접근/사용 가능'
    • 유연대응
    • 기능확장=동작확장 용어
  • 문법-구조 =>
  • 주의
  • super(현재클래스, self or cls)
  • 첫 번째 인수 - '부모 클래스 찾는데 사용 목적'
    • 현재 클래스 작성
  • 두 번째 인수 - '부모-메서드에 접근/사용하는 객체 전달 목적'
    • 현재 클래스 인스턴스 or 클래스 작체 작성

ㅡ MRO-다중상속-다이아몬드

• 키워드/문장 기록 =>

ㅡ 특수속성-MRO

• 키워드/문장 기록 =>
  • 메서드 결정 순서(Method Resolution Order)
    • 특수 속성(dunder/magic attribute)
    • 언더스코어(__)
      • 매직 메서드
    • __mro__
    • dir() 함수

ㅡ 정적메서드-직접참조-@staticmethod

• 키워드/문장 기록 =>
  • 정적 메서드 - "클래스 인스턴스 생성하지 않고 직접 메서드 참조-사용-호출 가능한 메서드"
  • ㅡㅡㅡㅡ
  • 언제 정의-사용
    • "다른 속성과 상호작용 할 필요 없는 경우 정의-사용" = "클래스와 관련이 있지만 클래스의 인스턴스에 의존하지 않는 경우"
  • 클래스 인스턴스 해당 메서드 접근x
  • 클래스 변수 해당 메서드 접근o
  • 정의 방법
    • 1. @staticmethod 데코레이터 표현식 - "가독성 높임. 따라서 일반적으로 해당 표현식 사용"
    • 2. 일반 메서드(self 생략)처럼 정의

ㅡ 매직메서드-종류

• 키워드/문장 기록 =>

  • 매직 메소드(Magic method) - "이미 특정한 기능이 정의된 함수"

  • ㅡㅡㅡㅡ

  • "직접 호출x > 정해진 규칙 호출"

  • 정의 > 자동호출 메서드

    • __init__ - "값 초기화"

  • 정의 > 직접호출 메서드

    • __len__ - "길이반환"
    • __str__ - "문자열 반환"
    • __repr__ - "객체표현"

  • __add__

  • new

  • __del__ | 예약어-키워드 - "메모리상 제거 시 안내문구 출력"

  • __iter__

    • iterable하다

  • __next__

  • __bool__

  • __call__ | call-기능-바인딩-용어

  • __add__, __sub__, __mul__, __truediv__

  • 매직 메서드 구현 연습코드

    • "직접 속성에 접근" 표현
    • "파이썬 객체지향 프로그래밍 언어"

ㅡ [[매직-특수메서드-__str__-__repr__]]

• 키워드/문장 기록 =>
  • 특수-매직-던더 메서드(Magic Method)
  • ㅡㅡㅡㅡ
  • 정의x > 객체 자체 출력=메모리 주소값 출력
  • 공통점 - "입력된 객체가 어떠한 타입이건 문자열로 반환 기능"
  • 차이점
    • __str__ - "서로 다른 데이터 타입끼리도 함께 작성-출력이 되도록 문자열 변환 > 인터페이스 역활 수행"
      • print함수 생각
      • int 클래스 내부구조 단순화 코드 - "파이썬 모든 데이터는 특정 클래스의 인스턴스/객체"
      • 자동호출
    • __repr__
      • eval()
      • 자동호출x > 일반함수처럼 직접호출 사용
  • 클래스 인스턴스 <> 내장함수
  • 내장함수(인스턴스) 직접 사용 x - "해당 내장함수를 특수 메서드로 정의 시 내장함수를 사용하는 것 처럼 사용 가능"
    • 예시코드 - "특수 메서드 내부에 클래스의 인스턴스 변수 data직접 접근 후 내장함수 호출하는 방식 로직작성"

ㅡ call-기능-바인딩-용어

• 키워드/문장 기록 =>
  • 특수 메서드
  • ㅡㅡㅡㅡ
  • __call__ 기능 - '클래스 인스턴스에 호출 가능성 부여 = 인스턴스가 클래스 내부 메서드를 함수처럼 호출가능'
    • () 연산자 사용 호출 가능
  • 예시코드1
  • 예시코드2 - '__call__ 사용 x 예시코드1 같은 결과 출력 방법' =>
  • 1. 일반적인 방법 = 클래스 내부 메서드 정의 - '인스턴스를 통해 접근/사용/호출 의미'
  • 2 . 바인딩 방법 - '변수-함수-메서드 <> 특정 객체 연결 방법/과정 의미'
    • 작동원리/작동방식
    • 바인딩 과정/방법 - '외부 함수가 클래스 인스턴스 속성에 할당 = 해당 속성/변수는 외부 함수 주소를 가리키게 된 상황'
      • 함수 > 인스턴스 메서드처럼 동작
    • 주의
      • 첫 번째 인수 명시적 전달

ㅡ 05-2 모듈

• 키워드/문장 기록 =>
• 파이썬 모듈 - 코드 파일 (확장자 .py) - "하나의 파이썬 코드 파일 안에 여러 개 클래스, 함수 등 (코드집합/코드블록)포함가능"

ㅡ 모듈-접근-참조-import구문

• 키워드/문장 기록 =>
  • import 구문
  • ㅡㅡㅡㅡ
  • import 모듈명
    • 모듈.클래스()
  • from 모듈명 import*
  • from 모듈명 import 함수명 또는 클래스명
    • 클래스()
  • import 구문 의미 - "참조/접근해서 사용 중"
  • from . import submodule_b
    • 점 - 현재 디렉토리 상대경로 의미 -- '같은 디렉토리 내 파일 참조/접근 가능'

모듈내부-서브모듈-표현" tabindex="-1">ㅡ 모듈내부-서브모듈-표현

• 키워드/문장 기록 =>
  • 하나의 모듈 내부에 서브모듈 정의 표현 이해
  • ㅡㅡㅡㅡ
  • os모듈
    • 복잡한 표준 라이브러리
    • 서브모듈(들) 독립적 존재
  • 서로 다른 모듈(들 서로) import 상황/관계 사용 표현
  • 예시코드 =>
  • import구문 사용 참조 상황 = 서브모듈 표현
  • a 모듈
    • 내부 import b 모듈 -- 'b 모듈은 a 모듈에 종속적인 관계'
    • b 모듈 = a 모듈의 서브모듈
  • 이러한 코드작성 방식 =>
  • 모듈간 의존성(dependency)
  • 모듈화
  • 장점
    • 재사용성
    • 해당 기능 확장

ㅡ 05-04 예외처리

예외처리구문-사용시기-이유" tabindex="-1">ㅡ 예외처리구문-사용시기-이유

• 키워드/문장 기록 =>

• 파이썬 예외처리 구문

• ㅡㅡㅡㅡ

• try - '예외 발생 가능성 구문'

• except - '예외 발생 시 실행 구문'

  • 여러 개 사용 > 여러 종류 예외 처리 가능

• else - '예외 발생 x > 실행 구문'

• finally - '항상 실행 구문'

• 예외처리 구문 활용

• 함수 내부 try문 작성 - '사용자로부터 함수 매개변수에 특정한 타입의 인수만 할당'

  • if문 사용 풀이

• 사용 시기-이유 =>

• 예외 = 에러 = 오류 상황 관리 > 흐름 제어

• 1. 코드 테스트-(디버깅)-오류식별 - "어느 부분 발생? 어떤 오류?"
  • 디버깅 용어
  • 코드 내 오류 식별 > 수정 > 코드 안정성 확보 과정
    • 변수 적절한 값 존재 확인
    • 코드 기능 작동 확인
• 2. 프로그램 안정성 - '예외 발생 시 > 서비스 중단 x'

• 예외처리 사용 과정

  • 오류 발생 > 발생 위치 확인 > 오류 유형-원인 파악 > 예외처리 로직 작성 > 오류 상황 대처

예외처리클래스-계층적구조-상속-파생-다형성" tabindex="-1">ㅡ 예외처리클래스-계층적구조-상속-파생-다형성

• 키워드/문장 기록 =>
• 예외(처리) 클래스
• TypeError
• NameError
• ValueError -- '잘못된 수를 입력했을 때 발생'
• ZeroDivisionError
• OSError - '운영체제 관련 오류'
  • FileNotFoundError
  • PermissionError
  • InterruptedError
• ㅡㅡㅡㅡ
• 계층적 구조 = 예외 처리 시스템
  • 상속받아 정의됨 = 파생되어짐 = 다형성 적용 = 공통의 인터페이스 공유
  • 포괄적인 처리 가능 + 세분화 처리 가능
• 최상위클래스
  • BaseException - '모든 예외 처리'
• 상위클래스 - '포괄적인 처리 = 유연하게 처리'
  • except Exception as e:
  • Exception - '일반적인 예외 처리'
• 하위클래스 - '세분화된 처리'
  • except ValueError:

ㅡ 05-5 내장함수

• 파이썬에서 미리 만들어 제공해 주는 함수 = 빌트인 함수
  • 내장함수 호출 함수이름(인수) <> 메서드 호출 객체.메서드(인수)
• 키워드/문장 기록 =>
• zip() -- '반복가능한 객체(iterables) 할당 > 동일한 인덱스 위치 요소 튜플로 묶고 > 리스트 자료구조 반환'
  • 사용예시 =>
  • 두 리스트 요소 묶기
  • 여러 시퀀스 객체(리스트-튜플 등) 동시순회 -- '동시순회 = 동시접근 = 변수할당 > 사용'
• hex() -- '정수 > 16진수 문자열 변환'
  • 접두사 표현 0x = 파이썬 16진수 표준 표기법
  • 예시코드
  • 십진수 : 10 > 16진수 : a > 파이썬 표준 표기법 : 0xa
• bin() -- '정수 > 이진수 문자열 반환'
  • 접두사 표현 0b
• round() -- '(기본값)가장 가까운 정수로 반올림 기능'
  • round(숫자, 자릿수=0)
  • 자릿수 양수 - 해당 자리 이후에서 반올림(위치)
    • round(346.36, 1)
  • 자릿수 음수 - 해당 자리에서 반올림(위치)
    • round(346, -1)
• pow()
  • 거듭제곱 계산 기능
  • 2개 필수 인수
  • 1개 선택적 인수
• abs() - "주어진 숫자의 절대값 반환 기능"

ㅡ 05-3,6 표준 라이브러리-패키지(Package)

• 별도 설치 없이 사용 가능 - "import 구문 작성 후 참조/접근/사용 가능"
• 키워드/문장 기록 =>
  • Unittest
  • random 라이브러리/모듈
  • ㅡㅡㅡㅡ
  • randint(a, b)함수 - "a 이상 b 이하의 랜덤한 정수를 반환"
  • shuffle('리스트') - "랜덤하게 석는다"

ㅡ 05-7 외부 모듈-패키지-라이브러리

ㅡ pylint-Unittest-라이브러리-스타일-기능분석

• 키워드/문장 기록 =>
  • 라이브러리
  • 차이점 - ' 코드 검사 및 테스트 접근 방식'
  • ㅡㅡㅡㅡ
  • pylint =>
  • 코드 (외형적) 스타일 분석/검증
    • 버그 가능성 식별
  • 표준 파이썬 코드작성 준수 여부 확인
    • PEP(파이썬 스타일 가이드)
    • 변수 이름
    • 모듈-함수-클래스 구성 여부
  • 코드 가독성-일관성 위함
  • 정적분석 도구
    • 실제 실행 X 의미 - '터미널 or 명령 프롬프트에서 실행'
  • Unittest =>
  • 기능 단위 테스트
    • 함수 - 클래스 메서드 개별 실행 > 반환 결과 일치여부 확인
  • 실행 기반 테스트 도구 - '해당 모듈 임포트 후 실제 코드 실행 > 검증'
  • 코드 안정성 위함

ㅡ 고급 파이썬 모듈

고급자료구조-딕셔너리" tabindex="-1">ㅡ 고급자료구조-딕셔너리

• 키워드/문장 기록 =>
• 예시코드
  • 고급 자료구조
  • 일반 자료구조
• ㅡㅡㅡㅡ
• 프로그래밍 언어 고급 자료구조 =>
• 파이썬
• 자바
  • 일반적인 자료구조 존재 <> 고급 자료구조 존재
  • HashMap
  • LinkedHashMap
  • TreeMap
• 고급 자료구조 필요한 이유
  • 특정 상황/복잡한 상황 > 효율성, 성능 향상
  • 고급 자료구조 자료형 사용 > 웹 어플케이션 데이터 저장-접근 성능향상
• 기본 자료구조 자료형
  • 딕셔너리 자료형
• 고급 자료구조 자료형
  • 고급 딕셔너리 자료형 -- '일반 딕셔너리 자료구조 기본적인 특성 유지 + 추가적인 기능/최적화된 기능 제공 > 특정 상황 성능향상'
  • OrderedDict
    • 삽입 순서 기억
  • defaultdict
    • 키가 없는 경우 > 기본값 자동 제공 기능

ㅡ 파이썬 정규 표현식

정규표현식-의미" tabindex="-1">ㅡ 정규표현식-의미

• 키워드/문장 기록 =>
• 정규 표현식 -- '특정 모양/패턴 정의 > 하나의 문자열에서 패턴에 일치하는 문자열 찾아 처리시 작성하는 코드 표현식'
  • 문자 처리작업 = 검색/찾는다, 매칭하다, 대체하다, 분리하다 작업
• ㅡㅡㅡㅡ
• 정규표현식 주의점 =>
• 암기 x
• 중요한 기본 개념 + 자주 사용 메타문자 키워드 이해
• re 모듈 사용 =>
• 예시코드-이메일 주소-특정한 패턴 존재 | 참고기록
  • 정의 방법
  • 메타문자 사용
  • findall()
    • 리스트 반환

정규표현식-패턴(모양)정의" tabindex="-1">ㅡ 정규표현식-패턴(모양)정의

• 키워드/문장 기록 =>
• 정규표현식
• 1. 특정 문자 자체 찾는다
• 2. 특정 패턴/모양 찾는다
• ㅡㅡㅡㅡ
• 전화번호 패턴 정의 방법 =>
• 메타 문자 사용 -- '해당 문자 조합으로 패턴/모양 정의'
  • 다양한 메타문자 존재
• 문자 클래스 사용
  • [] 대괄호
• 이스케이프 문자 사용
  • \

이메일-다양한형태-패턴" tabindex="-1">ㅡ 이메일-다양한형태-패턴

• 키워드/문장 기록 =>
• 이메일 주소 다양한 형식-패턴
• ㅡㅡㅡㅡ
• 기본구조
  • 사용자명@도메인명
• 사용자명
  • 특수문자 포함
  • 점(.), 밑줄(_), 하이픈(-)
  • 숫자 포함
• 도메인명
  • 국가코드 포함
  • 이메일 서비스 제공업체 도메인 포함

07장 파이썬 날아오르기 = 고급 문법

: 이 책을 다 읽은 후 자신에게 필요한 파이썬 프로그램을 만들어 볼 것.

간단한 프로그램이 아니라면 이때 반드시 파이썬 표준 라이브러리를 사용해야 하는 순간이 온다. 하지만 파이썬 표준 라이브러리 가운데 몇 가지는 앞에서 배우지 않은 고급 개념을 미리 알아야만 이해할 수 있다.
07장에서는 이 개념에 대해 알아본다.

ㅡ 컴프리헨션-표현식

• 키워드/문장 기록 =>
• 컴프리헨션 표현식 존재(Comprehension)= 리스트 내포 - "자료구조 자료형에 데이터들을 좀 더 간결하게 담기 위한 코드 작성 방법"
• ㅡㅡㅡㅡ
• "간결하게 담는 방법" - "반복문+조건문 하나의 구문으로 작성"
  • for문
  • 중첩for문
  • for문+ if문
  • if문+else문
• 리스트 "
• 딕셔너리 "
• 세트 "

데코레이터 섹션 강의자료" tabindex="-1">ㅡ 데코레이터 섹션 강의자료

• 키워드/문장 기록 =>
• 데코레이터 섹션 강의자료
  • 라우팅-라우트-매커니즘-용어
• ㅡㅡㅡㅡ
• 플라스크 웹 프레임워크 - 데코레이터 표현식/구문 사용

ㅡ Flask데코레이터-코드

• 키워드/문장 기록 =>
• 코드-플라스크 데코레이터 구문 | 플라스크-데코레이터-작동원리-이해
• ㅡㅡㅡㅡ
• View=뷰 함수
  • 데코레이터 구문 작성된 함수 -- @app.route()
    • 특정 요청 <> 처리하는 로직 정의된 함수 매핑
  • 특정 웹 페이지 요청(검색창 url 입력 행동) > 실행되는 함수(연결되어 있는 함수)
  • 동적인 웹 페이지 생성/반환 기능 수행
    • 템플릿 내 새로운 정보 삽입
    • 템플릿 = html코드파일 = 웹 페이지
  • 동적 라우팅 -- '고정된 템플릿/구조에 값을 변경해 출력'

플라스크-데코레이터-작동원리-이해" tabindex="-1">ㅡ 플라스크-데코레이터-작동원리-이해

• 키워드/문장 기록 =>
• 플라스크 데코레이터 구문 작동원리 이해
  • @app.route()
• ㅡㅡㅡㅡ
• 1. 데코레이터 어떻게 작동?
  • 데코레이터 함수 기본 원리 | 데코레이터-함수-구문-표현식 =>
    • 예시코드
  • 데코레이터 작동 방식 | Flask데코레이터-코드 =>
• 2. 플라스크 웹 프레임워크 라우팅 어떻게 처리?
  • @app.route() 데코레이터를 플라스크 웹 어플리케이션 라우트 설정 시 사용
• 데코레이터함수=route() 내부로직 코드= 라우팅 매커니즘 확인 =>
• url경로 <> 뷰 함수 매핑 코드/로직
  • 매핑 -- '딕셔너리 자료구조에 url 경로와 함수값을 키-값 쌍으로 저장하는 방식 의미'
• 요청 처리 + 응답 반환 코드/로직

데코레이터-함수-구문-표현식" tabindex="-1">ㅡ 데코레이터-함수-구문-표현식

• 키워드/문장 기록 =>
• 데코레이터 Decorator 2가지 의미
  • 1. 코드 작성 방법/표현식/구문 - '기존 함수에 추가적인 기능/로직을 작성하기 위한 방식을 제공하는 구문'
  • 2. 데코레이터 함수
    • "꾸며주는 기능을 수행하는 함수" = "기존의 함수 앞, 뒤로 로직을 추가한다"
    • 기존 함수를 다른 함수의 인수로 전달하기 위해 기존 함수를 감싸고 있는 (wrapper)함수를 반환하는 함수
• 연관내용1
• 일급 객체(First class citizen)
• 클로저(Closure)
• 데코레이터 작성 방식/흐름 - '기존 함수를 감싸는 또 다른 함수를 정의하면서 원본 함수의 기능을 확장 or 변경'
• ㅡㅡㅡㅡ
• 데코레이터-예시코드

데코레이터-예시코드" tabindex="-1">ㅡ 데코레이터-예시코드

• 키워드/문장 기록 =>

• 데코레이터 예시코드/구조

• def 외부함수 = 데코레이터 함수 - '실행목적 x , 기존함수 전달 목적 o'

  • def 내부함수 = 래핑함수 = wrap_func() - '밖에서 내부함수 접근/호출 x = 외부함수를 통해서만 호출/사용 o = 외부함수 내부에서 호출/사용 o'

• ㅡㅡㅡㅡ

• 외부함수 > 내부함수 반환 - "함수 자체를 반환한다 <> 함수를 호출/실행한 결과를 반환한다"

• 데코레이터 표현식(/구문) 작성 시 사용 기호 - @데코레이터명 - "서로 다른 함수가 연결되어 있다"

• 데코레이터 기호 사용 x <> 사용 o - '좀 더 간단하게 작성/호출 가능'

• 클래스 형식 데코레이터 구현 =>

  • 데코레이터 함수 - func 매개변수
  • "다른 함수가 인자로 전달" = "인자로 데코레이터를 적용할 함수를 전달"
  • __call__ | call-기능-바인딩-용어

• 데코레이터 함수 사용 장-단점 =>

  • "코드 중복 최소화" = "재사용성 증가" = "수정하기 용이함"
  • 중첩 표현 가능
    • 중첩 시 작동원리/실행순서

ㅡ 클로저-함수-속성-변수유효범위

• 키워드/문장 기록 =>
• 클로저 (Closure)
  • 1. 클로저 함수
  • 2. 클로저 속성(클래스 변수) - '__closure__'
    • "외부 scope에 존재하는 변수 값 저장"
    • 클로저 객체 확인 방법
      • 튜플 타입
  • "특정한 조건을 만족하는/특정한 기능을 수행하는 함수"
  • "데코레이터 함수 내부 함수"
  • 프리변수
• 변수 유효범위 - 스코프 scope
  • 클로저 속성 필요한 이유
• "Q. 그렇다면 내부함수가 어떻게 외부 함수 변수를 참조? 사라지는거 아님?"

ㅡ OOP-일급객체-조건

• 키워드/문장 기록 =>
• 파이썬(python) - 일급 객체(first-class citizen)
  • OOP 사용되는 개념
• ㅡㅡㅡㅡ
• 3가지 조건 만족 시 => - "따라서 파이썬에서 함수는 일급 객체"
• 변수, 자료구조 타입에 (함수)할당 가능 - "딕셔너리에 함수를 할당했다"
  • 함수 변수 할당 시 얕은 복사
  • 변수 = 참조자
• (함수)매개변수에 전달 가능
• (함수)리턴값으로 사용 가능

ㅡ 제너레이터(함수)-타입-yield

• 키워드/문장 기록 =>
• 제너레이터(<class 'function'> 함수임)-Generator 타입/객체 = 지연 평가(Lazy Evaluation) 가능한 구현체 - '호출 시 값 생성 > 반환'
• StopIteration 예외 | 이터레이터-iterator타입-이터러블-Iterable특징
• 기능 - 이터레이터 객체 생성
• ㅡㅡㅡㅡ
• 이터레이터 객체 -- '모든 i객체는 g객체이다 x'
  • 제너레이터 객체 -- '모든 g객체는 i객체이다 o'
• 이터레이터 프로토콜(특징/규칙) 구현/존재 + 지연 평가/행성 특징 존재 -- 'i특징 존재하기에 g객체를 i 객체라고 부를 수 있음. 하지만 i객체는 g객체 특징이 없기 떄문에 부를 수 없음'
  • next() 메소드 호출/사용 가능
• list 객체 - "lazy 하지 않은 객체"
  • 모든 요소값 메모리 상 생성되어 있는 상태
  • 장점 - '내부값들 직관적으로 확인 가능'
  • 단점 - '메모리 낭비'
  • 예시코드 - '같은 결과를 출력하지만 메모리 측면에서 더 효율적'
• 내부 작동원리 =>
• 함수 호출 > 제너레이터 객체 생성 > 호출 > yield 행까지 실행 후 상태 보존(일시 중지)
• 제너레이터 객체 = 이터러블 (특징 가진) 객체 -- '~객체가 생성되기 때문에 제너레이터는 이터레이터 객체를 생성한다! 표현 가능'
• (제너레이터) 함수정의/객체생성 =>
• 예시코드
  • 제너레이터 함수 정의 > 호출 > 새로운 객체 반환/출력 (generator객체) - <class 'generator'>
• 1. (제너레이터 생성) 컴프리헨션-comprehension 표기법
  • () 사용 <> 리스트 컴프리헨션 [] 사용
• 2. 함수 내부 yield 키워드 정의 - '일시 중지 + 값 반환 기능'
  • next(), for문 이용 > 순차적 접근/반환출력
  • yield from 키워드 - 'for문 사용하지 않고 1개식 접근 후 반환가능'

제너레이터-구조-연습기록" tabindex="-1">ㅡ 제너레이터-구조-연습기록

• 키워드/문장 기록 =>
• 제너레이터 문제풀이 연습
• ㅡㅡㅡㅡ
• 1. 숫자 제곱 생성 제너레이터 함수 정의
• 작동방식
  • 외부 for문 반복 시행 = next함수 호출 = 함수 내부 for문 호출 = 내부 값 생성 > 반환
• 2. 입력된 수 사이에 존재하는 수 출력
  • 응용
  • 대화형 프로그램
  • 검증로직
• 제너레이터 함수 장점 활용 구조 존재 =>
• 예시코드
  • 함수 정의 = yield 키워드
  • 함수 내부 for문 정의 > 각 반복시행 시 값 생성 반환
  • 함수 외부 for문 정의 > 제너레이터 객체 접근/순회
• 3. iter() 사용 형변환
• 4. 제너레이터 컴프리헨션 표현식

파이썬 실무기술

파이썬-웹스크래핑-이해" tabindex="-1">ㅡ 파이썬-웹스크래핑-이해

• 키워드/문장 기록 =>
• 파이썬 - '파이썬에만 한정된 기술은 아니며, 다른 프로그래밍 언어로도 수행될 수 있음'
• 웹 스크래핑 - '웹사이트-웹페이지에서 필요한 정보를 자동으로 추출/수집하는 기술'
• ㅡㅡㅡㅡ
• 기술 이유 - '수동 수집 < 자동 수집 효율적'
• 주의
• 웹 사이트 동작 방식 기본적인 이해 =>
• 사용자 요청 - '주소창 url 주소 입력'
• 웹 서버 응답
  • 웹 페이지 기본적인 형식 - '웹 페이지 기본형식을 알아야 파이썬 명령코드로 내가 필요한 데이터를 가지고 있는 위치 파악 > 수집'
  • 웹 페이지 데이터 = 코드파일 = html문서파일 + css + js
• 파이썬 라이브러리 이용 => | 웹스크래핑-라이브러리
• BeautifulSoup = bs4
• requests
• lxml

웹스크래핑-라이브러리" tabindex="-1">ㅡ 웹스크래핑-라이브러리

• 키워드/문장 기록 =>
• 웹 스크래핑 시 사용되는 파이썬 라이브러리
• ㅡㅡㅡㅡ
• requests 라이브러리 =>
• 역할
  • 웹 서버 HTTP 요청 > 웹 페이지 내용 가져오는 기능 = 데이터 요청 + 데이터 수신
• 사용과정
  • requests.get(url) 함수 호출 > 해당 페이지 HTML문서 요청 + 수신 > 객체반환
  • .text 속성
• 1. lxml 라이브러리, 2. bs4 라이브러리 (Beautiful Soup) =>
• 역할 - '가져온 데이터 파싱 > 원하는 정보 추출 기능'
• XML 및 HTML 코드 효율적인 파싱 기능 제공 | XML-용어-태그유연성-데이터전송
• 파싱 과정 > 원하는 데이터 추출 가능
  • 특정 태그, CSS 선택자 이용 > 원하는 HTML요소 선택 > 필요한 데이터 추출
• requests로부터 받은 HTML 데이터 파싱 > 구조화된 데이터 변환
• 차이점 =>
• lxml 라이브러리
  • XPath 및 CSS 선택자 통한 > 정밀한 요소 선택 가능
  • 엄격한 XML 구문 검사 >
    • 대규모 XML 또는 HTML 문서 빠르게 처리 시
    • 복잡한 문서 구조 정밀하게 요소 추출 시
    • 정확한 마크업 구조 가진 문서 시
• bs4 라이브러리 (Beautiful Soup)
  • 사용자 친화적인 API 제공
  • requests로부터 받은 HTML 데이터 파싱 > Beautiful Soup 객체 반환
  • 다양한 파서 옵션 제공 >
    • 불완전한 마크업 구조 가진 HTML 문서 처리 시
    • 유연한 방식 선호 시

ㅡ 파이썬 이미지 작업

ㅡ 파이썬 PDF 스프레드시트 작업

ㅡ 파이썬 이메일 작업

이메일작업-강의자료" tabindex="-1">ㅡ 이메일작업-강의자료

ㅡ 파이썬 미니프로젝트

<Python-크롬 공룡게임-프로젝트-목차>

<오목게임>

코드작성방식-모듈화-함수분할" tabindex="-1">ㅡ 코드작성방식-모듈화-함수분할

재귀적함수호출-팩토리얼" tabindex="-1">ㅡ 재귀적함수호출-팩토리얼

게임-텍스트기반-인터페이스" tabindex="-1">ㅡ 게임-텍스트기반-인터페이스

• 키워드/문장 기록 =>
  • 현재 미니 게임 상황
  • ㅡㅡㅡㅡ
  • 텍스트 기반 인터페이스 = 텍스트 기반 레이아웃
    • 문자열 정의(된) 게임 보드판 = 그래픽 요소 x 보드판
    • 문자열 입력 > 게임 상태 업데이트
    • 위치입력
    • 사용자 상호작용 | 반응형-대화형-프로그램 용어

함수구성패턴-전략-함수호출체인" tabindex="-1">ㅡ 함수구성패턴-전략-함수호출체인

• 키워드/문장 기록 =>
  • 예시코드-오목게임
  • 현재 코드 로직/상황
  • 함수간 작업 연결
    • 1번 함수 내부 > 2번 함수 호출
      • 2번 함수 내부 > 3번 함수 호출
  • 이전 단계 출력값(1번 함수 생성된 값) > 다음 단계 입력값 사용(2번 함수 호출 시)
  • ㅡㅡㅡㅡ
  • 함수 작성 방법 x = 함수 구성(/구현/구조) 패턴/전략 O =>
    • '특정 문제 해결을 위한 여러 함수를 어떻게 정의하고 어떻게 서로 연결할지에 대한 방법론'
  • 함수 호출 체인(Function Call Chain)
    • 함수 중첩 호출 = 연속적 호출 -- '한 함수 다른 함수 호출'
    • 함수 간 호출 관계 -- '한 함수가 다른 함수 작업 시 이용됨'
    • 계층적인 작업 흐름
    • 작업분할 방법
  • 해당 함수 구성 예시 =>
  • 웹 어플리케이션 사용자 인증 과정
  • 과정별 데이터 처리/조건 검사 상황
  • 로그인 요청 과정
    • 입력된 데이터 검증 과정
      • 사용자 결과 반환 과정