[파이썬(Python3)] 파이썬 기초 정리

요새는 자바위주로 공부를 하고있는데 파이썬도 까먹지 않기 위해서 정리중이다.

Python Overview

파이썬은 타입을 선언 할 필요가 없다. 동적 타입 언어(Dynamically Typed Language) 이다.
들여쓰기로 블록을 구분한다.
메모리를 자동으로 관리해준다.
객체 지향 프로그래밍과 구조적 프로그래밍 모두 지원한다.

내장 데이터 타입

타입설명예시
intinteger number 정수-5, 0, 10, 155
floatfloating point number 실수1.0, 0.05, 3.1415, -11.1
strstring 스트링 (문자열)‘Clazitive’, ‘peter’
boollogical value 논리형True, False
lista set of ordered elements 리스트[1, 2, ‘John’, 4]
tuplesimilar to the list but immutable 튜플(1, True, 3, 4)
seta collection of unordered elements 셋 (집합){1, 2, 3}
dicta set of unordered key-value pairs 딕셔너리{‘a’:1, ‘b’:2, ‘c’:3}

열거형 데이터 타입

리스트, 튜플, 스트링 등

열거형 데이터 타입의 연산

Operation결과예시
x in ss의 요소가 x와 같으면 True, 다르면 False를 반환한다.‘b’ in ‘abc’
-> True
x not in ss의 요소가 x와 다르면 True, 같으면 False를 반환한다.5 not in [2, 3, 7]
-> True
s+ts와 t를 잇는다.(1,2,3) + (4,5,6)
-> (1, 2, 3, 4, 5, 6)
s * n (or n * s)s 자신을 n번 더한 것 과 동일하다.‘a’ * 3
-> ‘aaa’
s[i]s의 i 번째 요소s = [1,2,3]
s[2]
->3
s[i:j]s의 i 에서 j까지의 일부분s = (1,2,3,4,5)
s[1:3]
-> (2,3)
s[i:j:k]s의 i 에서 j까지 일부분을 k간격으로 s = ‘abcdefg’ s[1:5:2]
-> ‘bd’
len(s)s의 길이s = [1, 5, ‘abc’] len(s)
-> 3
min(s)s의 가장 작은 요소s = (5, 14, 3, 8, 9) min(s)
-> 3
max(s)s의 가장 큰 요소s = ‘python’
max(s)
->‘y’
s.index(x[,i[, j]])s에서 처음 발견된 x의 인덱스 번호( 인덱스 i 와 인덱스 j 사이)s = [1,3,5,7,9] s.index(7)
-> 3
s.count(x)s에서 x의 전체 등장횟수s = (1,6,3,1,’ab’) s.count(1)
-> 2

연산자

+ – / * % in < <= > >= == != or and & | not

a +=b 는 a= a+b 와 동일, a/= b 는 a= a/b 와 동일
%는 나눈 나머지 값을 반환한다. 3 % 2 -> 1
> < >= <= 좌변과 우변의 크기를 비교하는 연산자
논리 연산자 or and & | not

주석

파이썬에서 주석을 작성하는 방법에는 두 가지가 있다.
#을 이용해서 # 이후의 문장을 주석처리하면 해당 부분은 실행되지 않는다.
“”” 큰따옴표 세개 “”” 로 묶어서 여러 줄을 주석처리 할 수 있다.
큰 따옴표 3개로 둘러싸인 코드는 실행되지 않는다.

test= """ heirfsjdflkdsamndalsnc.lzx,nclasnjdk;laxmc;xzlm;lasd

amklsfmlsk"""
#주석처리 실행되지 않는 부분
#print('hi')

"""여기서부터 
print("hello")
print(test)
여기까지는 실행되지 않는다."""
print(test) #여기만 실행된다

-> heirfsjdflkdsamndalsnc.lzx,nclasnjdk;laxmc;xzlm;lasd

amklsfmlsk


주의! 긴 문자열을 저장할 때 큰따옴표 3개로 사용하는 경우도 있다.

