Вышел Python 3.0 final

> GIL не убрали? > Ф топку питончег!

Многопоточность и многозадачность не осилили? В топку анонимуса!

К стати а этот цирк пофиксили?
>>> def lst(a=[]):
...     a.append(1)
...     return a
...

>>> lst()
[1]
>>> lst()
[1, 1]
>>> lst()
[1, 1, 1]

??

> К стати а этот цирк пофиксили?

Нет. А есть bug report на этот цирк?

>К стати а этот цирк пофиксили?

Прикольно. Подтверждаю. Да, это на одном уровне с http://www.linux.org.ru/view-message.jsp?msgid=3273356 ...

>>> def lst(a=None):
...     if a == None:
...             a = []
...     a.append(1)
...     return a
... 
>>> lst()
[1]
>>> lst()   
[1]
>>> lst()
[1]

http://docs.python.org/reference/compound_stmts.html#function

Кстати, в каком языке сделано по другому?

Сортировку списков поломали. Теперь сортировка не принимает функцию для сравнения элементов. А принимает функцию с одним (!) аргументом для выдачи ключа для элемента. В качестве вокэраунда хардкорные питононисты предлагают хак, оборачивающий функцию сравнения в объект (http://bytes.com/groups/python/844614-python-3-sorting-comparison-function). Это хак у меня, кстати, не заработал. Трижды прокляв создателей Python 3, мне пришлось преобразовать список элементов в список туплей, чтобы обойтись вообще без сравнивающей функции.

Вот такие танцы. Правильной дорогой идете, товарищи!

> >>> def lst(a=None): > ... if a == None: > ... a = [] > ... a.append(1) > ... return a > ... ... > Кстати, в каком языке сделано по другому?

irb(main):029:0> def lst(a=[]) irb(main):030:1> a.push(1) irb(main):031:1> return a irb(main):032:1> end => nil irb(main):033:0> lst => [1] irb(main):034:0> lst => [1] irb(main):035:0> lst => [1] irb(main):036:0> lst => [1] irb(main):037:0> RUBY_VERSION => "1.9.0"

Кажется, у Эккеля, в книге "Философия C++" написано, что нехорошо делать проверку на default значение и в зависимости от этого менять алгоритм. Но в плюсах для того, чтобы не делать таких проверок, можно определить несколько функций с одним именем и разными наборами аргументов.

> >>> def lst(a=None):
> ...     if a == None:
> ...             a = []
> ...     a.append(1)
> ...     return a
> ...
...
> Кстати, в каком языке сделано по другому?

irb(main):029:0> def lst(a=[])
irb(main):030:1>  a.push(1)
irb(main):031:1>  return a
irb(main):032:1> end
=> nil
irb(main):033:0> lst
=> [1]
irb(main):034:0> lst
=> [1]
irb(main):035:0> lst
=> [1]
irb(main):036:0> lst
=> [1]
irb(main):037:0> RUBY_VERSION
=> "1.9.0"

Кажется, у Эккеля, в книге "Философия C++" написано, что нехорошо делать проверку на default значение и в зависимости от этого менять алгоритм. Но в плюсах для того, чтобы не делать таких проверок, можно определить несколько функций с одним именем и разными наборами аргументов.

УРА, ТОВАРИЩИ!

> К стати а этот цирк пофиксили?

Это Фича.

> >>> def lst(a=None):
> ... if a == None:
> ... a = []
> ... a.append(1)
> ... return a


Хреновенько. И в 3.0 будет так же?

Это ж очевидный бажный бред - делает невозможным 
применение значений по умолчанию к непримитивным типам:

>>> class X:
...     def __init__(self):
...          self.s = "bu"
...
>>> def f(x=X()):
...     x.s += "-ga"
...     return x
...
>>> f().s
'bu-ga'
>>> f().s
'bu-ga-ga'
>>> f().s
'bu-ga-ga-ga'

одноразовая функция:)))

> Это ж очевидный бажный бред

Это даже в руководстве по языку описано, если что.

>Это даже в руководстве по языку описано, если что.

Я читал но зачем? Вернее зачем понятно - но почему так?

почему это работает вот так?

>>> x = 5
>>> def f1(y=x):
...     return y
...
>>> def f2(y=0):
...     y = x
...     return y
...
>>> f1()
5
>>> f2()
5
>>> x = 7
>>> f1()
5
>>> f2()
7

Я бы понял если бы суть биндинга была как в окамле:

# let x = 10;;
val x : int = 10
# let f1 ?(y = x) () = y;;
val f1 : ?y:int -> unit -> int = <fun>
# let f2 () = let y = x in y;;
val f2 : unit -> int = <fun>
# f1 ();;
- : int = 10
# f2 ();;
- : int = 10
# let x = 20;;
val x : int = 20
# f1();;
- : int = 10
# f2();;
- : int = 10


