yongmin

* 함수 

- 명명 규칙 : 소문자로만 구성, 스네이크케이스

* 클래스

- 명명규칙 : 대문자로 시작, 카멜케이스

* 사용자 입력 받기

- input() : 문자열 입력받음

- eval() : 인자를 분석하여 evalute하는 함수, 문자열->숫자 변환가능, 수식계산가능, 함수호출가능...

- num = int(str) // 문자열 -> 정수로 변환하는 함수

* for문

for i in range(a)  =>  i : 0~(a-1)

for i in range(a,b) => i : a~(b-1)

산술연산

+ 

-

*

** : 제곱연산

/  : 실수 나눗셈

// : 정수 나눗셈

% : 나머지연산

type(parameter)  : parameter의 타입반환

print( a, end = ' ') // 줄바꿈대신 ' '출력

print(1,2,3, sep=',' , end = '_') // 원소사이에 , 를 삽입하고 마지막에 _ 출력 => 1,2,3_

리스트형 자료형의 연산

1. 덧셈연산 : [1,2] + [1,2,3] = [1,2,1,2,3,]

2. 곱셈연산 : [1,2,3] * 2 = [1,2,3,1,2,3]

3. 인덱싱 연산 : list = [1,2,3] print(list[0], list[-1]) // 1 3

4. 슬라이싱 연산 : list[1:3] = [0,0,0,0,0] list[:3] = [0,0,0,0,0] list[2:] = [0,0,0,0] even = list[0:10:2]

리스트자료형 함수

len(list) : list의 길이 반환

min(list) : list의 값들 중 가장 작은 값 반환

max(list) : list의 값들 중 가장 큰 값 반환 

list.remove(a): list에서 첫번째 a값을 찾아서 삭제

list.append(a) : list 끝에 a 추가

list.extend(list2) : list끝에 list2 추가

list.clear() : list 내용 전부 삭제

list.insert(i, a) : list[i] 에 a 삽입

list.pop(i) : list[i] 반환및 삭제

list.count(a) : list에 속한 a 갯수 반환

list.index(a) : list의 첫번째 a의 인덱스 반환

문자열 자료형

- 작은따옴표 또는 큰따옴표로 묶을 수 있다

- 리스트 자료형과 비슷 : 덧셈연산, 곱셈연산, 인덱싱연산, 슬라이싱연산 (단! 문자열은 인덱싱연산으로 내용 바꿀 수 없다!)

문자열 함수

str.count(sub) : str에 sub이 등장하는 횟수 반환

str.lower() : str내용 전부 소문자로 바꾼 문자열 반환

str.upper()

str.lstrip() : str의 왼쪽 공백 모두 제거한 문자열 반환

str.rstrip() : str의 오른쪽 공백 모두 제거한 문자열 반환

str.strip() : 왼쪽 오른쪽 공배 모두 제거한 문자열 반환

str.replace(old,new) : str의 모든 old를 new로 교체한 문자열 반환

str.replace(old,new,2) : str의 두번째 old까지 new로 교체한 문자열 반환

str.split(' ') : str을 ' ' 기준으로 나눠서 리스트에 담아서 반환

str.isdigit() : str이 숫자로만 이루어져 있으면 True, 아니면 False

str.isalpha() : str이 알파벳만으로 이루어져 있으면 True, 아니면 False

str.startswith(prefix) : str이 prefix로 시작하면 True, 아니면 False

str.endswith(suffix) : str이 suffix로 끝나면 True, 아니면 False

문자열 탐색함수

str.find(sub) : str의 앞에서부터 sub을 찾아서 sub가 있으면 해당 인덱스값 반환, 없으면 -1 반환

str.rfind(sub) : str의 뒤에서부터 sub를 찾아서 sub가 있으면 해당 인덱스값 반환, 없으면 -1 반환

in 연산자

if 'sub' in str // str에 sub 있으면 True, 아니면 False

if a in list // list에 a 있으면 True, 아니면 False

not in 연산자

if 'sub' not in str // str에 sub 없으면 True, 있으면 False

if a not in list // list에 a 없으면 True, 있으면 False

함수 종류

- 객체 안에 있는 함수 : 해당 객체에 특화된 형태

- 객체 밖에 있는 함수 : 둘이상의 다양한 종류의 값을 대상으로 동작하는 함수

bool 자료형

True 

False

