컴퓨터 네트워크 및 실습 정리 - 파이썬

1. 데이터 형

파이썬 프로그램은 변수, 상수, 예약어, 연산자, 함수 등으로 구성

 -> 예약어는 변수나 함수명으로 사용 불가

# 예약어 확인하기
import keyword
keyword.kwlist

 

> 식별자

 변수, 사용자 정의 함수, 클래스, 모듈 등의 이름

- 숫자로 시작할 수 없음

- 영문자, 숫자, _밑줄, 유니코드 문자 사용 가능

- 예약어 사용 불가

- 식별자의 첫 문자는 알파벳 or 밑줄

 

> 주석

# 한줄 주석

 

'''

여러줄 주석

'''

 

"""

여러줄 주석

"""

 

기본 입출력 함수

- print()

print("i=", i, "j=", j)
# 출력: i=  10  j=  20

print(10+20)
# 괄호 속의 연산결과 출력 : 30

print("string" * 3)
# 문자열 3번 출력
# string string string

print(x, y)
# 10 20 //x=10,y=20

print(x,'+',y,'=',z)
# 25 + 32 = 57

print("10" +"20")
# 문자열 잇기
# *** 문자열끼리만 가능, 숫자랑 문자 잇기는 안됨

print("n = %d"%n)
# n = 10

print("m = %f, n = %d" %(m,n))
# m = 5.200000, n = 10

 

- input() : 입력된 정보는 문자열

 

> 상수

- 저장 값이 변하지 않는 장소를 나타내는 이름

- PI = 3.14

- C 언어의 const 와 같은 기능은 없음

 

자료형      -> type( value ) 로 알 수 있다.

Boolean : True, False

Integer : 정수

    0b0101 #이진수

    0o2734 #8진수

    0xDA4 #16진수

 

int, float형

- 숫자 식별을 위해 _를 사용

 >>> 100_000.000_0001

 

문자열

' ', " " 로 묶어서 표현

 

"I'm a Python fanatic"   #작은 따옴표 표시할 경우

'I"m a Python fanatic'   #큰 따옴표 표시할 경우

 

'A not very long string \

than spans two lines'     #문장을 두 줄 이상으로 표시할 경우

 

=======================================================

1. 연산자

- 지정 연산자

assignment operator

i = 3

변수의 값을 지정하기 위해 사용

 

- 산술 연산자

arithmetic operator

 사칙연산: +, -, *, /

 정수 나눗셈: //

 나머지 연산: %

 

a = 10
b = 3
c = a % b => 1
d = a // b => 3
e = a / b => 3.3333333333

 

- 논리 연산자

logical operator

and, or, not

연산 대상 => True, False

연산 결과 => True, False

exam = 85
report = 85
exam >= 80 and report>=80 => True

exam >= 90 or report >= 90 => False

not(exam < 90) => False

not( x )

x의 부정

x의 반대되는 결과를 출력

 

- 관계 연산자

relation operator

  = 비교 연산자

< , <=, >, >= , ==, !=

 

- 멤버 연산자

membership operator

in / not in

특정 문자열 또는 값이 문자열 또는 리스트에 속해 있는지 판별하는 연산자

'op' in 'operator' => True

'po' not in 'operator' => True

-> 'po' 가 'operator' 에 속해 있는지 판별

 

- 식별 연산자

identity operator

id(x) : x의 주소

 

is :  양쪽 변수의 주소가 같은지 판단.

    if id(a) == id(b)           --        a is b

-> True

 

is not :  양쪽 변수의 주소가 다른지 판단.

    if id(a) != id(b)            --        a is not b

-> False

 

- 연산 오류  type error

 : 연산할 수 없는 자료형을 연산하면 타입 에러 발생

 

2. 제어문

 

if - elif - else

while, for

break, continue

 

for 문

for i in [1,2,3]: ...

 

for i in range(1, 4, 1):

- range( start, stop, step ): (start ; start<stop ; start+=step)

 

===================================================================

 

04. 파이썬 자료 구조

 