Print() 함수

Print 말 그대로 화면에 출력하는 함수이다. () 안에 미리 선언한 변수를 넣을 수도 있고, 문자열을 넣어서 출력할 수도 있다. 값을 반환하는 함수를 넣을 수도 있다.

a=3
print("hi")
print(a)
print("I'm" + " clazitive")
print("nice", "to", "meet","you", end=" ")
print("nice", "to", "meet","you", sep="+")
->hi
->3
->I'm clazitive
->nice to meet you nice+to+meet+you

print함수를 사용할때 end 인자를 같이 넣어주면 print()함수를 실행한 마지막 효과를 변경할 수 있다. 입력하지 않으면 기본적으로 줄을 바꾼다.
sep 인자도 있는데, 컴마로 결합된 문장을 다르게 연결할 수 있다. 입력하지 않으면 기본적으로 공백을 이용해서 결합한다.

반복문

for 문과 while 문이 있다.

for문
for 변수 in 리스트(또는 튜플, 문자열):
    '''실행할 코드'''

주의할 점은 들여쓰기로 블록을 구분하기 때문에 for 다음 줄은 들여쓰기를 해주어야한다.
들여쓰기가 끝나는 부분이 for 블럭이 끝나는 부분이다.

대개 for문은 range함수와 쓰이는 경우가 많다.
range(5)는 0부터 5 미만의 숫자를 포함하는 range 객체를 만들어 준다.

for i in range(5):
    print(i, end=" ")

위와 같은 코드를 실행시키면

0 1 2 3 4
가 출력된다.
어떤 작업을 n 번 반복하고 싶으면 아래와 같이 진행하면 된다.

for i in range(n):
    do_something()

리스트를 for문으로 출력하는 경우가 많다.

fruits = ['apple', 'pineapple', 'banana', 'grape']
for fruit in fruits:
    print(fruit, end=" ")
print()
for item in fruits:
    print(item, end=" ")
->apple pineapple Banana grape 
->apple pineapple Banana grape 

fruits 는 문자열을 담고 있는 리스트이다. for fruit 이라고 할 수도 있고 for item 이라고 할 수 있다.
for 다음 반복문안에서 사용할 변수 이름은 마음대로 정할 수 있다.
위의 코드처럼 fruit을 해도 괜찮고 item, i라고 해도 상관없다.
다만 코드를 이해하기 쉽게 만드려면 의미있게 변수명을 잘 짓는게 중요하다.

while문
while (조건식):
    '''반복할 코드'''

while문은 조건식을 만족하는 동안 아래 코드를 계속 반복한다.
while문을 사용하는 방식은 크게 두가지가 있다.

#while 내부에서 조건식을 업데이트 하는 경우
index = 0
while (index <10):
    '''do something'''
    index = index+1
#while 문 안에서 조건을 체크해서 while문을 빠져나오는 경우
while True:
    '''do something'''
    if(조건식): # 조건을 만족하는 경우
        break

여기서 break은 반복문을 중단시키는 코드이다. 그렇기 때문에 for문과 while문 모두 사용가능하다.

조건문

if, else, elif 가 존재한다.