다른 자료형과 bool 자료형

0 = False

0이 아닌 수 = True

빈리스트 = False

비어있지 않은 리스트 = True

빈 문자열 = False

비어있지 않은 문자열 = True

조건문

if ~ elif ~ elif ~ else

반복문1

while 조건 :

    조건이 True인 동안 반복실행될 문장

반복문2

for 변수 in 반복범위 : 

    범위동안 반복실행될 문장들

튜플

- 리스트와 비슷하지만 ( a,b,c... )로 표현

- 튜플은 값을 추가하거나 수정할 수 없다

튜플 관련 함수

len()

max()

min()

tuple.count(a)

tuple.index(a)

덧셈연산

곱셈연산

인덱싱연산

슬라이싱연산

레인지

- 레인지 객체는 '값의 범위'를 나타낸다

- range(1,10) = range(1,10,1)

- range(1,10,2) : 1부터 2씩 증가하여 9까지

-  거꾸로 범위 지정 : range(10,1,-1) -> 10부터 2까지 -1씩 감소하는 정수

형변환

list(str)

list(range)

list(tuple)

tuple(str)

tuple(range)

tuple(list)

str(list)

str(tuple)

함수

- 디폴트값 : 디폴트 값을 가지는 매개변수는 뒤에 위치해야한다

- 매개변수 "참조" 관계 : 파이썬에서는 매겨변수를 위해 별도의 메모리 공간을 할당하지 않는다. 따라서 매개변수는 참조 형식으로 함수내부에서 접근된다

모듈

- 정의 : 모듈이란 함수나 변수 또는 클래스를 모아 놓은 '파일'

- import 모듈이름

- import 모듈 as 새로운모듈이름

- from 파일이름 import 함수1 (as 새로운함수이름)

- from 파일이름 import 함수1, 함수2 

- from mod1 import *

math 모듈

- math.pi

- math.e

- math.log(x) = lnx

- math.sqrt(x) = x^1/2

- math.fabs(x) = |x|

etc

패키지

- 패키지(Packages)는 도트(.)를 사용하여 파이썬 모듈을 계층적(디렉터리 구조)으로 관리할 수 있게 해준다. 

- 파이썬 패키지는 디렉터리와 파이썬 모듈로 이루어진다

딕셔너리 자료형

- 딕셔너리는 Key와 Value를 한 쌍으로 갖는 자료형

- value는 중복되어도 되지만 key는 중복되어서는 안된다

- 딕셔너리의 데이터는 저장 순서 중요하지 않다

- 딕셔노리를 대상으로 for문 구성이 가능 -> 딕셔너리의 'key'를 가지고 for문 동작

- dic = { 'key1' : value1, 'key2' : value2 }

- 참조 : dic[key1]

- 수정 : dic[key1] += 10

- 추가 : dic[newKey] = newValue

- 삭제 : del dic[key1]

- value1 in dic // True

set 자료형

- 집합 자료형은 set 키워드를 사용,  set()의 괄호 안에 리스트를 입력하거나 문자열을 입력

s1 = set([1,2,3]) >>> s1 = {1, 2, 3}

s2 = set("Hello") >>> s2 = {'e', 'H', 'l', 'o'}

- 중복을 허용하지 않는다

- 순서가 없다(Unordered). => set 자료형은 순서가 없기(unordered) 때문에 인덱싱으로 값을 얻을 수 없다. 

- set 자료형에 저장된 값을 인덱싱으로 접근하려면 다음과 같이 리스트나 튜플로 변환한후 해야 한다.

- 교집합 : s1 & s2  ||  s1.intersection(s2)

- 합집합 : s1 + s2 || s1.union(s2)

- 차집합 : s1 - s2 || s1.difference(s2)

- 값 1개 추가 : s1.add(4)

- 값 여러개 추가 : s1.update([4, 5, 6])

- 특정 값 제가 : s1.remove(2)

지역변수

- 함수 안에서 선언되는 변수

- 함수내에서 만들어 졌다가 함수를 벗어나면 사라진다

- 함수 밖에서 지역변수 접근 불가능 

전역변수

- 함수 밖에서 선언되는 변수

- 함수 내에서 전역변수 접근하려면 global 키워드 사용

클래스와 객체

- 클래스 : 특정 객체를 생성하기 위해 변수와 메소드를 정의하는 템플릿 