문자열='', 리스트 [], 튜플(), 딕셔너리{key:values}, 집합 {}

1. 문자열

word = 'Python'

word[-1] : 마지막 문자    'n'

word[-6] : 뒤에서 6번째 문자 'P'

 

- 문자열 슬라이싱

word[0:2] => 'Py'

    첨자 0~1 (0번째 부터 첨자 (2-1)개)

word[2:5] => 'tho'

    첨자 2 부터 첨자 (5-1) 까지

word[:2] => 'Py'

word[4:] => 'on'

word[-2:] => 'on'

 

문자열 합치기

word[:2] + word[2:] => 'Python'

 

- 문자열 인덱싱: 문자열 인덱스 접근은 범위를 벗어나면 오류이지만 슬라이싱은 오류를 발생시키지 않음

word[42:] => ''

word[4:42] => 'on'

 

** 문자열은 수정 불가

    word[0]='J'

 슬라이싱을 이용하여 새로운 문자열 생성

'J' + word[1:] => 'Jython'

 

- 문자열 길이 확인

 len(word) => 6

 

* 문자열 처리

# index 를 이용하여 문자열의 문자를 역순으로 만들기
outStr = "" # 변수 초기화(빈 문자열)
count, i = 0,0

inStr = input("Type String: ")
count=len(inStr)

for i in range(0,count):
	outStr += inStr[count - (i+1)]

print("Reversed String: %s" % outStr)

문자열도 객체

 

- 문자열 구성 파악하기

'123'.isDigit()   : 문자열이 숫자인가

      .isalpha()  : 문자열이 문자인가

      .isalnum() : 문자열이 문자+숫자인가

      .isupper()  : 문자열이 대문자인가

      .islower()  : 문자열이 소문자인가

      .isspace()  : 문자열이 공백인가

 

- 문자열 메소드

str.upper() : 대문자로 변환

str.lower()  : 소문자로

str.swapcase() : 대소문자 바꾸기

str.title()  : 첫글자만 대문자로 

str.count('i')  : 문자열에서 'i' 의 개수

str.find('o')  : 문자열에서 'o'의 처음 위치, 없으면 -1

str.rfind('o')  : 문자열에서 'o'가 나오는 가장 나중 위치

str.index('on')  : 문자열에서 'on'의 처음 위치, 없으면 ValueError

 

- 문자열 분리하기

'a bc'.split() => ['a', 'bc']

'a bc'.split('b') => ['a ', 'c']

 

- 문자열에서 공백 제거

' hello '.strip()  => 'hello'

str.rstrip()  => ' hello' : 오른쪽 공백 제거

str.lstrip()  => 'hello ' : 왼쪽 공백 제거

 

- 문자열 결합하기

'*'.join('hello')  : * 와 문자열의 각 문자를 하나씩 결합

> 'h*e*l*l*o'

 

- 문자열 채우기

'12'.zfill(5) => '00012'

 

- 문자열 정렬

>>> 'he'.rjust(5) => '_ _ _he'

5자리를 오른쪽으로 정렬

>>> 'he'.ljust(5) => 'he_ _ _'

왼쪽 정렬

>>> 'he'.center(5) => '_ _he_'

가운데로 정렬

 

2. 리스트

    : 여러 타입의 데이터를 하나의 이름으로 저장하는 자료구조

 

odd = [ 1, '3', 5, '7', 9 ]

empty=[ ] <- 공백 리스트

 

- 리스트의 인덱싱 / 슬라이싱

odd[0] => 1

odd[-1] => 9

odd[0:3] => [ 1, '3', 5 ]

odd[-3:] => [ 5, '7', 9 ]

 

- 리스트 합치기

odd + [ 2, 4, 6, 8 ]

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

a = [ 1, 2 ]

b = [ 3, 4 ]

a+b => [1, 2, 3, 4]

 

- 리스트 요소 수정

cubes = [ 1, 8, 27, 65, 125 ]

cubes[3] = 64

cubes[2:5] = ['3', '4', '5']

 

