==========================================================================
해당 공부한 python 내용은
https://www.codecademy.com/en/tracks/python-ko 내용을 바탕으로 작성하였으며,
그 외 필요한 부분은 검색 한 내용을 정리했습니다
내용 수정이 필요하다 하는 부분은 댓글을 달아주세요
==========================================================================
1. 불린 자료형과 따옴표(' or ") 함께 사용하지 않기
첫번째 글자는 대문자로 작성 - 파이썬 대소문자 구별
따옴표는 문자열과 함게 사용
int - 정수형
floats - 실수형
boolean - 참/ 거짓
-> python 자료형 쓰지 않는듯 하다
2. 명령문(statement)
자바스크립트는 ; 으로 각각의 문장이 끝나나 python은 공백으로 구분된다
인터프리터(interpreted)언어
3. 주석은 #
여러줄 주석은 """
4. 거듭제곱 **
예) 2 ** 3 = 2x2x2 = 8
모듈러스(modulus) : 어떤수를 정수로 나누고 난 나머지값 . 그냥 나머지값으로 생각하기
5. 아무기호나 문자열에 사용할 수 없으므로 몇몇 결과에는 특수한 문자들을 통해서만 얻을 수 있다
'Help! Help! I\'m being repressed!' 여기서 백슬래쉬를 쓰면 특수한 문자들이 들어있는 문자열 해결
6. pi => 문자로 만듬.
예) str = 3.12
변수 = str(pi)
7. len(변수),str(변수): 문자열로 만드는것 / 변수.lower()/변수.upper()
8. 동적 문자열 포맷팅
예)%s 으로 돌아가지 말자. 그곳은 멍청한 %s 이다." % (string_1, string_2)
근데 파이썬 2.6에는 동적 문자열 포맷팅을 구현하는 새로운 방법있다 % 쓰는것보다 진보된 .format 문자열 메소드 있다
다만 이건 2.6 이전 버전에는 작동하지 않는다
.format 메소드는 값을 지정한 뒤, 문자열 안의 값을 대체하도록 한다. 그 다음 {some_name} 같이 중괄호 속에 변수 이름 넣어 사용한다
예) "저는 {type} 입니다".format(type="문자열")
my_name = "철수"
"안녕하세요, 제 이름은 {name} 입니다".format(name=my_name)
흐름제어(control Flow) : 여러개의 결과값을 만들고, 프로그램의 진행상황에 따라 그 중 하나의 결과를 선택하도록 한다
불린 연산자(Boolean Operators)
True 그리고(and) True의 결과는 True
True 그리고(and) False의 결과는 False
False 그리고(and) True의 결과는 False
False 그리고(and) False의 결과는 False
True 또는(or) True의 결과는 True
True 또는(or) False의 결과는 True
False 또는(or) True의 결과는 True
False 또는(or) False의 결과는 False
True 부정(not)의 결과는 False
False 부정(not)의 결과는 True
불린 연산자에도 다음과 같은 우선 순위(order of precedence) 또는 연산 순서(order of operations)이 존재합니다:
not 연산자를 제일 먼저 연산합니다;
and 연산자를 그 다음으로 연산합니다;
or 연산자를 제일 마지막으로 연산합니다;
이 순서는 소괄호(())를 이용하면 변경할 수 있습니다. 소괄호 안의 연산은 소괄호 밖의 연산보다 먼저, 그리고 따로 진행됩니다.
if 수식:
# 실행할 코드 첫째 줄
# 실행할 코드 둘째 줄
# 기타 등등
answer = "이 정돈 그냥 긁힌거지!"
def black_knight():
if answer == "이 정돈 그냥 긁힌거지!":
return True
else:
return False # False 값을 반환하도록 만드세요
def french_soldier():
if answer == "저리 꺼져, 그렇지 않으면 또 다시 본떼를 보여주마!":
return True
else:
return False # False 값을 반환하도록 만드세요
파이썬에서는 raw_input 명령어를 사용해서 사용자에게 어떤 값을 입력할 것인지 물어볼 수 있습니다. 예를들어, 다음과 같이 작성한다면:
name = raw_input("이름이 무엇인가요?")
파이썬은 다음과 같이 출력할 겁니다:
이름이 무엇인가요? >
사용자가 무언가를 입력하고 Enter를 누르면, 파이썬은 해당 입력값을 변수 name에 저장할 것입니다.
함수(function)는 프로그램 안에서 특정 업무를 수행하도록 미리 쓰여진, 재사용 가능한 코드 부분입니다.
1.만약 코드 안의 무언가가 잘못 되었다면, 프로그램을 잘 정돈해 두는 쪽이 오류를 수정하는 데 훨씬 쉽습니다. 특정 업무를 분리된 함수 안에 할당함으로써 프로그램의 정돈을 도울 수 있죠.
2.특정 업무를 함수에 할당함으로써 (컴퓨터 과학자들은 이를 관심의 분리(separation of concerns)라고 부릅니다) 여러분의 프로그램을 덜 불필요한 동시에 더 재사용 가능하게 만들어 줍니다. 하나의 프로그램 안에서 반복되는 코드를 매번 다시 작성할 필요없이 함수를 사용할 수 있을 뿐더러, 심지어 또 다른 프로그램에서도 해당 함수를 사용할 수 있습니다.
3.객체(object)에 관해 좀 더 배우면, 객체에 속한 함수(메소드(method)라고 부릅니다)들을 가지고 얼마나 흥미로운 일들을 많이 할 수 있는지 알게될 겁니다.
4.D.R.Y. Don't Repeat Yourself, 즉 반복하지마라는 프로그래밍의 원칙 중 하나입니다. 함수를 이용하면 반복을 피하기 훨씬 쉽습니다.
5.재귀호출(Recursion)은 강력한 도구입니다. 이는 코드 덩어리를 몇 번이고 스스로 호출할 수 있게 합니다. 재귀호출 없이는 해결할 수 없는 프로그래밍 문제도 있습니다! 함수는 재귀호출이 가능하도록 만듭니다.
함수(Function) 연결
함수는 def 키워드("define"의 줄임형)를 사용하여 정의할 수 있습니다. 함수는 세 가지 부위로 이루어 집니다:
헤더(header), 이 부분은 def 키워드와 함수의 이름, 그리고 소괄호(()) 안에 받아들이는 매개변수(parameters), 콜론(:)을 포함합니다. (다음 과제에서 매개변수에 관해 다룰 것입니다.)
선택적 독스트링(docstring), 이 부분은 세 개의 따옴표(""")로 처리하며, 여러 줄 주석에서 무슨 기능을 하는지 간단하게 설명했었습니다.
바디(body), 이 부분은 함수가 진행하는 과정을 나타내는 코드 블럭입니다. 바디 부분은 if, elif, else 명령문의 코드 블럭처럼 들여쓰기 합니다.
console에 문자열 "Ni!"를 출력하는 간단한 함수 ni_sayer를 통해 함수의 문법 예제를 보여드리겠습니다:
def ni_sayer():
"""console에 문자열 'Ni!'를 출력"""
print "Ni!"
(이는 독스트링의 사용을 보여주는 좋은 예제가 아닙니다. 이상적으로, 독스트링은 한 눈에 파악하기 어려운 내용을 설명하는데 쓰여야 합니다.)
함수가 어떤 인자(arguments)를 가질 때, 우리는 이를 가리켜 해당 인자를 받아들인다(accept)고 한다. 예를 들어, 함수 no_one이 하나의 인자로 문자열 "The Spanish Inquisition"를 가질 때, 함수 no_one은 "The Spanish Inquisition"을 인자로 받아들인다고 할 수 있다.
엄밀히 말하자면, 인자(argument)는 함수를 호출할 때 함수의 소괄호 속에 집어넣는 코드 부분이며, 매개변수(parameter)는 함수를 정의할 때 함수의 소괄호 속에 집어넣는 코드의 이름입니다. 이를 테면 여러분이 이전 과제에서 함수 square를 정의할 때, 매개변수로 n ("number"를 뜻함)를 지정했지만, 함수를 호출할 때에는 여기에 인자로 숫자 10을 전달했습니다.
함수를 정의할 때 인자에 붙이는 일종의 별명이 매개변수라고 생각하셔도 됩니다. 이후 함수를 호출할 때 매개변수 위치에 들어갈 인자가 무엇이 될 지, 함수를 정의하는 단계에선 알 수 없기 때문입니다.
받아들인 인자를 그대로 출력하도록 만들어진 함수의 문법을 예제로 살펴보겠습니다:
함수 정의:
def no_one(sentence):
print sentence
함수 호출:
no_one("The Spanish Inquisition")
console에 출력될 내용:
"The Spanish Inquisition"
이는 함수 no_one을 호출했을 때, 인자로 전달한 "The Spanish Inquisition"을 매개변수 sentence가 받아들인 값입니다.
모듈 임포트(importing modules)의 예시입니다. 모듈(module)은 여러분이 사용할 수 있는 여러 변수와 함수의 정의를 담고 있는 파일입니다. 매번 변수와 함수들을 작성하는 건 인터프리터를 지저분하게 만들 수 있습니다. 따라서 모듈(module) 안에 이들을 담아두고 필요할 때마다 불러오는(import)
예를 들어 파이썬에는 math란 이름의 모듈이 있다. sqrt()를 비롯한 여러 변수, 함수 포함되어 있는데
이 모듈에 접근하려면 import 키워드를 사용하기만 하면 된다. 이렇게 단순한 방법으로 모듈을 불러올때 이를 제네릭 임포트(generic import) 라고 부른다
import math
print math.sqrt(25)
다만, 하지만 math 모듈 전체를 불러오는 것은 두 가지 이유로 성가시다고 할 수 있습니다: 첫째로, 오직 sqrt 함수만 필요해도 전체 모듈을 불러와야 하기 때문이고, 둘째로, math 모듈로부터 함수를 참조할 때 항상 math.sqrt()라고 작성해야만 하기 때문이죠.
다행히도 주어진 모듈로부터 특정 변수나 함수만을 불러올 수 있습니다. 모듈로 부터 하나의 함수를 불러오는 방법을 가리켜 함수 임포트(function import)라 부르고, 다음과 같이 from 키워드를 사용해서 작성할 수 있습니다:
from module import function
예) math 모듈로부터 sqrt 함수 임포트
from math import sqrt
import math를 이용해서 math 모듈을 불러오는 건 기본적으로 다음과 같은 의미입니다: "Math 상자를 내 방으로 가져와, 그래야 그 안에 있는 유용한 도구들을 이용할 수 있어." 언제든 math 안에 포함된 도구를 원하면, math 상자로 가서 해당 도구를 꺼내와야 합니다. (그래서 항상 math.name 이라고 작성하는 겁니다. math 상자를 방으로 가져왔음에도, 모든 유용한 도구들은 아직 그 상자 안에 담겨 있기 때문이죠.)
만약 from math import sqrt라고 작성한다면, 다음과 같은 뜻이 됩니다: "Math 상자에서 오직 제곱근 도구(sqrt)만 가져오고, math 상자는 내 방으로 가져오지마." 이는 math를 언급할 필요없이 sqrt를 사용할 수 있다는 의미입니다. 하지만 그 외의 것들을 math로 부터 가져오려면, 각각의 함수와 변수들을 따로 따로 불러와야(import) 합니다. 왜냐하면 전체 math 상자는 방 안에 없기 때문이죠.
세 번째 방법은 다음과 같습니다: "Math 상자를 방에 가져 오진 말고, 그 안에 있는 도구 거의 전부를 가져와." 이는 매우 다양한 도구를 가질 수 있다는 장점을 가집니다. 또한 해당 도구들을 math 상자로부터 꺼내 방으로 가져왔기 때문에, 변수나 함수를 사용할 때마다 계속 math.name이라고 작성할 필요가 없기도 합니다.
이 방법의 문법은 다음과 같습니다:
from module import *
유니버설 임포트(Universal Imports)는 겉으로 보기엔 대단해 보이지만, 한 가지 정말 중요한 이유로 그리 좋은 아이디어가 아니라고 할 수 있습니다: 유니버설 임포트를 사용하면 어마어마한 양의 변수와 함수를 불러올 수 있지만, 이들이 여러분이 작성한 변수나 함수와 충돌을 일으킬 수 있기 때문입니다.
만약 여러분이 직접 만든 sqrt라는 이름의 함수가 있는 상태에서 math 모듈을 제네릭 임포트(generic import)를 통해 불러온다면, 여러분의 함수는 안전합니다: 여러분이 만든 함수는 sqrt가 될 것이고, 모듈로 부터 불러온 함수는 math.sqrt가 될 것이기 때문입니다. 하지만 만약 유니버설 임포트(universal import)를 통해 from math import *라고 모듈을 불러오면, 문제가 생깁니다: 두 가지 다른 함수가 똑같이 sqrt라는 이름을 사용해서 충돌을 일으키기 때문이죠.
심지어 여러분이 작성한 정의가 모듈로 부터 불러들인 이름들과 직접적으로 충돌하지 않는다고 해도 import *를 통해 여러 모듈들을 한꺼번에 불러오면 어떤 변수와 함수가 어떤 모듈로부터 왔는지 파악하기 어려울 겁니다. 이는 마치 제각기 다른 여러 박스로부터 수 없이 많은 도구들을 여러분의 방 안에 무작위로 쏟아부어 섞은 다음, 박스는 치워버려서 각각의 도구가 어느 박스로부터 왔는지 찾을 수 없게 만드는 것과 같습니다.
이러한 이유로, 필요에 따라 제네릭 임포트를 사용하거나 특정 변수 및 함수를 모듈로부터 불러오는 것이 가장 좋은 방법입니다.
import math # math 모듈을 불러옵니다
everything = dir(math) # math 모듈 안의 모든 것을 목록으로 만들어 변수에 저장합니다
print everything # 변수 안에 담긴 리스트 전부를 출력합니다!
abs() 함수는 인자로 받아들인 숫자의 절댓값(absolute value) abs() 함수는 언제나 양수 값을 반환하며 오직 하나의 숫자만을 인자
type() 함수
마지막으로, type() 함수는 매우 흥미로운 기능을 담당합니다: 이 함수는 인자로 받아들인 값의 자료형(type)을 반환
예)
print type(42)
print type(4.2)
print type('spam')
print type({'Name':'John Cleese'})
print type((1,2))
<type 'int'>
<type 'float'>
<type 'unicode'>
<type 'dict'>
<type 'tuple'>
리스트형(Lists)은 자료형(data type)으로, 서로 다른 정보의 집합을 배열로써 하나의 변수 이름 안에 저장하는데 사용할 수 있습니다. (자료형은 이미 전에 배운 개념으로, 여기에는 문자열과 숫자, 불린값 등이 포함됩니다.)
다음과 같은 형식을 이용해서 리스트에 요소들을 할당할 수 있습니다:
list_name = [item_1, item_2]
대괄호 안에 리스트에 할당할 요소들을 넣으면 됩니다. 또한 empty_list = [] 와 같이 리스트는 비어있을 수도 있습니다.
색인(index)을 통해 리스트 안에 들어있는 개별 요소에 접근할 수 있습니다. 색인은 리스트 내에서 요소들의 위치를 나타내는 일종의 주소와 같습니다. 색인은 리스트 이름 바로 뒤 대괄호 사이에 list_name[index]
리스트는 고정된 길이를 가질 필요가 없습니다. 아무 때나 여러분이 원하면 요소들을 리스트의 끝에 추가할 수 있습니다! 파이썬에서, 우리는 리스트를 변경가능(mutable)하다고 여깁니다.
list_name[a:b]라는 코드는 리스트 list_name의 색인 a부터 시작해서 색인 b 이전까지의 위치를 반환합니다.
리스트를 자르던 방법과 똑같은 방법으로 문자열을 자를 수 있습니다! 사실 문자열을 문자들의 리스트라고 생각하셔도 됩니다: 문자열을 구성하는 각 문자들은 리스트 안에서 색인 0부터 시작하는 연속적 요소와 같습니다.
만약 리스트나 문자열을 자를 때, 리스트의 맨 앞이나 맨 끝이 포함되는 경우에는 다음과 같이 색인을 생략할 수 있습니다
my_list[:2]
# 앞 부분의 두 요소를 잘라냄
my_list[3:]
# 뒤로부터 네 개의 요소를 잘라냄
index() 함수를 이용해서 리스트를 검색할 수 있습니다
예)index() 함수를 이용하여 변수 duck_index에 문자열 "duck"의 색인을 할당하세요. 그런 다음 문자열 "cobra"를 "duck"이 있던 색인에 추가(insert)하세요.
animals = ["aardvark", "badger", "duck", "emu", "fennec fox"]
duck_index = animals.index("duck")
animals.insert(duck_index,"cobra")
for문
for variable in list_name:
# 실행할 코드!
for 키워드 다음에 변수의 이름이 위치하는데, 여기에 매번 반복이 진행될 때마다 리스트 안 각각의 요소들이 할당됩니다. in list_name 부분은 반복을 진행할 리스트로 list_name을 지정하는 역할을 합니다. for 구문 부분은 콜론(:)으로 작성을 마치며, 리스트 안의 요소들이 반복될 때마다 콜론 다음에 들여쓰기된 코드 부분이 실행됩니다.
사전형은 리스트와 유사합니다. 그러나 인덱스 대신 키(key*)를 통해 저장된 값에 접근합니다. 문자열이나 숫자를 키로 사용할 수 있습니다. 사전은 다음과 같이 중괄호 열고 닫습니다:
위의 코드는 d 라는 사전에 세 개의 키-값의 쌍(key-value pair)이 들어있음을 나타냅니다. 'key1' 이 값 1 을 가리키고, 'key2' 는 2 가리키는 식입니다.
사전형은 이름과 전화번호의 쌍으로 이루어진 전화번호부나, 이메일과 사용자 이름의 쌍으로 이루어진 로그인 페이지 등에 매우 유용하게 쓸 수 있습니다.
리스트와 마찬가지로, 사전형 역시 "변경 가능(mutable)"합니다. 이 특성 덕분에 사전형은 생성된 후에도 변경될 수 있습니다. 이러한 장점 덕에 생성 후에도 다음과 같이 새로운 키/값 쌍을 추가할 수 있습니다:
dict_name[new_key] = new_value
비어있는 대괄호 []가 빈 리스트를 나타내듯, 사전형에서 비어있는 중괄호 {}는 빈 사전형을 의미합니다.
사전형 안의 요소는 또한 del 명령어로 제거할 수 있습니다:
del dict_name[key_name]
my_list.remove(value)라는 코드는 리스트 my_list에서 value 값의 요소를 삭제합니다. del 과 .remove() 의 차이점은 다음과 같습니다:
del 은 키(key)를 기준으로 해당 키와 여기에 연관된 값을 지웁니다.
.remove() 는 값(value)을 기준으로 해당 값과 여기에 연관된 키를 지웁니다.
예)students 안의 모든 데이터를 출력(리스트 안에 사전 형태일때)
lloyd = {
"name": "Lloyd",
"homework": [90.0, 97.0, 75.0, 92.0],
"quizzes": [88.0, 40.0, 94.0],
"tests": [75.0, 90.0]
}
alice = {
"name": "Alice",
"homework": [100.0, 92.0, 98.0, 100.0],
"quizzes": [82.0, 83.0, 91.0],
"tests": [89.0, 97.0]
}
tyler = {
"name": "Tyler",
"homework": [0.0, 87.0, 75.0, 22.0],
"quizzes": [0.0, 75.0, 78.0],
"tests": [100.0, 100.0]
}
students=[lloyd,alice,tyler]
for dic in students:
print dic['name']
print dic['homework']
print dic['quizzes']
print dic ['tests']
리스트(lists)에서 요소 제거하기
이번 과제에서는 리스트로부터 요소를 삭제하는 여러 방법들을 살펴볼 텐데요, 몇 가지 조건이 존재합니다. 리스트 n과 관련하여:
n.pop(index)는 색인 index에 저장된 요소를 리스트로부터 제거하여 반환합니다:
n = [1, 3, 5]
n.pop(1)
# 결과로 3(색인 1에 저장된 요소)을 반환
print n
# 결과로 [1, 5] 출력
n.remove(item)은 리스트 안에 존재하는 요소 item을 제거합니다:
n.remove(1)
# 리스트로부터 요소 1을 삭제,
# 주의: 색인 1에 저장된 요소를 삭제하는 것이 아닙니다!
print n
# 결과로 [3, 5] 출력
del(n[1])은 .pop처럼 주어진 색인에 저장된 요소를 제거하지만, .pop과 달리 값을 반환하지 않습니다:
del(n[1])
# 아무런 값도 반환하지 않음
print n
# 결과로 [1, 5] 출력
파이썬의 range() 함수는 리스트를 만드는 손쉬운 방법으로, 따라서 리스트를 사용한 곳이라면 어디든 레인지를 사용할 수 있습니다.
Range 함수는 하나나 둘, 또는 세 개의 인자를 가질 수 있습니다. 만약 하나의 인자를 사용하면, 레인지는 0부터 시작해서 인자보다 1만큼 작은 값에 다다를 때까지 순차적으로 1씩 증가합니다. 예를 들면:
range(1) # => [0]
range(2) # => [0,1]
만약 두 개의 인자를 사용한다면, 첫 번째 인자로부터 시작하여 두 번째 인자보다 1만큼 작은 값에 다다를 때까지 다음과 같이 1씩 증가합니다:
range(1,3) # => [1,2]
만약 세 개의 인자를 사용한다면, 레인지는 첫 번째 인자로부터 시작하여 두 번째 인자에서 끝나며, 세 번째 인자는 증가치가 되어 기본값인 1을 대신하여 레인지가 순차적으로 얼마만큼 증가할 지를 결정합니다. 예를 들면:
range(2,8,3) # => [2,5]
range(2,9,3) # => [2,5,8]
isinstance() 내장 함수는 식별자가 특정 형의 데이터를 갖고 있는지 확인
쉼표나 따옴표 같은 서식을 지우기 위해서는 파이썬의 또 다른 내장 함수인 .join을 사용하면 됩니다.
print " ".join(row)
함수 안에 위의 코드를 작성하면, 파이썬은 각각의 열(row)에 있는 문자열 "O"들 사이에 공백을 남기면서 하나로 연결(concatenate)
while 반복문은 if 명령문과 비슷하게 작동하는데, 만약 어떤 조건이 참이라면 안에 들어있는 코드를 실행합니다. 차이점이라면 while 반복문은 해당 조건이 참인 동안은 계속해서 코드를 실행한다는 점입니다. 다른 말로 만약(if) 조건이 참인 경우 코드를 실행하는 대신 조건이 참인 동안(while) 코드를 실행한다고 할 수 있겠네요.
파이썬에서 완전히 다른 게 있다면 while/else 구조입니다. while/else는 if/else와 비슷하지만 차이점이 하나 있습니다: 반복문의 조건문이 False으로 판명되면 언제든지 else 블록을 실행한다는 것이죠. 이는 반복문이 한 번도 시작하지 않거나, 또는 일반적으로 종료되어도 else 부분이 실행된다는 의미입니다. 만약 반복문이 break로 인해 종료된다면 else 명령문은 실행되지 않을 겁니다.
print 명령어의 맨 마지막에 쉼표(,)를 쓰면 출력된 내용들이 각각의 줄에 따로 떨어지지 않고 다음과 같이 한 줄에 나타난다
예) print "X",
추가적으로, 하나의 줄에 여러가지 것들을 출력할 땐 쉼표(',')를 이용해서 서로 떼어놓으세요. print "string", 6이라고 작성하면 파이썬은 6을 문자열로 바꿀 것입니다
수 enumerate는 전달하는 리스트 안의 개별 요소들에 상응하는 색인을 제공함으로써 작동합니다. 매번 반복이 진행될 때마다, 색인(index)은 하나씩 증가할 것이고, 요소(item)는 순서상에서 다음 요소로 옳겨갈 것입니다. 이는 일반적인 for 반복문을 리스트에 사용하는 것과 매우 유사합니다. 이 방법이 우리가 지금까지 얼마나 많은 요소를 봤는지 셀 수 있는 쉬운 길
예)
choices = ['pizza', 'pasta', 'salad', 'nachos']
print 'Your choices are:'
for index, item in enumerate(choices):
print index+1, item
[결과 : Your choices are:
1 pizza
2 pasta
3 salad
4 nachos ]
===
파이썬의 함수 items()는 사전형을 반복하여 그 안의 키/값 쌍(pair)을 반환합니다
my_dict = {
"Name": "Guido",
"Age": 56,
"BDFL": True,
"lazy": True
}
print my_dict.keys()
print my_dict.values()
print my_dict.items()
함수 items()는 튜플(tuples)*의 배열(array)을 반환하며, 각각의 튜플은 사전형으로 부터 가져온 키/값 쌍으로 구성됩니다.
- [('Name','Guido'),('Age','56'),('BDFL',True),('lazy',True)] 식으로 출력이 된다
함수 keys()는 사전형 안에 있는 키(key)들의 배열을 반환합니다.
함수 values()는 사전형 안에 있는 값(value)들의 배열을 반환합니다.
다시 말씀드리지만, 위의 함수들은 사전형으로부터 받은 키나 값을 어떤 특정 순서에 맞춰 반환하지 않습니다.
하지만 만약 우리가 어떤 논리 구조에 따른 리스트를 생성하고 싶다면 어떨까요? 예를 들어, 0부터 50까지의 짝수로 이루어진 리스트와 같이 말입니다.
파이썬에서 이에 대한 해답은 리스트 내포(list comprehension)입니다. 리스트 내포는 for/in과 if 키워드를 사용하여 리스트를 생성하는 강력한 방법입니다.
new_list = [x for x in range(1,6)]
# 결과로 다음의 값 출력 => [1, 2, 3, 4, 5]
doubles = [x*2 for x in range(1,6)]
# 결과로 다음의 값 출력 => [2, 4, 6, 8, 10]
doubles_by_3 = [x*2 for x in range(1,6) if (x*2)%3 == 0]
# => [6]
두 배로 만든 숫자 중에서 3으로 나누어 떨어지는 숫자만을 남기고 싶다 ↑
리스트 내포시 a = [ y for y in range(1,11)] 일때
range(1,11)통해 숫자 1~10 생성한것을 for y . 2번째 y를 통해 숫자를 하나씩 꺼내고 첫번째 y로 리스트를 생성한다
만약, a = [ y+5 for y in range(1,11)] 이면 2번째 y를 통해 숫자를 하나씩 꺼낸것을 y+5를 더한 값으로 리스트 생성한다
doubles_by_3 = [x*2 for x in range(1,6) if (x*2)%3 == 0]
- 숫자를 1~5로 생성하고, if()조건에 해당하는 숫자를 for x. 즉 2번째 x를 통하여 하나씩 꺼낸것 가지고 첫번째 x로 리스트를 생성한다
a = [i * j for j in range(2, 10)
for i in range(1, 10)]
이런식으로 for문을 여러개 작성할 수도 있는데, 순서는 다음과 같다.
- for j in range(2,10) 2~9까지 숫자를 하나씩 꺼낸것을
- for i in range(1,10) 1~9까지 숫자를 하나씩 꺼낸것을
- i * j 로 리스트를 생성한다
종종 리스트의 일부분만을 필요로 할 때도 있습니다. 앞 부분의 몇 요소만 원하거나, 뒷 부분의 몇 요소만 원할수도 있습니다. 또는 그 외의 요소들이 필요할 수도 있죠!
(기존 [:] 했던것의 응용이라고 생각하기)
리스트 슬라이싱(list slicing)은 리스트의 축약된 부분의 요소들에 접근할 수 있도록 합니다. 문법은 다음과 같습니다:
[start:end:stride(step)]
step: 단계라고 생각하기 건너뛰기로
근데 step 이 음수면
my_list = range(1, 11)
backwards = my_list[::-1]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 이 된다
수의 스트라이드(stride)는 왼쪽부터 시작해서 오른쪽으로 리스트를 가로지르며, 음수의 스트라이드는 오른쪽부터 시작해서 왼쪽으로 리스트를 가로지릅니다.
또한 스트라이드 길이(Stride Length)가 1인 경우에는 리스트의 요소를 "하나씩" 가로지르며, 스트라이드 길이가 2인 경우에는 리스트의 요소를 "둘 씩" 가로지릅니다. 이런식으로 계속됩니다.
함수형 프로그래밍: 함수를 마치 변수나 값처럼 전달할 수 있다는 의미입니다
lambda x: x % 3 == 0 식은
def by_three(x):
return x % 3 == 0 과 같다
유일한 차이점은 함수에 이름을 지정하지 않는다는 겁니다; 해당 함수는 이름 없이도 작업을 수행하고 값을 반환합니다. 바로 이런 이유로 람다(Lambda)를 통해 생성한 함수를 무명 함수(anonymous function)
람다(Lambda) 함수는 다음의 문법을 사용해서 정의됩니다:
lambda variable: expression
람다(Lambda)는 작업을 하기 위해 빠르게 함수를 필요로 할 때 유용합니다. 만약 앞으로 계속해서 사용할 함수를 만들 계획이라면, def 키워드를 사용해서 함수에 이름을 지정하는 것이 좋습니다.
람다 형식은 인공지능 분야나 AutoCAD라는 설계 프로그램에서 쓰이는 Lisp 언어에서 물려받았다고 하는데요, 함수를 딱 한 줄만으로 만들게 해주는 훌륭한 녀석
다시 람다 표현식을 예제와 함께 살펴보게 되면
def plus_ten(x):
return x+10
lambda x : x+10
plus_ten(x) 즉 매개변수 x 가 lambda: x 가 되고
return x+10이 :x+10 이 된다.
람다는 map, filter, reduce 함수가 있다.
여기서 filter는 각각의 요소에 대해 boolean 값을 반환하는데 true 면 그 요소는 남게 되고 false는 제거 된다
languages = ["HTML", "JavaScript", "Python", "Ruby"]
filter() 함수 사용하여 python 단어 만 뽑아내려면?
filter(function,iterable)
filter(lambda x : x == 'Python', languages)
비트 단위 연산(Bitwise operations)은 직접적으로 비트(bits)를 조작하는 연산
파이썬에서는 숫자를 0b으로 시작함으로써 이진법으로 해당 숫자를 작성
print 0b1, #1
print 0b10, #2
print 0b11, #3
print 0b100, #4
print 0b101, #5
print 0b110, #6
print 0b111 #7
파이썬에는 비트 단위 연산을 돕는 함수들이 있습니다. 함수 bin()을 이용해서 이진수로 숫자를 출력할 수 있습니다. 함수 bin()은 정수형 값을 입력값으로 받아 해당 값의 이진수 형태를 문자열로 반환. 함수 oct()와 hex()를 이용해서 숫자를 각각 8진수와 16진수로 나타낼 수 있습니다.
int()가 추가적으로 두 번째 매개변수를 가질 수 있다는 사실이죠. 첫 번째 인자는 알다시피 정수형으로 변환할 숫자를 담은 문자열을 넣고, 두 번째 인자는 첫 번째 인자 안의 숫자가 몇진수인지를 나타내는 숫자. 그럼 함수는 해당 진수의 숫자 십잔수 정수형으로 반환해준다
따라서 int("1010", 2)라는 코드는 결과로 10
앞으로 다뤄볼 두 가지 연산은 좌측 시프트(left shift)와 우측 시프트(right shift) 비트 단위 연산자
좌측 시프트 연산 (<<)
0b000001 << 2 = 0b000100 (1 << 2 = 4)
0b000101 << 3 = 0b101000 (5 << 3 = 40)
우측 시프트 연산 (>>)
0b0010100 >> 3 = 0b000010 (20 >> 3 = 2)
0b0000010 >> 2 = 0b000000 (2 >> 2 = 0)
비트 단위 AND 연산자(&)는 각각의 슬롯을 개별적으로 비교하는데, 두 숫자 모두 해당 슬롯이 공통으로 1일 경우에만 1을, 한쪽이라도 0이라면 0
비트 단위 OR 연산자(|)는 두 개의 숫자를 비트 단위에서 비교하여 숫자를 반환 두 숫자 중 어느 한 쪽이라도 해당 슬롯이 1이라면 1을, 양쪽 모두 0일 경우에만 0
XOR, 또는 배타적 논리합(exclusive OR) 연산자는 두 개의 숫자를 비트 단위에서 비교하여 숫자를 반환 두 숫자 중 어느 한 쪽의 해당 슬롯만 1일 경우 1을, 양쪽 모두 0일 경우나 모두 1일 경우에는 0을 반환
NOT 연산자(~)는 하나의 숫자 안에 있는 모든 비트들의 현재 값을 반대
비트 마스크(Bit Mask)는 비트 단위 연산을 돕기위해 사용하는 일반적인 변수입니다. 비트 마스크는 특정 비트를 켜고(1로 전환) 끄거나(0으로 전환), 어떤 정수 안의 비트 상태에 관한 정보를 모으는 등의 작업을 돕습니다............?
파이썬은 객체 지향 프로그래밍(object-oriented programming) 언어로, 이는 파이썬이 객체(object)라 불리는 프로그래밍 구조를 다룬다는 뜻입니다. 하나의 자료 구조(data structure) 안에 함수(객체에 지정된 함수를 메소드(method)라 부릅니다)와 데이터들을 담고 있는 것을 객체
기본적인 클래스는 class 키워드, 클래스의 이름, 그리고 새로운 클래스가 상속(inherit)받을 클래스가 괄호 안에 들어간 형태
일반적으로 클래스는 데이터의 추상적인 집합을 생성하고 접근하는데 매우 유용
소괄호 안에는 object라는 단어를 적어 넣는데, 작성할 클래스가 object 클래스로부터 상속받기(inherit)를 바라기 때문입니다. 이는 작성한 클래스가 가장 단순하며 기초가 되는 object 클래스의 모든 속성을 가진다는 의미
class NewClass(object):
- 클래스 이름 NewClass, 상속받을 클래스 object
__init__(self) : 클래스에 사용되며, 클래스가 생성하는 객체를 초기화(initialize)합니다. 함수 __init__()은 항상 적어도 하나의 인자 self를 갖는데요, 이는 생성된 객체를 나타냅니다. 함수 __init__()를 일종의 클래스가 생성하는 각각의 객체들을 "부팅하는" 함수라고 생각하셔도 됩니다.
self 이 매개변수가 생성된 객체에 그 객체의 식별값(identity)을 부여. 첫 번째 매개변수로 이 단어를 사용하는 건 일반적인 일입니다. 따라서, 다른 사람들이 여러분의 코드를 이해할 수 있도록 self를 이용
파이썬의 클래스에서 또 다른 중요한 요소는 바로 범위(Scope)입니다. 변수의 범위는 프로그램 내에서 해당 변수가 어느 맥락에서 사용 가능한지를 나타냅니다.
어디서든 사용 가능한 변수(전역변수. Global variables), 특정 클래스의 맴버로만 사용 가능한 변수(멤버 변수. Member variables), 클래스의 특정 인스턴스에만 사용할 수 있는 변수(인스턴스 변수. Instance variables)
예를 들어
class Car(object):
condition = "new"
my_car = Car()
print my_car.condition
있을 때, car 클래스의 인스턴스인 객체 my_car를 생성했고, my_car에는 이미 condition 이라는 멤버 변수를 가지고 있고
이 속성은 my_car가 생성되는 즉시 값을 할당받는다
해당 클래스 만의 함수를 가질 때, 이 함수를 가리켜 메소드(method)라고 부릅니다. 이미 여러분이 봤던 함수 __init__()가 메소드의 하나
*********클래스, 인스턴스***********
'김연아'는 실제로 존재하죠? 네, 여러분이 생각하시는 그 김연아 맞아요. ㅎㅎ '김동성'도 실제로 존재하죠? 두 사람 다 실제로 존재하는 사람입니다.
두 사람의 공통점은 무엇일까요? 여러 가지를 들 수 있겠지만 둘 다 '스케이터'라는 공통점을 갖고 있지요.
'스케이터'라는 단 하나의 사람이나 물건이 실제로 존재할까요? 그렇지는 않습니다. 하지만 우리는 '스케이트 타는 사람'을 '스케이터'라고 말합니다. 이런 것을 일컫는 말이 클래스(class)입니다. 우리 말로 옮기기는 쉽지 않지만 '부류'라는 의미로 생각하시면 좋을 것 같아요.
다른 예를 들어볼까요?
'사과'는 클래스이구요, '내가 엊저녁에 먹은 사과 다섯 개 중에 두 번째 것'이라고 콕 찍어서 말해주면 실체(instance)로 봐줄만합니다.
'좋은 집'은 실체일까요? 어느 한 집만을 콕 찍어서 '좋은 집'이라고 하기는 힘들 것 같군요. 그럼 '우리 집'은 실체일까요? 그건 실체라고 해도 될 것 같네요. 단, 집을 여러 채 가진 사람이 '우리 집'이라고 말할 때는 정확히 어느 집을 가리키는 것인지 알 수 없겠죠. 프로그램 작성을 위해 클래스를 설계하다보면 이런 애매한 문제를 만날 때도 있지요
>>> class Singer: # 가수를 정의하겠느니라…
... def sing(self): # 노래하기 메서드
... return "Lalala~"
...
>>> taeji = Singer() # 태지를 만들어랏!
>>> taeji.sing() # 노래 한 곡 부탁해요~
'Lalala~'
클래스를 만들 때는 위와 같이 class 클래스이름: 형식으로 시작해서 그 다음부터 그 클래스의 성질이나 행동을 정의해주면 됩니다. 둘째 줄에는 함수가 정의되어 있죠? 이와 같이 클래스 내부에 정의된 함수를 메서드(method)라고 부릅니다.
여기서 sing 메서드는 Singer라는 클래스가 하는 행동을 정의하고 있죠. Singer 클래스를 만든 다음에는 taeji라는 객체를 만들었습니다. 인스턴스명 = 클래스()와 같이 만들면 되죠.
**********************
class Animal(object):
"""귀여운 동물(animal)들을 생성."""
is_alive = True
health = "good"
def __init__(self, name, age,):
self.name = name
self.age = age
# 여기에 메소드를 추가하세요!
# self 전달-어떤것을 언급하고 있는지 모름
def description(self):
print self.name
print self.age
hippo = Animal("hippo","4")
sloth = Animal("sloth","3")
ocelot = Animal("ocelt","6")
print hippo.health #good 출력
print sloth.health #good 출력
print ocelot.health #good 출력
__init__에 name, age 전달.
보다 현실적인 예제:
class ShoppingCart(object):
"""웹사이트 이용자들을 위한 쇼핑 카드 객체 생성."""
items_in_cart = {}
def __init__(self, customer_name):
self.customer_name = customer_name
def add_item(self, product, price):
"""상품을 카트에 추가."""
if not product in self.items_in_cart:
self.items_in_cart[product] = price
print product + " added."
else:
print product + " is already in the cart."
def remove_item(self, product):
"""카트에서 상품을 제거."""
if product in self.items_in_cart:
del self.items_in_cart[product]
print product + " removed."
else:
print product + " is not in the cart."
// ShoppingCart의 __init__이 customer_name을 받으니까 이름 준채 부팅 시킨 후 해당 메소드 이용
my_cart = ShoppingCart("jiwon")
my_cart.add_item("lemon",30)
상속은 하나의 클래스가 또 다른 클래스로부터 속성과 메소드를 받는 과정으로, is-a 관계라고 표현됩니다. 예를 들어, 판다는 곰이므로, (Panda is a bear), Panda 클래스는 Bear 클래스로부터 상속받을 수 있습니다. 하지만 도요타 자동차는 트랙터가 아니므로, Toyota 클래스는 Trector 클래스로부터 상속받을 수 없습니다. (속성이나 메소드 등, 둘 사이의 많은 부분이 비슷하다고 하더라도 말이죠.) 대신 Toyota와 Trector 클래스 모두 자동차이므로, 같은 Vehicle 클래스로부터 상속받을 수 있습니다.
그 위에 덮어 쓰도록(오버라이드. Override)
class Employee(object):
"""실제 종업원을 모델로 생성!"""
def __init__(self, employee_name):
self.employee_name = employee_name
def calculate_wage(self, hours):
self.hours = hours
return hours * 20.00
# 아래에 코드를 추가하세요!
class PartTimeEmployee(Employee):
def calculate_wage(self, hours):
return hours * 12.00
위와 같이 class Employee 의 함수 calculate_wage를 덮어씌웠다
super() 함수 호출하기
파생 클래스(또는 서브클래스(subclass))를 가지고 작업을 하다보면, 종종 베이스가 되는 클래스(부모(parent) 클래스, 또는 슈퍼클래스(superclass))로부터 상속받은 속성이나 메소드를 덮어 썼는데, 알고 봤더니 상속받은 값이 필요하다는 걸 깨달을 때도 종종 있습니다. 겁먹지 마세요! 파이썬의 내장 함수인 super를 호출해서 슈퍼클래스의 속성이나 메소드에 직접 접근할 수 있습니다.
class Employee(object):
"""실제 종업원을 모델로 생성!"""
def __init__(self, employee_name):
self.employee_name = employee_name
def calculate_wage(self, hours):
self.hours = hours
return hours * 20.00
# 아래에 코드를 추가하세요!
class PartTimeEmployee(Employee):
def full_time_wage(self, hours):
return super(PartTimeEmployee, self).calculate_wage(hours)
// super(클래스이름, self).부모메소드중내가사용할메소드(부모메소드중내가사용할메소드의 인자)
// 부모 변수 참조할때는 부모클래스.변수 하면 된다
milton = PartTimeEmployee("milton")
print milton.full_time_wage(10)
컴퓨터 파일로부터 정보를 읽거나, 정보를 다른 파일에 작성하고 싶다면 어떻게 해야할까요?
이 과정을 가리켜 파일 입/출력(File I/O) (I/O는 Input/Output의 줄임말)
f = open("output.txt", "w")
"w" 모드("w"는 "write(쓰기)"의 줄임말)로 output.txt를 열라고 전달합니다. 그리고 이 연산의 결과를 파일 객체인 f에 저장
쓰기 모드의 파일을 열고, 파이썬에게 파일에 데이터를 전달할 준비를 시킵니다.
"r+"는 파일이 읽고 쓰기 모두 가능
my_file.write(적을단어 + "\n") 하면 한줄씩 적혀나온다
my_file.read() 이렇게 파일 읽기 근데 이건 파일 전체 한번에 읽어나감
한줄에 하나씩 읽어나가려면 my_file.readline()
근데 늘 my_file.close() . 자꾸 파일 읽고 쓴 다음 close()로 파일을 닫아야 한다고 했는데 그 이유는,
파일 입/출력 과정 진행 중, 데이터들은 버퍼(buffer) 처리됩니다: 이는 해당 데이터들이 파일에 쓰여지기 이전에 일시적인 장소에 담겨있다는 의미입니다. 파이썬은 여러분이 작성을 끝냈다고 확인하기 전까지 버퍼를 플러쉬(flush the buffer)(즉, 파일에 데이터를 작성)하지 않습니다. 이를 위한 또 하나의 방법은 파일을 닫는 것입니다. 만약 파일을 닫지 않고 작성한다면, 데이터는 이를 타겟 파일로 만들지 못할 것입니다.
다음은 최악인 코드다
# 파일 열어 데이터 읽기
read_file = open("text.txt", "r")
# 두 번째 인자를 이용하여 읽기 전용 파일 열기
write_file = open("text.txt", "w")
# 파일에 데이터 쓰기
write_file.write("Not closing files is VERY BAD.")
# 파일로부터 데이터를 읽어보세요
print read_file.read()
바로 실행시키면 read_file.read()코드 아무런 데이터 읽어드리지 못하는것 확인
프로그래밍이란 건 결국 컴퓨터에게 작업을 시키기 위한 것입니다. 만약 파이썬에 파일을 자동으로 닫게끔 하는 방법이 있다면 어떨까요?
물론 존재합니다. 그래야 바로 파이썬
파일 객체는 특별한 내장 메소드 쌍을 가지고 있는데요, __enter__()와 __exit__() 입니다. 이에 대한 세부 내용보다 중요한 것은 파일 객체의 __exit__() 메소드가 적용될 때, 파일이 자동으로 닫힌다는 겁니다. 그럼 이 메소드를 어떻게 적용시킬 수 있을까요? with와 as를 사용하면 됩니다.
문법은 다음과 같습니다:
with open("file", "mode") as variable:
예) with open("text.txt", "w") as textfile:
textfile.write("Success!")
그럼 자동으로 잘 닫혀있나 확인하기 위해서
파일 객체에는 closed라는 속성이 있는데 이는 파일이 닫혔을 땐 값으로 True를, 그렇지 않을땐 False를 갖습니다. fileobject.closed라고 작성함으로써 해당 파일이 닫혔는지 여부를 알 수 있으며, 만약 닫히지 않았을 땐 close() 함수를 호출해서 닫아줄 수 있습니다.
예)
with open("text.txt","w") as my_file:
my_file.write("i love greentea!")
//my_file이 close가 되지 않으면 닫아줘라
if(my_file.closed != True):
my_file.close()
print my_file.closed
