← Сtrl

terabayt · Фев. 25, 2015 23:10:59

vrabey
так не создавайте промежуточную переменную

очень запутано!

————————————————
-*- Simple is better than complex -*-

Stright · Фев. 25, 2015 23:16:21

vrabey
так не создавайте промежуточную переменную

Так то да, сорри

vrabey · Фев. 25, 2015 23:20:10

terabayt
очень запутано!

не уверен но если передавать аргументом то это как то более гибко что ли -
на вход f2 можно передать и другую функцию - возвращающую список

Stright · Фев. 25, 2015 23:20:20

terabayt
а условие задания какое? может мы поможем сделать еще лучше!

Я очень сильно упростил задачу, еще пару деньков попробую подумать над ней, и, наверное, в другой теме выложу, в этой теме неосновная ее часть

py.user.next · Фев. 26, 2015 01:09:36

Stright
Знаю, что можно присвоить результат какой-либо глобальной переменной, но в этом случае пользоваться глобальными переменными, наверное, будет неправильно.

Связывать функции между собой точно так же неправильно, как и связывать функции через глобальные переменные. Функции должны быть независимыми друг от друга, даже если используются совместно. Связь между функциями должна поддерживаться через передаваемые аргументы и возвращаемые значения. Причём эти данные должны быть максимально простыми, чтобы исключить ещё одну связь.

>>> def f1():
...     return [1, 2, 3, 4, 5]
... 
>>> def f2(lst):
...     lst.append(1)
...     return lst
... 
>>> f1()
[1, 2, 3, 4, 5]
>>> f2([8, 9])
[8, 9, 1]
>>> f2(f1())
[1, 2, 3, 4, 5, 1]
>>>
>>> x = []
>>> _ = f2(x)
>>> x
[1]
>>>

Лучше и list.append() исключить из f2(), так как изменение аргумента не видно из заголовка. Это побочный эффект, и их следует точно так же избегать.

>>> def f1():
...     return [1, 2, 3, 4, 5]
... 
>>> def f2(lst):
...     return lst + [1]
... 
>>> f1()
[1, 2, 3, 4, 5]
>>> f2([8, 9])
[8, 9, 1]
>>> f2(f1())
[1, 2, 3, 4, 5, 1]
>>>
>>> x = []
>>> f2(x)
[1]
>>> x
[]
>>>

Отредактировано py.user.next (Фев. 26, 2015 01:22:16)

Stright · Фев. 26, 2015 08:08:59

То есть получается, что при передаче результата, например, из первой функции во вторую, а в свою очередь из второй в третью предпочтительная схема получается примерно такой:

def f1():
    ...
def f2(arg1):
    ...
def f3(arg2):
    ...
f2(f1())
f3(f2())

?

py.user.next
Это побочный эффект, и их следует точно так же избегать.

А если этот побочный эффект как раз и требуется от функции?

py.user.next · Фев. 26, 2015 09:50:05

Stright
То есть получается, что при передаче результата, например, из первой функции во вторую, а в свою очередь из второй в третью

f3(f2(f1()))

Stright
А если этот побочный эффект как раз и требуется от функции?

Рано или поздно у тебя окажется объект, который нельзя менять. И из-за этого побочного эффекта ты не сможешь применить к нему эту функцию. Будешь писать новую функцию, которая делает то же самое без побочного эффекта.

MiK · Фев. 26, 2015 13:56:05

py.user.next
Чего-то я запутался. Ты против того чтобы, вообще, вкладывать функции друг в друга?

py.user.next · Фев. 26, 2015 21:28:17

MiK
Ты против того чтобы, вообще, вкладывать функции друг в друга?

Не, там он список подаёт, который после работы функции становится изменённым. Когда надо будет сделать то же самое со списком, который нельзя менять, он не сможет это сделать. К тому же в описании функции придётся писать, что у неё есть побочный эффект, потому что из названия и аргументов этого не видно.

Вот, например, он написал функцию:

>>> def f(lst, item):
...     lst.append(item)
...     return lst
... 
>>> lst = [1, 2, 3]
>>> out = f(lst, 1)
>>> lst, out
([1, 2, 3, 1], [1, 2, 3, 1])
>>>

Кажется, что всё нормально, только список меняется немного.

Но тут в другой программе потребовалась та же самая операция. Он думает “а я же писал функцию такую” и берёт её:

>>> import sys
>>> 
>>> out = f(sys.argv, '..')
>>> sys.argv, out
(['', '..'], ['', '..'])
>>>

И тут оказывается, что она не подходит, потому что меняет список, а это в данном случае не нужно.

А вот если так он написал сначала:

>>> def f(lst, item):
...     return lst + [item]
... 
>>> lst = [1, 2, 3]
>>> out = f(lst, 1)
>>> lst, out
([1, 2, 3], [1, 2, 3, 1])
>>> 
>>> import sys
>>> 
>>> out = f(sys.argv, '..')
>>> sys.argv, out
([''], ['', '..'])
>>>

То и функция становится более применимой.

MiK
вкладывать функции

Вкладывать можно:

>>> def f(lst):
...     def g(seq):
...         return (i + 1 for i in seq)
...     def h(seq):
...         return (i ** 3 for i in seq)
...     return list(h(g(h(g(lst)))))
... 
>>> f([1, 2, 3])
[729, 21952, 274625]
>>>

Отредактировано py.user.next (Фев. 26, 2015 21:43:42)

MiK · Фев. 26, 2015 22:55:11

py.user.next
Интересно, твоё мнение как специалиста: на питоне можно нормально в функциональном стиле писать? Я имею ввиду именно парадигму. А то мнения очень неоднозначны на этот счёт, и я не знаю есть ли смысл лезть в эти дебри.

Python-сообщество

Уведомления

#1 Фев. 25, 2015 23:10:59

Передача результата первой функции в качестве аргумента для второй

#2 Фев. 25, 2015 23:16:21

Передача результата первой функции в качестве аргумента для второй

#3 Фев. 25, 2015 23:20:10

Передача результата первой функции в качестве аргумента для второй

#4 Фев. 25, 2015 23:20:20

Передача результата первой функции в качестве аргумента для второй

#5 Фев. 26, 2015 01:09:36

Передача результата первой функции в качестве аргумента для второй

#6 Фев. 26, 2015 08:08:59

Передача результата первой функции в качестве аргумента для второй

#7 Фев. 26, 2015 09:50:05

Передача результата первой функции в качестве аргумента для второй

#8 Фев. 26, 2015 13:56:05

Передача результата первой функции в качестве аргумента для второй

#9 Фев. 26, 2015 21:28:17

Передача результата первой функции в качестве аргумента для второй

#10 Фев. 26, 2015 22:55:11

Передача результата первой функции в качестве аргумента для второй

Board footer