- 객체 : 속성(변수)과 행동(메소드)을 가지는 표현하려는 대상

- 인스턴스 : 클래스를 통해 실제 생성된 객체

- 인스턴스 변수(속성) : 인스턴스 안에 존재하는 변수

- 인스턴스 메소드 : 인스턴스 안에 존재하는 함수

- 일반 함수와는 달리 파이썬에서 객체의 메서드의 첫 번째 매개변수 self는 객체 자기자신이다.

- 생성자 : 인스턴스 생성시 변수의 초기화를 동시에 진핼하는 함수 => def __init__( ) 

- 파이썬의 모든 데이터는 객체! => 문자열, 정수, 실수 모든 값들은 객체이다

특정 예외 여러개 처리

try :

    실행문장

except 예외1 (as 변수1) :  // 변수1에 오류메세지 저장된다

    예외1 발생시 실행문장

except 예외2 (as 변수2) : // 변수2에 오류메세지 저장된다

    예외2 발생시 실행문징

finally :   

    try영역에 진입하면 예외 발생 유무 상관없이 무조건 실행해야 하는 내용

모든 예외처리

try :

    실행문장

except :

    어떤 예외가 발생하던 실행되는 문장

오류 발생하는 경우

• 디렉터리 안에 없는 파일을 열려고 시도했을 때 발생
• 0으로 다른 숫자를 나누는 경우
• 선형자료형의 범위 밖을 참조하는 경우

예외처리기법

1. try, except문

• try 블록 수행 중 오류가 발생하면 except 블록이 수행된다. 하지만 try 블록에서 오류가 발생하지 않는다면 except 블록은 수행되지 않는다.

try:
    ...
except [발생 오류[as 오류 메시지 변수]]:
    ...

2. try, finally 문

• try문에는 finally절을 사용할 수 있다. finally절은 try문 수행 도중 예외 발생 여부에 상관없이 항상 수행된다. 보통 finally절은 사용한 리소스를 close해야 할 때에 많이 사용한다.

f = open('foo.txt', 'w')
try:
    # 무언가를 수행한다.
finally:
    f.close()

3. 여러개의 예외 처리

• try문에서 여러 개 except문을 작성하여 여러개의 오류 처리 가능

try:
    ...
except 발생 오류1:
   ... 
except 발생 오류2:
   ...
finally : 
   실행문장

오류 회피

• 프로그래밍을 하다 보면 특정 오류가 발생할 경우 그냥 통과시켜야 할 경우,  pass를 사용하여 오류를 그냥 회피하도록 작성

try:
    f = open("나없는파일", 'r')
except FileNotFoundError:
    pass

예외만들기

• 프로그램 수행 도중 특수한 경우에만 예외 처리를 하기 위해서 종종 예외를 만들어서 사용
• 예외는 파이썬 내장 클래스인 Exception 클래스를 상속하여 만든다

class MyError(Exception):
    pass

출처 : https://wikidocs.net/30

1. 클래스

2. 모듈과 패키지

클래스

• 클래스 : 똑같은 무엇인가를 계속해서 만들어 낼 수 있는 설계, 틀
• 객체 : 클래스로 만든 인스턴스
• 클레스 구조
• 메소드 : 클래스 안에 구현된 함수
  • 파이썬 메서드의 첫 번째 매개변수 이름은 관례적으로 self를 사용한다. 객체를 호출할 때 호출한 객체 자신이 전달되기 때문에 self를 사용한 것이다. 물론 self말고 다른 이름을 사용해도 상관없다.
• 생성자 : Constructor란 객체가 생성될 때 자동으로 호출되는 메서드를 의미한다.
  • 파이썬 메서드 이름으로 __init__를 사용하면 이 메서드는 생성자가

• 상속 : 어떤 클래스를 만들 때 다른 클래스의 기능을 물려받을 수 있게 만드는 것
  • class 클래스 이름(상속할 클래스 이름)

• 오버라이딩 : 부모 클래스(상속한 클래스)에 있는 메서드를 동일한 이름으로 재정의 하는 것. 메서드를 오버라이딩하면 부모클래스의 메서드 대신 오버라이딩한 메서드가 호출된다.
• 오버로딩 : 매개변수에 따라 다르게 기능하는 메서드를 중복 정의
• 예시) 4칙연산 클래스와, 거듭제곱 클래스

