Schema : 데이터베이스의 전체 구조, 데이터 타입, 제약 조건, 테이블 간의 관계 등을 정의한 메타데이터 == 설계

“”” 이 데이터베이스는 어떻게 생겼고, 어떤 데이터를 어떻게 저장할 것이다 ””” 라는 약속

역할 : 어떤 종류의 데이터를 어떤 형식으로 저장할 것인가 - 에 대한 규칙을 정함

주요 요소 : table, column, data_type, 제약조건(데이터의 무결성을 보장하기 위한 규칙 | PK,FK ) * 데이터 무결성이란? 데이터의 수명 주기 동안 정확성, 일관성, 유효성이 유지되고 승인 없이 변경되거나 손상되지 않은 상태

• 주요 유형 : 개체 무결성(PK | 고유값 | NOT NULL), 참조 무결성(FK | 테이블 간의 관계가 일관되게 유지되도록 보장), 도메인 무결성(필드의 데이터 타입, NULL여부, 허용된 값 범위 등 올바르게 입력되었는지 확인)
• 무결성이 중요한 이유 : 오류/실수 방지, 운영 효율성, 규정 준수

[ EX ] CREATE TABLE Customers( customer_id INT PRIMARY KEY, - 고객 ID, 정수형, 기본키 name VARCHAR(100) NOT NULL, - 이름, 최대 100자 문자열, NULL아님 email VARCHAR(255) UNIQUE, - 이메일, 최대 255자 문자열, 고유해야 함 phone_number VARCHAR(20) - 전화번호, 최대 20자 문자 );

SQL을 쓸 때는 거의 항상 데이터베이스.테이블 두 단어로 위치를 가리킴

EX) FROM pharma_sales.part_d_prescriber

SELECT 쿼리는 쓰는 순서와 읽는 순서가 다르다

쓰는 순서 SELECT | FROM | WHERE | AND | ORDER BY | LIMIT

읽는 순서 FROM : 먼저 어떤 테이블을 읽을지 정한다 WHERE : 원본 처방 행에서 주, 약물, 조건을 먼저 줄인다 SELECT : 강의와 분석에 필요한 컬럼만 남긴다 ORDER BY : 처방량, 비용처럼 볼 기준으로 줄을 세운다 LIMIT : 상위 몇 건만 꺼내 결과를 빠르게 확인한다

[ 집계 함수 ]

어떤 데이터를 집계하는 함수들을 의미.

COUNT “ SELECT COUNT(*) FROM citykorea ; “ 모든 레코드의 수를 출력하는 query

SUM “ SELECT SUM(population) FROM citykorea ; ” 인구수 합계를 출력하는 query

MAX / MIN “ SELECT name, max(population) FROM citykorea ; ” 가장 많은 인구수를 가진 도시의 이름과, 인구수를 출력한 query

AVG “ SELECT AVG(population) FROM citykorea ; ” citykorea의 평균 인구수를 출력하는 쿼리

[ Group Query ]

집계함수의 결과를 특정 컬럼을 기준으로 묶어 결과를 출력해주는 쿼리

GROUP BY 정의 : 같은 기준을 가진 여러 행을 한 행으로 접어 요약값을 만드는 문법 원본 행을 의사결정 단위로 접는다 원본에 대한 해상도는 떨어지지만 통합본은 볼 수 있음 SQL에서 GROUP BY에 넣는 함수를 제외하고 다 집계함수가 되어야 함 SELECT에 GROUP BY할 것만 둠 나머지 집계함수에 들어갈 것들을 COUNT() AS name SELECT 와 GROUP BY 순서를 맞추면 좋음 “”” SELECT column, 집계함수(column) FROM TABLE GROUP BY column ; “””

HAVING 정의 : GROUP BY로 만든 요약값에 조건을 거는 문법 WHERE과 차이 : WHERE는 집계 전 원본 형 필터, HAVING은 집계 후 그룹 필터 GROUP BY 이후에 생긴 SUM, AVG, COUNT 같은 요약값으로 거른다. “”” SELECT column, 집계함수(column) FROM TABLE GROUP BY column HAVING 집계함수(column) 부등호 data ; “””

COUNT DISTINCT 중복을 제거한 고유한 행의 개수를 구하기 위해 적용 “ SELECT COUNT(DISTINCT name) FROM data_table ; ” name 컬럼에서 중복을 제외한 이름의 총 개수

