혼자 공부하는 파이썬 36강 - 함수를 사용하는 추가적인 이유
HTML-код
- Опубликовано: 9 фев 2025
- 5-2절의 조금 더 알아보기와 확인 문제를 다룹니다.
여기까지가 이 책의 핵심적인 부분이고, 난이도가 가장 높았던 부분입니다. 지금까지의 내용들을 완벽하게 이해하셨다면, 다음 강의부터는 난이도가 완전히 내려가며, 6장부터는 난이도가 완전히 떨어져서, 설명도 대충할 예정입니다[얌마].
제가 잠시 갑작스럽게 입원을 해서, 일주일 있다가 뵙겠습니다 ㅠ_ㅜ [목이 쉴 기회가 되겠군요][...]....
재귀함수 강의 부분이라서 재귀 함수로 풀었어야 좀 더 좋았겠지만, 재귀에 많이 약한지라,,ㅜ 저는 다르게 풀어보았네용!
def flatten(data):
list_var = []
if type(data) == list:
for i in range(len(data)):
if type(data[i]) == list:
for j in range(len(data[i])):
if type(data[i][j]) == list:
for k in range(len(data[i][j])):
list_var.append(data[i][j][k])
else:
list_var.append(data[i][j])
else:
list_var.append(data[i])
return list_var
example = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]] # 0, 1, 2, 3
print("원본:", example)
print("변환:", flatten(example))
ㅋㅋㅋ;; 풀고나서 윤인성님의 답을 확인하는 순간 어디 한 대 얻어맞은 것처럼 순간 멍.. 했네욬ㅋㅋㅋ
좋은 코드입니다! 하지만 flatten()이 2단계 넘게 들어갈 경우에는 재귀를 활용해야 대응할 수 있습니다! 재귀는 다양하게 활용할 수 있고 + 사실 하다보면 쉽게 습득할 수 있는 내용이라 → 금방 강해지실 수 있을 것이라 생각합니다!
이제 질문 올려도 보실지모르곘지만
example = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
flatlist=[]
def flatten(list_of_list):
for i in list_of_list:
if type(i)==list:
flatten(i)
else:
flatlist.append(i)
return flatlist
print(flatten(example))
이런식으로 짯는데
선생님코드에서 굳이 if 에 output += 이 필요한가요? 그냥 flatten(item)으로 사용하면 혹시 예외적으로 걸리는 부분이있는지 궁금합니다
현재 코드처럼 flatlist를 밖으로 빼면 → 함수를 1회 밖에 사용 못합니다[함수로 만드는 의미가 사라집니다].
2:53에서 output.append(item)은 아웃풋인 []에 item을 추가하라는 소리잖아용? 근데 output+=[item]은 output=output+[item] 아닌가용 ,,이 듀개가 왜 동일한지요?
그리고 return output을 하면 어떤 결과가 생기는거죠? return이 가지고 있는 값을 가지고 원래자리로 돌아가라 라고는 알고있습니다 output을 가지고 어디로 돌아가는거죠..ㅠㅠ재귀함수이해하느라 재귀함수만했더니 앞부분은 기억이 또 안나군요 ㅠㅠ후
간단한 인터랙티브 셸 실행을 보시면 이해가 되실 것 같습니다...!
>>> a = []
>>> a += [1]
>>> a
[1]
>>> a += [2]
>>> a
[1, 2]
그래서 append()와 += []이 같습니다. return output을 하면 output을 들고 실행한 쪽으로 돌아가게 됩니다. 재귀 함수로 함수가 중첩되서 여러 번 실행되므로 처음에 실행 결과를 이해하기 힘들 수 있는데, 한 번 진짜로 손으로 실행이 어떻게 되는지 한 줄 한 줄 적어보면 어느 정도 이해되실 것이라 생각합니다(적을게 너무 많은데, 하다보면 대충 감이 오실 것이라 생각합니다!).
마지막 같이 읽어본 내용이 참 와 닿았습니다. 책에서도 급하게 넘어가다가 갑자기 읽어보게 되네요. 매 강의마다 새로운 개념들을 배워가고있어 참 도움이 많이 됩니다. 끝까지 놓치지 않고 가겠습니다 항상 감사드립니다.
4:22에 def flatten: 아래에 output = []이 있어서 재귀함수로 다시 함수가 호출 될 때마다 output이 리셋 될 것 같은데 안되는 이유가 무엇인가요??
각각의 호출에서는 리셋됩니다.
한 번 pythontutor.com/visualize.html#mode=edit 여기에 코드를 넣고 돌려보시면
어떤 형태로 동작하는지 확실하게 이해하실 수 있을 것이라 생각합니다!
저도, 당연히 책 구매해서 함께 보고 있습니다. 감사합니다. ^^
1년도 더 전이지만, 강의하시면서 아프셨었다니.. ㅠㅠ
지금도 다른 강의 계속 업로드 하시던데, 쉬어가며 하시기 바랍니다. 건강이 최고^^
아이고...여기서 다시 막히네요...ㅠㅠㅠ 차근차근 복습해보면서 이해하고 넘어가봐야겠습니다:D 좋은 강의 감사합니다!
함수까지가 제일 어렵고 + 그 다음부터는 하나도 안 어려워서 → 일단 그냥 진행하는 것도 추천드립니다![앞의 것은 그냥 차근차근 복습해도 됩니다!]
@@윤인성 감사합니다!!!☺
이전 강의도 다 너무 재밌네요ㅎㅎ 너무 감사합니다!!
일본어도 하신다니.. 진짜 멋져요
일본어 번역으로도 먹고 살고 있습니다 ☺️
함수 부분들은 나중에 다시 복습해야 겠네요
강의 감사합니다! 그리고 깨알같은 자막도 너무 재밌네요ㅋㅋ
4:06 example 이 [[1,2,3],[4,[5,6]],7,[8,9]] 입니다.
def flatten(data) 속 item은 1 ,2 3, 4, 5 ,6 7, 8, 9인가요?? [1,2,3,] [4,[5,6]], 7, [8,9]가 아니고?? 요소 속의 요소도 다 낱개로 치는 건가요?
질문이 어떤 의미인지 조금 더 자세하게 해주실 수 있을까요 'ㅁ' ...! flatten()은 내부 요소 다 꺼내는 함수로 설계해서 만든 것입니다 'ㅁ'
@@윤인성 답해주신게 제가 궁금했던거랑 일맥상통한 것 같습니다. 제가 의문이었던 건 example 속 요소 하나 ex)[4,[5,6]]의 경우 크게 한 묶음으로 돼있지만 그 안에는 2개의 요소 4와 [5,6]이, 또 [5,6]이라는 요소 안에는 2개의 요소 5,6이 있기 때문에 총 3개의 요소로 for item in example을 할 경우 빠지는지 아니면 그냥 큰 한묶음 통째로 빠지는지 몰랐습니당 ㅜㅡ
@@DailySangmin 무조건 그냥 "한 단계 아래 것을"로 빠지게 됩니다...!
@@윤인성 [[1,2,3],[4,[5,6]],7,[8,9]] 에서 한 단계 아래는 [1,2,3] , [4,[5,6]], 7, [8,9] 이렇게 아닌가용?
@@DailySangmin 넵 그것입니다 'ㅁ'
책은필수죠~ 항상 강의 감사합니다.. ^^
이해가 쏙쏙되게 설명 너무 잘해주세요.항상 건강 챙기시고 좋은 강의 많이 올려주세요. 감사합니다~
안녕하세요^^
강의 감사합니다.
날씨가 엄청 덥습니다.
건강 하세요
수고 하셨습니다.^^
좋은 강의 올려주셔서 감사합니다
저는 추적자? y 넣고 각 프린트 마다 *#@$ 표시를 넣어서 추적해 보았습니다
그렇게 flat(item)이 어떻게 작동되는지 이해 할 수 있어서
다른 분들도 도움이 될 것 같아 올려 봅니다
결과 중간에
* ['y', 4, 'y', 5, 6]
* ['y', 'y', 1, 2, 3, 'y', 4, 'y', 5, 6]
에서
* ['y', 4, 'y', 5, 6]
가 없는게 맞는건지 고민했지만 반복문이 끝이 난 후에
$ ['y', 'y', 1, 2, 3]+ * ['y', 4, 'y', 5, 6] 되는게 맞다는 걸 알았네요
def flat(data):
outfut=['y']
print('u',outfut)
for item in data:
if type(item) == list:
print('$',outfut)
outfut += flat(item)
print('*',outfut)
else:
print('@',outfut)
outfut += [item]
print('#',outfut)
return outfut
exam =[[1,2,3],[4,[5,6]],7,[8,9]]
print(flat(exam))
결과
u ['y']
$ ['y']
u ['y']
@ ['y']
# ['y', 1]
@ ['y', 1]
# ['y', 1, 2]
@ ['y', 1, 2]
# ['y', 1, 2, 3]
* ['y', 'y', 1, 2, 3]
$ ['y', 'y', 1, 2, 3]
u ['y']
@ ['y']
# ['y', 4]
$ ['y', 4]
u ['y']
@ ['y']
# ['y', 5]
@ ['y', 5]
# ['y', 5, 6]
* ['y', 4, 'y', 5, 6]
* ['y', 'y', 1, 2, 3, 'y', 4, 'y', 5, 6]
@ ['y', 'y', 1, 2, 3, 'y', 4, 'y', 5, 6]
# ['y', 'y', 1, 2, 3, 'y', 4, 'y', 5, 6, 7]
$ ['y', 'y', 1, 2, 3, 'y', 4, 'y', 5, 6, 7]
u ['y']
@ ['y']
# ['y', 8]
@ ['y', 8]
# ['y', 8, 9]
* ['y', 'y', 1, 2, 3, 'y', 4, 'y', 5, 6, 7, 'y', 8, 9]
['y', 'y', 1, 2, 3, 'y', 4, 'y', 5, 6, 7, 'y', 8, 9]
4:25 flatten함수에서 질문있습니다! 피보나치 재귀함수는 처음 n =1 or 2 일때를 지정해놓아서 그다음 실행이 이해가 되는데, 여기서는 처음 for 반복문 돌렸을때 [1, 2, 3]이 item 에 들어가고 그럼 type이 list여서 바로 output에 flatten([1, 2 ,3])이 추가되어야 하잖아요? 그런데 flatten()이 뭔지 아직 지정하지 않은 상태에서 어떻게 실행되는지(?) 잘 모르겠습니다ㅜㅜ
앗 flatten()이 무엇인지는 이미 모두 완성한 상태입니다. 어떤 부분을 잘 모르시겠는지 질문을 조금 더 구체적으로 주실 수 있을까요...!
@@윤인성 네 제가 재귀함수 개념을 제대로 이해못한것같습니다 ㅜㅜ 잘 이해가 안되는거는 저는 피보나치를 이해할때 f(n) = f(n-1) + f(n-2) 라고 정의하면서 f(0)과 f(1) 값을 우리가 지정하니까 컴퓨터가 그 다음부터( f(2)부터) 이를 토대로 값을 구하고, 또 f(3)은 f(2)를 토대로 구하는 것으로 이해했는데요.... flatten에서는 아직 컴퓨터가 flatten()이 어떤건지 모르는 상태에서 어떻게 output([ ])에 flatten(item)을 추가하는지 잘 모르겠습니다!
박범구 “숫자인 경우까지 파고 들어가서 새 리스트에 넣는 것”이라는 것을 생각해보시면서 실행을 한 번 손으로 차근차근 추적해보시면 좋을 것 같습니다...!
@@윤인성 감사합니다!!
지난 강의때 말씀하신 알고리즘 보고 왔더니 저의 부족함이 더 느껴지네요. 그래도 열심히 꾸준히 해야겠죠 ㅎㅎㅎ 오늘 강의도 감사합니다.
강의 감사합니다! 날씨가 갑자기 많이 추워졌네요ㅠ 감기 조심하세요! 항상 초보자의 입장에서 쉽고 알기쉽게 알려주셔서 감사합니다. 책 복습도 열심히 하겠습니다
혹시 8:34 에 pi를 global키워드 없이 써도 되는 건가요?
없이 코드를 썻는데 오류가 나진 않았어요.
책과 강의에서 언급했던 것처럼, "오류가 뜨면 그때 사용하면 된다"로 기억하시는 것이 편할 것 같지만
조금 더 자세히 설명 드리면
"해당 변수가 있는 주소의 값을 교체할 때", global 키워드를 사용하는 것입니다.
따라서 단순하게 값을 확인(참조)하는 것은 문제가 없습니다!
강의 보고 책을 구매했다는 답변들이 무수히 왜 있는지 알았어요 ㅎㅎㅎㅎ 이미 저도 구매 완룟!!!!!
def flatten(data):
output = []
for value in data:
if type(value) == list:
output.extend(flatten(value))
else:
output.append(value)
return output
저는 이렇게 코드를 작성해보았습니다.
+= 기호는 append 가 아니라 extend 인가요? 그래서 output += [item] 으로 하여 정수가 아닌 리스트로 만들어 extend를 시키는 것인지요?
+) 밑에 댓글에 append()와 += []이 같다는 설명 보고 왔습니다.
append(), += [], extend([]) 모두 같다고 보면 되나요?
넵 extend()입니다!
책도 사서 강의 잘보고 있습니다. 프로그램 초보에게는 최고 강의 인거같아요
1번문제에 대해서 제가 이해한 방법을 적어볼께요...
For반복문 에서 우선[123]이 item에들어가면 ...
[123]은 리스트이므로..output+=flatten([123])입니다.
그런데 여기서 flatten은 원래함수 입니다 그러니깐..
쉽게 말하면 맨처음 으로 돌아가서 data에 [123]을 넣고
For부터 다시 시작한다고 생각하시면 됩니다..
그러면 [123]이 for i in [123] 으로 들어가서
반복되면 i는 1.2.3.. 즉 else에 해당되서 output에
채워지게 됩니다
마찬가지로 [4 (56)]의 경우도
For j in 로 들어가면.. 4,(56)이 되고 4는 빠지고
(56)은 list이므로 다시 data에 (56)을 넣고
나중에 else로 빼면됩니다. 이걸 다하면 답이 나옵니다
근데 제가 배운지 1주일 된 초보자라 틀린것이 있을 수도
있습니다. 틀렸다면 지적해주세요ㅎ
넵 문제 없습니다!!!
확인문제 1번 질문 드립니다.
def flatten(data):
output = []
for item in data:
if type(item) == list:
output += flatten(item)
else:
output += [item]
return output
example = [[1,2,3], [4,[5,6]],7,[8,9]]
print("원본:", example)
print("변환:", flatten(example))
if문에 걸려있는 flatten(item) 의 경우 output 리스트에 값이 저장되고 재귀함수기 때문에 다시 올라가는 건가요?
처음 output에 값이 저장될 때 [1,2,3]이 저장되고, item값이 올라갈 때 나머지 [4,[5,6]],7,[8,9] 올라가는 식인지..
현재 재귀함수가 언제 올라가는지, for문이 전부 실행되고 올라가는건지.. if조건문에 걸려있는 output 값에는 어떤순서대로 값이 저장되는지 모르겠습니다..(그냥 하나도 모르겠다는 소리 ㅜㅜ)
번거로우시겠지만 실행되는 순서와 올라가는 값이 무엇인지 알려주시면 감사하겠습니다...
[[1, 2, 3], [4]]를 기준으로 한다면
1. flatten([[1, 2, 3], [4]])
a. output = []
b. 반복 시작
c. for [1, 2, 3] 리스트이므로 바로 flatten(item)호출
2. flatten([1, 2, 3])
a. output = []
b. 반복 시작
c. 전부 숫자이므로 output = [1, 2, 3]
d. return [1, 2, 3]
1-d. output += [1, 2, 3] // output = [1, 2, 3]
1-e. 반복 계속 진행
1-f. for [4]인데
1-g. 또 리스트 이므로
2. flatten([4])
a. output = []
b. 반복 시작
c. 숫자이므로 output = [4]
d. return [4]
1-h. output += [4]가 되므로
1-i. output = [1, 2, 3, 4]
1-j. 반복이 종료되어서 return output // [1, 2, 3, 4]
print([1, 2, 3, 4])가 되어서
[1, 2, 3, 4]를 출력합니다.
비슷한 방법으로 해보시면 될 것 같습니다.
호출 될 때 내려올 뿐이고 리턴될 때 올라갈 뿐입니다.
궁금한게 있어서 질문드립니다 !! 독학하고있고 책을 몇일 동안 봐도 이해가 가지 않아서 질문드립니다.
def flatten(data)
output=[ ]
for item in data :
if type(item) == list:
output += flatten(item)
else:
output.append(item)
return output
example = [[1,2,3],[4,[5,6]],7,[8,9]]
print(flatten(example))
1번 문제입니다. 매개변수를 example 넣고 함수를 실행하면
첫번째로 첫 줄 output = [ ] output 라는 공백의 리스트를 만들고
두번째로 반복문으로 넘어가 첫번째 요소가[1,2,3] 리스트이니까 output +=flatten(item) -> flatten([1,2,3] -> output =[ ] -> output.append(1~3)
output = [1,2,3]이 되는것 까지는 알겠습니다.
★질문★ 근데 그 다음 요소[4,[5,6]]을 수행할때도 리스트이니까
flatten([4,[5,6]])을 수행할텐데 이때 다시 output = [ ] 이 명령을 하니까 전에 있던 output = [1,2,3]이 공백[ ]으로 바뀌어야 하지 않나요?...
----------------------
k= [1,2,3,4,5]
for i in k:
o = []
o += [i]
print(o)
--------------------
예를들어 이것 처럼 반복을 할 때마다 o=[]이 되니까 결국 마지막 5만들어가게 되는 것처럼요 ㅠㅠ 재귀함수도 결국 함수를 반복하는건데
그렇게 되면 계속 output=[] 되어야 한다고 생각이 들어가지고.... 어디서 부터 잘못된건지 모르겠네요 ㅠㅠ
답변주시면 정말 감사하겠습니다.!!
함수는 호출될 때마다 다른 공간을 생성하고, 리턴될 때 그 공간을 제거합니다. 따라서 함수 호출 때마다 만들어지는 output 변수는 모두 다른 공간에 만들어진 다른 아이들입니다!
그럼 처음의 output에 호출되며 생긴 새로운output들이 더해진다고 생각하면 될까요??
넵!
@@윤인성 이에 관련해서 다시한 번 질문 드리고 싶습니다..!
type(item)이 list이면
output += flatten(item)
근데 그러면 이 코드는 왜 이렇게 될까요...?
우선 코드부터 보여드리겠습니다
def flatten(data):
output = []
for item in data:
if type(item) is list:
flatten(item)
else:
output.append(item)
return output
example = [[1, 2, 3], 4, 5, 6, 7, 8, 9]
print("원본:", example)
print("변환:", flatten(example))
저는 변환값이 [1, 2, 3, 4, 5, 6, 7, 8, 9]일거라고 생각했습니다
왜냐면
저 [1, 2, 3]이라는 리스트가 뒤쪽이 아니고 맨 앞쪽에 있기 때문에
설령 flatten함수를 위부터 훑음으로 인해서 output 리스트가 비워진다 하더라도
애초에 [1, 2, 3]은 example 리스트의 맨앞 요소이기 때문에
output 리스트가 비워졌든, 비워지지 않았든 다행히 상관이 없고
item으로서의 [1, 2, 3]은 list이니까 if문에 들어가므로
flatten함수를 당하고
그럼 output은 비워지고 (이때 아까 말했듯이 어차피 첫 요소니까 상관 없지 않나요...??)
[1, 2, 3] 내부의 요소들은 else문에 들어가서 output에 append되면
결국엔 output은 [1, 2, 3]이 될 것이고
이 이후에 4, 5, 6, 7, 8, 9같은
리스트가 아닌 일반적인 요소들은
else문에 들어가서
아까 1, 2, 3이 쌓여있던 output 리스트에 얌전히 들어가서 쌓이게될것
이라고 생각했기 때문입니다
그런데 변환값이 [4, 5, 6, 7, 8, 9]로 나오네요...
왜일까요... ㅠㅠ
파이썬 크롤러 때문에 우선 기초적인것 부터 배워 볼려고 찾아보다가 책 샀는데 강의까지 있으니까 정말 좋네요!
당삼공 크롤링 강의도 이 채널에 있으니 참고해보시면 좋을 것 같아요 "-" ...!
이부분이 가장 어려운거 같네요..흐아
empty = []
def flatten(data):
global empty
for i in data:
if type(i) == list:
flatten(i)
else:
empty.append(i)
return empty
example = [[1,2,3], [4, [5,6]], 7, [8,9]]
print("원본:", example)
print("변환:", flatten(example))
>>저는 이렇게 코드 작성했습니다. 아무리 생각해봐도 global 변수로 꺼내놓지 않고 넣어버리면 재귀함수가 시작되면서 초기화 되어버려서요... 제가 아직 코린이긴해도 global을 쓰는건 왠지 기피해야될거 같아서요. 코드가 뭔가 아름다운 느낌이 안듭니다.
질문 요약하자면 저렇게 global 써서 풀어도 괜찮나요?
이렇게 코드를 작성하면, 함수를 2번 이상 실행할 때 문제가 발생합니다.
재귀 함수로 구성할 때는 책과 같이 작성해주셔야 합니다.
3:05초에 flatten에다 item을 전달한다는 무슨말인지 모르겠습니다...
flatten(item)이 무슨 뜻인지 모르겠습니다
flatten(item)은 함수를 호출하는 코드이고 + 매개변수로 item을 전달하는 코드입니다! 잠시 뒤의 함수 기본부터 한 번 더 듣고 진행하시면 좋을 것 같습니다!!
@@윤인성 되물어서 죄송합니다.
def flatten(data):
output = []
for item in data:
if type(item) == list:
output += flatten(item)
else:
output.append(item)
return output
example = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
print("원본:", example)
print("변환:", flatten(example))
여기서 item이 리스트면 output에 넣고 아니여도 넣어라 라는 코드인가요?
@@kuuo099 코드는 그냥 있는 그대로 실행됩니다.
리스트라면
- flatten(item)의 결과를 리스트에 추가하고
리스트가 아니라면
- 그 값을 리스트에 추가하라는 의미입니다.
p243 1번에서 if(type)==list: 이면 output+=flatten(item)인데요. 앞에서 살펴본 피보나치수열은 f(n)이 결국 return f(n-1)+f(n-2)처럼 함수의 결과를 알기가 쉬운반면에 output에 flatten(item)을 더하라고 컴퓨터가 입력받았을때 어떤과정을 거쳐서 flatten(item)을 이해하고 output에 리스트가 분해되서 추가되는건지 도저히 모르겠습니다.... 아무리고민해도모르겠어요 도와주세여..
"""어떤 형태를 예상하셨는데
어떤 결과가 나와서 이상하다"""를 조금 더 자세하게 써주시면 관련되어서 이야기를 드릴 수 있을 것 같습니다. 코드의 실행 흐름은 그냥 전부 손으로 다 써보면 되는 것이라 시간을 넉넉하게 잡고 써보시는걸 추천드립니다[처음에는 당연히 굉장히 오래 걸리고 헷갈리는 과정입니다].
@@윤인성 확인문제로 말씀드리면, example의 첫번째 요소인 [1,2,3]이 함수를 타고들어갈때 리스트이므로 output=[flatten([1,2,3])]이 되고 마찬가지로 두번째 요소일때도 output=[flatten([1,2,3])+flatten([4,[5,6]])]이 되겠는데 이게 어떻게 output=[1,2,3,4,5,6]이 되는지 그 과정을 모르겠습니다.. 선생님께서 [4,[5,6]]이 다시한번타고간다고 짧게언급하시고가신것도 왜 반복문은 한번실행됐는데 다시 탄다는건지잘 모르겠습니다..ㅠㅠㅠ
def flatten(data) 에서 data를 넣는 이유를 알 수 있을까요?
단순히 data는 'data에 example 에 해당하는 값들을 넣어라' 라는 의미로 넣어준 매개변수로 해석하면 될까요? (그냥 굳이 data를 안쓰고 a, element, key 등등 아무 식별자나 넣어도 되냐는 뜻입니다!!)
넵 그냥 매개변수 이름이니 아무 곳이나 사용해도 됩니다.
안녕하세요. 강의 정말 잘 보고 있습니다.
궁금한 점이 있어 여쭤볼려 합니다.
def flatten(data):
output = []
for item in data:
if type(item) == list:
flatten(item)
else:
output += [item]
return output
example = [[1, 2, 3], [4, [5, 6], 7, [8, 9]]]
print("원본 : ", example)
print("변환 : ", flatten(example))
if 조건문에서 타입이 리스트라면 flatten(item)이 재귀 되며 다시 위로 올라 걸 것이고
for item in data 구문에서 리스트는 계속해서 분해된다는 생각에
마지막에는 모든 리스트가 없어지고 정수만 남게 된다고 생각했습니다.
그래서, 다른 부분은 다 같지만 if 조건문에서 output += flatten(item) 이 부분을 flatten(item)으로 바꿔봤습니다. 그러면 자연스럽게 else 구문으로 가 output에 정수가 추가 될 것이라 생각하고요.
왜 output += flatten(item)이라는 구문이 꼭 필요한건지 궁금해서 질문합니다.
flatten()의 현재 코드 구성이 비파괴적 함수이기 때문입니다. 비파괴적 함수이므로 단순하게 flatten(item)하면 어떠한 변화도 주지 못하고 쓸데없이 돌리는 코드로 전락합니다.
@@윤인성
그러면 [[1, 2, 3]]만 본다고 했을 때 중간 순서를 확인하자면
def flatten(data):
output = [flatten([1, 2, 3])]
이남규 앗 어떤 의도로 코드를 그렇게 작성하셨는지 조금 더 자세하게 알려주실 수 있을까요? flatten() 함수 내에서 초기화를 하면 실행해보시면 아시겠지만, 그 초기화한 값이 flatten() 함수가 실행된 만큼 최종 결과에 들어가는 문제가 발생합니다.
@@윤인성 아 죄송합니다. 설명이 부족했네요. output = [flatten([1, 2, 3])은 직접 코드를 작성하는 것이 아니라 컴퓨터가 코드를 해석하는 과정을 제 생각으로 적은 것입니다. 실제론 output=[]이며 중간 과정이 저게 맞나 싶어서 여쭈어봤습니다.
이남규 이게 재귀함수이다보니 flatten()이 굉장히 많이 실행되므로, 한 번
- output 생성 바로 뒤에 print(data, "시작")
- 리턴 전에 print(data, "종료", output)
을 넣어서 결과를 쭉 확인해보시는걸 추천합니다.
아래로 쭉 파고 들었다가 위로 쭉 타고 올라가는 이상한 형태라서, 이 결과를 보신 뒤 이해해보시면 좋을 것 같은데,
- 괄호 열고 닫고 타고들어가는 것처럼 [{}{}{}] 이렇게 data 부분이 같은 녀석들이 매칭될 것입니다.
이걸 주의깊게 보면서 이해해보시면 조금 더 잘 이해될 것 같습니다...!
재귀함수를 이용한 리스트평탄화에 대해 다시 질문드립니다. 함수내에서 output=[]이라는 빈 리스트를 선언했는데요 값이 누적되어 추가되다 재귀함수를 만날때마다 output=[]이 반복실행되어 output이 다시 빈리스트로 초기화 되지 않나 싶은데요 print를 이용해 재귀를 돌때마다 즉, 각각의 리스트요소 마다 값이 초기화되면서 채워지는걸 알수있는데 최종적으로 output이 출력될때에 그동안에 추가된 값이 유지된채 출력되는지 그 흐름이 잘 이해가 되지 않는데 어떻게 이해하면 될까요? ^^;
함수 내부에 있는 변수는 해당 함수 호출에서만 유효합니다. 따라서 재귀로 들어갈 때 외부에 있던 함수의 변수가 초기화되지 않습니다[호출 때마다 모두 다른 녀석이라서요!]
안녕하세요.
구문을 쓰다가 문득
for i in data:
if type(data[i]):
위와 같이 각 요소에 data[i]로 접근 하게되었는데요. data[i]로 접근하니 에러가 뜹니다. 위와 같이 요소에 접근하면 안되는 이유가 궁금합니다.
i에는 요소가 들어갑니다.
data[i]로 접근하려면 i가 인덱스여야 합니다.
print(i)로 i를 출력해보시면 바로 이해하실 수 있을 것 같습니다!
243p 확인문제 1번 질문있어요!
output = []
def flatten(data):
global output
for i in data:
if type(i) is list:
output += flatten(i)
else:
output += [i]
return output
example = [[1,2,3], [4,[5,6], 7, [8,9]]]
print("원본:", example)
print("변환:", flatten(example))
global 키워드는 함수외부에 있는 변수를 참조하게 해주는 기능아닌가요?
하지만 global 키워드를 이용할때 답이 달라지게 됩니다.
왜 답이 달라지는지 궁금합니다...ㅜㅠ
현재 output = []의 위치가 잘못되어 있어서 오류가 발생하는 것입니다. global 키워드와는 관계가 없습니다!
현재 코드처럼 해주시면 모든 함수에서 같은 output 리스트를 활용하게 되므로, 재귀함수의 기본적인 형태(각각의 함수에서 무언가를 만들어서 리턴)를 수행하지 않습니다.
안 되는 이유는 코드 실행을 자세하게 분석해보시면 쉽게 이해하실 수 있을 것이라 생각합니다!
@@윤인성 도움이 되었습니다! 감사합니다 :)
안녕하세요! 강의 잘 듣고 있습니다!
앞 부분 문제에서 5번째 줄이 이해가 잘 안 가서 질문 남깁니다.
flatten(item)으로 재귀함수를 사용하면 내부 리스트 [1,2,3]이 순차적으로 else로 가는 것 아닌가요?? 그렇게 되면 알아서 output+=[item]으로 더해질텐데, 왜 5번째 줄에도 'output+=' 을 사용해야 하는 건지 이해가 안가요... 중복해서 더해져야 할 것 같은데 5번째 줄에도 사용하는 게 맞다는 게 납득이 잘 안갑니다.
아 output이 함수 실행될 때마다 달라서 그렇게 되는 건가요...? output+=flatten(item)이 결국에 output+=flatten(item)에서 리턴된 output 값 이런 식으로 되어서 그렇게 써야 하는 건가요??
넵! 함수 실행 때마다 함수 내부에 변수들을 위한 전용 공간이 따로 만들어집니다.
다음 강의에 나오는 Python Tutor 사이트에 코드를 붙여 넣어보시면 + 전용 공간이 어떻게 만들어지는지 하나하나 살펴볼 수 있으므로 참고해보세요!
ruclips.net/video/5m1qyapPvXw/видео.html
안녕하세요 선생님 예제 1번 평탄화를 응용해서 코딩해 봤는데..
def 함수이름(data):
output=[]
for 이거이거 in data:
if type(이거이거)==list:
output+=함수이름(이거이거)
else:
output+=[이거이거]
return output
example=[[1,2,3],[4,[5,6]],7,[8,9]]
print(example)
print("변환:",함수이름(example))
실행해보니 왜 Line 10에서오류가 나는걸까요?
열고 닫는 괄호 개수가 맞지 않습니다! 앞에 [를 하나 제거해야 할 것 같습니다!
오류를 올려주실 때는 오류 내용을 함께 올려주시면 조금 더 빨리 답변드릴 수 있습니다!
[없는 경우 한 번 또 실행해봐야 하다보니 집에 와야 답변 드릴 수 있어서요!]
안녕하세요 인성님!
예제 1번에 왜 output += flatten(item) 인지 고민했는데
example안에서 첫번째 list인 [1,2,3]이 item으로 들어가서 재귀하면
example = [[1,2,3],[4,[5,6]],7,[8,9]] 대신에 example'=[1,2,3] 일때 실행한 값인 output '= [1,2,3]을 output에 더하고
두번째 list인 [4,[5,6]]이 들어가서 재귀하면
example = [[1,2,3],[4,[5,6]],7,[8,9]] 대신에 example'' = [4,[5,6]]일때 실행하고 안에 [5,6]이 한번더 실행되어 output''=[4,5,6] 이 output에 더해지는 식으로 이해하면 맞을까요??
넵 그렇습니다!
책보니깐, 교재 239쪽에, 어떠한 설명도 없는 코드 첫행은 radius에서 number_input_a로 수정되어 있는거 같은데
주석이 있는코드 첫행도 radius가 아니라 number_input_a로 바꿔야하는거 아닌가요?
아앗 오탈자 제보 감사 드립니다 😂...!!!
안녕하세요 선생님 도저히 혼자 해결이 안되서 질문드립니다..
아래 댓글 중 옥**(3개월 전)님의 댓글(재귀함수가 호출될 때마다 output이 초기화되야하는 거 아닌지?)과 같은 궁금증이 생겼다가 선생님 댓글보고 제가 이해한 게 맞는 지 여쭤보려구요..
1. output=[]에서 output=[1,2,3]이 된 후
2. item에 [4[5,6]]이 들어간 후 재귀함수가 호출될 때 사용하는 output은 [4,[5,6]]이 독립적으로 사용하는 output(output_1이라하자.)이다.
3. output_1=[4,5,6]으로 생성된 후 output += flatten([4,[5,6]]) 코드에 의해 output = [1,2,3,4,5,6]이 된다.
이게 맞을까요? 질문이 이상하네요 ㅠ
그리고 강의 정말감사드립니다!
함수 내부의 변수는 함수 실행 때마다 개별적으로 만들어집니다!
즉 1번째 호출 때 output과
2번째 호출 때 output은 완전히 다른 녀석이라서
덮어 쓰거나 하지 않습니다.
재귀 호출 횟수만큼 output이 만들어졌다가
+ return으로 돌아오면서 이전 단계의 output에 요소를 추가하면서 빠져나오는 형태입니다!
@@윤인성 헉 감사합니다! 질문드려놓고 조금이해돼서 댓글을 수정했는데, 이제 완전히 이해된 것 같습니다. 감사합니다!!
질문이 있어서 댓글 남깁니다! 파이썬 옛날에 공부했었는데 그 이후로 몇 달만에 다시 복습한다고 보기 시작했어요 ㅠㅠ 앞으로 꾸준히 열심히 하겠습니다!
제 질문은 7번째 행에서 왜 item에 [ ]를 씌우는지입니다. data= example에서 7이라는 item이 for문을 통해 추출되었으면 그냥 그 자체로 output에 int로 들어갈 수 있지 않나요? 왜 굳이 리스트 형태를 취해줘야되는지 이해가 안됩니다.
사실 아래 댓글설명도 봤는데 이해가 잘 되지 않아 질문드립니다. 감사합니다.
item은 숫자입니다.
"리스트 + 숫자"라는 문법은 존재하지 않습니다.
그래서 item을 리스트로 바꿔서
"리스트 + 리스크"가 되어 리스트가 연결되게 만든 것입니다!
@@윤인성 감사합니다!!
안녕하세요 작가님! 여러줄을 선택하는건 shift로 가능한건 알겠는데 혹시 한번에 여러줄을 수정하는건 어떻게 하는건지 문의드립니다. (예를 들어 한번에 여러줄에 주석을 추가한다거나 문자를 추가한다는 등) 여러줄을 선택한 다음 ctrl + # 등을 시도해봤는데 안되네요;; 참고로 저는 macbook을 사용하고 있습니다.
선택한 뒤에 글자를 그냥 입력하시면 됩니다!
안녕하세요 ! 강의 잘 들었습니다. \
항상 재밌게 듣고있습니다 ㅎㅎㅎ!
혹시 8:52 부분에서 def get_circumference(radius) 등의 함수에서 사용할 때 PI=3.14 변수를 쓰기 위해 global PI라는 명령어는 쓰지 않아도 되는 건가요??
앗 실제 코드에서는 써줘야 합니다. 간단하게 이름 붙이기의 사용 방법을 보여드리기 위해서 최대한 코드를 간단하게 구성했을 뿐입니다...!
@@윤인성 앗 ! 그렇군요 감사합니다 !
질문이 있습니다.. 강의에는 없는대요. 교재 244~245페이지에 패밀리 레스토랑에서 앉는방법구하는게 있는대요답을 봐도 도저히 이해가 안되네요..일단 초기 def로 만든것과, 맨마지막 print로 확인하는거랑 왜 매개변수가 다른걸까요..?def 문제(남은사람수,앉힌사람수) : print(문제(전체사람의수,앉힐수있는최소사람수) :
def로 만든 것은 함수 정의 이고, print(문제())에서 호출할 때 넣는 것은 호출하는 부분입니다. 현재 질문을 보면 재귀 함수 쪽을 이해 못 하신 것보다는 함수의 정의와 호출을 이해하지 못하신 것 같습니다.
- 함수는 프로그래밍 문법에서 가장 어려운 부분이고
- 재귀함수는 함수를 활용하는 테크닉 중에 가장 어려운 부분이고
- 해당 문제도 쉬운 문제가 아니다보니
함수 부분을 한 번 더 살펴보신 뒤 + 다시 재귀 함수와 해당 문제를 살펴볼 것을 추천드립니다.
안녕하세요 예제 1번 관련해서 질문이있습니다.
def flatten(data):
list_a = []
for a in data:
if type(a) == list:
flatten(a)
else:
list_a += [a]
return list_a
example = [[1,2,3]]
print("변환:", flatten(example))
이렇게 예제 1번을 풀면 코드를 실행했을때 저는 변환: [1,2,3] 이 나올거라고 생각하는데 자꾸 빈 리스트만 출력되네요.....천천히 한단계씩 생각해봐도 자꾸 왜 빈 리스트가 나오는지 잘 이해가 되지 않습니다.
중간에 if type(a) == list 들어가서
flatten(a)를 실행해서 나온 결과를 다른 어떤 곳에도 저장되지 않고 그냥 아무 것도 안 해서 사라져서 그렇습니다!
@@윤인성 와 빠른 답변 감사드립니다. 그런데 왜 중간에 if type(a) == list 들어가서
flatten(a)를 실행해서 나온 결과를 다른 어떤 곳에도 저장되지 않는 다는건지 잘 이해가 되지 않네요.
중간에 if type(a) == list 들어가서
flatten(a)를 실행 하면
결국 flatten([1,2,3]) 을 실행하는것을 의미하고
이렇게 실행하면 이제 for a in data 에서 a에 들어가는 요소들이 더이상 리스트가 아니라서
else 문으로 가게될 것입니다.
그리고 결국 거기서 list_a += [a] 를 실행하니까 결과적으로는
list_a += [1] 그리고 list_a += [2] 그리고 list_a += [3] 이 실행되어 list_a 에는 [1, 2, 3] 이 저장되는 것 아닌가요?
@@Traptrapb
flatten() 내부에서 flatten()을 실행해서 들어가면, 그 안에서의 list_a는 다른 list_a입니다. 이름이 같다고 같은 것을 가리키는게 아닙니다.
중간중간 print() 함수를 실행해서 출력해보시면 좋을 것 같습니다.
안녕하세요 확인문제 1번에 대해 제가 푼 방식은 이전에 반복문 중복을 이용하여
def f(data):
output=[]
for a in data:
if type(a)is list:
for b in a:
if type(b)==list:
for c in b:
output.append(c)
else:
output.append(b)
elif type(a)==int:
output.append(a)
return output
example=[[1,2,3],[4,[5,6]],7,[8,9]]
print("원본:",example)
print("변환:",f(example))
복잡하게 풀었는데 나름 풀고 뿌듯하게 (정답이 아니라는 것은 알지만) 영상을 봤으나 4배는 간단하게 정답이 나오더라구요. 혹시 저처럼 푸는 것 또한 파이썬을 옳게 배우고 있는게 맞는지 궁금합니다. 물론 정답처럼 재귀함수를 이용하여 푸는 게 더 맞다고 생각은 합니다.
+) output+=flatten(item)에서 +를 빼면 [8,9]만 남더라구요. 여기서 +=가 붙는 이유를 잘 모르겠습니다. +=뒤에 f(item)이 오면 f(item)을 추가한 output[ ]이 다시 함수를 타고 내려온다고 생각하면 되는건가요??
공부는 크게 2가지 길을 따라 해야한다고 생각하는데요.
- 테크닉[+ 강의, 책 등의 외부 정보]: 남이 알려줄 수 있는 부분은 사실 테크닉적인 부분입니다.
강의를 보시면서 짧게 풀 수 있는 방법을 보신 것도 테크닉적으로 새로운 테크닉을 공부하시게 된 것입니다.
이런 테크닉은 사실 남이 알려주지 않는한 개인이 알아내기는 매우 힘듭니다.
지금은 이론들이 많이 등장했으므로, 그런 것을 책 등으로 습득할 수 있지만,
이론을 혼자서 처음 만들어질 때는 수 천 년이 걸렸습니다. 그래서 혼자 할 수 있는 범위가 아닙니다.
- 발상: 발상은 남이 알려주기 힘듭니다.
아무리 피아노를 잘 쳐도 "곡을 쓰라고? 뭘 어떻게 해야하는데?"라는 말이 나오는 사람이 많습니다.
그림을 아무리 잘 그려도 "그래서 뭘 그리면 되는데? 뭐 참고할 것 없어?"라는 말이 나오는 사람이 많습니다.
이는 모두 테크닉적으로는 매우 앞서갔는데,
혼자서 발상하는 연습을 전혀 하지 못해서 발생하는 문제입니다.
지금 혼자서 하신 부분은 "발상을 공부하는 법"이 되겠고
강의를 보면서 짧은 코드를 보신 부분은 "테크닉을 공부하는 법"되겠습니다.
그래서 두 가지가 병행되는 현재 공부하시는 방법이 제일 좋습니다.
PS. 둘 중 하나만 너무 앞서가도 나중에
- 테크닉이 앞서는 경우: "내가 재능이 없나.... 남이 한 것 보고 하는 것 밖에 못하네...."
- 발상이 앞서는 경우: "아니 이걸 해야하는데 이걸 못하네 내가 재능이 없나...."
라는 식으로 좀 충돌이 생깁니다.
---
+=는 리스트 결합입니다.
[1] + [2] → [1, 2]이므로
최종 결과를 만들기 위해서 리스트를 조합하는 과정입니다.
윤인성 감사합니다!!!
당연히 책 사서 보고 있습니다!!!!
감사합니다!!
안녕하세요, 강의 감사합니다. 243p 1번에서 궁금한 점이 if뒤랑 else뒤에 각각 return을 주지 않고 마지막에 한번 return을 주는 것이 헷갈립니다. 예를들어 238p의 위에 있는 예시코드에서 보면 if와 else뒤에 각각 return을 주는데, 왜 여기서는 그렇지 않은건지, 어떤 기준으로 다르게하는 것인지 궁금합니다.
그냥 코드의 실행을 "그렇게 하고 싶어서" 이외에는 답이 없을 것 같습니다. 문법은 문법일 뿐이라 문법이 내용을 강제하지는 않습니다(함수 내에 if 조건문이 나왔다고 return을 여기에서 해야하지는 않습니다).
global 키워드에 대한 질문이 있습니다.
함수 내부에서 함수 외부에 있는 변수를 참조할 때 쓴다고 했는데,
p.236~237 메모화를 통해 피보나치 수열을 구할 때 메모 변수로 dictionary를 함수 외부에서 선언했는데, 함수 내부에서 이 딕셔너리를 global 키워드 없이 쓸 수 있고,
p.245 연습문제에서도 "앉힐수있는최대사람수" 라는 변수가 global 키워드 없이 함수 내부에서 쓰이는 것을 보았습니다.
그래서 어떨 때 global을 써야하고, 어떨 때 global을 쓰지 않아도 되는지 그 기준을 잘 이해할 수 없어서 질문드립니다
정확하게는
- 변수를 새로 덮어 쓰는 경우 => global 키워드 사용해야함
- 기존의 변수를 그냥 활용하는 경우 => global 키워드 필요 없습니다.
딕셔너리를 활용할 때도
dictionary = {} 등으로 새로 덮어 쓰는 것이 아니라,
dictionary.get(), dictionary["키"] = 값 등으로 기존의 변수를 활용하는 중이라 global 키워드를 붙이지 않아도 괜찮습니다.
사실 이걸 좀 인지해도
코드 작성 중에 여기까지 생각하는 것이 약간 힘들어서
"오류가 뜰 경우에만 붙이면 된다"라고 간단하게 알려드린 것입니다.
빠른 답변 감사합니다! 이제 이해됐습니다
하나만 더 질문하겠습니다. 그러면 피보나치수열 메모화에서 dictionary[n] = output으로 새로운 키와 값을 넣는 것도 기존의 변수를 활용하는것으로 보는건가요?
@@5DHypercube 넵 아예 dictionary = {}을 하는 것이 아닌 이상 기존의 것을 활용하는 것입니다. 조금 더 깊게 들어가면
"메모리 위치 내에 값이 변경되는 경우"입니다.
PS. 딕셔너리 등을 dictionary = {}로 하면
{}의 참조값(주소값)이 dictionary라는 메모리 위치를 변경해버리지만,
dictionary[n] = output은
dictionary의 메모리 위치의 참조값을 변경하지 않습니다.
@@윤인성 아 그렇군요 자세한 답변 감사합니다!!
안녕하세요. 우선 좋은 책과 강의에 감사드립니다. 이 부분을 공부하면서 궁금한 점이 있어서 사소한 질문 하나 드립니다.
우선 영상에 나온 코드는 어느정도 이해가 갔는데 밑에 나온 코드처럼
output = []
def flatten(data):
for item in data:
if type(item) == list:
flatten(item)
else:
output.append(item)
return output
example = [[1,2,3],[4,[5,6]],7,[8,9]]
print("원본:",example)
print("변환:",flatten(example))
이렇게 output 을 flatten 함수의 외부에 선언하고 append 를 이용하면 결과가 똑같이 나오는데요. 혹시 이렇게 output을 밖으로 빼면 좋지 않다거나 아니면 flatten안에 선언하는 방향으로 가는게 좋나요? 아니면 그냥 여러가지 방법중 하나인가요? 궁금해서 질문 드립니다..감사합니다!!
Output을 밖으로 빼버리면, 해당 코드를 2번 이상 실행했을 때 문제가 발생합니다[재귀함수에서 사용되는 변수를 밖에 빼면 대부분의 경우에 두 번 이상 실행할 때 문제가 발생할 가능성이 있습니다]. 따라서 안에 선언하시는 것이 좋습니다...!
@@윤인성 답변 감사합니다!!
저자님 안녕하세요! 제가.. 혼공파 책에서 배운 글로벌 변수를 사용해서 응용을 해보았는데요!!
맨 아랫부분 로 짜도 평탄화가 올바르게 작동 되는 걸 확인했습니다.
그런데 과정을 출력해보고자
# print("--평탄화 작업중--
", flatten(item))의 주석을 해제하고 실행을 하면,
결과값이 아래와 같이 나오고... 1,2,3이 두번씩 실행이 되고, output 변수에도 한번씩 반복되어 저장됩니다.
--평탄화 작업중--
[1, 2, 3, 1, 2, 3]
--평탄화 작업중--
[1, 2, 3, 1, 2, 3, 4, 5, 6, 5, 6]
--평탄화 작업중--
[1, 2, 3, 1, 2, 3, 4, 5, 6, 5, 6, 4, 5, 6, 5, 6]
--평탄화 작업중--
[1, 2, 3, 1, 2, 3, 4, 5, 6, 5, 6, 4, 5, 6, 5, 6]
--평탄화 작업중--
[1, 2, 3, 1, 2, 3, 4, 5, 6, 5, 6, 4, 5, 6, 5, 6, 7, 8, 9, 8, 9]
[1, 2, 3, 1, 2, 3, 4, 5, 6, 5, 6, 4, 5, 6, 5, 6, 7, 8, 9, 8, 9]
질문 1) print()함수만 넣었을 뿐인데 왜 변수값에 영향이 있을까요?
print("--평탄화 작업중--
", flatten(item)) 를 넣지 않으면, output 으로 [1,2,3,4,5,6,7,8,9] 만 올바르게 나옵니다!!
질문 2) 왜 리스트 안의 요소들이 1번씩 더 반복이 되어 나오는 걸까요?
ex. 맨 처음 반복문 실행으로 [1,2,3]만 저장되어야 하는데, [1,2,3,1,2,3]이 두 번 들어갑니다 ㅜㅜ
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
>
output = []
def flatten(data):
global output
for item in data:
if type(item) != list:
output.append(item)
else:
flatten(item)
#print("--평탄화 작업중--
", flatten(item))
return output
ex = [[1,2,3],[4,[5,6]],7,[8,9]]
print(flatten(ex))
단순하게 출력을 한 것이 아니라, print() 함수 내부에서 flatten(item)을 호출하므로, flatten 함수에 한 번 들어가는 문제가 발생하게 됩니다(즉 지우기 전에는 flatten() 함수를 두 번 호출하는 코드가 됩니다).
코드가 들어간 댓글은 유튜브가 "일반 민간인을 위협하는 악성 코드 아닌가...!"해서 잠시 스팸으로 분류되어서 @_@ , 약간 늦게 확인했군요 @_@ ...! 죄송합니다 _@@ ..>!
@@윤인성 아 !!!!! print() 함수 내부에서 함수를 또 호출하면, 이 아이도 변수에 저장되게 되네요 !!!
감사합니다........
def flat(data):
output = []
for item in data:
if type(item) == list:
output = output + flatten(item)
이거랑
def flat(data):
output = []
for item in data:
if type(item) == list:
output = output + (item)
이거의 차이가 재귀함수 차이인것 같은데 두 개 동작이 어떻게 다른지 궁금합니다...
재귀함수는 반복문과 전혀 다른 구조를 갖게 됩니다[대응시켜서 비교하는 것 자체가 불가능합니다]. 반복문은 (리스트 등을) 선형적으로 돌지만, 재귀함수는 트리 구조를 만들면서 돕니다.
트리는 ruclips.net/video/apuLBFfGlQs/видео.html 의 3강 정도까지를 살펴보시면 무엇인지 이해하실 수 있으실 것이라 생각합니다.
PS. 일반적으로 트리가 좀 더 다양하게 구현할 수 있어서
- 반복문으로 구현할 수 있는 것 = 재귀 함수로 모두 구현 가능
- 재귀함수로 구현할 수 있는 것 = 반복문으로는 구현 못 하는 경우도 있음[아니면 반복문을 아주아주 복잡하게 구현]
하게 됩니다.
PS. 재귀함수가 사실 굉장히 복잡해서
실무에서도 실수로 잘못 구현하는 경우가 많다보니
학교 등에서는 "재귀함수 아예 쓰지 말고 + 반복문으로만 구현해라"라고 가르치기도 하는데
잘 쓰면 코드가 워낙 간단해지고 좋습니다 'ㅁ' ...![이해하는게 어렵지만 이해하고 나면 다양하게 활용할 수 있게 됩니다]
1번 문제에서 첫 반복문이 [1,2,3]이라 리스트니깐 다시 한 번 돌아 else부분으로 가 1,2,3이 output에 들어가는거 같은데 왜 if type(item)==list의 경우 item을 다시 반복문 돌려라가 아니라 output+=flatten(item)이 들어가는건가요? 저 경우 flatten([1,2,3])이 output인 []에 어떻게 더해지는지 이해가 안갑니다ㅠㅠ
해당 코드가 있는 이유는
[1,2,[3]]처럼 내부 요소가 또 중첩되어 있을 까봐
"중첩 리스트가 있으면 펴서 추가해라"라는 의미입니다.
현재 [1,2,3]은 중첩이 없으므로
flatten([1,2,3])하면 "중첩 없구나!"로
내부에서 판단하고 처리한 뒤
[1,2,3]을 그대로 리턴합니다.
따라서 output += [1,2,3]이 되어서
output에 요소 1,2,3이 추가됩니다.
감사합니다ㅎㅎ재귀함수가 어렵네요ㅠㅠㅠ
강의 잘 보고 있습니다. 리스트 평탄화 문제에서
def flatten(data):
output = []
for a in data :
if type(a) == list :
output.append(flatten(a))
else :
output.append(a)
로 함수를 만들었는데
example과 같은 값을 출력합니다.
선생님이 만드신 +=연산자와 append의 차이인거 같은데 왜 그런지가 궁금합니다. 항상 답변해주셔서 감사합니다.
append(flaaten(a))는
+= flaaten(a)가 아니라
+= [flaaten(a)]와 대응됩니다...!
안녕하세요~ 강의만 보다가 처음으로 질문 남겨봅니다 ㅎㅎ
우선 강의 잘 보고 있습니다! 조금 시간이 지나서 답변 해주실지는 모르겠지만 혹시나 해서 남겨봅니다~
처음 함수 내에서 output =[]으로 초기화하고, 다시 함수 내에서 재귀적으로 함수를 콜하면서 output =[]로 초기화가 되는데, 이 초기화된 함수와 상위 함수의 output은 다른거로 여겨지는 것이 맞나요?
함수 콜할때마다 output = []으로 초기화하면 이전 값들이 사라져야하는데 계속 남아있어서요.
저는 이것 때문에 함수 밖에서 output을 초기화해야하는 것이 아닌가 했는데(물론 아래 댓글 남기신 것처럼 여러 번 콜 할 때 문제가 발생하긴 하지만요.) 함수 내에서도 되니까 어떠한 메커니즘으로 되는지 궁금해서요.. ㅎ
늦었지만 혹시나 보시면 답변 부탁 드릴게요 :)
아 그리고 6분 정도에 원 넓이 구하는 공식이 주석있는 부분에서는 잘 나왔는데 없는 부분에서는 2*radius*radius로 오타인 것 같네요 :) 본문에 설명도요~
1. 넵 정확하게 보셨고 다르게 여겨집니다...!
2. 앗 오탈자 감사드립니다 @_@ ...!!
안녕하세요 책과 함께 인강 잘보고있는 학생입니다. 확인문제 정답을 보려고 하는데 혼공 홈페이지에 정답지 다운로드 버튼이 안눌리는데, 정답지를 받을수 있는 방법이 있을까요?
답은 책 뒤에 개정판 기준 521페이지에 있습니다! 개정 이전 판도 뒤에 있습니다!
안녕하세요! 처음으로 질문을 남겨보네요.. 항상 좋은 강의 감사드립니다!
flatten함수의 매개변수로 data를 사용하셨는데, 저는 example이라는 리스트가 어떻게 data와 같은 매개변수와 동일취급이 되어 인식할 수 있는건지 잘 모르겠습니다 ㅠㅠ 이전 재귀함수 예시에서는 마지막에 다 print()형태로 매개변수가 눈에 띄게 어떤 것인지가 보여서, 인식할 수 있다고 생각했는데 이번 예시는 그냥 example이 어떤 리스트인지만 써놨는데도 인식이 되어서요.. 어떤 원리인지 알려주시면 감사하겠습니다.
다음 사이트에 코드를 넣고 실행해보면
프로그램의 흐름을 시각화해줍니다! 이를 활용해서 분석해보시면 좋을 것 같습니다.
pythontutor.com/visualize.html#mode=edit
또한 다음 강의도 한 번 참고해보시면 위의 파이썬 튜터의 흐름을 조금 더 이해하실 수 있을 것 같습니다!
ruclips.net/video/9tbjjZb65ng/видео.html
@@윤인성 감사합니다. 열심히 이해해보도록 노력해보겠습니다.
안녕하세요^^ 확인문제 1번문제에서 만약 평탄화한 결과가 [4 5 6 1 2 3 7 8 9] 이렇게 위치도 맞춰야하면 어떻게 해야할까요??
위치도 맞춘다는 것이 어떤 의미인지 조금 더 자세하게 설명해주실 수 있을까요?
[[1, 2, 3], [4, [5, 6]], 7, [8, 9]]를 평탄화하면 [1, 2, 3, 4, 5, 6, 7, 8, 9]가 나올 뿐입니다.
저도 책을 먼저 사서 보다가 강의가 있다는 것을 나중에 알았습니다 ㅎㅎ
수업 열강중입니다!
질문이 있는데
example = [[[1, 2, 3], [4, [5, 6]], 7, [8, 9]] 여기서
type([1,2,3]) == list 가 맞으니
flatten(item)으로 재귀가 되면 다시 처음으로돌아가 flatten([1,2,3])이 되는건가요?
돌아간다면 for 구문에서 data 자리에는 리스트[1,2,3]이 되고 여기서 다시 반복을 돌리면 요소가 되어버려 else구문으로 가서 output으로 반환한다는 것인지.... 제가 이해한게 맞는지 헷갈리네요 ㅠㅠ
다음 강의의 사이트를 참고해보세요!
ruclips.net/video/5m1qyapPvXw/видео.html
선생님 output += [item] 의 의미는 그럼 해당 output을 item에 넣는다고 생각하면 될까요?
* 해외 거주중이라 책은 구매하지 못했습니다 ㅠㅠㅠㅠ 뭔가 강의 듣다가 찔려서.. 그래도 정말 좋은 강의 계속해서 듣고 있고 굉장히 도움이 많이 되고 있다는 점 알아주셨으면 감사하겠습니다
넵! output이 리스트일 때 뒤에 추가합니다!
안녕하세요! 지금 확인문제 1번풀고있는데
조건문쪽에서
리스트일땐 output에다가 flatten(item)한걸 집어넣고
리스트가 아닐땐 output 뒤에다가 요소를 추가한다고 생각해도 될까요?
그리고 flatten(item)을 리스트의 []를 없앤다고 생각해도 될까요?
넵 전부 맞습니다!
@@윤인성 ㅠㅠ정말감사합니다
인성 쌤 먼저 늘 친절한 독자를 위한 A/S 감사드립니다.
제가 이해한 것이 맞는지 헷갈려서요 (어렵네요 ^^;;;;;)
1. def flatten(data):
2. output = []
3. for item in data:
4. if type(item) == list:
5. output += flatten(item)
6. else:
7. output += [item]
8. return output
9. example = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
10. print("변환:", flatten(example))
Q. 여기서 가장 먼저 6번 라인 'else' 의 true 를 받아서 '7'을 반환 하게 되는 것이 맞나요? 그런데 print 되어진 결과값을 보건데 -리스트 내부에 작은수부터 정렬 기능이 없으므로- 다음 함수 이행시에 'if type(item) == list'의 true 를 받아서 [1, 2, 3] 리스트의 요소에 접근하게 되는 것이 맞나요?
^^ ;;;;;;
코드는 무조건 순서대로 출력되므로,
리스트 내부에서 가장 처음 확인하는 요소는 [1,2,3]입니다.
이걸 말로 전부 설명하는 것보다는
pythontutor.com
라는 사이트에서 Start visualizing your code now를 누르면
코드를 입력할 수 있는 공간이 나옵니다.
여기에 코드를 넣고 실행해보시면
어떤 형태로 실행되는지 코드를 한 줄 한 줄 메모리 공간과 함께 보여줍니다!
참고해보시면 좋을 것 같습니다!
.
추가로 메모리 공간을 분석할 때는
ruclips.net/video/9tbjjZb65ng/видео.html
이 강의를 한 번 보시면 조금 더 쉽게 이해하실 수 있을 것 같습니다!
이번 풀이는 제 손으로 한 문제도 못 풀었네요ㅠㅠ 책을 끝까지 돌리고 다시 도전해 봐야 될 것 같습니다
넵 일단 넘어가고서 진행하셔도 될 것 같습니다 'ㅁ' ...!
질문이 있습니다.
연습문제 1
"output +=[item]"에 [ ]
리스트 문항을 넣는다는게 어떤 의미인지 조금 더 자세하게 알려주실 수 있을까요[코드로 보여주시면 질문 의도를 쉽게 파악할 수 있을 것 같습니다!]
1번 확인문제에서 example 안 값을 바꾸면 변환된값에도 바뀌어야 정상 아닌가요? 코드 따라했더니 example 값이 바뀌어도 변환된 값은 1~9까지로 항상 동일하네요 설명좀 ㅁ해주세요..
안의 값을 다른 숫자로 바꾸었는데 변화가 없다면, 코드를 저장하고 실행하셨는지 확인해주세요(단순하게 괄호를 변경하는 것으로는 결과가 같습니다).
첫번째 item이 [[1,2,3]]을 의미하는 거겟죠? 그렇다면 자기 자신을 평탄화한 다음 output에 추가되어서 output= [1,2,3] 이되는거고 두번째 item이 [4,[5,6]] 인데 이거는 어떻게 해석되는지 잘 모르겠네요.. 일단 앞부분 다시 보러 가는데 혹시 한번더 설명해주시면 감사드립니다(흑흑)
1. 리스트인 경우 리스트를 확인합니다.
2. 숫자면 output에 추가합니다.
가 반복되는 것입니다...!
요소를 하나하나 확인하는데, 일단 [1, 2, 3]이 리스트이므로, 1번으로서 확인합니다. 따라서 2번으로서
1> 숫자
2> 숫자
3> 숫자
전부 추가합니다.
이어서 [4, [5, 6]]이 리스트이므로 1번이라
4> 숫자 : 2번으로서 추가
[5, 6]> 리스트: 1번으로서 확인
[5, 6]이므로
5> 숫자: 추가
6> 숫자: 추가
하는 형태로 쭉쭉 반복합니다...!
@@윤인성 아하 감사합니닷
책 구매하여 강의보고 있습니다.감사합니다!!!
감사합니다. 책은 당연히 구매했지요 ㅎㅎ
def flatten(data): output = [] for i in data: if type(i) is int: output.append(i) elif type(i) is list: output.append(flatten(i)) return output
example = [[1,2,3],[4,[5,6]],7,[8,9]]print("원본:", example)print("변환:", flatten(example))이렇게 하면 결과 값이 그냥 원래 값이랑 같이 나오는데 이때 append함수를 쓰면 안되는건가요?
아래의 장호재님 댓글을 확인해보시면 좋을 것 같습니다...!
저뜻이 잘이해가안되서요ㅠㅠ 혹시 좀더자세하게 설명해주실수 있으신가요
@@카이마루 어떤 것이 이해가 안 되는지 조금 더 자세하게 설명해주시면, 그쪽에 맞게 답변 드릴 수 있을 것 같습니다...!
왜 독립적으로 다른 리스트로 인식이되어야하나요???
@@카이마루앗 위의 코드가 일자로 되어 있어서, 잘못 봤었군요 ;ㅁ; ....
output.append(flatten(i))
# 이 코드는
# output += flatten(i)가 아니라
# output += [flatten(i)]에 해당하는 코드입니다.
다음과 같이 리스트의 요소를 추가하는 것으로 변경해주셔야 합니다.
output.extend(flatten(i))
안녕하세요 ^^ 강의 잘 보고 있습니다.
실은 제가 몇 가지 질문이 있는데
def flatten(data):
output = []
for item in data:
if type(item) == list:
output += flatten(item)
else:
#output.append(item)
output += [item]
return output
example = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
print(example)
print(flatten(example))
if문의 실행문인 output += flatten(item)도 리스트 함수를 사용해서
바꿔보고 싶은데 어떻게 하면 좋을까요? 알려주세요 ㅠㅠ 잘 모르겠어요 ㅠㅠ
첫 번째 리스트인 [1,2,3]이 item에 들어가
if 조건문을 충족해서 flatten 재귀함수가 작동하고
다시 [1,2,3]의 요소가 for문의 item 변수에 하나씩 들어가
이번엔 else문이 작동해 append로 1,2,3이 차례로 output으로
들어가는데 여기서 else문이 끝나고 return output까지 다 실행되서
return output 값으로 output = [1,2,3]을 flatten(item)함수에 돌려주고 재귀함수가
종료되는 게 맞나요?
그리고 첫 번째 재귀함수가 끝나면 다시 돌아왔을 때
output += flatten(item)은 어떻게
되는 건가요?
재귀함수가 작동할 때 else문에서 output 리스트에
append 함수로 1,2,3을 넣어줬었는데 그러면 다시 재귀함수가 끝나고
다시 돌아왔을 때 output += flatten(item)이 작동해서 flatten(item) 재귀함수에서 나온
output = [1,2,3]이라는 결과값이 output리스트에 두 번 중복되는게 아닌건가요??
output = [1,2,3,[1,2,3]] 이런 식으로요?
아니면 재귀함수가 작동하기 전의 output리스트와 작동할 때의 output리스트는 따로따로인건가요?
따로따로여도 flatten(item)이 받은 값은 [1,2,3]이라는 리스트 형태인데 그럼 output += flatten(item)이 실행되도
output = [[1,2,3]] 형태가 되는 게 아닌건가요?
그리고 else문에서 output += [item]으로도 작성할 수 있었는데
item에 꼭 대괄호가 필요한 건가요?
output.append(item)를 쓸 때는 첫 번째 리스트 [1,2,3]으로
재귀함수가 작동할 때 for문의 item 변수에 1,2,3 차례로
들어가서 정수들이 output 리스트에 들어간다고 생각해서 알겠는데
output += [item]에서 대괄호를 빼보니까
'int' object is not iterable라는 오류가 뜨는데 어떤 차이가 있는건가요?
제가 좀 이상한 질문들을 했죠....? 뭔가 알것 같은데 잘 와닿지는 않아서 질문을 하게 됐습니다.
긴 글 읽어주셔서 감사합니다.
1. 지금 분석은 맞습니다. 다만 코드에서 문제가 있는데요[다른 댓글을 보셔도 아실 수 있겠지만 extend()라는 함수를 잘 생각하지 않다보니 많은 분들이 헷갈려하는 부분입니다]. output.append(flatten(i))는
# output += flatten(i)가 아니라
# output += [flatten(i)]에 해당하는 코드입니다.
따라서 output.extend(flatten(i))를 사용해주셔야 합니다. 아마 이걸 생각하시면서 분석해보시면 위쪽에 적어주신 내용을 제대로 분석하실 수 있을 것입니다.
2. [item]의 경우, 예를 들어 [1]은 리스트이지만, 1은 int(정수)입니다. for i in 1이라고 입력되어서, 정수는 반복을 돌릴 수 있는 대상이 아니다(int object is not iterable)이라는 오류가 발생하는 것입니다.
@@윤인성 알려주셔서 정말 고맙습니다! 바보같이 리스트 함수랑 연결 연산자를 헷갈려서 이중 리스트 만든다는 듯이 생각해버렸네요. 이중 리스트 만들거나 풀려면 반복문도 이중으로 돌려야한다고 알려주셨었는데... 알려주셔서 정말 고맙습니다!!!!
@@윤인성 더 궁금한 게 있는데 output.append(flatten(i))은
output += [flatten(i)]에 해당하는 코드라고 알려주셨는데
그럼 재귀함수가 돌아가서 받은 리턴값인 output = [1,2,3]은
output.extend(flatten(i))로는 output.extend([1,2,3])처럼 되서
output = [1,2,3]이 되고 다음 리스트 요소로 반복문과 재궈함수가 돌아가는데
output.append(flatten(i))를 사용하면 리턴값이었던 [1,2,3]을
하나의 요소로 생각해서 extend처럼 output = [1,2,3]이 되는 게 아닌
output = [[1,2,3]]처럼 이중으로 된다고 생각하면 되는 건가요?
그리고 함수 밖에서 선언한 변수를 사용하려면 global 키워드를 사용해야
된다고도 알려주셨는데 그럼 함수 내에서 선언되고 사용된 변수의 값은
리턴으로 주지 않으면 그 함수가 끝나면 사라진다고 보면 되는건가요?
김대업
1. 설명해주신대로 extend()와 리스트 연결 연산자는 이중 리스트가 되는 것이 아니라, [1, 2, 3] + [4, 5, 6] = [1, 2, 3, 4, 5, 6]이 됩니다.
2. 그냥 append([])하면 이중 리스트로서 들어가는 것이 맞습니다.
3. 함수 밖에 선언한 변수를 사용할 때 오류가 발생할 경우 global을 붙여주세요. 정확하게는 변수에 저장된 값을 변경하는 경우(문자열, 숫자, 불, 레퍼런스 직접 변경)에만 global이 필요하며, 어떤 자료가 갖고 있는 함수를 호출하거나 할 때는 필요가 없습니다. 다만 이걸 초보자 단계에서 구분하는 것이 어렵기 때문에 오류가 발생할 경우 global을 붙인다고 생각하시는 것이 쉬울 것입니다.
4. 함수 내부에서 선언된 변수는 해당 함수 호출이 끝나면 제거됩니다.
@@윤인성 알려주셔서 고맙습니다 ^^
output이 리스트여서 함수 밖에서 선언해도 될 줄 알았는데 함수 밖에서 선언하면 오류가 뜨네요.
내부에서 선언해 줘야 하나요??
어떤 코드에서 어떤 오류가 발생하는지 올려주실 수 있을까요?
output = []
def flatten(data):
for item in data:
if type(item) == list:
output += flatten(item)
else:
output += [item]
return output
example = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
print("원본:", example)
print("변환:", flatten(example))
-----------------------------------
이렇게 output = []을 밖으로 빼면 오류가 나옵니다.
선생님 혹시 언급하신 알고리즘 퍼즐 서적도 파이썬기반으로 쓰여진 책인가용?? 다른 언어 몰라도 볼수 있는 책인지 궁금합니당
넵 파이썬 기반의 책입니다. 다만 난이도가 좀 상당한 편입니다.
안녕하세요. 혹시 245p 2번 문제 풀이 강의를 찾지를 못해서 문의드립니다 ㅠㅠ 혼자 많이 생각을 해봤는데 어떤 메커니즘으로 돌아가는건지 모르겠습니다.. 감사합니다 ㅠ
다음입니다!
ruclips.net/video/594WmZdC_ts/видео.html
감사합니다
하루에 한 강의씩 잘 듣고 있습니다. 친절한 강의 감사합니다.
확인 문제 1번 실행순서
를 적어보았는데, 확신이 서지 않습니다.
제가 return을 명확히 이해하지 못한 것 같습니다.
11번에서 12번으로 넘어가는 것이 맞는지요?
01 data = example = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
02 output = []
03 type([1, 2, 3]) == list
04 output = [] + [1, 2, 3] = [1, 2, 3]
05 type([4, [5, 6]]) == list
06 output = [1, 2, 3] + [4, [5, 6]] = [1, 2, 3, 4, [5, 6]]
07 type(7) != list
08 output = [1, 2, 3, 4, [5, 6], 7]
09 type([8, 9]) == list
10 output = [1, 2, 3, 4, [5, 6], 7, 8, 9]
11 return output
12 data = output = [1, 2, 3, 4, [5, 6], 7, 8, 9]
13 output = [1, 2, 3, 4]
14 type[5, 6] == list
15 output = [1, 2, 3, 4, 5, 6]
16 output = [1, 2, 3, 4, 5, 6, 7, 8, 9]
현재 주신 것만으로는 제가 원본 코드와 줄 위치의 대조가 힘들어서, 어떤 순서로 쓰셨는지 알기 어려울 것 같습니다[또한 코드 실행 순서 표기 방법이 사람마다 제각각이라]. 일단 코드 줄을 확인하실 때는 모든 줄 사이에 print("A 위치 입니다") 등을 넣어보시면 쭉 확인할 수 있습니다.
감사합니다!
print를 두 곳(if, else)에 추가해서 실행보니, 아래와 같이 실행순서를 구체적으로 알 수 있었습니다.
그런데 의문점이 생겼습니다.
원본: [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
output = [1]
output = [1, 2]
output = [1, 2, 3]
output = [1, 2, 3]
output = [4]
output = [5]
output = [5, 6]
output = [4, 5, 6]
output = [1, 2, 3, 4, 5, 6]
이하 생략
output=[1,2,3]과 함께 return을 하지만,
함수 초깃값이 output=[]이기 때문에,
그 다음으로 [4]를 얻는데,
후에 [4,5,6]으로 합쳐지는 과정이나,
마찬가지로 [1,2,3,4,5,6]으로 되는 부분이
어떻게 가능한지 모르겠습니다.
결과만 놓고 예상했을때는
output값을 갖고 가서 함수로 돌아가니,
초깃값을 무시하고 [1,2,3]에 [4]가 붙어서
[1,2,3,4]로 추가될 줄 알았습니다.
분석이 트리 분석으로 들어가야해서
단순하게 숫자를 붙이는 것으로는 전체적인 형태를 잡기 어려우실 수 있는데요.
ruclips.net/video/594WmZdC_ts/видео.html 여기와 같은 형태로 트리 순회가 일어나서
건너뜀뛰는 것과 같은 효과가 발생하는 것입니다.
비슷한 재귀 문제이므로 이 예제 먼저 참고해보시면 좋을 것 같습니다!
감사합니다!!!
제가 확인문제 1번 혼자 풀어본 코드가 있는데요
---------------------------------------------------------
output = []
def flatten(data):
for i in data:
if type(i) == list:
flatten(i)
if type(i) == int:
output.insert(i,i)
return output
example = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
print("원본:", example)
print("변환:", flatten(example))
-----------------------------------------------------------
위처럼하면 잘 실행이 되는데
-----------------------------------------------------------
def flatten(data):
output = []
for i in data:
if type(i) == list:
flatten(i)
if type(i) == int:
output.insert(i,i)
return output
example = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
print("원본:", example)
print("변환:", flatten(example))
-----------------------------------------------------------
아래처럼 output = []을 함수 안으로 나오면 답이 틀리게 나옵니다.
파괴적, 비파괴적의 차이이지 않을까 싶은데.... 혹시 설명 부탁드려도 될까요!
코드가 많이 들어가면 유튜브가 스팸으로 인식해서 알림을 안 주다보니 댓글을 늦게 보았군요 @_@ .일단 코드 자체가 다른 것이라 파괴적 비파괴적을 떠나서 답이 당연히 다르게 나올 수 밖에 없습니다. 위의 코드는 output이 계속 유지되는 형태이고, 아래 코드는 output이 함수를 실행할 때마다 증발되니까요.
현재 아래 코드에서는 내부에서 추가로 실행되는 flatten 함수의 리턴값이 아무 의미 없이 증발해버리므로(함수 호출만하고 그 결과를 활용하는 것이 없으므로), 답이 나오지 않습니다.
추가로 코드는 위처럼 output을 밖에 두시면 안 됩니다. 그럼 flatten() 함수를 두 번 이상 실행했을 때 문제가 발생합니다.
답변감사합니다! 그런데 제가 만든 코드와 정답 코드를 비교하니 계속 이해가 안되는 점이 있네요 ㅠㅠ
------------------------------------------------
output = []
def flatten(data):
for i in data:
if type(i) == list:
flatten(i)
if type(i) == int:
output.insert(i,i)
return output
example = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
print("원본:", example)
print("변환:", flatten(example))
-------------------------------------------------
는 output이 밖으로 나와야 정답인데
-------------------------------------------------
def flatten(data):
output = []
for item in data:
if type(item) == list:
output += flatten(item)
else:
output += [item]
return output
example = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
print("원본:", example)
print("변환:", flatten(example))
---------------------------------------------------
는 output이 안으로 들어가야 정답입니다. output이 밖으로 빠지면 unboundlocalerror가 뜨더군요.
output이 함수를 실행할 때마다 증발된다는 소리는 이해를 했는데 왜 아래 코드는 다르게 적용이 되는 지 모르겠습니다...
이해가 안돼서 계속 질문 드려 죄송합니다 ㅠㅠ
선생님 안녕하세요? 강의를 정말정말 잘 듣고 있습니다.
문제 1번과 관려하여 질문이 생겨서 댓글 남깁니다
문제 1번의 코드를 다음과 같이 짜다가 아래 주###가 있는 줄을 강의와 다르게 입력하였더니
def flatten(data):
output = []
for item in data:
if type(item) == list:
output += [flatten(item)] #######################
else:
#output.append(item)
output += [item]
return output
example = [[1,2,3], [4,[5,6]],7,[8,9]]
print(example)
print(flatten(example))
실행결과가 exmaple과 동일한
>>> [[1,2,3], [4,[5,6]],7,[8,9]]
나왔습니다.
혹시 몰라서 간단한 list 함수를 가지고 실행해보니
혹시 몰라서 간단한 list 함수를 가지고 실행해보니
A = [1,2,3]
A += [4,5,6]
의 결과는
>>> A = [1,2,3,[4,5,6]]
이 나올 것으로 예상했는데
>>> A = [1,2,3,4,5,6]
으로 나왔습니다.
한편
A = [1,2,3]
A += 4,5,6
의 결과는
>>> A = [1,2,3,4,5,6] 이 나왔습니다.
으로 나왔습니다.
왜 위와 같은 결과가 나온 것일까요?
list의 뒷쪽에 변수를 추가하기 위해 "+=" 를 사용할 때 , [ ] 의 역할과 관련하여 제가 놓치고 있는 부분이 있는 것 같은데 한 번 확인 부탁드리고 싶습니다.
감사합니다.
1. 리스트의 += 연산자는 리스트의 요소를 추가합니다.
따라서 a = [1]
a += [2]하면
a는 [1,2]가 됩니다.
.
PS. append()가 아니라 extend() 함수처럼 동작합니다.
.
2. 파이썬에 숫자를 단순하게 쉼표로 연결하면 튜플로 인식합니다. 따라서
a = [1]
a += 2,3 # 하면 a += (2,3)이 되어
a는 [1,2,3]이 됩니다.
.
3. += 연산자는 append와 다릅니다.
a.append([1,2])를 하려면
a += [[1,2]]를 해야 합니다.
@@윤인성 빠른 답변 감사합니다! 틀린 부분을 바로 잡아주셔서 감사합니다.
선생님 그런데 아직 궁금한 점이 있습니다.
위의 댓글에도 적었듯이, 교재의 1번 내용에 해당되는 코드의 if 에 해당되는 내용 중에서
output += [flatten(item)] 이랑 output += flatten(item)
을 넣었을 때 차이가 나는 이유는 무엇인가요??
@@임연수-o8h 둘은 코드 자체가 달라서 실행 결과가 다를 뿐입니다!
다른 코드는 다른 결과를 냅니다.
책 구매하여 보고 있습니다 책이 킬링포인트 넘좋죠잉
강의 잘보고있습니다. 질문이 있는데요, 문제 1번 5행에서 output.append(flatten(item)) 이 안되는 이유가 무었인가요?
실제 실행이 다릅니다!
a += b와 같은 것은 a.extend(b)입니다.
다음 실행 결과들을 참고해주세요!
# a += b
>>> a = [1, 2, 3]
>>> a += [4, 5, 6]
>>> a
[1, 2, 3, 4, 5, 6]
# a.append(b)
>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]
# a.extend(b)
>>> a = [1, 2, 3]
>>> a.extend([4, 5, 6])
>>> a
[1, 2, 3, 4, 5, 6]
@@윤인성 와 감사합니다 사실 2년전 강의라 답글이 안달릴줄알았는대 명쾌한 답변 너무 감사드리고 책사서 공부열심히 하고있습니다. 명강의 감사드립니다!!
선생님.. 1번문제는 나름 쉬워서 괜찮았는데 2번문제는 그냥 넘어가도 될까요;;?
지금은 넘어 가셔도 되지만, 나중에는 돌아와서 다시 푸는 것을 추천드립니다!
p.239 어떠한 설명도 없는 코드 첫줄이 틀린 것 같네요.
radius = input("숫자 입력> ")이 아니라 number_input_a = input("숫자 입력> ") 이 되어야 할 것 같습니다.
앗 오탈자 보고 감사드립니다 @_@ ...!!!
초보인데요.. 한 3번 보고 3~4시간 머리 쥐어짜니 평탄화가 이해가 되는군요...
규진님 머리가 비상하시군요.. 이틀짼데 그냥 외워야 하나 싶습니다. ㅠㅠ
확인문제 1번
[1,2,3]
[4,[5,6]
7
[8,9]로 나눠지지않습니까 요기서 [1,2,3]이 리스트니깐
output = output([]) + (flatten(item) = [1,2,3]) 이거니깐
리스트 + 리스트로 output = [1,2,3] 이렇게 바로 나오는거 맞습니까?
그다음은 output = output + [4,[5,6]은 더해지지않으니 [4,[5,6]은 올라가서 다시 4,[5,6]으로 변환해서 계산하는거 맞습니까?
넵 그렇습니다!
강의 내용이 좋아서 '혼공파' 책을 사서 공부하고 있습니다. 고맙습니다. 다만, 제 컴퓨터로는 에디터로 비주얼 스튜디오 코드를 내려받지 못해서, idle 에디터를 사용하고 있죠^^
flatten을 직접 만들어보려고 시도해보았는데 flatten을 파괴적 함수로 생각하고 파괴적 함수가 되도록 작성해보았는데 비파괴적이 되네요. 매개변수로 받는 것은 변수 자체가 아니라 거기에 저장된 값인듯 합니다.
유지태 기본 자료형은 값이 복사되고, 딕셔너리와 리스트 등은 레퍼런스가 전달되므로 비파괴적 함수로 만들 수는 있습니다.
def 함수(레퍼런스):
레퍼런스.append(10)
리스트 = [1, 2, 3]
함수(리스트)
print(리스트)
아마 실패하신 것은 위의 코드 같은 때에 "레퍼런스 = []" 같은 코드로 최종적으로 매개 변수로 전달 받은 녀석에게 값을 할당하신 것 같은데, 이러면 완전히 다른 레퍼런스로 대체되어 버리므로 변수(레퍼런스)가 아예 다른 리스트로 등록됩니다(clear extend 를 활용해야 합니다).
@@윤인성ｄ（ T ㅆ T） 乃
(대충 울면서 쌍따봉 하는 모습)
죄송한데 244-245쪽 연습문제 풀이도 올려주실 수 있을까요?? 아무리 보면서 생각해보려고 해봐도 자꾸 헷갈리네요ㅠㅠㅠㅠㅠ
이 문제는 이전 강의에서 언급했던 것처럼 ruclips.net/video/594WmZdC_ts/видео.html 에 풀이가 있습니다...! 굉장히 어려운 문제에 속합니다 @_@ ...!
몸이 호전될때까지 쉬시는게 좋을 듯 합니다..
5-2 공부하다보니..오히려 4장이 쉽게 느껴지는 건 무엇,,,?;; 4장을 하도 반복해서 봐서 그런가.;; 5-2는 일단 사알짝 넘어 가서..5-3부터 진도 나가야겠군요. 막막하게 멍하게 붙잡고 있는거 같아서. ㅜㅜ
5장까지만 어려우니 힘내세요 😂...!!!
안녕하세요 혹시 확인문제 2번 답은 어디서 볼수있을까요?>
답은 다른 문제와 마찬가지로 424 페이지에 있습니다!
그리고 추가로 혼공파 다음에 혼공 첫 프로그래밍 도서를 공부하는 순서로 추천하시는지도 궁금합니다 ^^
해당 책을 읽어보지 않아서 추천을 드릴 수가 없습니다 😭. 기본적으로는 언어 기본서 한 번 읽었으면 또 기본서를 읽기보다는 라이브러리와 프레임워크를 활용하는 책을 읽어보는 것을 추천드립니다[이후에 읽고 뭐 만들면서 부족했다 느낀 부분을 기초 공부 더 하는 형태로 반복].
@@윤인성 저자가 같은 줄 알았어요.. ㅎㅎ 감사합니다!
output+=[item] 했으면 output+=[flatten(item)] 도 해야 돼거 아닌가요?
flatten(item)이 이미 리스트이므로 그렇게 쓰면 다른 결과가 나옵니다.
아...연습문제 스을 스을 벽이 느껴진다
문제 1번에 [4, [5, 6]]은 어떻게 처리가 되는건가요?
마찬가지로 처리됩니다.
[5, 6]을 처리할 때 flatten()이 한 번 더 호출되어 단계가 들어간다는 차이만 있습니다!
저.. 확인문제 2번이 죽어도 이해가 안돼요.. 제발.. 가르쳐주세요...ㅠㅠㅠㅠ
어떤 부분이 이해가 안되는지 조금 더 자세히 설명해주실 수 있을까요! 어떤 것을 생각했는데 → 어떻게 되어서 이해가 안 된다 등을 알려주세요.
ebook으로는 없나요? 검색했는데 안나와서요
현재 이북은 제공되고 있지 않습니다! 출판사 쪽에서도 이북 출간을 이래저래 고민하고 있는 것 같습니다.
책구매해서 동영상만(?) 보고 있습니다. 감사합니다. (;;;;;;)
한번 다 둘러보고 책 보면서 다시한번 시작해 봐야겠습니다....^^
아참 이정도 까지 들으신 분들은 책을 다들 들고 계실듯합니다^^
책을 오늘 구매했는데, 정말 담백하게 잘 집필됨.. 공부 시작...
책을 사는데 이 유튜브없더라면 어려워서 책을 집어 던져있을겁니다......
"근데 왜 새 책을 사는데 불구하고 맨 용어 노트가 자르선부분에 쥐가 파먹어 거 처럼 찢어있어서......
헌책 산 기분이....이놈에 교×문×...........
교보문고 😭...!!!!
넘 어렵네요 ㅋㅋ ㅠㅠ
프로그래밍이 반복문과 함수가 좀 어려눈 편입니다 😂...! 여기만 지나가시면 다 쉽습니다!