- 기초, 자료형
- >>> a = 4.24E10 >>> a = 4.24e-10
- 4.24 x 10^10
- x의 y제곱을 나타내는 ** 연산자
- >>> a = 3
- >>> b = 4
- >>> a ** b 81
- 나눗셈 후 몫을 반환하는 // 연산자
- >>> 7 / 4 = 1.75
- >>> 7 // 4 = 1
- 문자열 슬라이딩
- >>> a = "Life is too short, You need Python" >>> a[0:4] 'Life'
- a[시작번호:몇개]
- a[ : 몇개] : 처음부터 몇개
- a[시작번호 : ] : 시작번호부터 끝까지
>>> a = [1, 2, 3, 4, 5]
>>> b = a[:2]
>>> c = a[2:]
>>> b
[1, 2]
>>> c
[3, 4, 5]
//리스트 길이 구하기
a=[1,2,3]
len(a)
3
//리스트 수정
a=[1,2,3]
a[2]=4
a=[1,2,4]
//del 함수 리스트삭제
a=[1,2,3]
del a[1]
a=[1,3]
a=[1,2,3,4,5]
del[2:0] //2부터끝까지삭제한다.
a=[1,2]
//리스트 요소 추가
a=[1,2,3]
a.append(4)
a=[1,2,3,4]
a=[1,2,3]
a.append([5,6])
a=[1,2,3,[5,6]]
//리스트 정렬
a=[1,4,3,2]
a.sort()
a
a=[1,2,3,4]
a=[1,2,3]
a.reverse()
a=[3,2,1]
//리스트 find=index
a=[1,2,3]
a.index(3)
2
//리스트 요소삽입(insert)
a=[1,2,3]
a.insert(0,4)
a=a=[4,1,2,3]
a=[1,2,3]
a.insert(3,5) //배열a[3]=5이다.
a=[1,2,3,5]
//리스트 요소 삭제(remove)
a.remove(x) : 처음나오는 x를 삭제한다.
a=[1,2,3,1,2,3]
a.remove()
a=[1,2,1,2,3]
//리스트 요소 끄집어내기(pop)
pop_back()
a=[1,2,3]
a.pop()
a=[1,2]
//리스트의 포함된 x의 개수 새기 count(x)
a=[1,2,3,1]
a.count(1)
2
//리스트 확장
//extend(x)에서 x는 리스트만 올 수 이쓰며 원래의 a리스트이 x리스트를 더하게 된다.
a=[1,2,3]
a.extend([4,5])
a
a=[1,2,3,4,5]
- 문자열 포맷팅
- 숫자 바로 대입
- >>> "I eat %d apples." % 3
- 'I eat 3 apples.'
- number = 3
- >>> "I eat %d apples." % number
- 결과 : 'I eat 3 apples.'
- 숫자 바로 대입
- 문자열 바로 대입
- >>> "I eat %s apples." % "five" '
- 결과 : I eat five apples.
- >>> number = 10 >>> day = "three"
- >>> "I ate %d apples. so I was sick for %s days." % (number, day)
- 결과 : 'I ate 10 apples. so I was sick for three days.'
- format 함수를 사용한 포매팅
- >>> "I eat {0} apples".format(3)
- 결과 : 'I eat 3 apples'
- >>> number = 3
- >>> "I eat {0} apples".format(number)
- 결과 : 'I eat 3 apples'
- >>> number = 10 >>> day = "three"
- >>> "I ate {0} apples. so I was sick for {1} days.".format(number, day)
- 결과 : 'I ate 10 apples. so I was sick for three days.'
=================================================================================================================리스트 ==================================
============================================================================
- 리스트 자료형
- 형식 -> odd = [1, 3, 5, 7, 9]
- 예제)
- >>> a = [1, 2, 3, ['a', 'b', 'c']]
- >>> a[0] 1
- >>> a[-1] ['a', 'b', 'c'] //뒤로 가기 가능
- >>> a[3] ['a', 'b', 'c']
- 형식 -> odd = [1, 3, 5, 7, 9]
- 리스트에 요소 추가(append)
- >>> a = [1, 2, 3]
- >>> a.append(4)
- 결과 : >>> a [1, 2, 3, 4]
- 리스트 정렬(sort)
- >>> a = [1, 4, 3, 2]
- >>> a.sort()
- 결과 : >>> a [1, 2, 3, 4]
- 위치 반환(index)
- >>> a = [1,2,3]
- >>> a.index(3) 2
- 결과 : >>> a.index(1) 0
- 리스트에 요소 삽입(insert)
- >>> a = [1, 2, 3]
- >>> a.insert(0, 4)
- 결과 : >>> a [4, 1, 2, 3]
- 리스트 요소 제거(remove)
- >>> a = [1, 2, 3, 1, 2, 3]
- >>> a.remove(3)
- 결괴 : >>> a [1, 2, 1, 2, 3] //첫번째 3만 없어진 것을 알 수있다
- 리스트 요소 끄집어내기(pop)
- >>> a = [1,2,3]
- >>> a.pop() //맨 뒤 3을 꺼낸다. ==pop_back() = vector랑 같은 후입선출...
- >>> a [1, 2]
=================================================================================================================튜플 ===================================
============================================================================
- 튜플(tuple)은 몇 가지 점을 제외하곤 리스트와 거의 비슷하며 리스트와 다른 점은 다음과 같다.
- 리스트는 [ ]으로 둘러싸지만 튜플은 ( )으로 둘러싼다.
- 리스트는 그 값의 생성, 삭제, 수정이 가능하지만 튜플은 그 값을 바꿀 수 없다.
- 형식
- >>> t1 = ()
- >>> t2 = (1,)
- >>> t3 = (1, 2, 3)
- >>> t4 = 1, 2, 3
- >>> t5 = ('a', 'b', ('ab', 'cd'))
===============================================================================================================딕셔너리 ===================================
============================================================================
a={key1:value1,key2:velue2,...}
b={1:'a','b':[1,2,3]}
//딕셔너리 요소 삭제하기
del a[1]
del a[key] 처럼 입력하면 지정한 key에 해당하는 {key, value} 쌍이 삭제된다.
//key 리스트 만들기
a={'name':'pey','phone':'0123123'}
a.keys()
dict_keys(['name',phone'}
a.keys()는 딕셔너리 a의 key만 모아서 dict_keys객체를 돌려준다.
//value 리스트 만들기 (values)
a.values()
dict_values(['pey','0123123'}
//key,value 쌍 얻기(items
a.tiems()
dict_items(...)
//key:value 쌍으로 지우기
a.clear()
a
{}
//key로 value 얻기
a.get('name')
'pey'
a.get('phone')
'001010203'
//key가 딕셔너리안에 존재하는지 조사하기(in)
a={'name':'pey','phone':'0123123'}
'name' in a //a안에name이있나
True
'email' in a
False
- 딕셔너리
- key,value형식 이며 {}로 둘러싸여 있다.
- key값은 중복을 허용하지 않는다. =map
- 형식
- {Key1:Value1, Key2:Value2, Key3:Value3, ...}
- >>> dic = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}
- 딕셔너리 쌍 추가하기
- >>> a = {1: 'a'}
- >>> a[2] = 'b'
- 결과 : >>> a {1: 'a', 2: 'b'}
- 딕셔너리 요소 삭제
- >>> del a[1]
- 결과 : >>> a {2: 'b', 'name': 'pey', 3: [1, 2, 3]}
- del 함수를 사용해서 del a[key] 처럼 입력하면 지정한 Key에 해당하는 {key:value}쌍이 삭제된다.
- key값이용하여 value값 얻기.
- >>> grade = {'pey': 10, 'julliet': 99}
- >>> grade['pey'] 결과 : 10
- >>> grade['julliet'] 결과 : 99
- (get)이용
- >>> a = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}
- >>> a.get('name') 결과 : 'pey'
- >>> a.get('phone') 결과 : '0119993323'
- key가 딕셔너리에 존재 하는지 조사 하기(in)
- >>> a = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}
- >>> 'name' in a True
- >>> 'email' in a False
===============================================================================================================IF조건문===================================
============================================================================
money = True
if money :
print("택시")
else:
print("걸어가라")
pocket =['paper','cellphone','money']
if 'money' in pocket:
print("택시")
else
print("걸어가라")
>>> pocket = ['paper', 'cellphone']
>>> card = True
>>> if 'money' in pocket:
... print("택시를 타고가라")
... elif card:
... print("택시를 타고가라")
... else:
... print("걸어가라")
...
===================================================================================================================while==================================
============================================================================
treeHit=0
while treeHit<10:
treeHit = treeHit +1
print("나무를%d번 찍었습니다" %treeHit)
iftreeHit==10:
print("나무넘어갑니다")coffee = 10
while True:
money = int(input("돈을 넣어 주세요: "))
if money == 300:
print("커피를 줍니다.")
coffee = coffee -1
elif money > 300:
print("거스름돈 %d를 주고 커피를 줍니다." % (money -300))
coffee = coffee -1
else:
print("돈을 다시 돌려주고 커피를 주지 않습니다.")
print("남은 커피의 양은 %d개 입니다." % coffee)
if coffee == 0:
print("커피가 다 떨어졌습니다. 판매를 중지 합니다.")
break===================================================================================================================for문==================================
============================================================================
//기본구조
for 변수 in 리스트(또는 튜플, 문자열):
수행할 문장1
수행할 문장2
...
//1) 예제
test_list = ['one', 'two', 'three']
for i in test_list;
print(i)
결과 :
one
two
three
//2) 예제
>>> a = [(1,2), (3,4), (5,6)]
>>> for (first, last) in a:
... print(first + last)
...
3
7
11
//3) 예제
marks = [90,25,67,45,80]
number=0
for mark in marks:
number =number +1
if mark >=60:
print("%d번 학생은 합격입니다" %number)
else:
print("%d번 학생은 불합격입니다"%number)
//4) 예제 range 함수
a= range(10)
-->결과 : range(0,10) // 0부터 10미만의 숫자를 포함하는 range 객체를 만들어 줍니다.
add=0
for i in range(1,11)
add = add+i
print(add)
//5) 예제 range함수 활요
marks =[90,24,23,1,32]
for number in range(len(marks)):
if marks[number] < 60:
continue
print("%d 학생 축하합니다. 합격입니다" %(number+1))
>>> for i in range(2,10): # ①번 for문
... for j in range(1, 10): # ②번 for문
... print(i*j, end=" ")
... print('')
...
2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81==================================================================================================================함수==================================
============================================================================
def 함수이름(매개변수):
<수행할 문장>
...
return 결과값
def add(a, b):
result = a + b
return result
//일반적인 함수
def add(a,b)
result = a+b
return result;
//입력값이 없는 함수
def say()
return 'HI'
// 입력값이 몇 개가 될지 모를 때는 어떻게 해야 할까?
def add_many(*args)
result = 0
for i in args:
result = result + i
return result
result = add_many(1,2,3)
print(result)
결과 : 6
result = add_many(1,2,3,4,5,6,7,8,9,10)
print(result)
결과 : 10
//다른 예시
>>> def add_mul(choice, *args):
... if choice == "add":
... result = 0
... for i in args:
... result = result + i
... elif choice == "mul":
... result = 1
... for i in args:
... result = result * i
... return result
...
>>>
>>> result = add_mul('add', 1,2,3,4,5)
>>> print(result)
15
>>> result = add_mul('mul', 1,2,3,4,5)
>>> print(result)
120
//함수의 결괏값은 언제나 하나이다
>>> def add_and_mul(a,b):
... return a+b, a*b
>>> result = add_and_mul(3,4)
결과 : result = (7, 12)
>>> result1, result2 = add_and_mul(3, 4)
결과 : result=7, result2=12==================================================================================================================내장함수================================
===================================================
abs
abs(x)는 어떤 숫자를 입력받았을 때, 그 숫자의 절댓값을 돌려주는 함수이다.
>>> abs(3) 3 >>> abs(-3) 3 >>> abs(-1.2) 1.2=========================
chr
chr(i)는 아스키(ASCII) 코드 값을 입력받아 그 코드에 해당하는 문자를 출력하는 함수이다.
※ 아스키 코드란 0에서 127 사이의 숫자를 각각 하나의 문자 또는 기호에 대응시켜 놓은 것이다.
>>> chr(97) 'a' >>> chr(48) '0'
divmod
divmod(a, b)는 2개의 숫자를 입력으로 받는다. 그리고 a를 b로 나눈 몫과 나머지를 튜플 형태로 돌려주는 함수이다.
>>> divmod(7, 3) (2, 1)
몫을 구하는 연산자 //와 나머지를 구하는 연산자 %를 각각 사용한 결과와 비교해 보자.
>>> 7 // 3 2 >>> 7 % 3 1
enumerate
enumerate는 "열거하다"라는 뜻이다. 이 함수는 순서가 있는 자료형(리스트, 튜플, 문자열)을 입력으로 받아 인덱스 값을 포함하는 enumerate 객체를 돌려준다.
※ 보통 enumerate 함수는 다음 예제처럼 for문과 함께 자주 사용한다.
잘 이해되지 않으면 다음 예를 보자.
>>> for i, name in enumerate(['body', 'foo', 'bar']): ... print(i, name) ... 0 body 1 foo 2 bar
순서 값과 함께 body, foo, bar가 순서대로 출력되었다. 즉 위 예제와 같이 enumerate를 for문과 함께 사용하면 자료형의 현재 순서(index)와 그 값을 쉽게 알 수 있다.
for문처럼 반복되는 구간에서 객체가 현재 어느 위치에 있는지 알려 주는 인덱스 값이 필요할때 enumerate 함수를 사용하면 매우 유용하다.
filter
filter란 무엇인가를 걸러낸다는 뜻으로 filter 함수도 동일한 의미를 가진다.
filter 함수는 첫 번째 인수로 함수 이름을, 두 번째 인수로 그 함수에 차례로 들어갈 반복 가능한 자료형을 받는다. 그리고 두 번째 인수인 반복 가능한 자료형 요소가 첫 번째 인수인 함수에 입력되었을 때 반환 값이 참인 것만 묶어서(걸러 내서) 돌려준다.
다음 예를 보자.
#positive.py def positive(l): result = [] for i in l: if i > 0: result.append(i) return result print(positive([1,-3,2,0,-5,6]))
결과값: [1, 2, 6]
즉 위에서 만든 positive 함수는 리스트를 입력값으로 받아 각각의 요소를 판별해서 양수 값만 돌려주는 함수이다.
filter 함수를 사용하면 위 내용을 다음과 같이 간단하게 작성할 수 있다.
#filter1.py def positive(x): return x > 0 print(list(filter(positive, [1, -3, 2, 0, -5, 6])))
결과값: [1, 2, 6]
여기에서는 두 번째 인수인 리스트의 요소들이 첫 번째 인수인 positive 함수에 입력되었을때 반환 값이 참인 것만 묶어서 돌려준다. 앞의 예에서는 1, 2, 6만 양수여서 x > 0 문장이 참이되므로 [1, 2, 6]이라는 결괏값을 돌려주게 된 것이다.
앞의 함수는 lambda를 사용하면 더욱 간편하게 코드를 작성할 수 있다.
>>> list(filter(lambda x: x > 0, [1, -3, 2, 0, -5, 6])) [1, 2, 6]
람다(lambda)
lambda 인자 : 표현식
다음은 두 수를 더하는 함수입니다.
>>> def hap(x, y): ... return x + y ... >>> hap(10, 20) 30
이것을 람다 형식으로는 어떻게 표현할까요?
>>> (lambda x,y: x + y)(10, 20)
30
너무나 간단하죠? 함수가 이름조차도 없습니다. '그냥 10 + 20이라고 하면 되지'라고 말씀하시면 미워잉~.
몇 가지 함수를 더 배워보면서 람다가 어떻게 이용되는지 알아보도록 하죠.
hex
hex(x)는 정수 값을 입력받아 16진수(hexadecimal)로 변환하여 돌려주는 함수이다.
>>> hex(234) '0xea' >>> hex(3) '0x3'
id
id(object)는 객체를 입력받아 객체의 고유 주소 값(레퍼런스)을 돌려주는 함수이다.
>>> a = 3 >>> id(3) 135072304 >>> id(a) 135072304 >>> b = a >>> id(b) 135072304
input
input([prompt])은 사용자 입력을 받는 함수이다. 매개변수로 문자열을 주면 다음 세 번째 예에서 볼 수 있듯이 그 문자열은 프롬프트가 된다.
※ [ ] 기호는 괄호 안의 내용을 생략할 수 있다는 관례 표기법임을 기억하자.
>>> a = input() hi >>> a
'hi'
>>> b = input("Enter: ")
Enter: hi
int
int(x)는 문자열 형태의 숫자나 소수점이 있는 숫자 등을 정수 형태로 돌려주는 함수로, 정수를 입력으로 받으면 그대로 돌려준다.
>>> int('3') 3
>>> int(3.4) 3
int(x, radix)는 radix 진수로 표현된 문자열 x를 10진수로 변환하여 돌려준다.
2진수로 표현된 11의 10진수 값은 다음과 같이 구한다.
>>> int('11', 2) 3
16진수로 표현된 1A의 10진수 값은 다음과 같이 구한다.
>>> int('1A', 16) 26
isinstance
isinstance(object, class )는 첫 번째 인수로 인스턴스, 두 번째 인수로 클래스 이름을 받는다. 입력으로 받은 인스턴스가 그 클래스의 인스턴스인지를 판단하여 참이면 True, 거짓이면 False를 돌려준다.
>>> class Person: pass ... >>> a = Person() >>> isinstance(a, Person) True
위 예는 a가 Person 클래스가 만든 인스턴스임을 확인시켜 준다.
>>> b = 3 >>> isinstance(b, Person) False
b는 Person 클래스가 만든 인스턴스가 아니므로 False를 돌려준다.
len
len(s)은 입력값 s의 길이(요소의 전체 개수)를 돌려주는 함수이다.
>>> len("python") 6 >>> len([1,2,3]) 3 >>> len((1, 'a')) 2
list
list(s)는 반복 가능한 자료형 s를 입력받아 리스트로 만들어 돌려주는 함수이다.
>>> list("python") ['p', 'y', 't', 'h', 'o', 'n']
>>> list((1,2,3)) [1, 2, 3]
list 함수에 리스트를 입력으로 주면 똑같은 리스트를 복사하여 돌려준다.
>>> a = [1, 2, 3]
>>> b = list(a)
>>> b [1, 2, 3]
map
map(f, iterable)은 함수(f)와 반복 가능한(iterable) 자료형을 입력으로 받는다. map은 입력받은 자료형의 각 요소를 함수 f가 수행한 결과를 묶어서 돌려주는 함수이다.
다음 예를 보자.
# two_times.py
def two_times(numberList):
result = [ ]
for number in numberList:
result.append(number*2)
return result
result = two_times([1, 2, 3, 4])
print(result)
two_times 함수는 리스트 요소를 입력받아 각 요소에 2를 곱한 결괏값을 돌려준다. 실행 결과는 다음과 같다.
결과값: [2, 4, 6, 8]
위 예제는 map 함수를 사용하면 다음처럼 바꿀 수 있다.
>>> def two_times(x): ... return x*2 ...
>>> list(map(two_times, [1, 2, 3, 4]))
[2, 4, 6, 8]
이제 앞 예제를 해석해 보자. 먼저 리스트의 첫 번째 요소인 1이 two_times 함수의 입력값으로 들어가고 1 * 2의 과정을 거쳐서 2가 된다. 다음으로 리스트의 두 번째 요소인 2가 2 * 2 의 과정을 거쳐 4가 된다. 따라서 결괏값 리스트는 이제 [2, 4]가 된다. 총 4개의 요솟값이 모두 수행되면 마지막으로 [2, 4, 6, 8]을 돌려준다. 이것이 map 함수가 하는 일이다.
※ 위 예에서 map의 결과를 리스트로 보여 주기위해 list 함수를 사용하여 출력하였다.
앞의 예는 lambda를 사용하면 다음처럼 간략하게 만들 수 있다.
>>> list(map(lambda a: a*2, [1, 2, 3, 4]))
[2, 4, 6, 8]
max
max(iterable)는 인수로 반복 가능한 자료형을 입력받아 그 최댓값을 돌려주는 함수이다.
>>> max([1, 2, 3]) 3 >>> max("python") 'y'
min
min(iterable)은 max 함수와 반대로, 인수로 반복 가능한 자료형을 입력받아 그 최솟값을 돌려주는 함수이다.
>>> min([1, 2, 3]) 1 >>> min("python") 'h'
oct
oct(x)는 정수 형태의 숫자를 8진수 문자열로 바꾸어 돌려주는 함수이다.
>>> oct(34) '0o42' >>> oct(12345) '0o30071'
ord
ord(c)는 문자의 아스키 코드 값을 돌려주는 함수이다.
※ ord 함수는 chr 함수와 반대이다.
>>> ord('a') 97
>>> ord('0') 48
pow
pow(x, y)는 x의 y 제곱한 결괏값을 돌려주는 함수이다.
>>> pow(2, 4) 16
>>> pow(3, 3) 27
range
range([start,] stop [,step] )는 for문과 함께 자주 사용하는 함수이다. 이 함수는 입력받은 숫자에 해당하는 범위 값을 반복 가능한 객체로 만들어 돌려준다.
인수가 하나일 경우
시작 숫자를 지정해 주지 않으면 range 함수는 0부터 시작한다.
>>> list(range(5)) [0, 1, 2, 3, 4]
인수가 2개일 경우
입력으로 주어지는 2개의 인수는 시작 숫자와 끝 숫자를 나타낸다. 단 끝 숫자는 해당 범위에 포함되지 않는다는 것에 주의하자.
>>> list(range(5, 10)) [5, 6, 7, 8, 9]
인수가 3개일 경우
세 번째 인수는 숫자 사이의 거리를 말한다.
>>> list(range(1, 10, 2)) // 1~9까지 +2씩 for(int i = 0 ; i < 10 ; i=i+2)
[1, 3, 5, 7, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
round
round(number[, ndigits]) 함수는 숫자를 입력받아 반올림해 주는 함수이다.
※ [, ndigits]는 ndigits가 있을 수도 있고 없을 수도 있다는 의미이다.
>>> round(4.6) 5 >>> round(4.2) 4
다음과 같이 실수 5.678을 소수점 2자리까지만 반올림하여 표시할 수 있다.
>>> round(5.678, 2) 5.68
round 함수의 두 번째 매개변수는 반올림하여 표시하고 싶은 소수점의 자릿수
str
str(object)은 문자열 형태로 객체를 변환하여 돌려주는 함수이다.
>>> str(3) '3'
>>> str('hi') 'hi'
>>> str('hi'.upper()) 'HI'
sum
sum(iterable) 은 입력받은 리스트나 튜플의 모든 요소의 합을 돌려주는 함수이다.
>>> sum([1,2,3]) 6
>>> sum((4,5,6)) 15
type
type(object)은 입력값의 자료형이 무엇인지 알려 주는 함수이다.
>>> type("abc") <class 'str'>
>>> type([ ]) <class 'list'>
>>> type(open("test", 'w')) <class '_io.TextIOWrapper'>
zip
zip(*iterable)은 동일한 개수로 이루어진 자료형을 묶어 주는 역할을 하는 함수이다.
※ 여기서 사용한 *iterable은 반복 가능(iterable)한 자료형 여러 개를 입력할 수 있다는 의미이다.
잘 이해되지 않는다면 다음 예제를 살펴보자.
>>> list(zip([1, 2, 3], [4, 5, 6]))
[(1, 4), (2, 5), (3, 6)]
>>> list(zip([1, 2, 3], [4, 5, 6], [7, 8, 9]))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> list(zip("abc", "def"))
[('a', 'd'), ('b', 'e'), ('c', 'f')]