PYTHON 기초 정리

파이썬기초를 한 포스팅으로 정리하였습니다. 간단한 예제를 열심히 만들어서 따라 해보도록 블로그에 게시할 예정입니다. 예제로 배워보는 게 최선이라 생각합니다. 

 

PYTHON 자료형

 

1. Numbers (int, float, complex)
2. Strings
3. Lists
4. Tuples
5. Dictionaries
6. Sets
7. Boolean
8. None

 

변수선언 시 제약사항

1 변수 이름은 문자 또는 밑줄(_)로 시작해야 하며 문자, 숫자 및 밑줄만 포함할 수 있다. Python 키워드가 될 수 없다.

2. 파이썬은 스네이크_케이스라는 명명 규칙을 가지고 있는데, 이는 변수가 소문자로 작성되어야 하고 단어는 `_'로 구분되어야 한다.  `age_of_person`

3. 루프 변수 및 임시 변수를 제외한 단일 문자(i, a, b, c)는 변수 이름으로 사용하지 않는다.

4. 변수 이름에는 !, @, #, $, % 등의 특수 문자를 사용하지 않는다.

5. 변수 이름에 공백을 사용하지 말고, 대신 `_`을 사용하여 단어를 구분한다.

6. 내장 함수 이름을 변수 이름으로 사용하지 않는다.(예: 'str', 'int' 등).

 

주석 달기

1. 싱글라인 주석 : # 이후 한 줄 

2. 멀티라인 주석 : ''' or """을 사용하여 여러 줄 주석을 달 수 있다

'''

멀티라인 1

멀티라인 2

멀티라인 3

'''

 

코딩 블록 구분(:)과 들여쓰기(공백 4문자)

자바스크립트나 자바는 구문의 블록은 중괄호로 {} 쌍으로 구분한다.

그러나 파이썬은 공백으로  들여쓰기를 하고 라인을 맞춰야 한다. 주로 이 라인 맞추기가 문제가 발생하여 오류가 발생하는 경우가 있다.  indentationError: unexpected indent등의 오류가 발생.

코딩 블록을 시작하는 문장은 콜론(:) 을 사용하고 내부의 코딩 블록은 보통 4개의 공백을 사용한다.

 

for person in people:
    print(person["name"])

if is_running:
    print("The program is running")
else:
    print("The program is not running")

 

변수선언

파이썬의 변수타입은 입력한 값에 의존하여 초기 설정된다.

x = 6
name = "John Doe"
is_student = True

y = x + 2  # y is now 8
z = x * 3  # z is now 18

print("The value of x is:", x)  # The value of x is: 6

 

실수형 변수 사용예

x = 3.14
y = -0.5

z = x + y  # z is now 2.64
result = x * y  # result is now -1.57

a = float(5) # a is now 5.0
b = float("3.14") # b is now 3.14

c = 3.0
print(c.is_integer()) # True
d = 3.5
print(d.is_integer()) # False

정수형 변수에 문자열할당 시 오류가 나며 변환해야 한다.

 

x = 5
x = "hello" # TypeError: cannot assign 'str' to 'int'

x = int("5") # x is now 5

x = int("hello") # ValueError: invalid literal for int() with base 10: 'hello'

숫자로 변환가능한 문자열의 경우에만 형변환 후 대입할 수 있다.

 

불린 변수 사용

x = 5
y = 10

result = (x > 0) and (y < 20) # True
result2 = (x > 0) or (y < 5) # True
result3 = not (x > 0) # False


result = x == y # False
result2 = x != y # True
result3 = x > y # False
result4 = x >= y # False

is_running = True
is_sleeping = False

if is_running:
    print("The program is running")
else:
    print("The program is not running")

 

list 자료형 선언 및 예제

배열은 list() 똔 [] 로 선언하며 배열의 인덱스를 사용하여 배열 데이터에 접근한다.

list 자료형에는 일반 변수 뿐만아니라 dictionary 타입이나 객체타입을 쌓아놓을 수 있다.

numbers = [1, 2, 3, 4, 5]
words = ["apple", "banana", "cherry"]
mixed = [1, "hello", 3.14]

# [인덱스번호]로 값을 가져온다.
print(numbers[0]) # 1
print(words[1]) # "banana"

# append() method로 값을 추가
numbers.append(6)
words.append("date")


# insert() method로 특정위치에 삽입
numbers.insert(2, 7)
words.insert(1, "orange")

# remove() method or del 문으로 제거
numbers.remove(2)
del words[2]

# len(list)로 리스트 사이즈 구한다.
print(len(numbers)) # 5
print(len(words)) # 3

# sorted() function으로 가나다순으로 정렬
sorted_numbers = sorted(numbers)
sorted_words = sorted(words)

# *로 list를 몇배로 늘린다.
repeated_numbers = numbers * 3
repeated_words = words * 2

# + 연산자로 두개의 배열을 더한다.
concatenated_list = numbers + words

# [0부터 시작 인덱스:1부터 시작 가져올 위치]로 특정위치를 잘라낼 수 있다.
print(numbers[1:3]) # [2, 7]
print(words[0:2]) # ["apple", "orange"]

 

dictionary 자료형 및 사용 예

자바 해시맵처럼 키:값의 구조이며 자료형에 핵심사항이다.

보통 list에  dictionary를 집어넣어서 자료구조를 관리한다.

그러므로  list에서 dictionary를 집어넣고 끄집어내는 부분을 명확하게 이해해야 한다.

person = {"name": "John", "age": 30, "city": "New York"}

print(person["name"]) # "John"
print(person["age"]) # 30
person["gender"] = "male"
person["age"] = 35
del person["city"]
print(len(person)) # 3
print(person.keys()) # ["name", "age", "gender"]
print(person.values()) # ["John", 35, "male"]
print(person.items()) # [("name", "John"), ("age", 35), ("gender", "male")]

dictionary형은 고유한 키를 사용하여 데이터를 신속하게 저장하고 검색해야 할 때 유용하다. 예를 들어, dictionary을 사용하여 학생 정보를 저장할 수 있습니다. 여기서 각 키는 학생 ID이고 각 값은 학생의 이름, 나이 및 성적이 포함된 자료구조이다.

 

빈 딕셔너리에 키추가 및 할당

empty_dict = {}
empty_dict["name"] = "Jane Doe"
empty_dict["phone"] = "555-555-5555"

# or
empty_dict.update({"name": "John Doe"})
empty_dict.update({"phone": "555-555-5555"})

print(empty_dict)

{'name': 'Jane Doe', 'phone': '"555-555-5555'}

 

list 자료형에 dictionary 자료를 집어넣어 사용한 예

절반이상의 자료처리는 list 자료형에는 dictionary 타입을 집어넣어 사용하는 형태로 자료구조를 만들어 사용하는 방법으로 간단히 해결할 수 있다.

person1 = {"name": "John", "age": 30, "city": "New York"}
person2 = {"name": "Jane", "age": 25, "city": "San Francisco"}
people = []
people.append(person1)
people.append(person2)

people = people + [{"name": "Bob", "age": 35, "city": "Los Angeles"}]

people[1]["age"] = 28

del people[0]
people.remove(person2)

for i in range(len(people)):
    print(people[i])

print(people)
print(len(people))

for person in people:
    print(person["name"])

 

if 조건문

if: .. elif: .. else: 구문을 따른다.

x = 5
if x > 0:
    print("x is positive")
elif x == 0:
    print("x is zero")
else:
    print("x is negative")

x = "hello"
if x == "hello":
    print("x is 'hello'")
elif x == "goodbye":
    print("x is 'goodbye'")
else:
    print("x is something else")

 

in 을 사용하여 포함여부도 판단 할 수 있다.

x = ["apple", "banana", "cherry"]
if "apple" in x:
    print("apple is in the list")

 

switch 조건문

파이썬은 switch문이 별도로 존재하지 않는다. if 문으로 대체한다.

x = "apple"

if x == "apple":
    print("x is an apple")
elif x == "banana":
    print("x is a banana")
elif x == "cherry":
    print("x is a cherry")
else:
    print("x is something else")

x = 5

if x == 1:
    print("x is one")
elif x == 2:
    print("x is two")
elif x == 3:
    print("x is three")
elif x == 4:
    print("x is four")
elif x == 5:
    print("x is five")
else:
    print("x is something else")

 

for 반복문

list자료형 반복처리

my_list = [1, 2, 3, 4, 5]

for item in my_list:
    print(item)

for i in range(5):
    print(i)

1
2
3
4
5

 

break 문 사용한 for 반복문

break문은 조건이 맞으면 반복루프에서 탈출하는 것으로 오류회피, 제약조건을 걸어서 반복시킬 때 사용

my_list = [1, 2, 3, 4, 5]

for item in my_list:
    if item == 3:
        break
    print(item)

1
2

 

continue 문 사용한 for 반복문

continue문은 조건이 맞으면 하위 코드는 패스하고 다음 루프로 계속하는 것으로 조건에 해당되는 코드만 실행할 경우 사용

my_list = [1, 2, 3, 4, 5]

for item in my_list:
    if item == 3:
        continue
    print(item)

1
2
4
5

 

while 반복문

조건이 참일 경우에 실행되며 break, continue문과 같이 사용될 수 있다.

my_list = [1, 2, 3, 4, 5]
i = 0
while i < len(my_list):
    if my_list[i] == 3:
        break
    print(my_list[i])
    i += 1

1
2

 

dictionary 객체 사용 시 반복문

in문을 주로 사용하여 키와 값을 끄집어 내어 반복 처리한다.

my_dict = {"a": 1, "b": 2, "c": 3}

for key, value in my_dict.items():
    print(key, value)

a 1
b 2
c 3

 

함수 선언

det 함수명(): 형식으로 함수블록을 만들어 선언

def my_function(my_var):
    print("My variable is:", my_var)

my_function("Hello World")

My variable is: Hello World

 

기본값을 인자로 받는 함수 선언

함수 선언 시 인자에 = "값"으로 기본값을 집어넣을 수 있다.

def my_function(my_var, my_default = "default value"):
    print("My variable is:", my_var)
    print("My default variable is:", my_default)

my_function("Hello World")

def my_function(my_var, my_default = "default value"):
    print("My variable is:", my_var)
    print("My default variable is:", my_default)

my_function("Hello World")

 

다중 인자(*)를 한 번에 받는 함수

def my_function(*my_args):
    for arg in my_args:
        print(arg)

my_function("Hello", "World", "!")

Hello
World
!

 

키:값을 다중 인자(**)로 받는 함수

def my_function(**my_kwargs):
    for key, value in my_kwargs.items():
        print(key, ":", value)

my_function(first_name="John", last_name="Doe")

first_name : John
last_name : Doe

 

에러 핸들링 (try ~ except ~ finally)

try:
    # code that might raise an exception
except ExceptionType:
    # code to handle the exception

try:
    x = 5 / 0
except ZeroDivisionError:
    print("You can't divide by zero!")

try:
    x = 5 / 0
except ZeroDivisionError:
    print("You can't divide by zero!")
finally:
    print("This code will always be executed.")

 

클래스 선언

`class 클래스명:` 구문으로 클래스 블록을 만들어 선언

class MyClass:
    def __init__(self, my_var):
        self.my_var = my_var
    
    def my_method(self):
        print("My variable is:", self.my_var)

my_object = MyClass("Hello World")
my_object.my_method()

My variable is: Hello World

 

클래스 상속 후 함수 재선언

`class 클래스명(부모클래스명):` 구문으로 부모클래스를 상속받고 클래스 블록을 만들어 선언

class MyParentClass:
    def __init__(self, my_var):
        self.my_var = my_var
    
    def my_method(self):
        print("My variable is:", self.my_var)

class MyChildClass(MyParentClass):
    def my_method(self):
        print("My child variable is:", self.my_var)

my_object = MyChildClass("Hello World")
my_object.my_method()

My child variable is: Hello World

 

super() 함수

- 자식 클래스에서 부모 클래스의 함수를 호출할 때 사용

class MyParentClass:
    def __init__(self, my_var):
        self.my_var = my_var
    
    def my_method(self):
        print("My variable is:", self.my_var)

class MyChildClass(MyParentClass):
    def my_method(self):
        super().my_method()
        print("I am from child class")

my_object = MyChildClass("Hello World")
my_object.my_method()

My variable is: Hello World
I am from child class

 

예제

1부터 10까지 더하기

total = 0
for i in range(1, 11):
    total += i
print(total)

total = 0
i = 1
while i <= 10:
    total += i
    i += 1
print(total)

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(sum(numbers))

 

1부터 무한대까지 더하다가 100,000이 넘으면 빠져나오고, 그 시점까지 진행된 순차번호

sum = 0
i = 1
while True:
    sum += i
    if sum > 1000000:
        break
    i += 1
print(i-1)

 

가위바위보 게임

import random

# 옵션목록
options = ["바위", "보", "가위"]

while True:
    # 사용자로 부터 가위, 바위, 보 중에 입력받는다.
    user_choice = input("바위, 보, or 가위? ").lower()

    # 사용자 선택 유효성 체크
    if user_choice not in options:
        print("가위 바위 보 중에 입력하세요.")
        continue

    # 컴퓨터 선택
    computer_choice = random.choice(options)

    # 승자를 결정한다
    if user_choice == computer_choice:
        print("Tie!")
    elif user_choice == "바위" and computer_choice == "가위":
        print("You win!")
    elif user_choice == "보" and computer_choice == "바위":
        print("You win!")
    elif user_choice == "가위" and computer_choice == "보":
        print("You win!")
    else:
        print("You lose!")

    # 게임을 계속할 지 묻는다.
    play_again = input("게임을 계속하시겠습니까? (y/n) ").lower()
    if play_again != "y":
        break

 

csv파일 읽기

import csv

with open('sample.csv', 'r') as file:
    reader = csv.reader(file)
    for row in reader:
        column1 = row[0]
        column2 = row[1]
        column3 = row[2]
        print(column1, column2, column3)

 

csv파일 읽은 뒤 다른 csv파일에 특정 위치만 뽑아서 저장

import csv

# Open the input file in read mode
with open('sample.csv', 'r') as file:
    # Create a CSV reader object
    reader = csv.reader(file)
    # Get the header row
    header = next(reader)
    # Create a new list to store the filtered data
    filtered_data = []
    # Iterate over the rows in the input file
    for row in reader:
        filtered_data.append([row[0]]) # Append only the "id" column to the filtered_data list

# Open the output file in write mode
with open('filter.csv', 'w', newline='') as file:
    # Create a CSV writer object
    writer = csv.writer(file)
    # Write the header row to the output file
    writer.writerow(["id"])
    # Write the filtered data to the output file
    writer.writerows(filtered_data)

 

판다스로 읽어서 특정  칼럼만 뽑아 다른 파일로 저장

import pandas as pd

# read the csv file
df = pd.read_csv('sample.csv')
# filter the dataframe
df = df[['id']]
# write the filtered data to filter.csv
df.to_csv('filter.csv', index=False)

 

json 포맷으로 저장된 파일을 list & dictionary로 읽어오기

import json

# Open the json file
with open("sample.json", "r") as file:
    # Load the json data
    json_data = json.load(file)

# Iterate through the json array
for item in json_data:
    # Print the item (which is a dictionary)
    print(item)

 

postgresql > usedb > employees 테이블로 부터 CRUD구현

import psycopg2

# Connect to the database
conn = psycopg2.connect(
    host="127.0.0.1",
    port=5432,
    dbname="userdb",
    user="your_username",
    password="your_password"
)

# Create a cursor object
cur = conn.cursor()

# Execute a SELECT statement
cur.execute("SELECT * FROM test.employees")

# Fetch all the rows from the SELECT statement
rows = cur.fetchall()

# Print the rows
for row in rows:
    print(row)

# Close the cursor and connection
cur.close()
conn.close()


cur.execute("INSERT INTO test.employees (id, name, telephone, email) VALUES (1, 'John Smith', '555-555-5555', 'john.smith@example.com')")
conn.commit()

cur.execute("SELECT * FROM test.employees")
rows = cur.fetchall()

cur.execute("UPDATE test.employees SET telephone='555-555-5555' WHERE id=1")
conn.commit()

cur.execute("DELETE FROM test.employees WHERE id=1")
conn.commit()

 

employees테이블에서 name, email만 출력하는 예제

import psycopg2

# Connect to the database
conn = psycopg2.connect(
    host="127.0.0.1",
    port="5432",
    dbname="userdb",
    user="your_username",
    password="your_password"
)

# Create a cursor object
cur = conn.cursor()

# Execute the SELECT query
cur.execute("SELECT name, email FROM test.employees")

# Fetch all rows
rows = cur.fetchall()

# Iterate through the rows
for row in rows:
    # Create a dictionary with keys "name" and "email"
    employee = {"name": row[0], "email": row[1]}
    print(employee)

# Close the cursor and connection
cur.close()
conn.close()

 

네이버에서 대전지역 날씨를 가져오는 크롤링 샘플

- BeautifulSoup을 사용해 DOM 셀렉팅 및 파싱

import requests
from bs4 import BeautifulSoup

url = 'https://search.naver.com/search.naver?query=대전+날씨'

response = requests.get(url)

soup = BeautifulSoup(response.text, 'html.parser')

weather_info = soup.select_one('.info_data .info_temperature .temp').text

print(weather_info)

 

FASTAPI로 postgresql > usedb > employees 테이블로 부터 CRUD구현

from fastapi import FastAPI
from psycopg2 import pool

app = FastAPI()

connection_pool = pool.SimpleConnectionPool(
    1, #minconn
    20, #maxconn
    host="127.0.0.1",
    port=5432,
    user="your_username",
    password="your_password",
    database="userdb"
)

@app.get("/employees")
async def list_employees():
    connection = connection_pool.getconn()
    cursor = connection.cursor()
    cursor.execute("SELECT * FROM test.employees")
    result = cursor.fetchall()
    connection_pool.putconn(connection)
    return result


@app.post("/employees")
async def add_employee(employee: dict):
    connection = connection_pool.getconn()
    cursor = connection.cursor()
    cursor.execute("INSERT INTO test.employees (name, email, phone) VALUES (%s, %s, %s)", (employee["name"], employee["email"], employee["phone"]))
    connection.commit()
    connection_pool.putconn(connection)
    return {"status": "success"}
    

@app.delete("/employees/{id}")
async def delete_employee(id: int):
    connection = connection_pool.getconn()
    cursor = connection.cursor()
    cursor.execute("DELETE FROM test.employees WHERE id = %s", (id,))
    connection.commit()
    connection_pool.putconn(connection)
    return {"status": "success"}

@app.put("/employees/{id}")
async def update_employee(id: int, employee: dict):
    connection = connection_pool.getconn()
    cursor = connection.cursor()
    cursor.execute("

 

세션 생성 및 파기

from fastapi import FastAPI, SessionMiddleware
from fastapi.security import HTTPBasic, HTTPBasicCredentials

app = FastAPI()

app.add_middleware(SessionMiddleware, secret_key="secret_key")
security = HTTPBasic()

@app.post("/login")
async def login(credentials: HTTPBasicCredentials, session: dict):
    if credentials.username != "test" or credentials.password != "test":
        raise HTTPException(status_code=400, detail="Incorrect username or password")
    session["username"] = credentials.username

@app.get("/")
async def read_root(session: dict):
    username = session.get("username")
    if not username:
        raise HTTPException(status_code=401, detail="Not authorized")
    return {"Hello": username}

@app.post("/logout")
async def logout(session: dict):
    session.clear()