[Python] 파이썬 기초 문법

파이썬 (Python) : 소스 코드를 한 줄씩 읽는 인터프리터 언어 (Interpreter Language)

• 대화식 프로그래밍 (>>>) : 사용자가 입력하면 인터프리터가 바로 번역 및 처리 작업을 한 후 결과를 응답
• 블록 처리 규칙 : 괄호 ({}) 대신 들여쓰기 (Indentation)를 블럭 단위로 사용
  • : : 제어문이나 함수나 클래스의 이름의 끝을 표현
• 순수 객체 지향 : 변수, 클래스, 함수, 상수 등 모든 것을 객체로 취급

변수 (Variable) : 객체를 저장할 수 있는 메모리 공간

• 객체 (Object) : 어떠한 상태 (State)와 행동 (Behavior)을 가지고 있는 데이터
  • 객체의 상태는 속성값 (Value), 객체의 행동은 메소드 (Method)으로 메모리에 저장됨

>>> x = 100 # x는 100의 값을 가짐

• None : 변수에 아무런 값이 존재하지 않는 것을 표현

>>> y = None  # y는 어떤 값도 가지지 않음

연산자 (Operator) : 변수 및 특정한 값들에 대한 작업을 위해 사용되는 기호

• 산술 연산자 (Arithmetic~) : 더하기 (+), 빼기 (-), 곱하기 ( *), 나누기 (/), 나머지 (%), 제곱 (**), 몫 (//)
• 할당 연산자 (Assignment~) : 대입 (=), 산술하고 대입 (+=, -=, *=, /=, %=)
• 비교 연산자 (Comparison~) : 같음 (==), 같지 않음 (!=), 큼 (>), 크거나 같음 (>=), 작거나 같음 (<=), 작음 (<)
• 논리 연산자 (Logical~) : 모두 참 (and), 하나라도 참 (or), 결과와 반대로 (not)
• 식별 연산자 (Identity~) : 두 변수가 같은 객체 메모리이면 (is), 두 변수가 같은 객체 메모리가 아니면 (is not)
• 멤버 연산자 (Member~) : 객체 내에 해당 값이 포함되면 (in), 객체 내에 해당 값이 포함되지 않으면 (not in)
• 비트 연산자 (Bitwise~) : 비트 AND 연산 (&), 비트 OR 연산 (|)

자료형 (Data type) : 저장되는 데이터의 종류에 따른 변수의 형태

>>> type(1)
<class 'int'>                               # 수치) 정수

>>> type(3.14)
<class 'float'>                             # 수치) 실수

>>> type(1+2j)
<class 'complex'>                           # 수치) 복소수

>>> type('hello')
<class 'str'>                               # 문자열

>>> type(False)
<class 'bool'>                              # 부울

>>> type([1,2,3,4,5])
<class 'list'>                              # 리스트

>>> type((1,2,3,4,5))
<class 'tuple'>                             # 튜플

>>> type({1,2,3,4,5})
<class 'set'>                               # 집합

>>> type({1:10,2:20,3:30,4:40,5:50})
<class 'dict'>                              # 딕셔내리

수치 (Numbers) : 수학에서 사용하는 수를 표현하는 자료형

• 정수 (int) : 양수, 음수, 0 등의 정수를 표현
  • 파이썬은 메모리가 허용하는 범위에서 지원 가능한 수까지 지원
  • b, o, x : 2진수, 8진수, 16진수로 표현

num1 = 0
num2 = -1
num3 = 10 # 10진수의 10
num4 = 0b10 # 2진수의 10, 10진수로 표현하면 2
num5 = 0x10 # 16진수의 10, 10진수로 표현하면 16

• 실수 (float) : 유리수와 무리수 등의 실수를 표현
  • e : 10의 거듭제곱을 표현

num1 = 3.14 # 3.14로 출력
num2 = 3.14e2 # 314.0로 출력
num3 = 3.14e-3 # 0.00314로 출력

• 복소수 (complex) : 복소수를 표현 (실수부 + 허수부 (j) 로 구성)
  • .real : 복소수의 실수부를 실수형 상수로 표현
  • .imag : 복소수의 허수부를 실수형 상수로 표현
  • complex(x, y) : 복소수형 상수를 표현

num1 = 1+2j
num2 = num1.real # 1.0으로 표현
num3 = num2.imag # 2.0으로 표현
num4 = complex(1,2) # (1+2j)로 표현

부울 (bool) : 참 또는 거짓을 표현하는 자료형 (첫 글자는 대문자로 시작)

• True : 참을 표현 (1의 값을 가짐)
• False : 거짓을 표현 (0의 값을 가짐)

bool1 = True
bool2 = False

시퀀스 (Sequence) : 자료들이 순서를 가지고 나열되어 있는 자료형

인덱싱 (Indexing) : 인덱스에 해당하는 요소 하나를 취함

• 인덱스 (Index) : 위치를 가리키는 정수값 (0부터 시작)

data[0], data[1], data[2]

슬라이싱 (Slicing) : 자료에서 일정 범위에 해당하는 부분을 취함

data[1:2]
data[3:]
data[-1:]

print('hello'[::2]) # 홀수 번째 문자들만 추출한 문자열
print('hello'[::-1]) # 거꾸로 된 문자열 

연결 (+) : 두 개의 자료를 순서 있게 연결해 새로운 자료로 만듬

data = 'hello'[0] + 'hello'[4]

반복 (*) : 자료를 일정한 횟수로 반복해 새로운 자료로 만듬

data = [1, 2, 3, 4, 5] * 3 

data = 'hello' * 2

len : 자료를 구성하는 요소의 개수 / 길이 출력

data = len([1, 2, 3, 4, 5])

data = len('hello')

ìn: 자료에 값이 있는지 확인

data = 1 in data

data = 'e' in 'hello'

• 문자열 (str) : 한 글자 이상의 문자, 숫자, 기호를 표현

str1 = `hello`
str2 = "World"
str3 = """
hello World
"""
str4 = "hello 'World'"
str5 = 'hello "World"'

이스케이프 문자 : 키보드로 입력하기 어려운 기호를 나타내기 위한 문자

• \n : 줄바꿈
• \t : 탭
• \\ : \
• \' : '
• \" : "

• 리스트 (list) : 값을 변경할 수 있는 여러 개의 데이터를 하나의 변수로 표현

>>> li1 = [ 1, 'two', 3, 3, 'five' ]        # 리스트
>>> li2 = [  ]                              # 빈 리스트

• 튜플 (tuple) : 값을 변경할 수 없는 여러 개의 데이터를 하나의 변수로 표현

>>> tp1 = ( 1, 2, 3, 4, 4 )                 # 튜플
>>> tp2 = (  )                              # 빈 튜플

논시퀀스 (Non-Sequence) : 자료들이 순서를 가지지 않고 나열되어 있는 자료형

• 집합 (set) : 값을 변경할 수 있고 여러 개의 데이터를 중복되지 않게 하나의 변수로 표현하는 자료형

>>> st1 = { 1, 2, 3, 4, 5 }                 # 집합
>>> st2 = set()                             # 빈 집합

• 딕셔내리 (dict) : 서로 대응되고 중복되지 않는 키와 값으로 데이터를 표현하는 자로형

>>> dc1 = { 1:"one", 2:"two" }              # 딕셔내리
>>> dc2 = {}                                # 빈 딕셔내리

for i in range(10):
dc2[i] = str(i)

print(dc2) # {0: '0', 1: '1', 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7', 8: '8', 9: '9'}

제어문 (control flow) : 프로그램의 흐름을 지시하는 문장

• 조건문 if : 조건이 참인 경우에 실행할 문장을 지정해 수행
  • else : 조건이 거짓인 경우에 실행할 문장을 지정해 수행
  • elif : else if. 여러 개의 조건을 순차적으로 체크하기 위해 사용

if condition1:
    statement1
elif condition2:
    statement2
else:
    statement3

• 반복문 for : 반복할 블록을 특정한 범위를 지정해 반복해 수행
  • continue : 현재 반복중인 블록의 나머지 부분을 실행하지 않고 다음 반복문을 수행
  • break : 반복문을 수행하지 않고 블록 밖으로 탈출
  • else : 반복문이 모두 수행되었을 때 수행

range = [1,2,3,4,5,6,7,8,9]

for i in range:     
  print(i)

• 반복문 while : 반복할 블록을 특정한 조건을 지정하고, 조건이 참이면 반복해 수행
  • continue : 현재 반복중인 블록의 나머지 부분을 실행하지 않고 다음 반복문을 수행
  • break : 반복문을 수행하지 않고 블록 밖으로 탈출

while condition:
    if condition1:
        break
    if condition2:
        continue
    statement1
else:
    statement2

반복 가능한 (iterable) 데이터 : 문자열, 리스트, 튜플, 집합, 딕셔내리, 바이트

• __iter__ 메소드를 가지고 있음 : 반복자를 반환
  • 반복자 (iterator) : __next__ 메소드를 통해 컨테이너의 개별 요소를 반복

임포트 (import) : 모듈에 있는 함수들을 활용하기 위해 가져오는 것

모듈 (module) : 이미 만들어진 함수들을 하나의 파이썬 파일에 묶어둔 것

import mod

패키지 (package) : 모듈을 계층적인 디렉터리 형태로 구성한 것

• 디렉터리를 파이썬 패키지로 인식하려면 계층적으로 이루어져 있는 각 디렉토리마다 __init__.py 파일이 필요

pack 디렉토리에 mod.py와 __init__.py (내용 : version = 1.0)이 있는 구조

import pack.mod

import time # 파이썬 내장 모듈인 time 모듈 : time.sleep() 함수를 활용하기 위해 임포트

print('장비를 정지합니다.')
time.sleep(5)
print('안 되잖아?')
time.sleep(5)
print('어, 정..정지가 안 돼. 정지시킬 수가 없어.')

• from : 계층구조를 모두 표시하지 않고 패키지나 모듈의 함수 호출

from 모듈 import 함수
from 패키지 import 모듈

• as : 이름이 복잡하거나 계층구조가 복잡한 모듈에 이름을 붙어서 호출

import 모듈 as 별명

클래스 (class) : 객체지향 프로그래밍에서 특정 객체의 생성을 위해 변수와 메소드를 정의하는 공간 (namespace)

• 객체지향 프로그래밍 (OOP) : 프로그램을 객체 단위로 나누고 이들 간의 상호 작용으로 서술하는 방식
  • 객체 (object) : 하나의 역할을 수행하는 멤버 (변수와 메소드)의 집합
    • 변수 (variable) : 데이터를 저장하기 위해 할당된 메모리 공간
    • 메소드 (method) : 특정 작업을 수행하는 일련의 문장을 하나로 묶은 것

• 클래스 멤버 (class member) : 클래스에 정적으로 선언된 변수와 메소드
  • 클래스 내에서 변수와 메소드를 선언
• 인스턴스 멤버 (instance member) : 클래스에 동적으로 선언된 변수와 메소드
  • 클래스의 메소드 내에서 변수와 메소드를 선언

인스턴스 멤버는 클래스 멤버를 참조할 수 있지만, 클래스 멤버는 인스턴스 멤버를 참조할 수 없다.

• 클래스 멤버 : 클래스가 메모리에 로드될 때 생성
• 인스턴스 멤버 : 인스턴스가 생성될 때, 즉 클래스가 메모리에 로드된 이후에 생성

… 인스턴스가 생성될 때 클래스는 항상 메모리에 로드되어 있다. 그러나, 클래스의 생성이 인스턴스의 존재를 보장하지 않는다.

class myClass:
  def func(self, name): # 클래스 메소드는 첫번째 인자가 반드시 self이여야 함
    self.name = name
    print(name + ' : ' + var)

obj = myClass()
var = obj.var
obj.func(var) # '클래스 멤버 : 클래스 멤버' 출력

• 클래스 생성자 init : 클래스의 인스턴스 객체가 생성될 때 제일 먼저 호출되어 실행 (인스턴스 멤버 초기화)
• 클래스 소멸자 del : 클래스의 인스턴스 객체가 메모리에서 제거될 때 자동적으로 호출

class myClass:
  def __init__(self):
    self.var = '클래스 멤버'
    print('> myClass 클래스 시작') # '> myClass 클래스 시작' 출력

...

  def __del__(self):
    print('> myClass 클래스 종료') # '> myClass 클래스 종료' 출력

obj = myClass()
...
del obj

• 클래스 상속 (class inherit) : 부모 클래스가 가진 멤버나 메소드를 상속받는 자식 클래스가 사용할 수 있게 하는 것

class subClass (myClass):

함수 (function) : 소스 코드에서 일정한 동작을 수행하는 코드

• 사용자 정의 함수 def( parameter ) : 함수 이름과 인수로 함수 정의
  • 인자 (parameter) : 함수 호출 시 입력받을 값
    • 인자의 이름와 값을 넣어 호출할 수 있음 : 넣지 않으면 입력한 순서대로 배정
    • 인자는 기본값을 지정할 수 있음 : 기본값이 있는 인자는 기본값이 없는 인자 뒤에 와야 함
    • 가변 인자 : 개수를 정하지 않고 입력하는 값을 모두 인자로 사용 (* : 튜플로 저장, ** : 딕셔내리로 저장)
  • 반환값 (return value) : 반환문 return으로 반환할 값 정의
    • 반환문을 만날 경우, 해당 함수를 종료하고 반환값을 반환

# 사용자 정의 함수 선언
def function_name( p1 = 2, p2) :
    return p1

# 사용자 정의 함수 호출
>>> user_func = function_name( p1 = 3, p2 = 4 )

• 전역 변수 (global) : 코드 전반에 걸쳐 유효한 변수

def function():
  global param
  param = 23

• 내장 함수 (Built-in Functions) : 다른 파이썬 모듈의 임포트 없이 사용할 수 있는 함수

> dir(__builtins__) # 파이썬에서 사용할 수 있는 내장 함수를 확인

print() : 인자로 입력된 객체 값을 화면에 출력

• end="" : 출력되는 값 뒤에 추가될 값 지정 (기본값 : \n)

x = 100
print(x)
print(x, end = "") # 맨 뒤에 줄바꿈이 되지 않은 문장 출력

포맷 문자열 : 변하는 값을 포함하는 문자열을 표현하기 위해 사용되는 기호

• %s : 문자열에 대응
• %c : 문자나 기호 1개에 대응
• %d : 정수에 대응
• %f : 실수에 대응

input() : 키보드로 입력된 객체 값을 문자열로 반환

• 인수로 입력된 문자열은 화면에 출력

x = input('> 값을 입력하세요 : ')
print('입력된 값 : ' + x)

type() : 인자로 입력된 객체 값의 자료형을 반환

print(type(1))                           # <class 'int'>
print(type(3.14))                        # <class 'float'>
print(type(1+2j))                        # <class 'complex'>
print(type('hello'))                     # <class 'str'>
print(type(False))                       # <class 'bool'>
print(type([1,2,3,4,5]))                 # <class 'list'>
print(type((1,2,3,4,5)))                 # <class 'tuple'>
print(type({1,2,3,4,5}))                 # <class 'set'>
print(type({1:10,2:20,3:30,4:40,5:50}))  # <class 'dict'>

divmod() : 첫번째 정수 인자를 두번째 정수 인자로 나눈 결과 (몫, 나머지)를 튜플 형태로 반환

a = 11
b = 3
c, d = divmod(a, b) # c와 d에 3, 2 저장

hex()/bin()/int() : 10진수를 16진수로 / 10진수를 2진수로 / 2진수나 16진수를 10진수로 변환해 반황

b = 0b11110000; h = 0xf0
print(int(b)) # 240
print(int(h)) # 240
print(bin(int(b))) # 0b11110000
print(hex(int(h))) # 0xf0

abs() : 인자로 입력된 수치형 값의 절대값을 반환

print(abs(-3)) # 3 
print(abs(-3.14)) # 3.14

max()/min(): 인자로 입력된 시퀀스형 값의 최댓값 / 최솟값을 반환

print(max(pneumonoultramicroscopicsilicovolcanoconiosis)) # s
print(min(pneumonoultramicroscopicsilicovolcanoconiosis)) # p
print(max([1, -3, 2, 0, -5, 6])) # 6
print(min(1, -3, 2, 0, -5, 6)) # -5

round() : 인자로 입력된 수치형 값의 반올림한 값을 반환

print(round(3.14)) # 3

int()/float()/str() : 인자를 실수형 값으로 / 정수형 값으로 / 문자열로 변환

print(int(3.14)) # 3
print(float(i(3.14))) # 3.0
print(int('3')) # 오류
print(float('3.14')) # 오류
print(str(3.14)) # 3.14

filter() : 첫번째 인자인 함수에 두번째 인자인 반복 가능한 데이터의 값을 순서대로 넣어 참인 것만 리스트로 반환

def positive(x):
    return x > 0

print(list(filter(positive, [1, -3, 2, 0, -5, 6]))) # [1, 2, 6]

.count() : 문자열이나 리스트에서 인자로 입력된 특정 문자(열)의 개수를 반환

print('hello world'.count('l')) # 3
print('hello world'.count('he')) # 1
print('hello world'.count(' ')) # 1

.find() : 문자열에서 인자로 입력된 특정 문자(열)이 처음 나오는 위치를 나타내는 인덱스 반환

• 두번째 인자를 입력할 경우, 두번째 인자에 해당되는 인덱스부터 탐색

print('hello world'.find('l')) # 2
print('hello world'.find('he')) # 0
print('hello world'.find('l', 6)) # 9

.split() : 문자열을 인자로 입력된 문자(열)로 나눈 결과를 리스트로 반환

• 구분자 (separator)로 들어올 인자가 없으면, 공백을 기준으로 문자열을 나눔

print('http://naver.com'.split('/')) # 'http:', '/', '/', 'naver', '.com'
print('hello world'.split()) # 'hello', 'world'

.join() : 인자로 입력된 리스트의 모든 요소를 연결된 문자열을 반환

print('/'.join(['2022', '12', '25'])) # 2022/12/25

replace() : 문자열에서 인자로 입력된 특정 문자(열)을 다른 문자(열)로 바꾼 문자열을 반환

print('hello world'.replace('l', 'L') # heLLo worLd

sorted() : 인자로 입력된 문자열이나 리스트, 딕셔내리의 요소를 오름차순으로 정렬한 리스트를 반환

• reverse = true : 문자를 내림차순으로 정렬

print(sorted(input())) # 입력된 문자열을 오름차순으로 정렬
print(sorted(input(), reverse = true)) # 입력된 문자열을 오름차순으로 정렬

• key = : 딕셔내리의 특정 기준을 바탕으로 오름차순으로 정렬

dc2 = {}
for i in range(10):
  for j in range(10, 0):
    dc2[i] = str(j)

def f1(x):
  return x[0]

def f2(x):
  return x[1]

ret_dc2 = sorted(dc2.items(), key = f1 | f2) # key | value를 기준으로 정렬

range() : 인자로 범위를 지정해 순차적인 정수 리스트를 반환

• 인자가 1개 : 0부터 (인자 - 1)까지 순차적인 정수 리스트
• 인자가 2개 : (첫번째 인자)부터 (두번째 인자 - 1)까지 순차적인 정수 리스트

print(range(10))
print(range(10, 20))

.reverse()/reversed() : 인자로 입력된 리스트를 거꾸로 함 / 거꾸로 한 리스트를 반환

listData = list(range(5))
listData.reverse()

print(listData) # 4,3,2,1,0
print(reversed.(listData)) # 0,1,2,3,4

append() : 인자로 입력된 값을 리스트의 맨 마지막 요소로 추가

listData = list(range(5))
listData.append(7)

print(listData) # 0,1,2,3,4,7

insert() : 리스트의 첫번째 인자의 인덱스에 해당되는 위치에 두번째 인자로 입력된 값을 삽입

listData = ['0', '1', '2', '3', '4']

listData.insert(2, '7')
print(listData)  # 0,1,7,2,3,4

remove()/del() : 리스트나 딕셔내리의 특정 요소를 / 인덱스가 인자인 요소를 삭제

listData = ['0', '1', '2', '3', '4']

listData.remove('1')
print(listData) # 0,2,3,4

del listData[3]
print(listData) # 0,2,3

sum() : 임의의 정수가 요소인 리스트에서 모든 요소의 합을 반환

print(sum(list(range(5))))

clear() : 딕셔내리의 모든 요소를 제거한 빈 딕셔내리로 바꿈

dc2 = {}
or i in range(10):
dc2[i] = str(i)

dc2.clear()

print(dc2) # {}

keys()/values()/items() : 딕셔내리의 키 / 값 / 모두를 추출해 반환

• list()로 변환하지 않으면 print()에 넣으면 dict_keys([...]), dict_values([...]) dict_items([...])로 출력

dc2 = {}
or i in range(10):
dc2[i] = str(i)

print(list(dc2.keys()))
print(list(dc2.values()))
print(list(dc2.items()))

all()/any() : 리스트의 모든 요소가 True이면 False / False면 True

listData = [False, False, True, True]
print(all(listData))
print(any(listData))
print(all(listData[::2]))
print(any(listData[::2]))

lambda : 함수 이름 없이 한줄로 함수를 정의

f = lambda x: x * x
print(f(8)) # 64

f = lambda x, y: x + y
print(f(8,9)) # 17

map() : 인자를 바꾸어 함수를 반복해 호출한 결과를 나열

f = lambda x: x * x
args = [1,2,3,4,5]
ret = map(f, args)
print(list(ret))

파일 입출력 (file input & output) : 텍스트나 바이너리 파일을 읽고 쓰는 것

• open : 파일 열기 (파일이 없는 경우 생성)
  • r, rt : 읽기 모드 (파일을 읽을 때 사용)
  • w, wt : 쓰기 모드 (파일을 편집할 때 사용)
  • a, at : 추가 모드 (파일의 마지막에 내용을 추가할 때 사용)

파일이 해당 디렉토리에 존재하지 않는 경우, 새로운 파일이 생성됨

파일 객체 = open(파일 이름, 모드)

f1 = open("readme1.txt", 'r')
f2 = open("readme2.txt", 'w')
f3 = open("readme3.txt", 'a')

• .read()/.readline()/.readlines() : 파일을 모두 문자열로 / 한줄씩 문자열로 / 한줄을 요소로 한 리스트로 읽기

f = open("readme.txt", 'r')
data1 = f.read()
data2 = f.readline()
data3 = f.readlines()

• .write()/.writelines() : 파일에 입력받은 인자를 전부 / 한줄씩 쓰기

f = open("readme.txt", 'w')
data1 = '> 다음은 입력된 값입니다.'
data2 = input('> 파일에 입력할 값 : ')
f.write(data1 + data2)

• .close : 열려 있는 파일을 닫기

f.close()

• with ~ as : 파일을 열고 파일에 대한 처리가 끝나면 자동으로 파일을 닫음

with open('readme.txt', 'w') as f:
  ...