엘리스-데이터분석(2)

iterable 과 iterator

iterable:반복 가능한 객체(list, dict, set, str, bytes, tuple, range)
iteratoer:값을 차례대로 꺼낼 수 있는 객체

iterator와 next

iterable 과 iterator

elice=['e','l','i','c','e']

elice_iterator=iter(elice)
#이터레이터의 에터형은 나 자신이다!
print(iter(elice_iterator)==elice_iterator)

print(next(elice_iterator)) #next를 통해 다음으로 요소로 넘어간다!
print(next(elice_iterator))
print(next(elice_iterator))
print(next(elice_iterator))
print(next(elice_iterator))
print(next(elice_iterator)) #마지막요소를 지나치면 에러를 낸다!

True
e
l
i
c
e
Traceback (most recent call last):

iterator과 반복문

dict={'a':1,'b':2,'c':3,'d':4}
dict_iter=iter(dict) #dict도 iterable하기떄문에 iterator가 될 수 있다!
print(list(dict_iter))
for i in dict_iter: #for 는 자동을 iter(iterable객체)를 해주고 next를 통해 다음으로 넘어가기에 위에서 list메서드에서 이미 다 next를 해줘서 현재의 for는 순회안한다!
    print(i)

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

언패킹

data=['Hi','im','good','coder']
a,b,c,d=data
print(a,b,c,d)

Hi im good coder

패킹

def sum_all(*packing):
    sentence=""
    for word in packing:
        sentence+=word+' '
    print(sentence)
sum_all(*['Hi','im','good','coder'])

Hi im good coder

제너레이터

#yield를 통해 순서가 있는 이터레이터를 생성
def gen(n):
    for i in range(n):
        yield(i*2)
        
iterator=gen(5)
for i in iterator:
    print(i)

0
2
4
6
8

List comprehension

msg="i love python"
msg_list=msg.split()
a=[len(i) for i in msg_list]
print(a)

[1, 4, 6]

Dictionar.get()

dict={'a':1,'b':2,'c':3,'d':4}
#'a'리는 요소가 있다면 불러오고 없다면 뒤의 20을 반환!
print(dict.get('a',20))
print(dict.get('e',20))

1
20

lambda 표현식

#set(lis1+list2)은 둘의 중복된 요소를 걸러준다! 
union=lambda x,y:list(set(x+y))
#lambda는 이름없는 함수의 기능을 한다!
print(union([1,2,3,4],[3,4,5,6]))

[1, 2, 3, 4, 5, 6]

Map

numbers=[1,2,3,4,5,6]
#앞의 익명함수에 뒤의 iterable한 객체들의 원소를 하나씩 넣고 반환한 것들의 iterator를 list로 변환
result=list(map(lambda x:x*x,numbers))
print(result)

[1, 4, 9, 16, 25, 36]

Filter

numbers=[1,2,3,4,5,6]
#Map과 유사하지만 앞의 익명함수의 return 이 true인 것만 모은다!
result=list(filter(lambda x:x%2==0,numbers))
print(result)

[2, 4, 6]

sorted

student=[('jane','70'),('steve','52'),('jack','88'),('harry','82')]
#key라는 익명함수의 반환값을 기주으로 오름차순 정렬!
print(sorted(student,key=lambda x:x[1]))

[('steve', '52'), ('jane', '70'), ('harry', '82'), ('jack', '88')]

all,any

#any는 iterable객체중 하나라도 True가 있으면 True반환!
print(any([True,False]))
#all은 iterable객체중 모두가 True이어야 True반환!
print(all([True,False]))
print(all([True,True]))

True
False
True

sorted

import itertools
print("=====count======")
#iteratior객체의 요소를 무한히 생성!
x=itertools.count()
for i in x:
    print(i)
    if(i==5):
        break
print("=====repeat======")
#3으로 이루어진 3개의 iterator 생성!
x=itertools.repeat(3,3)
for i in x:
    print(i)
print("======combinations=====")
#[1,2,3]의 원소중 2개로 만들 수 있는 조합의 iterator를 생성!
x=itertools.combinations([1,2,3],2)
print(list(x))
print("======permutations=====")
#[1,2,3]의 원소중 2개로 만들 수 있는 순열의 iterator를 생성!
x=itertools.permutations([1,2,3],2)
print(list(x))
print("======accumulate=====")
x=itertools.repeat(3,3)
#[3,3,3]으로 하나씩 누적한 iterator 생성!
x=itertools.accumulate(x)
print(list(x))

=====count======
0
1
2
3
4
5
=====repeat======
3
3
3
======combinations=====
[(1, 2), (1, 3), (2, 3)]
======permutations=====
[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]
======accumulate=====
[3, 6, 9]

import functools
data=[1,2,3,4]
#data를 순회하며 리턴값들이 앞의 익명함수의 x인자로 들어간다!
print(functools.reduce(lambda x,y:x+y,data))

10