a= 5 
if (조건비교식(True or False):
    '''실행할 코드'''
elif (조건비교식):
    '''실행할 코드'''
else:    # 앞선 경우가 모두 아닌 경우 else
    '''실행할 코드'''

else if 가 아닌 elif 이다.

a= 5 
if  a > 5:
    print("a is bigger than 5")
elif a> 4:
    print("a is bigger than 4 lesser than 5")
else:
    print("?")

문자열 조작[strip(), replace(), split(), join()]

수정, 대체

s = ” Hello, World! ‘
s.strip() #문자열 양쪽의 공백을 모두 제거한다.
->Hello, World!
s.replace(‘World’ , ‘Clazitive’) #문자열을 대체한다.
-> Hello, Clazitive!

분리, 결합

s = “How’s it going today”
s.split() # 공백을 기준으로 갈라진 substring을 리스트 형태로 반환한다. ()안에 다른 문자열을 넣으면, 입력한 문자열을 기준으로 나눠준다.
-> [“How’s”, ‘it’, ‘going’, ‘today’]
t=s.split()
‘_’.join(t) #쪼개진 문자열을 사이에 구분 문자열을 삽입하여 하나의 문자열로 합친다.
->How’s_it_going_today

함수

함수란?
호출 가능한 단위의 명령문 집합
코드를 기능 단위로 나누는데 유용하다.
함수를 이용하면 코드 재사용성 및 가독성을 높일 수 있다.
문법
def function_with_return(parameters):    #반환값이 있는 함수
    """ code """

def function_without_return(parameters): #반환값이 없는 함수
    """ code """
    return value
예시
def say_hello():  
    print('hello')

say_hello()
->"hello"

#파라미터가 없는 함수

def say_hello_to(name): 
    print('hello', name)

say_hello_to('clazitive')   
->"hello clazitive"

#파라미터가 있는 함수
사용시 파라미터를 입력해주어야 한다

def avg3(x,y,z): 
    return (x+y+z)/3

result = avg3(1,2,3) 
print(result)
->2

#리턴이 있는 함수
변수에 avg3의 반환값을 할당한다

def sum_avg3(x,y,z): 
    return (x+y+z) , (x+y+z)/3

sum, avg = avg3(1,2,3) 
print(sum, avg)
->6 2

#리턴이 여러개 함수
두 변수에 각각 반환값을 할당한다

리스트 정렬 함수 sort() and sorted()

리스트를 직접 정렬하는 .sort() vs 정렬된 리스트를 반환하는 sorted()
a=[5,4,1,9] 
b= a.sort()
print(a)
->[1,4,5,9]
print(b)
->None
a=[5,4,1,9]
b= sorted(a)
print(a)
->[5,4,1,9]
print(b)
->[1,4,5,9]

역순으로 정렬을 할때는 sort(), sorted() 메소드에 reverse 파라미터를 True 로 주는 방법과 reverse(), reversed() 함수를 이용하는 방법이 있다.

a=[5,4,1,9]
b= a.reverse()
print(a)
->[9,5,4,1]
print(b)
->None
a=[5,4,1,9]
b= reversed(a)
print(a)
->[5,4,1,9]
print(b)
->list_reverseiterator object
print(list(b))
->[9,5,4,1]

sort 와 다르게 reversed 는 iterator 객체를 반환한다. 출력 하려면 list() 메소드를 이용해서 리스트로 변환 시켜야 한다.

sorted(), reversed() 의 경우에는 아래처럼 for문과 같이 자주 쓰인다.
한줄이 줄어들었다.

a=[5,4,1,9]
a.sort() 
for i in a:
  print(i)
a=[5,4,1,9]
for i in sorted(a):
  print(i)

클래스

class <클래스 이름>:
    멤버변수 = 값

    def 메소드(self, 다른 arguemtns):
        명령블록

클래스 = 멤버 변수 + 메소드의 집합
“self” 는 클래스로 생성된 인스턴스를 의미한다.
메소드 parameter 처음에 self를 넣는 이유는 메서드의 첫 번째 인자로 항상 인스턴스가 전달되기 때문이다.

class Value:
    def set_val(self, val):
         self.val = val
a= Value() # a 라는 변수에 Value 객체를 생성

생성된 객체를 통해서 클래스의 멤버변수와 method에 접근할 수 있다.
객체.메소드 또는 객체.멤버변수와 같은 방식으로 접근한다.
ex) a.set_val(20)
set_val 은 self.val 에다가 입력받은 argument val 을 저장한다.
set_val(20)을 실행시킨 이후에 변화된 값을 보려면
print(a.val)를 통해 볼 수 있다.

만약 a.set_val() 을 실행하면 argument가 입력되지 않았기 때문에 오류가 발생한다.

생성자(Constructor)

클래스 method 중 이름이 ‘__init__’ 인 메소드는 인스턴스를 초기화 하는 메소드로 인스턴스가 생성될 때 호출된다.