но это же не так.

я в том смысле что поскольку в обчных определениях передается все by reference - зачем это было делать отлично в дефултных параметрах? Пусть бы f1 был короткой формой f2.

>>Это даже в руководстве по языку описано, если что.

>Я читал но зачем? Вернее зачем понятно - но почему так?

А мне как раз понятно "почему", но непонянтно "зачем" %)

> почему это работает вот так?

Потому что int - иммутабельный тип.

>Потому что int - иммутабельный тип.

>>> x = [1,2,3,4]
>>> def f1(y=x):
...     return y
...
>>> def f2(y=None):
...     y = x
...     return y
...
>>> f1()
[1, 2, 3, 4]
>>> f2()
[1, 2, 3, 4]
>>> x = [5,6,7,8,9]
>>> f1()
[1, 2, 3, 4]
>>> f2()
[5, 6, 7, 8, 9]


Рояля не играет:)

> Рояля не играет:)

А ты присмотрись ;)

куда? В приведенном примере не играет.

>Кстати, в каком языке сделано по другому?

$ php -a

php > function lst($a=array()) { $a[] = 1; return $a; }

php > print_r(lst());
Array
(
    [0] => 1
)

php > print_r(lst());
Array
(
    [0] => 1
)

php > print_r(lst(array(1,2,3)));
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 1
)

>почему это работает вот так?

Чудовищный side-эффект, однако :)

> куда?

вот сюда: >>> x = [5,6,7,8,9]

Ты меняешь binding, но не значение. Сделай x.append(5) и посмотри, что будет.

>Ты меняешь binding, но не значение. Сделай x.append(5) и посмотри, что будет.

Дело не в этом - это понятно. Биндинг я поменял ниже дефинишена, а он аффектит описание сверху. Согласно описанию питона значения по умолчанию присваюиваются в момент дефинишена. Нафига, если даже обычные биндинги ведут себя не так? В этом была бы хоть какая-то логика, если бы все работало как в окамле. А то ведь такое странное исключение, которое делает непримитивные значения по умолчанию бесполезными да еще и странный спешел кейс в язык заводит. Зачем? Есть какая-то хитромудрая фигня которая без этого работать не будет?

Это в смысле с учетом того что значение присваевается в момент 
описания нелогично себя ведет f2. Если допустить что такое поведение 
f2 задумано (каким бы странным оно не было) - тогда нелогично себя 
ведет f1. То что создание переменной с единственным начением было бы 
жертвой в пользу регулярности языка - то есть привязывание к любому 
значению существующему на момент описания  - выглядело бы нормально, 
если бы не "чудовищный сайд эффект" (c) kron73 во всех прочих случаях.
А поскольку он все равно есть - непонятно зачем такое странное 
поведение с параметрами.

ocaml:

# let x = 5;;
val x : int = 5

# let f y = x + y;;
val f : int -> int = <fun>

# let x = 10;;
val x : int = 10

# f 5;;
- : int = 10

python:

>>> x = 5
>>> l = lambda y: x + y
>>> l(6)
11
>>> x = 10
>>> l(6)
16

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

Вот к стати пример организации питоновского поведения в окамле:

# let x = ref 5;;
val x : int ref = {contents = 5}
# let f y = !x + y;;
val f : int -> int = <fun>
# f 6;;
- : int = 11
# x := 10;;
- : unit = ()
# f 6;;
- : int = 16

То есть там поведение регулярное - по умолчанию лексическое окружение 
захватывается.Если хочется странного - опять все одинаково. А в питоне
поразному - для параметров окружение захватывается а для самого тела 
нет. Нафига?

Ну не додумал Гвидо малёк - он же всего лишь человек, а не патреГ какой ... :)

> Биндинг я поменял ниже дефинишена, а он аффектит описание сверху.

Где? O_o Результат f1 не меняется, результат f2 зависит от текущего__ значения глобальной переменной x. При изменении binding x результат f1 не меняется, а результат f2 - меняется. Всё правильно и логично.

> В этом была бы хоть какая-то логика, если бы все работало как в окамле.

То есть ты не видишь логики. Что ж, понятно.

>Где?

f2

>То есть ты не видишь логики.

А где тут логика?

x = some;

fun y=x { z=x }

x = other

результат

y == some

z == other

офигенно консистентно. И непонятно зачем.

>пример ООП-реализации открытия двери с 3мя замками и 2мя цепочками :)

door.open();

void Door::open()
{
foreach(Lock lock in locks){
lock.open();
}
throwSelf();
}