- 마지막에 요소 추가

cubes.append(216)

 

- 리스트 요소 제거

cubes[2:5]=[ ]

- 리스트 요소를 모두 제거

cubes[ : ] = [ ]

 

- 중첩 리스트

x = [ ['a', 'b', 'c'], [1, 2, 3] ]

>>> x[0]

['a', 'b', 'c']

>>> x[0][1]

'b'

 

- 리스트의 길이 알아내기

>>> li = [ 1,2,3,4]

>>> len(li)  => 4

- 리스트의 합, 최소, 최대

sum(li) => 10

min(li) => 1

max(li) => 4

 

list 메소드                                사용법 확인: help( list.method )

- cars.sort() : 오름차순, list의 배열을 정렬함

- cars.sort(reverse=True) : 내림차순

- sorted(cars) : 오름차순으로 배열한 리스트를 따로 생성

                (cars의 요소는 그대로)

 

- cars.reverse() : 요소 순서를 뒤집음

 

3. 튜플

: 요소 값을 변경할 수 없다

 

>>> t1 =(1,2,3)     # ( ) 괄호 속에 요소를 나열

>>> t2 = 1,2,3      # () 괄호 없이 항목 나열

>>> t3 = 1,          # 요소가 한개인 경우 ,

>>> t4 = tuple()    # 빈 튜플 생성

 

- 튜플 인덱싱과 슬라이싱 == 리스트와 동일

 

- 튜플 연산

>>> t1 + t2   # 두개의 튜플을 하나로 합치기

>>> t1 * 2     # 동일한 튜플을 하나 더 생성하여 합치기

 

- 튜플과 리스트 상호 변환

T1 = (1,2,3)

L1 = list(T1)

T1 = tuple(L1)

 

- 튜플 언패킹

>>> a, b, c = (1,2,3)

튜플의 요소를 변수에 하나씩 할당

 

4. 딕셔너리

key: value 로 구성되는 자료구조

키 : 정수, 실수, 문자열, 튜플

값 : 임의의 데이터형

 

height = { 'Jun':174,'Kim': 170 }

height['Jun'] => 174

 

test = dict()  # 빈 딕셔너리 생성

 

- 딕셔너리 키 조사

>>> 'Kim' in height  => True

 

- 딕셔너리 요소 수정, 추가

>>> height['Kim']=174;

>>> height['Lee']=168;

 

- 딕셔너리 키, 값, 요소 추출

# 키 추출

>>> height.keys()

dict_keys( ['Jun', 'Kim', 'Lee' ] ) # iterable 이 반환됨

# 값 추출

>>> height.values()

dict_values( [174, 180, 169] )

# 요소 분리하기

>>> height.items()

dict_items( [ ('Jun', 174), ('Kim', 170), ('Lee', 165) ])

(key:value)를 튜플로 묶은 값을 리스트로 반환

 

# 뽑아낸 키를 리스트로 변환

keys_list = list(height.keys())

 

# 딕셔너리 요소 제거하기

>>> height.pop('Lee') => 168

'Lee' 요소 제거

 

# 딕셔너리 지우기

>>> height.clear()

딕셔너리 비우기

5. 집합

: { } 안에 요소들이 중복되지 않고 순서 없이 모아놓은 자료구조

* 빈 집합 생성

empty = set()

 

>>> numbers = { 1,2,3 }

>>> name = set([1,2,3])

>>> len(numbers) => 3

>>> numbers.add(4)  # 집합 요소 추가

>>> numbers.remove(4)  # 요소 제거

 

집합 연산

- 교집합

setA & setB      ==    setA.intersection(setB)

 

- 합집합

setA | setB   ==   setA.union(setB)

 

- 차집합

setA - setB   ==   setA.difference(setB)

 

- 부분집합 연산

setA == setB

setA < setB     ==    setA.issubset(setB)

   : A가 B의 부분집합인가

 

===============================================================

05. 함수

1. 함수

함수를 사용하는 이유

- 중복된 코드 제거