# 사칙연산 클래스
>>> class FourCal:
...     def __init__(self, first, second):
...         self.first = first
...         self.second = second
...     def setdata(self, first, second):
...         self.first = first
...         self.second = second
...     def add(self):
...         result = self.first + self.second
...         return result
...     def mul(self):
...         result = self.first * self.second
...         return result
...     def sub(self):
...         result = self.first - self.second
...         return result
...     def div(self):
...         result = self.first / self.second
...         return result
...
>>>
# 거듭제곱 클래스
>>> class MoreFourCal(FourCal):
...     def pow(self):
...         result = self.first ** self.second
...         return result
...
>>>

모듈과 패키지

모듈

• 정의 : 함수, 변수, 클래스등을 모아 놓은 파일. 파이썬 확장자 ".py"로 만든 파이썬 파일은 모두 모듈이다.

• 모듈만들기 

# mod1.py
def add(a, b):
    return a + b

def sub(a, b): 
    return a-b

위와 같이 add와 sub 함수만 있는 파일 mod1.py를 만들고 C:\디렉터리에 저장. 이 mod1.py 파일이 바로 모듈이다

• 모듈 불러오기

C:\>python
>>> import mod1
>>> print(mod1.add(3, 4))
7
>>> print(mod1.sub(4, 2))
2

반드시 mod1.py를 저장한 C:\ 디렉터리로 이동해야 모듈을 읽을 수 있다. 

• if __name__ == "__main__" 의미

# mod1.py 
def add(a, b): 
    return a+b

def sub(a, b): 
    return a-b

if __name__ == "__main__":
    print(add(1, 4))
    print(sub(4, 2))

if __name__ == "__main__"을 사용하면 C:\>python mod1.py처럼 직접 이 파일을 실행했을 때는 __name__ == "__main__"이 참이 되어 if문 다음 문장이 수행된다. 반대로 대화형 인터프리터나 다른 파일에서 이 모듈을 불러서 사용할 때는 __name__ == "__main__"이 거짓이 되어 if문 다음 문장이 수행되지 않는다.

• 모듈에 있는 변수 클래스 사용

#mod2.py 작성
PI = 3.141592

class Math: 
    def solv(self, r): 
        return PI * (r ** 2) 

def add(a, b): 
    return a+b 

모듈 안에 있는 변수 및 클래스를 사용하려면 "."(도트 연산자)로 클래스 이름 앞에 모듈 이름을 먼저 입력해야 한다.

>>> import mod2
>>> print(mod2.PI)
3.141592
>>> a = mod2.Math()
>>> print(a.solv(2))
12.566368

• 다른 파일에서 모듈 불러오기 : 동일한 디렉토리에 있는 서로 다른 파일은 "import 모듈이름"으로 다른 파일의 모듈을 불러와 사용할 수 있다.

패키지

• 정의 : 패키지(Packages)는 도트(.)를 사용하여 파이썬 모듈을 계층적(디렉터리 구조)으로 관리할 수 있게 해준다. 예를 들어 모듈 이름이 A.B인 경우에 A는 패키지 이름이 되고 B는 "A 패키지의 B모듈"이 된다.

• 패키지 만들기

1. C:/디렉터리 밑에 game 및 기타 서브 디렉터리를 생성

C:/game/__init__.py
C:/game/sound/__init__.py
C:/game/sound/echo.py
C:/game/graphic/__init__.py
C:/game/graphic/render.py

2. 각 디렉터리에 __init__.py 파일을 만들어 놓기만 하고 내용은 일단 비워 둔다.

3.  echo.py 파일은 다음과 같이 작성.

# echo.py
def echo_test():
    print ("echo")

4. render.py 파일은 다음과 같이 작성

# render.py
def render_test():
    print ("render")

5. game 패키지를 참조할 수 있도록 명령 프롬프트 창에서 set 명령어로 PYTHONPATH 환경 변수에 C:/ 디렉터리를 추가

C:\> set PYTHONPATH=C:/
C:\> python
Type "help", "copyright", "credits" or "license" for more information.
>>> 

• 패키지 안의 함수 실행

1.  echo_test 함수를 실행

# echo 모듈을 import하여 실행
>>> import game.sound.echo
>>> game.sound.echo.echo_test()
echo

# echo 모듈이 있는 디렉터리까지를 from ... import하여 실행
>>> from game.sound import echo
>>> echo.echo_test()
echo