LEFT JOIN 왼쪽 테이블의 모든 데이터와 오른쪽 테이블에서 조건이 일치하는 데이터를 연결하여 반환하는 방 “”” SELECT * FROM tableA A LEFT JOIN tableB B ON A.key = B.key ; “”” table A는 항상 결과에 포함. A.key = B.key 값이 같은 행이 있다면 함께 출력, 없으면 table B자리에 NULL

[ CASE ]

기본 문법 CASE
WHEN 조건1 THEN 조건1 충족할 때 반환되는 값 WHEN 조건2 THEN 조건2 충족할 때 반환되는 값 ELSE 모든 조건 해당되지 않을 때 반환되는 값 END WHEN - THEN 항상 같이 사용 | 조건문 마지막에 END 꼭 써주기
CASE 문을 사용할 때 별칭AS을 사용해주는 것이 좋음 --> EX CASE WHEN total_claims >=100 THEN ‘고처방’ ELSE ‘저처방’ END AS name

[ DECIMAL ]

실수의 값을 정확하게 표현하기 위해 사용 , DECIMAL타입은 NUMERIC을 구현하여 만들어짐 DECIMAL(7,2) == -99999.99 ~ 99999.99 까지 실수를 저장할 수 있도록 DECIMAL(A,B) == A는 실수의 총 자릿수 | B는 소수 부분 “ CAST( table_name AS DECIMAL(num , num)) ”

[ with절 ]

임시 테이블 , 복잡한 서브쿼리를 가상의 테이블로 미리 정의해 재사용 할 수 있게 해주는 CTE 기능 쿼리를 단순화하고 가독성을 높일 수 있음

--> EX WITH SalesEmployees AS ( SELECT FirstName, LastName, JobTitle, Salary FROM employees e JOIN departments d ON e.DepartmentID = d.DepartmentID WHERE DepartmentName = ‘Sales’ ) SELECT FirstName, LastName, JobTitle, Salary FROM SalesEmployees ;

[ WINDOW 함수 ]

정의 : 행을 줄이지 않고 계산값을 붙인다. 원본 행을 유지하고, 그룹 안에서 계산한 값을 새 컬럼으로 붙인다. partition을 어떻게 나눌것인가? , order by 정렬 , row number/lag/sum 무엇을 넣을 것인가? row_number : HCP별 가장 최근 접점 또는 첫 접점을 찾는다. LAG : 이전 접점, 이전 처방량, 이전 방문값을 현재 행 옆에 붙인다 SUM OVER : 누적 지급액, 누적 처방량, 누적 방문 수를 만듦 원본 함수를 살리고 싶으면 window함수가 좋다.

[ 기본 문법 ] 

“ SELECT WINDOW_FUNCTION (ARGUMENTS)
OVER ( [PARTITION BY column] [ODER BY column] [WINDOWING 절] ) FROM 테이블명 ; ”

--> EX “ SELECT name, age, sal, sum(sal) OVER(ORDER BY sal ROWS BETWEEN unbounded preceding AND CURRENT row) 누적 연봉 FROM test” 처음부터 현재 행까지의 누적

GOOGLE_DRIVE

""" Requirements Definition ➔ API Specification & Design ➔ Infrastructure & Core Implementation ➔ Swagger API Testing ➔ Git PR & Code Review """

📌 Stage 4 — User Authentication & Authorization APIs (9 Endpoints)

Design & Review: Converted requirement specifications (REQ-USER-001~009) into detailed API mapping tables. During reviews, I corrected common mistakes like putting hardcoded data into endpoints, swapping Request Body with Response structures, and properly distinguishing Authentication (login status) from Authorization (role permissions).

Implementation: Built core security features using JWT and password hashing (core/security.py). I manually filled in logic for 9 endpoints, catching frequent async bugs like missing await statements.

Testing & Git: Verified full user workflows in Swagger UI (Registration ➔ Login ➔ Auth Header ➔ Profile Fetch). Encountered a Git branching mistake by accidentally setting main as the base branch for a PR, which taught me how to fast-forward sync dev with main.

📌 Stage 5 — Patient & Medical Record APIs with File Upload (8 Endpoints)

Design & Domain Logic: Handled requirements for Patients and Medical Records. Discovered key database behaviors like how ON DELETE CASCADE automatically deletes associated records and X-rays when a patient is removed. Also mapped out multi-part file uploads for X-ray images.