소멸자(Desturctor)

method 이름이 ‘__del__’ 이며, 인스턴스가 메모리에서 해제될 때 호출된다.

class Example:
    def __init__(self, desc):
        self.desc = desc
    def explain(self):
        print(self.desc)
    def __del__(self):
        print("removed from memory")

ex1 = Example("explaining consturctor and destructor")
ex1.explain()
-> explaining consturctor and destructor
del ex1 
-> removed from memory

parameter가 있는 생성자를 정의하면, 객체 생성시에 파라미터를 입력해주어야 한다.

ex1 을 생성하면서 desc에 입력한 문자열이 저장된다.
ex1에서 explain() 메소드를 호출하면 인스턴스의 desc를 출력한다
del 명령어로 ex1 객체를 지우면, 소멸자가 호출되어 removed from memory 가 출력된다.

상속

상속을 하게 되면 상위 클래스(부모 클래스)에서 정의한 멤버변수와 메소드를 하위 클래스(자식 클래스) 에서 사용할 수 있게 된다.

파이썬에서 클래스를 상속하는 경우에는 class 를 정의할때 다음과 같이 정의한다.

class 부모클래스():
    pass
class 자식클래스(부모클래스):
    pass

괄호 안에 상속받을 클래스 이름을 넣어주면 된다.

class Point1D:
    def __init__(self,x):
    	self.x = x
    def print_x(self):
    	print('x: ', self.x)

class Point2D(Point1D):
	def __init__(self, x, y):
		super().__init__(x)
		self.y = y
	def print_y(self):
		print('y: ', self.y)

p = Point2D(10,20)
p.print_x()
p.print_y()

Point2D 는 생성시 x,y 를 입력받아서 super().__init__(x) 코드로 부모의 x 를 초기화 시키고 자신의 y에 값을 저장한다. 여기서 super() 은 부모(상속받은 Point1D)를 의미한다.

Point1D의 메소드를 상속받았기 때문에 p 객체는 print_x 메소드를 사용할 수 있다.

고으급 기술

List Comprehension

리스트를 만들때 좀더 짧은 코드로 만드는 방법이다.
s1 은 기존 for문을 활용해서, s2는 리스트 컴프리핸션을 이용해서 만들었다.

s1= []
for i in range(10):
    s1.append(i*5)
print(s1)
s2= [i * 5 for i in range(10)]
print(s2)
->[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]
->[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]

결과는 동일하다.
여기에 조건문을 추가할 수도 있다.

s1= []
for i in range(10):
    if (i % 2) == 0:
    	s1.append(i*5)
print(s1)
s2= [i * 5 for i in range(10) if i% 2== 0]
print(s2)

Lambda 함수

람다함수는 함수를 코드 한줄에 이름없이 정의하여 사용하는 방식이다
lambda <파라미터>:<반환식>

#입력 파라미터 없이 1을 반환하는 람다함수
func = lambda:1   
print(func())
 #파라미터 2개를 입력받아 평균을 반환하는 람다함수
func = lambda x,y : (x+y)/2 
print(func(10,40))

Unpacking 언패킹

언패킹은 우변에 있는 iterable 을 좌변에 대응하는 변수에 할당하는 것이다.

x, y, z = [1,2,3]
print(x, y, z)
->1 2 3

Extended unpacking 확장된 언패킹

t = list(range(5))
a, *b = t
print(a,b)
->0 [1, 2, 3, 4]
t = list(range(5))
a, *b , c = t
print(a,b,c)
->0 [1, 2, 3] 4

*을 이용해서 함수의 argument로 전달할 수도 있고, 함수에서 *을 이용해서 여러 argument를 받을 수 있다.

def sum5(a,b,c,d,e):
	return a+b+c+d+e

t = (1,3,5,7,9)
print(sum5(*t))
->25
def scale_sum(scale, *items):
	return scale*sum(items)

print(scale_sum(0.6, 1, 2, 3, 4))
->6.0