#  echo 모듈의 echo_test 함수를 직접 import하여 실행
>>> from game.sound.echo import echo_test
>>> echo_test()
echo

2. import game을 수행하면 game 디렉터리의 모듈 또는 game 디렉터리의 __init__.py에 정의한 것만 참조

>>> import game
>>> game.sound.echo.echo_test()
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'sound'

3. 도트 연산자(.)를 사용해서 import a.b.c처럼 import할 때 가장 마지막 항목인 c는 반드시 모듈 또는 패키지여야만 한다.

>>> import game.sound.echo.echo_test
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
ImportError: No module named echo_test

• __init__.py : __init__.py 파일은 해당 디렉터리가 패키지의 일부임을 알려주는 역할을 한다. 

1. 제어문

2. 함수

3. 입출력

1. 제어문

if 문

• 기본구조
  • if 조건문 1 : 
        수행할 문장 1
        수행할 문장 2
    elif 조건문 2 :
        수행할 문장 1
        수행할 문장 2
    else :
        수행할 문장 a
        수행할 문장 b

while문

• 기본구조
  • while 조건문 : 
        수행할 문장 1
        수행할 문장 2
        수행할 문장 3
        if 조건문 1 :
            수행할문장 1
            continue
        if 조건문 2 :
            break

for문

• 기본구조
  
  • for 변수 in 리스트|튜플|문자열 : 
        수행할 문장 1
        수행할 문장 2
        if 조건문 1 :
            continue
        if 조건문 2 :
            break
• for문+ range( )
  
  • for 변수 range(시작숫자, 끝 숫자)
        수행할 문장 1
        수행할 문장 2
        if 조건문 1 :
            continue
        if 조건문 2 :
            break
• 리스트내포 (list comprehension) : 리스트 안에 for문을 포함하는 것
  
  • a = [1,2,34]
    result = [num*3 for num in a] // [3,6,9,12]

2. 함수

• 함수의 구조
  • def 함수이름(매개변수) : 
        수행할문장1
        수행할문장2
        return 결과값
• 매개변수(parameter) : 함수에 입력으로 전달된 값을 받는 '변수'
• 인수(arguments) : 함수를 호출할 때 실제 전달하는 입력'값'
• 입력값이 몇개가 될지 모를때
  • 여러개의 입력값을 받는 함수 : 매개변수 앞에 * 을 붙이면 입력값을 모아서 튜플로 만든다
    
    • def 함수이름( * 매개변수) 
          수행할문장1
          수행할문장2
          return 결과값

• 매개변수 초깃값 설정 // 초깃값설정시 맨 오른쪽 매개변수부터 차례대로 설정
  
  • def 함수이름(매개변수1, 매개변수2=값2) 
        수행할문장1
        수행할문장2
        return 결과값

• 스코프 : 변수의 효력범위
  • 함수 안에서 사용할 변수의 이름을 함수 밖에서도 동일하게 사용하여도 함수 밖의 변수는 함수의 영향을 받지 않는다
  • 함수 안에서 함수 밖의 변수를 변경하는 방법
    • return 사용하여 결과값을 함수 밖의 변수에 할당
    • global 키워드 사용
• 람다 : 함수생성시 사용하는 예약어로 함수를 매우 간단하게 생성하게 한다
  
  • lamda 매개변수1, 매개변수2, ... : 매개변수를 사용한 표현식 ( 반환값)
  • ex) add = lamda a, b : a+b; add(3,4) // 7
          or (lamda a,b : a +b)(3,4) // 7

3. 입출력

• 사용자입력 : input( ) 
• 프롬프트 출력 : print( )
  • 문자열 띄어쓰기 : print('aa', 'bb', 'cc') // aa bb cc
  • 한줄에 결과값 출력 : for i in range(10) : print( i, end=' ') // 0 1 2 3 4 5 6 7 8 9
• 파일열기
  • 파일객체 = open(파일이름, 파일열기모드)
    • f = open('file.txt', r)
  • 파일열기모드
    • r : 읽기모드
    • w : 쓰기모드
    • a : 추가모드 (파일 마지막에 새로운 내용 추가)
• 파일 객체 닫기 : f.close( )
• 파일쓰기
  • f.write(data)