New Concepts Learned: Applied Query Parameters (search/filtering), Path Parameters (/{patient_id}), and Multipart/Form-Data file handling.

Swagger Testing: Successfully tested the end-to-end flow: Creating a patient ➔ Uploading actual X-ray images to the media/xray/ directory ➔ Retrieving medical records with linked media.

📌 Stage 6 — AI Pneumonia Prediction (Full Workflow)

1. Model Pipeline & Ensemble Setup

Environment & Setup: Installed PyTorch CPU version (uv add torch torchvision --index ...) and analyzed 10 pre-trained .pth checkpoints (ConvNeXt-Tiny 5-fold + DenseNet121 5-fold).

Domain Verification: Re-verified preprocessing specifications (224x224 Resize, ImageNet Normalization) and the OR-ensemble strategy (predicts pneumonia if either model flags it) from an earlier project report (폐렴_Xray_분류_프로젝트_보고서.docx).

Git Strategy & Debugging: Added heavy model weights (worker/models/*.pth) to .gitignore to stay under GitHub's 100MB limit. Debugged key issues, including a loop return bug that loaded only a single fold, and a tuple syntax mistake in Resize((224, 224)).

Inference Test: Tested with actual X-ray images—achieved accurate predictions with a 0.9986 / 0.9888 confidence score in just 0.78 seconds!

2. API Design & Requirements Alignment

Requirements Reconciliation: Compared past design documents against current requirements (REQ-PRED-001/002). Identified key updates: expanded access rights from admin/doctor-only to all departments, and made heatmap URLs optional.

Database Precision Update: Updated DB precision for prediction confidence scores from DECIMAL(5,2) to DECIMAL(5,4) and allowed heatmap_url to be nullable.

3. API Implementation & Asynchronous Execution

Database Migration: Ran alembic revision --autogenerate and alembic upgrade head to apply schema updates, verifying accuracy directly via DESCRIBE table queries.

Non-blocking AI Inference: Integrated FastAPI’s run_in_threadpool to run heavy, synchronous PyTorch CPU inference on a background thread without blocking the async event loop!

Logic Implementation: Written and refined run_ai_analysis and list_ai_analysis functions after resolving missing await keywords.

4. End-to-End Testing & Git Repository Clean-up

Swagger Testing: Verified full user flows: User Registration ➔ Login ➔ POST /ai-analysis (201 Created with is_pneumonia: true, confidence: 0.9986) ➔ Duplicate request caching check (200 OK) ➔ Error handling (404/401/403).

Git Clean-up: Created PR #9 to dev, synchronized dev to main via fast-forward, and cleaned up the repository by deleting 9 merged branches (both local and remote), leaving a clean repository with only main and dev!

Google_drive
github

Back then, we used Claude Code to generate the entire codebase, resulting in a clean and well-structured project. However, because so much of it was auto-generated, I found it hard to remember which parts I was specifically responsible for and how the underlying logic actually worked.

So, I’m taking a fresh start! My goal this time is to rebuild the code line by line, really understanding every detail (though I’ll still use AI as a smart assistant, of course!). Beyond the backend, I plan to develop a much richer frontend and complete end-to-end deployment on AWS. Overall, I will proceed according to the template and stages already set up by the bootcamp.

Project Roadmap & Stage Breakdown

The project follows a structured progression: FastAPI Stages 1–7, followed by Docker Stages 1–4, and finally the Deployment Stage.

• Stage 1: Repository Setup Cloned the starter template repository and pushed it to my own GitHub main branch.
• Stage 2: Branch Strategy & Core CRUD APIs Adopted a hybrid branching strategy. Implemented 5 core CRUD API endpoints (Single/List Read, Delete, Create, and Update) and registered the routers in app/main.py.
• Stage 3: Database Modeling & Migration Reviewed the ERD and set up the DB models and registrations as follows:
  1. Created the .env environment file.
  2. Ran the MySQL container using docker compose up -d mysql.
  3. Built 5 database model files.
  4. Executed database migrations.
  5. Applied the schemas directly to the live database.

github link
google drive link

1. Branching & Merging Basics

2. 3-Way Merge Concepts

3. Remote Repositories & Commands

4. Project Workflow

5. Useful Shortcut Command

Create a new branch named 'document' and switch to it simultaneously

• git switch -c document

Setting Up the Local Repository

1. cd Desktop - Move to the Desktop directory
2. cd git-practice-folder - Move into your specific practice folder
3. mkdir new-project - Create a new directory for the project
4. cd new-project - Move into the newly created folder
5. git init - Initialize a empty Git repository (.git folder created)
6. code . - Open the current directory in VS Code

The Git Workflow: Working Directory to Staging Area

Once VS Code opens, let's create a file named hello.txt and check its status. 'git status' - output

let's move the file to the Staging Area and take a snapshot (Commit).

Tracking History and Time Travel (Checkout)

Let's make a second file, hi.txt, commit it, and look at our project timeline.

Relative Shortcuts and Branching

Instead of copying long commit hashes every time, you can travel backward relatively using HEAD

1. git checkout HEAD~1 - Move back exactly 1 commit before the current one
2. Creating a New Branch git branch feat/python - Create a new branch named 'feat/python'
   git switch feat/python - Switch your active workspace to the new branch

Handling Secrets and Visualizing History

1. .env and .gitignore In real-world projects, we often handle configuration files like secret.env. These contain sensitive system environment variables (API keys, passwords) that should never be exposed online.
   To hide them from Git, we use a special file named .gitignore.

2. Visualizing the Git As branches grow, the timeline can get messy. You can display a beautiful, text-based visual graph of all your branches splitting and merging using this ultimate command
   

*, /, and |, acting like a roadmap for your project history.

• git log --all --graph --oneline

Pneumonia X-ray Binary Classification Model Development

• Period: Apr 29, 2026~ May 15, 2026
• Key Contributions & Experience

1. Baseline Construction & Transfer Learning:
   Established an initial training pipeline based on prior technical workflows. Selected ResNet18 as the standard benchmark model and successfully implemented transfer learning by adapting the Fully Connected (FC) layer for binary classification.
2. Data Pipeline Optimization: Applied structural image transformation and augmentation techniques tailored for thoracic radiography scans to improve feature representation.
   3. Hyperparameter Tuning: Configured the training to run for 50 epochs considering the limited dataset scale, gaining hands-on insight into computational bottlenecks and training time efficiency in deep learning models.
   4. Collaborative Peer Review: While executed as an individual project, actively engaged in technical discussions and brainstorming sessions with peers. Exchanged research directions, presented empirical hypotheses, and integrated constructive feedback to continuously pivot and refine the model's structural approach.

Main Pipeline Source Code

Try 1. ResNet18 == Baseline

my report (https://docs.google.com/document/d/1ziIdKBA0Pum8dKkn2q6UeUovgWPivUo-/edit?usp=sharing&ouid=108193830019374178715&rtpof=true&sd=true)

1. Git and GitHub

1. Git : A version control tool and program that operates locally on my computer. It acts as an engine to track and manage changes in the source code.
2. GitHub : A cloud-based web service where Git repositories are hosted. It serves as a collaboration platform, providing powerful features like Pull Requests, Issues, and Code Reviews.
   In Short, Git is the 'version control engine', while GitHub is the 'service for collaboration and sharing'

2. Core Keywords- Commit & Branch

1. Commit : A unit of record that saves changes as a specific version. It creates a snapshot of the code, and the key is to leave as clear message explaining 'what was changed and why'.
2. Branch : An independent, virtual workspace. IT allows you to develop new features safely without messing up the existing, stable. Multiple features can be developed simultaneously and merged back later.

3. Git's 3 Structural Areas

1. Working Directory : The actual project folder on my computer where I edit files.
2. Staging Area : A temporary "shopping cart" where files are gathered before making a snapshot. We use the 'git add' command here.
3. Repository : The secure 'vault' where the staged files are permanently saved with a label. We use the 'git commit' command here.

4. Branch Management Strategy

I also explored how professional teams structure and manage their branches effectively.

1. Main - The most stable version, always ready for production/ deployment.
2. Dev - The central integration branch where newly developed features are merged and tested.
3. Feature - Dedicated branches used to develop individual features independently.
4. Hotfix - Urgent branches created to quickly fix bugs found dirsctly in the productionmainenvironment.

5. Step by step Guide to Creating the Invitation Page

step 1. Initialize the Local Repositoty - init

Open the terminal-powershell- and initialize the project folder so Git can start tracking.

• command : git init -- this creates a hidden '.git'folder inside your directoty

  step 2. Create a File and First Commit - add , commit

  Open vs code, create the 'invitation.html'file, write the markup, and log the very first version.
• command : 'git add invitation.html'-stage the file , 'git commit -m "feat: invitation base"'-commit the file to the vault

  step 3. Feature Development & Merging - branch , merge

  keep the original codebase safe while experimenting with new styling or designs on a separate branch.

1. Create and switch to a design branch: 'git switch -c feat/design'
2. After editing, return to the main line with 'git switch main' and combine them via 'git merge feat/design'

• Key Check point : Since there were no divergent changes, Git performed a clean 'Fast-forward' merge, simply moving the main pointer forward.

  step 4. Connect to GitHub & Upload - remote , push

  Publish the local work to the cloud repository so it can be accessed globally.

1. link the remote repository : 'git remote add origin [my URL]'
2. push the code : 'git push -u origin main'

step 5. Web Deployment via GitHub Pages

1. Navigate to 'settings' > 'pages' within your GitHub repository.
2. Under the branch configuration, select 'main' and click 'save'.
3. After a brief moment, click the generated URL link to confirm your live invitation page works flawlessly across the globe.

1.Setting - MongoDB Atlas

2.Using with Colab

➀make Collection
➁put Document : insert_one, insert_many ➂search Data: find(), find_one()
➃Projection ➄sort() & limit()
➅Update: update_one(), update_many() ➆delete: delete_one()
➇delete Collection: drop
➀➁➂➃➄➅ temp_collection = db.temp_movies my_movie = { "title": "My Test Movie", "year": 2023, "genres": ["Action", "Comedy"] } result_one = temp_collection.insert_one(my_movies) display(movies.find_one({“title”:”The Great Train Robbery”)) my_movie_list=[{content},{content},{content}] result_many= temp_collection.insert_many(my_movies_list) for doc in temp_collection.find({content}): display(doc)

➃➄➅ for doc in movies.fine({content},{content}).sort(,-1).limit(5) display(doc) uqdate_result_one= \ temp_colletion.update_one( {content}, {content}) update_result_many= \ temp_collection.update_many( {content}, {content}) delete_result_one= temp_collection.delete_one({content}) temp_collection.drop()

3. Aggregation

Step . $match = WHERE

① $eq : = ② $gte: >= ③ $lte: <= ④ $gt: > ⑤ $lt: < ⑥$ne: != ⑦ $in: in ⑧ $nin: not in

Logical Operators

① $and ② $or ③ $nor

$goup

① $sum ② $avg ③ $min ④ $max

$project = SELECT

review

import pymysql conn = pymsql.connect( host = ‘ ’ user= ‘ ’ password= ‘ ’ db= ‘ ’ charset= utf8m64 cursorclass = pymysql.cursors.DictCursor ) cursor = conn.cursor()

2.JOIN + GROUP BY + ORDER BY + LIMIT

(EX) cur.execute(“”” SELECT d.first_name, COUNT(*) AS visits FROM appointments a JOIN doctors d ON a.doctor_id = d.doctor_id GROUP BY d.doctor_id ORDER BY visits DESC LIMIT 3 “””)

3.COMMIT() / ROLLBACK()

TRY ~ EXCEPT AS - ex - try: cur.execute( “UPDATE patient_info SET city=%s WHERE id=%s”, (‘Busan’, 2) ) conn.commit() print(‘정상 업데이트 -> commit 완료’) except Exception as e: conn.rollback() print(‘에러발생!! 롤백 실행’)

review

REVIEW INNER JOIN vs LEFT JOIN inner join: common data only left join: all from left + matches form right
WHERE diagnosis_name = ‘Diabetes’ or ‘Hypertension’ => WRONG WHERE diagnosis_name in ( ‘Diabetes’ or ‘Hypertension’ )
or WHERE diagnosis_name= ‘Diabetes’ or diagnosis_name= ‘Hypertension’
SQL- Execution Oder FROM → JOIN → WHERE → GROUP BY
When using aggregate functions like COUNT or MAX, we must include a GROUP BY clause to define the groups
UNION- ALL

SELECT patient_id AS id FROM patients WHERE patient_id <=10; UNION ALL -> 위의 환자 ID, 밑의 의사 아이디 합쳐서 결과 나옴 -> combine high content’s result and low content’s result SELECT doctor_id AS id FROM doctors WHERE doctor_id BETWEEN 10 AND 20;

EXISTS ( ) , NOT EXISTS ()

SELECT d.doctor_id, d.first_name, d.specialty from doctors d where exists( select 1 from admissions a where a.attending_doctor_id = d.doctor id ) select * from admissions where exists ( select 1 from patients p where p.allergies is not null and p.patient_id = a.patient_id );

Today class

1.SQL Basic process

Create , Read, Update, Delete Insert, Select, Update, Delete

2.DATABASE CREATE & DELETE

CREATE DATABASE db_name ; ⇨ USE db_name ; DROP DATABASE db_name;

3. TABLE CREATE & DELETE

   CREATE TABLE table_name( column1 datatype , column2 datatype) ; DROP table_name;

4. check or watch

   DESC table_name -> read a summery SHOW tables; -> table list SHOW CREATE TABLE table_name; -> check all SQL tables

5. Alter tables

   add column: ALTER TABLE (table_name) ADD (-) condition; del column: ALTER TABLE (table_name) DROP COLUMN (-); change column type: ALTER TABLE (table_name) MODIFY column Type; change column name: ALTER TABLE (table_name) CHANGE column condition; change basic value: ALTER TABLE (table_name) ALTER(value) SET DEFAULT(-); change table name: ALTER TABLE (table_name) RENAME TO (-);

6.INSERT

INSERT INTO table_name (column1, column2, column3 ….) VALUES (‘a1’,’a2’,’a3’.....)

7.UPDATE

UPDATE table_name SET column1 = value1, column2 = value2, column3=value3…… WHERE condition; –=> very important

8.DELETE

DELETE FROM table_name WHERE condition; 실무에서는 delete 대신 soft delete 사용

1. SQL
2. JOIN
3. GROUP BY / HAVING / LIMIT / Aggregation review

SQL

1.SELECT ⇾ Select an Search every or part of columns 2.WHERE ⇾ WHERE + condition ⇾ = > < between, in, like, is null, is not null 3.ORDER BY ⇾ ORDER BY column ASC( or DESC ) ⇾ It is rule that ‘ WHERE and then ORDER BY ‘

JOIN

1.one table cannot express medical data. 2.cannot connect patient and story without Join 3.how to use Join ⇾ INNER JOIN FROM table A INNER JOIN table B ON A.key=B.key ⇾ LEFT JOIN FROM table A LEFT JOIN table B ON A.key = B.key

GROUP BY, HAVING, LIMIT

GROUPBY SELECT * FROM table GROUP BY group_column GROUP BY Requirement: Match with non-aggregated SELECT columns. HAVING GROUP BY AND THEN HAVING HAVING condition LIMIT limit result numbers LIMIT num or LIMIT offset, num

Introduce Database

Basic of RDBMS

ERD Modeling

Basic SQL

Review

Data Preprocessing

first step : Data cleaning -Missing Values - NaN or None or Null second step : Basic Transformation

Data Preprocessing - isnull, notnull isnull : Null=> return True / isna == isnull notnull : Null=> return False / notna == notnull
Handling missing values - dropna() axis=0 del row , axis=1 del column subset=['column's name'] inplace = False, inplace= True
Filling missing values - fillna() fillna: constant imputation ffill: forward fill bfill: backward fill
Detecting Duplicate data - duplicated() Ture: duplicated data False: the first occurrence of the data, the original entry
delete duplicated row - drop_dulicates keep option

1. first : keep the first occurrence of the row(basic value)
2. last : keep the last occurrence of the row

Outliers

ex: bp 300/200, bst 700 Data Error -> drop, clinical extreme -> capping

Search Outliters to use IQR IQR < Q1-1.5IQR & IQR > Q3+1.5IQR Q1 = df.quantile(0.25) , Q3 = df.quantile(0.75) IQR = Q3-Q1
Problem about data types astype() - type casting pd.to_numeric() | pd.to_datetime()

EDA(Exploratory Data Analysis)

Stage 1: Overall Data Overview - Descriptive Statistics
Stage 2: Exploring Differences by Target - Group Analysis
Stage 3: Verifying the Authenticity of Differences - Statistical Hypothesis Testing
Stage 4: Identifying Relationships Between Variables - Correlation Analysis

Environment Setup

basic words

index : the range and data type of the index entries : the total number of rows in the dataset< data columns *: the total count and names of each individual column *non-null count : the number of actual data points, excluding missing values(=NaN) ** Dytpe : the data type of each column **Memory usage : the total amount of memory occupied by the DataFrame

Descriptive analysis - describe()

example

Numerical Data

• mean,median calculations are possible
  

1. Continuous Data - float type -distribution analysis -regression analysis -ex- -height=[156.2, 168.8, 180.1]
2. Discrete Data -int
   • can count data
   • frequency analysis
   • ex-
   • patient_counts=[10, 25, 15]

Categorical Data

• None calculable
• Frequency & Proportions

1. Ordinal Data - clear rank -clear logical order between categories -statistical metrics -ex- -pain_level =['none','normal','serious']
2. Nominal Data - no rank, just group

-no natural order -frequency analysis -ex- genders=['male','female','male']

satisfaction_scores = [1, 2, 3, 4, 5, 3, 4, 4, 5, 3] satifs_series = pd.Series(satisfaction) ## list -> pandas Series satifs_median = satifs_series.median() ## 중간값 median satifs_mode = satifs_series.mode() ## 최빈값 most frequent satifs_count = satifs_series.value_counts() ##빈도수 frequency

ext i don't like computer i don't like python i don't like math but i should make it😭 review rink

organized class structure to avoid repeating the same code when starting a child classs, put the parent class name in brackets super().init() overriding a parent class method by defining a function with the same name.
Method Overriding Redefining a parent's method in a child class to change its behavior
-ex- class MedicalStaff:  def init(self, name, department):     self.name = name     self.department = departmentdef    def introduce(self):      return f"hello. I'm {self.department} {self.name}"
class Doctor(MedicalStaff):    def init(self, specialty):      super. init(name,department)      self.specialty = specialty
    def introduce(self):       return f"hello. I'm {self.specailty}{self.name}"       • only change from department to specailty

File I/O is required

open() - Open the file, check the mode and decide what do we do basic: file = open('file name.txt', 'mode', encoding='utf-8') and file.close()     c'file close' is very important !!! w= write , r= read, a = add, r+ = read and write, utf-8 = korean Using with is safer than not using it.!  - ex - 😒 patient_file = open('patient_info.txt', 'w', encoding='utf-8') patient_file.write('patient info') patient_file.close() 😊 with open('patient_info.txt','w',encoding='utf-8') as file: file.write('patient info')

exception handling

try - except  - ex - try:   -> Error-prone code except:   ->Catch every error   print(' A error occurred') finally block: this code always runs without any errors   except ZeroDivisionError:# key = 0   print('height is bigger than zero')   except ValueError:# when enter str, instead of int   print('only enter numbers')   except Exception as e:# unexpected error   print(f"an error occured: {e}")   finally:   print('ending the bmi calculate')   print('record in the system log')
   more ~~## FileNotFoundError - no exist PermissionError - reject permission ValueError - value is wrong IsADirectoryError - try opening folder instead of file UnicodeDecodeError - read wrong encoding OSError - error about OS IOError - IN/OUT General error

my review file

lambda - sorted - key lambda x : x[] age, name = lambda x : (x[age],x[name])

day-6 + class

every method's first (vale) is 'self' returns a value back to the caller when the function ends.

my review link

this class was difficult...

Today, we covered defining and calling functions in our coding class. I found passing a list of dictionaries into a function particularly tricky. I solved three practice problems to help me understand it.

1. bools have only two values, T and F

> ex) patient_age = 25
> if patient_age == 18:
> print('he has become an adult')

> ex) is_emergency = False
> if is_emergency:
> print('It is an emergency')

> ex) blood_sugar = 180
> is_diabetes = blood_sugar >= 150
> print(is_diabetes)

2. Basic structure of conditional statements

-if the condition is true, the code executes. temp = 38.2 if temp >= 37.5: print('checked fever') else: print('no fever')

-if 'a' is false patient_age=16 if patient_age>=18: print('prescribe an adult's med') else:

print('prescribe a children's med')

3. Conditional Operators

비교 연산자 - ex) >, >=, <, <=, ==, != 포함 연산자 - ex) in , not in -> A in B : If 'B' contains 'A', That's true. -> A not in B : If 'B' does not contains 'A', That's true.

4. Logical Operators

and : If all conditions are true,That's true. or : If at least one condition is true, That's true not: Inverts the value

5. Ternary Operators

If - else -> result'A' if condition else result'B' -if condition is true, result'A' is returned -if condition is false, result'B' is returned