- 복잡한 작업을 간단한 작업들로 분해

- 함수는 다른 프로그램에서도 재사용 가능

- 가독성 증대, 유지관리 쉬워짐

 

* 파이썬의 함수는 일급 함수, 함수를 변수처럼 사용한다.

변수 할당 : a = func

다른 함수에 인자로 전달 : func1(func)

함수를 반환 : return func

 

- 내장함수, 사용자 정의 함수

 

def hello(name):
	print("Hello world!!!",name)
    
hello('hi')

 

* 반환 값이 없는 함수

def prtStr(str):
	print("%s"%str)
    return
    
prtStr("Welcome to Python")

* 값을 반환하는 함수

def square(s):
	area=s*s
    return area
    
a = square(10)

 

main 함수

if __name__ == '__main__':
	n = eval(input())
    print(dec2bin(n));

 

- 지역 변수: 함수 내에서만 유효한 값

- 전역 변수: 프로그램 내에서 값이 유효

def func1():
	v=10
    print(v)

def func2():
	print(v)
    global v
    v=30
    print(v)

v = 20

func1() # 10
func2() # 20, 30

전역 변수를 함수 안에서 변경하려면 함수 내에서 global 키워드로 전역변수임을 알려준 후, 값을 변경해야 한다.

(선언과 수정을 분리)

 

2. pass 키워드

- 함수 몸체의 작성을 잠시 보류할 때 사용

- 문법적 오류를 피하고 아무것도 실행하지 않을 때 사용

 

3. 함수의 매개변수

- 매개변수의 기본값 지정

def prtMesg(message, count=1):
	print(message*count)

prtMesg('default')
prtMesg('Hi',5)

 

- 가변 매개변수

def total(*numbers): # 튜플
	sum=0
	for n in numbers:
    	sum+=n
    return sum
    
print(total(1,2,3))

def dic(**keyword):
	for i in keywords.keys():
    	print(i, keyword[i])

dic(Kim=35,Obama=44, Trump=45)
# (key=value) 로 전달

- 매개변수가 *arg 로 표시되면 튜플로 처리

- 매개변수가 **keywords 로 표시되면 딕셔너리로 처리

 

- 키워드를 이용한 매개변수 전달

def func(a, b=2,c=3):
	print(a,b,c)
    return a+b+c

print(func(4,5)) # a=4, b=5
print(func(5, c=7)) # a=5, c=7, b=기본값

4. 람다 함수

: 이름이 없는 한 줄짜리 함수

lambda 매개변수: return 식

>>> sum = lambda x, y: x+y

>>> print(sum(10,20))

30

 

- 두개 이상의 값을 return 하려면 튜플/리스트 사용

lambda x, y: (x+y, x*y)    # 튜플을 반환

 

- 람다 함수 호출

>>> (lambda x, y: x +y)(1,2)

3

 

5. 내장 함수

1) any(seq)

seq 요소 중 True 가 있으면 True를 반환

>>> any([1,0])

True

>>> any([0,0,0])

False

 

2) bin, oct, hex <-> int

- bin(x), oct(x), hex(x)

- 10진 정수에 대한 2, 8, 16진수 문자열 반환

 

3) chr(code)

- 0~255 까지의 code에 대한 문자

- chr(0x41) => 'A'

 

4) dir( [obj] )

- obj 의 모든 속성(변수, 메서드) 이름을 보여줌

 

5) enumerate

- enumerate(iterable, start=0)

- 번호(index)와 iterable 요소 쌍을 iterable 로 반환

names = ['Corey','Chris', 'Dave', 'Travis' ]
for index, name in enumerate(names, start=1):
	print(index, name)

 

6) eval(expr, [globals, locals])

- 문자열로 표시된 expr의 계산 결과를 반환

 

- int(str, base =10)

str을 10진수로 변환

 

7) filter(func, seq)

- seq 의 각 요소에 대해 func를 호출하여 결과 True인 요소만 모아서 iterable로 반환