• 파일 읽기
  • line = f.readline( ) // 파일의 첫번째 줄을 읽는다
  • lines = f.readlines( ) // 파일의 모든 줄을 읽어서 각각의 줄을 요소로 갖는 리스트 반환
  • data = f.read( ) // 파일의 내용 전체를 문자열로 반환
• with 키워드
  • with 키워드를 사용하여 with 블록을 지정하고, 그 안에서 파일을 열고 작업한다. 이후 with 블록을 벗어나게 되면 해당 파일 객체를 자동으로 close( ) 한다
  • ex) with open("foo.txt", "w") as f :
             f.write("this is data")
         // 이후 with 블록 벗어나므로 자동으로 f.close 가 된다

1. 숫자형

2. 문자열

3. 리스트

4. 튜플

5. 딕셔너리

6. 집합(set)

7. 불

8. 변수

1. 숫자형

• 정수형 
  • >>> a = 123
• 실수형 
  • >>> a = 1.7
• 8진수
  • >>> a = 0o777
• 16진수
  • >>> a = 0xCDE
• 연산 (a=3, b=2)
  • a + b // 5
  • a - b // 1
  • a * b // 6
  • a / b // 1.5
  • a ** b // 9
  • a % b // 1
  • a // b // 1

2. 문자열

• 문자열 생성
  • "string"
  • 'str'
  • """string""" // 여러줄인 문자열 입력시
  • '''string''' // 여러줄인 문자열 입력시
• 문자열 연산
  • "abc" + "def" // "abcedf"
  • "abc" * 2 // "abcabc"
  • len("abc") // 3
• 문자열 인덱싱
  • a = "this is string" // a[5] = 'i' , a[-2] = 'n' 
• 문자열 슬라이싱
  • a = "this is string"
  • a[0:5] = "this i"
  • a[3:] = " s is string"
  • a[:-2] = "this is stri"
• 문자열 포매팅(formatting)
  • "this is %s" %string // 'this is string'
  • "%d is three" %3 // '3 is number'
  • "{0} is {1}" .format(3, "number") // '3 is number'
• 문자열 내장함수
  • a = "apple"; a.count('p') // 2 : p의 갯수
  • a = "apple"; a.find('p') // 1 : 첫번째 p의 인덱스
  • "," .join('abcd') // 'a,b,c,d' : 문자열 의 각각의 문자 사이에 "," 삽입
  • a = "     bc"; a.lstrip() // a="bc" : 문자열의 가장 왼쪽 공백 제거
  • a = "bc      "; a.rstrip() // a="bc" : 문자열의 가장 오른쪽 공백 제거
  • a = "  bc  ";  a.strip() // a="bc" : 문자열 양쪽 공백 제거
  • a = "abc"; a.replace("bc", "ee") // a= "aee" : 문자열 바꾸기
  • a = "this is string"; a.split() // ["this", "is", "string"] 공백을 기준으로 문자열 나눔

3. 리스트

• 리스트생성
  • a = [ 1, "abc", [ 2, "def"]]
• 리스트 인덱싱
  • a[2][1] // "def"
  • a[0] + a[2][0] // 3
• 리스트 슬라이싱
  • a[1: ] // ["abc", [2,"def"]]
• 리스트 연산
  • a = [1,2,3]; b[4,5,6]; a+b // [1,2,3,4,5,6]
  • a = [1,2,3]; len(a) // 3
• 리스트 수정
  • a = [1,2,3]; a[1] = 4 // [1,4,3]
• del함수 - 요소삭제
  • a = [1,2,3]; del a[1] // [1,3]
• 리스트내장함수
  • a = [1,2,3]; a.ppend(4) // [1,2,3,4]
  • a = ['c', 'a', 'a']; a.sort() // ['a', 'b', 'c']
  • a = [1,2,3]; a.index(2) // 1
  • a = [1,2,3]; a.insert(1, 'a') // [1,'a',2,3]
  • a = [1,2,3,4,3]; a.remove(3) // [1,2,4,3]
  • a = [1,2,3]; a.pop() // 3, a = [1,2]

4. 튜플

• 특징 : 요소값의 수정이 불가능
• 튜플 생성
  • a = (1, 'a', ( 2, 'bc'))
• 튜플 인덱싱
  • a[1] // 'a'
  • a[2][0] // 2
• 튜플 슬라이싱
  • a[1:] // ('a',(2,'bc'))