>>> list(filter(lambda x: len(x)>2, ['this','is','a','test']))

['this', 'test']   # 리스트 요소 중에서 길이가 2 이상인 요소만 모음

 

8) map( func, seq, ...)

- seq 의 각 요소에 대해 func를 호출하여 실행하고 결과를 iterable로 반환

def Squares(n):
	return n**2

numbers=[1,3,5,9]

# Square 함수에 numbers요소를 하나씩 대입
print(map(Squares, numbers))

 

9) ord(ch)

- ch에 대한 ASCII 코드를 반환

- ord('A') => 65

 

10) round(x, n=0)

- 실수 x를 소수점 아래 n자리로 반올림하여 반환

>>> round(12.345, 1)

12.3

 

11) zip(seq, *seqs)

 

==============================================================

06. 모듈

1. 모듈이란

- 함수, 변수, 클래스들을 모아놓은 파일 (라이브러리)

- 사용하는 이유: 프로그램의 재사용이 가능

- 표준모듈, 서드 파티 모듈, 사용자 정의 모듈

 

2. 모듈 불러오기

- import

프로그램 외부에 존재하는 모듈을 프로그램 내부로 불러와서 사용하기 위해 필요한 명령

 

import socket

- socket 모듈에 포함된 속성을 사용할 수 있다(변수, 메소드, 클래스)

- dir(socket) : socket 모듈에 들어있는 속성이름을 보여줌

- dir(socket.socket) : socket 모듈의 socket 클래스에 포함된 변수, 메소드를 보여줌

 

>>> socket.gethostname()    # 모듈이름.속성 형태로 호출

 

- from module이름 import class | method

import 된 class , method를 사용할 수 있음

 

from module명 import *

- from socket import *

: socket 모듈의 모든 속성을 사용할 수 있다.

>>> gethostname()    # 메소드를 직접 호출

 

- 모듈을 단축이름으로 불러오기

import socket as so

>>> so.gethostname()    # 단축이름으로 속성 호출

 

- 모듈 탐색 경로

: 불러오는 모듈은 현재 디렉토리, sys.path(환경변수)에 지정된 디렉토리 순서로 찾음

>>> import os, sys

>>> os.getcwd()   #현재 dir

>>> sys.path    # 환경변수에 지정된 dir

 

3. 사용자 정의 모듈

- 모듈은 일반 프로그램과 같이 작성됨

 

if __name__ =='__main__':    # main 함수, 해당 파일을 직접 호출하면 실행됨

    print(sum(5))

- 모듈을 독립된 프로그램으로 사용할 때만 실행됨

- 모듈의 기능을 테스트하기 위해 사용

- 모듈로 사용될 때는 실행되지 않음

-------------------사용자 정의 모듈의 사용-------------------------

import myModule

mysum = myModule.sum(10)

-----------------------------------------------------------------------

 

* sys 모듈: 파이썬 인터프리터에 관한 정보

* random 모듈: 난수를 만들 때 사용

>>> import random

>>> random.randint(1,5)

4

>>> random.random()

0~1 사이의 실수 생성

>>> random.randrange(1, 10, 1)

1 ~10 사이에서 step =1로 난수 발생

>>> random.choice('hello')

'hello'에서 임의로 하나의 문자 반환

 

* math 모듈: 수학적 계산

math.pi

math.sin(math.pi/6)

math.log10(2)

 

* time 모듈

: 시간을 문자열로 표시하는 모듈

- time.time()

 1970.01.01 0시 ~ 현재까지 초

- time.asctime()

현재 날짜와 시간

 

* calendar 모듈

- 달력을 출력하는 모듈

 

* enum 모듈

:열거형 상수를 정의하기 위한 모듈

class Color(Enum):

    RED = 1   # name = Value

 

# 상수값이므로 값을 변경할 수 없다

Color.RED.name

Color.RED.value

 

============================

07. 클래스

1. 객체지향 프로그래밍

- 소프트웨어도 객체들로 구성될 수 있다는 생각을 기반으로 한 프로그래밍 방법

- 객체지향 프로그램은 객체의 상태(속성)와 동작(메서드)을 나타내는 클래스를 작성하고, 이로부터 객체를 생성하여 프로그램을 작성

- 클래스: 사용자 정의 자료 구조

- 상속 클래스는 부모 클래스가 갖지 않는 속성과 메서드를 가질 수 있다.

- 객체는 클래스의 속성과 메서드를 갖는다

- 객체는 일반 변수처럼 사용된다.

(함수의 인자, 함수에서 객체를 반환, 튜플이나 딕셔너리의 요소로 사용될 수 있다.)

 

2. 클래스

class C_Name(부모 클래스):
	클래스 몸체

- 부모 클래스는 없으면 생략

- 클래스 몸체는 변수와 메서드로 구성됨

 

* 클래스 객체

- 클래스를 인스턴스화하여 만들어진 것을 객체라고 한다.

- 객체 -> 클래스의 속성과 메서드에 접근

 

ex) 클래스의 예시

class Car:
    def __init__(self, color, speed):	# 초기화 메서드(생성자), self 는 객체
        self.color = color			# 인스턴스 변수 정의
        self.speed=speed
    
    def speedUp(self, v):		# method 의 첫번째 매개변수는 self
    	self.speed=self.speed+v
        return self.speed
        
    def speedDown(self, v):
    	self.speed = self.speed-v	# 다른 메서드에서 정의된 변수 접근
        return self.speed

self.변수     : 인스턴스 변수

 - 클래스 전체에서 유효한 변수, 클래스 속성 -> 인스턴스 변수로 정의

 - self._ 가 없는 변수는 메서드 내에서만 유효한 지역변수이다

 

* 생성자 __init__()

- 객체를 생성할 때 자동으로 실행됨

- 인스턴스 변수를 초기화 할 때 사용

- self 를 첫번째 매개변수로 가짐(self = 클래스 객체 )

- 인스턴스 변수 -> 클래스 내부의 모든 메서드에서 접근 가능하다.

- 객체를 생성할 때 같이 실행할 메서드를 호출할 수도 있다.

 

* 클래스 객체

mycar = Car('Black', 60)

 

class Calc:
	count = 0
    def add(self, a=0,b=0):
    	self.a=a
        self.b=b
        self.count+=1
        return self.a+self.b
        
    def minus(self, a,b):
    	if a==0 or b==0:
        	return a-b, self.count
        else:
        	return a-b
            
obj = Calc()
obj.minus(3,0)
obj.add(1,2) -> 3, count++
obj.count # 1
Calc.count # 0

클래스 변수를 self 와 함께 사용하면 인스턴스 변수처럼 사용

obj.count -- 인스턴스 변수

Calc.count -- 클래스 변수

 

3. 클래스 상속

- 객체지향 프로그램의 장점 : 상속을 통한 코드 재사용

- super class, sub class

 

상속의 구현

class subclass(superclass):

 

- 파이썬 프로그램의 모듈은 대부분 클래스로 구현되어 있고 자신의 프로그램에서는 모듈에 포함된 부모 클래스를 상속받아 구현된다.

 

class Teacher(People):
	def __init__(self, age=0,name=None, school=None):
    	super().__init__(age, name)   # 부모 클래스의 속성 할당
        self.school = school		# 자신의 인스턴스 변수 추가     

- 부모클래스에만 구현되어 있는 메서드는 상속되므로 자식클래스에서 호출이 가능하다.

 

4. 메서드 오버라이딩

- 자식클래스에서 부모클래스의 메서드 중 필요한 것을 수정해서 다시 정의하는 것

 

5. 다형성

- 전달된 인자에 따라 함수 또는 연산이 달라지는 기능

- 동일한 함수인데 객체 타입에 따라 출력이 달라짐

 

class Korean(object):

    def greeting(self):

 

class American(object):

    def greeting(self):

 

def sayhello(people):

    people.greeting()

 

sayhello(Korean())  # 안녕

sayhello(American())   # hello