• 튜플 연산
  • a[0] + a[2][0] // 3
  • len(a) // 3

5. 딕셔너리

• 정의 : '키-값'의 쌍으로 이루어진 자료형
• 딕셔너리 생성
  • a = { 'name' : 'kim', 'age' : 22, 'list' : [1,2,3] }
• 딕셔너리 쌍 추가
  • a['job'] = 'police' // a = { 'name' : 'kim', 'age' : 22, 'list' : [1,2,3], 'job' : 'police' }
• 딕셔너리 쌍 삭제
  • del a['age'] // a = { 'name' : 'kim', 'list' : [1,2,3], 'job' : 'police' }
• 딕셔너리 요소 접근
  • a['list] // [1,2,3]
• 내장함수
  • 키 리스트 만들기 1 : a.keys() // dict_keys(['name', 'age', 'list']) : 키값을 가지고 있는 "객체" 반환
  • 키 리스트 만들기 2 : list(a.keys()) // ['name', 'age', 'list'] : 키 값을 가지고 있는 "리스트"반환
  • 값 리스트 만들기 1 : a.values() // dict_values(['kim', 22, [1,2,3]]) 객체반환
  • 리스트 만들기 2 :  list(a.values()) // ['kim', 22, [1,2,3] ]
  • 키-값 쌍 얻기 1 : a.items() // dict_items( [ ('name', 'kim'), ('age', 22), ('list', [1,2,3] ) ] )
  • 키-값 쌍 얻기 2 : list(a.items()) // [('name', 'kim'), ('age', 22), ('list', [1,2,3] ) ]
  • 키-값 쌍 모두 지우기 : a.clear()
  • 키로 값 얻기 : a.get('name') // 'kim'
  • 해당 키가 딕셔너리 안에 있는지 검사 : 'name' in a // true 

6. 집합(set)

• 정의 : 집합 관련 연산을 쉽게 처리하기 위해 만들어진 자료형으로 고유한 특징을 가진다.
• 특징 
  • 중복을 허용하지 않는다
  • 순서가 없다 -> set자료형에 저장된 값을 인덱싱으로 접근하려면 리스트나 튜플로 변환 후 접근
• 생성
  • s1 = set([1,2,3]); s2 = set([3,4,5])
•  연산
  • 교집합 : s1 & s2 or s1.intersection(s2) // { 3 }
  • 차집합 : s1- s2 or s1.difference(s2) // { 1, 2 }
  • 합집합 : s1 | s2  or s1.union(s2) // { 1, 2, 3, 4, 5 }
• 내장함수
  • 값 추가 : s1.add(4) // { 1, 2, 3, 4 }
  • 값 여러개 추가 : s1.update([4,5]) // { 1, 2, 3, 4, 5 }
  • 특정값 제거 : s1.remove(2) // { 1, 3 }
• 활용법
  • 리스트로 변환 :  l1 = list(s1); l1[1] // 2
  • 튜플로 변환 : t1 = tuple(s1); t1[1] // 2

7. 불

• 정의 : 침과 거짓을 나타내는 자료형
• 생성
  • a = True
  • b = False
• 자료형의 참과 거짓 : 문자열, 리스트, 튜플, 딕셔너리 등의 값이 비어 있으면 거짓이 되고, 비어 있지 않으면 참
  • False : "", [], (), {}, 0, None
  • True : "a", [0], (1), {2:3}, -1 (영이 아닌 숫자)
• 불연산
  • bool([]) // False
  • bool((0)) // True

8. 변수

• 정의 : 객체(자료형)가 저장된 메모리 주소를 가리키는 것
• 메모리 주소 확인 : id(a) // 123123243
• 복사
  • 단순 복사 : 동일한 객체를 가리킴
    • a = [ 1,2,[1,2]]; b= a; id(a) == id(b) // True 
  • 얕은 복사 : 복합객체(껍데기)만 복사, 그 내용은 동일한 객체
    • import copy; b = copy.copy(a); b[0] =3; b[2].append(3);
    • print(a) // [1,2,[1,2,3]]
    • print(b) // [3,2,[1,2,3]]
  • 깊은 복사 : 복합객체 복사 + 그 내용도 재귀적으로 복사
    • import copy; b = copy.deepcopy(a); b[0] = 3; b[2].append(3);
    • print(a) // [1,2,[1,2]]
    • print(b) // [3,2,[1,2,3]]