Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[Starver]

Call-by-sharing is the common description.  In Python, strings are immutable, so when you assign  (arg = 'One')  you're only creating a new string for arg to reference within the function, and val remains unchanged since it's still referencing the 'Two' string.

Python now officially confuses me.  Usually if we set variable=constant, then var is still as variable as it once was.  And what if we set var2=var?

I pride myself on understanding all kinds of languages (even if I can't yet reliably write with them), but looks like Python is... too strange.

(Obviously, it could be the same sort of 'trick' as if you "shift @_" in a Perl sub (ruining the connection between caller parameters and making any $_[0] assignments local only), or dealing with $_[0] and $_[1] directly which (assuming the parameter is assignable to, i.e. not a constant) keeps itself being an alias for the original scalar variable and usable as an 'Lvalue' (thing wot can sit on the left hand side of an assignment).  While I always liked that feature in Perl, and use it, I always considered it a bit 'hacky', in the midst of all the rest of the default behaviour...  Even for me.  Even for Perl.)

[SethCreiyd]

I'm not the best explainer of things, nor the most experienced with the language, but I'll try to clarify:

Spoiler (click to show/hide)

In normal conditions, every variable in Python is a reference to a specific object.  When you make an assignment to a variable, you're just assigning its reference, even when assigning strings or integers (which are themselves instances of the basestring and int types, respectively).

Variables remain variable no matter their assignment, as they hold only references to values and don't actually bear any values themselves.  In fact, there are no real constant variables in Python: by convention, constants are simply variables with names in ALL_CAPS, and it's up to the coder to leave them unchanged. 

You could easily declare SCREEN_RESOLUTION = (800, 600) at the top of the code only to set SCREEN_RESOLUTION = (640, 480) later in the program - bad practice, but possible.  You could also define a function with the name "eat_eggs", and then set eat_eggs = True; then eat_eggs would reference True and abandon the function.

So for setX:
 

Code: [Select]

>>> def setX(arg):
    arg="Two"

>>> val="One"
>>> setX(val)
>>> val
'One'

When setX(val) is called, it first assigns the arg variable to the same reference as val, but then arg="Two" makes arg reference the string "Two".  setX doesn't change the passed variable's references.  The reason mutations work is because before assignment, the passed variable and the function argument reference the same thing:

Code: [Select]

>>> def setY1(arg):
arg.append('spam')
arg.remove('juice')

>>> def setY2(arg):
arg = ['milk', 'cereal']
# arg references a new list now, so the passed reference is ignored

>>> thelist = ['eggs', 'juice']
>>> setY1(thelist)
>>> thelist
['eggs', 'spam']
>>> setY2(thelist)
>>> thelist
['eggs', 'spam']

Similarly, the following works because the obj argument references the same object as the passed variable, in this case, the function itself:

Code: [Select]

>>> def setZ(obj, arg):
obj.val = arg

>>> setZ.val = "One"
>>> val2 = "Two"
>>> setZ(setZ, val2)
>>> setZ.val
'Two'
Assigning var1 to var2 passes the reference of var1 to var2:

Code: [Select]

>>> var1 = "Apple"
>>> var2 = "Orange"
>>> var2 = var1
>>> var1, var2
('Apple', 'Apple')
>>> var1 = "Chocolate"
>>> var1, var2
('Chocolate', 'Apple')

var2 = var1 means not that 'var2 is now var1' but just that 'var2 will now reference var1's reference', which is "Apple".  So var1 = "Chocolate" has no effect on var2, which still references "Apple".  I need to stop coding before breakfast.

Mutable types can again be changed; by modifying a referenced object directly you'll affect all variables referencing it:

Code: [Select]

>>> var1 = ['apple', 'orange', 'banana']
>>> var2 = var1
>>> var1.remove('banana')
>>> var1, var2
(['apple', 'orange'], ['apple', 'orange'])

I hope that helps the confusion, though it's probably easier to understand than my explanations make it.  Though there are some weird aspects to it, Python makes sense once one gets used to it.  If I can learn to use it, anyone here can.

[MadocComadrin]

I'd say your assertion isn't actually true, and never was...

For a more software-relevant technical term (though eigenvalues are used quite a bit in physics engines too), try finding out what a "dual quaternion" is and what it's useful for by its name alone - even when knowing which of the many, many meanings of "dual" it refers to and what a "quaternion" is.

I think you might have missed the words "a general goal." It implies that there are other goals to balance and does not always hold for specific instances. I did not say trend; I did not say rule. You're not going to change my opinion that the term "call-by-sharing" is silly, and for every example you come up with that do not appear descriptive (I actually find the term eigenvalue to be rather poetic) I can find just as many that do.

That's implementation-specific. Python implementations (there is more than one already) can implement the same call-by-sharing semantics by actually copying the argument values, then copying them back if they were modified in the function. This is useful if the function is running on a different computer from the calling environment.

Then that's call-by-copy-restore! (And remote evaluation can throw a monkey wrench in many things.).

[EvilTwin]

Actual Response to the OP:

If you are interested in programming games with Python, you should check out Blender 3D. It's a free 3D modeling software, but it includes a lot of additional things, for instance a game engine. This game engine utilizes a sensor-logic-actuator mechanism, whereby the sensor and actuator can actually be read out by a special Python-script logic-brick, so basically, Blender gives you a framework to run your scripts in, which then control game objects. I think that the Blender game engine is a great way to start out with game programming as you won't have to deal with resource-management and all that and can get a first grasp of game logic.

[etgfrog]

I'd consider myself competent with programing in python and overall I think it would be possible to write df in python and might even run faster in some cases(referring to late game fortresses, being able to cull the old unit list and having multi-threading split pathfinding across multiple cpus) but I seriously doubt anything done in even a years worth of work could stack up to DF, but I'd say the biggest hurdle would be getting pathfinding to be as efficient. Anyways...if you are interested in trying to make some sort of game, I'd recommend looking at pygame, so far I've found it to be pretty good for 2d and sprite based stuff.

[Starver]

Started replying to SethCreiyd, but I ended up writing an awful lot more than I intended...  Basically, it appears that Python blatantly passes a reference in a situation where references are so ubiquitous that they are rarely remarked upon.  Which is perhaps subtly different from standard "pass-by-reference", but only subtly.

Spoiler: In case you're interested (click to show/hide)

So, as I read it...

Code: (Python) [Select]

>>> def setX(arg):
    arg="Two"

>>> val="One"
>>> setX(val)
>>> val
'One'
...is like...

Code: (Perl Equivalent) [Select]

sub setX { my ($arg) = @_;         # Takes a value
  $arg="Two";                      # Sets the value
}                                  # Ends, without doing anything external

my $val="One";                     # Puts a string-looking thing into the $val scalar
setX(\$val);                       # Calls setX() with the \reference\ to the $val scalar
                                   #  Within setX: $arg is a scalar with something like "SCALAR(0x183f0d4)"
                                   #               Then, $arg becomes "Two";
                                   #               Meanwhile, location "SCALAR(0x183f0d4)" is unchanged
print "$val\n";                    # Outputs $val (from "SCALAR(0x183f0d4)", or wherever it is).


Code: (Output) [Select]

One

(I'd do that in C, but Perl is open-typed enough to make it meaningful that a variable is a scalar which is a string which is actually a reference-code to another memory location, but C would comlain mightily unless I wrote some support-code.)

Code: (Python) [Select]

>>> def setY1(arg):
arg.append('spam')
arg.remove('juice')

>>> def setY2(arg):
arg = ['milk', 'cereal']
# arg references a new list now, so the passed reference is ignored

>>> thelist = ['eggs', 'juice']
>>> setY1(thelist)
>>> thelist
['eggs', 'spam']
>>> setY2(thelist)
>>> thelist
['eggs', 'spam']

c.f. with

Code: (Perl) [Select]

sub SetY1a { my ($arg) = @_;       # Takes a value (assumed to be a reference to an array)
  push @$arg, 'spam';              # 'Append' the item "spam".
# arg.remove('juice')              # Trickier, with an array, but one way of doing it may be...
  @$arg = map {($_ eq 'juice')?():$_;} @$arg;       # (But I'd want to test that, ideally. ;)
}                                  # End of SetY1a (array referencing code)

sub SetY1h { my ($arg) = @_;       # Takes a value (assumed to be a reference to a hash)
  $$arg{'spam'}++;                 # Just set an item for 'spam' (or increment, if one already exists)
  delete $$arg{'juice'};           # If we /had/ a 'juice' item, we don't any more, although alternatively we could...
# if (defined($$arg{'juice'}) && !(--$$arg{'juice'})) { delete $$arg{'juice'} }
                                   # If it exists, decrement the number,
                                   #    and if that decrement made it zero, delete it, for neatness
  # Of course, hashes don't allow ordering (like ['bacon', 'eggs', 'eggs'] as distinct from ['eggs', 'bacon', 'eggs'];
}                                  # Anyway, end of SetY1h (hash-referencer)


sub setY2 { my ($arg) = @_;        # This one, we know won't work
  $arg = ['milk', 'cereal'];       # Sets up something like "ARRAY(0x183f0d4)" in $arg
  my @arg = ('milk', 'cereal');    # We could /also/ do this, but @arg is nothing to do with $arg, so it's fairly pointless
                                   #                              (a list)                   (a scalar with a list reference)

}                                  # And ends, with no external effect

my @thelist = ('eggs1', 'juice');       # List (@-prefixed)
my $thelist = ['eggs2', 'juice'];       # /Reference/ to a list (scalar string, with "ARRAY(...)"-type thing contained)
my %thehash = ('eggs3'=>1, 'juice'=>1); # Hash (%-prefixed)
my $thehash = {'eggs4'=>1, 'juice'=>1}; # /Reference/ to a hash  (scalar string, with "HASH(...)"-type thing contained)

SetY1a(\@thelist);                 # That'd work
SetY1a($thelist);                  # and this
SetY1h(\%thehash);                 # and this
SetY1h($thehash);                  # this too
print join(", ",@thelist)."\n";    # Prints the list @thelist
print join(", ",@$thelist)."\n";   # Prints the (separate) list referenced by $thelist
print join(", ",map {$_."=>".$thehash{$_}} keys %thehash)."\n";     # Prints the hash items from %thehash
print join(", ",map {$_."=>".$$thehash{$_}} keys %$thehash)."\n";   # Prints the (separate) hash items referenced by $thehash


setY2(@thelist);                   #
setY2($thelist);                   #
setY2(%thehash);                   #
setY2($thehash);                   # ...what can I say?
print join(", ",@thelist)."\n";    # Prints the list @thelist
print join(", ",@$thelist)."\n";   # Prints the (separate) list referenced by $thelist
print join(", ",map {$_."=>".$thehash{$_}} keys %thehash)."\n";     # Prints the hash items from %thehash
print join(", ",map {$_."=>".$$thehash{$_}} keys %$thehash)."\n";   # Prints the (separate) hash items referenced by $thehash


Code: (Output (with added clarifications)) [Select]

eggs1, spam                       # @thelist, after being sent as a reference
eggs2, spam                       # $thelist, already a reference
eggs3=>1, spam=>1                 # %thehash, after being sent as a reference
spam=>1, eggs4=>1                 # $thehash, already a reference
eggs1, spam                       # @thelist was sent as a list ($arg='eggs1', but overwritten)
eggs2, spam                       # $thelist was sent as a scalar ($arg=an ARRAY() reference, but overwritten)
eggs3=>1, spam=>1                 # %thehash was sent as a list ($arg='eggs3', or maybe 'spam', but overwritten)
spam=>1, eggs4=>1                 # $thehash was sent as a scalar ($arg=a HASH() reference, but overwritten)

By the above equivalence, I see that Python is passing a reference (where Perl passes a value, and we have to provide the value of the reference), and and then being used in a reference-friendly context (which is the default with object methods, like ".append" and ".remove").  When you use it in a non-referential context (as I also do in Perl, with setY2) then the passed reference is lost

Code: (Python) [Select]

>>> def setZ(obj, arg):
obj.val = arg

>>> setZ.val = "One"
>>> val2 = "Two"
>>> setZ(setZ, val2)
>>> setZ.val
'Two'
Ah, now, we're going into OO country... which I'd do completely different in Perl, but in an attempt to keep it approximate to your example,  I supposed I'd have to work with hashes, again, and do something like...

Code: (Perl) [Select]

sub setZ { my $self = shift;         # First element of @_ is the reference object, extract it
  if (@_) { $$self{'$val'} = shift } # Make the referenced item equal what comes after
                                     # (after quickly testing that anything /does/ come after!)
}                                    # end of setZ

# More down-to-earth Perlish version, lacking the OO '$self'-ishness.
sub setZZ { my ($ref,$val) = @_; # Following this?
  $$ref{'val'}=$val;             # Should work...
}                                # end of setZZ

my %setZ = (val=>"One");   my %setZZ = (val=>"One");
my $val2 = "Two";          my $val22 = "TwoTwo";
setZ(\%setZ,$val2);        setZZ(\%setZZ,$val22);
print "SetZ: ".$setZ{'val'}."\tSetZZ: ".$setZZ{'val'}."\n";


Code: (Output) [Select]

SetZ: One       SetZZ: TwoTwo



Assigning var1 to var2 passes the reference of var1 to var2:

Code: (Python) [Select]

>>> var1 = "Apple"
>>> var2 = "Orange"
>>> var2 = var1
>>> var1, var2
('Apple', 'Apple')
>>> var1 = "Chocolate"
>>> var1, var2
('Chocolate', 'Apple')
You know (unless I've misread it disasterously) This looks like the same as copying values, with the assignment, as much as passing the references.
 In fact, if var2 was point at var1 (when both became 'Apple'), then you should have ended up with ('Chocolate','Chocolate').  What you have there is values, I'm fairly sure.  Of course, your explanation (which is doubtless equally as correct) is that var2 points exactly at what var1 was pointing at, but that now var1 is pointing somewhere different.  But that's functionally no different from var1 always pointing at location A (first containts Apple, then Chocolate by the end), while var2 points at location B (first of all Orange, then the value from location A is copied into B, i.e. Apple, and this stays until the end, even after the location A has been changed).

Code: (Let's try the Perl again) [Select]

## Natural value-based variable handling
my ($var1,$var2);  # Just pre-defining these, to be nice to Perl if it's in full strict/warnings mode
                   #  and to avoid having to "my" (sort of like "local", but not) them on the (next) first sight
                   # (because I want the rest of the assignments to look identical, above all)
$var1 = "Apple";   # $var1 is "Apple".  As literally as memory abstractions allow.
$var2 = "Orange";  # $var2 is "Orange".
$var2 = $var1;     # $var2 is given a literal value of "Apple"
print "A1: $var1, $var2\n";  # What the $vars contain
print "A0: ".\$var1.", ".\$var2."\n"; # Where the $vars reside

$var1 = "Chocolate"; # $var1 is given a literal value of "Chocolate", which doesn't affect $var2;
print "B1: $var1, $var2\n";  # What the $vars contain
print "B0: ".\$var1.", ".\$var2."\n"; # Where the $vars reside

## Now let's do it with references
my ($Apple,$Orange,$Chocolate)=("Apple", "Orange", "Chocolate"); # ( Yes, I could have qw/quoted/ that list, for those that know Perl. )
print "Apple='$Apple'\@".\$Apple.", Orange='$Orange'\@".\$Orange.", Chocolate='$Chocolate'\@".\$Chocolate."\n"; # The original breakdown
$var1 = \$Apple;   # $var1 is now a reference to where "Apple" is stored,
$var2 = \$Orange;  # $var2 is now a reference to where "Orange" is stored,
$var2 = $var1;     # $var2 is now a reference identical to that of $var1;
print "C1: $var1, $var2\n";    # What the $vars contain (raw)
print "C2: $$var1, $$var2\n";  # What the $vars ultimately contain (following their references)
$$var1 = "Apple2"; # A small diversion from the original example
print "C1: $var1, $var2\n";    # What the $vars contain (raw)
print "C2: $$var1, $$var2\n";  # What the $vars ultimately contain (following their references)

$var1 = \$Chocolate; # $var1 is now re-referenced to where "Chocolate" is stored,
print "D1: $var1, $var2\n";    # What the $vars contain (raw)
print "D2: $$var1, $$var2\n";  # What the $vars ultimately contain (following their references)

print "Apple='$Apple'\@".\$Apple.", Orange='$Orange'\@".\$Orange.", Chocolate='$Chocolate'\@".\$Chocolate."\n"; # The final breakdown


Code: (Output (with comments)) [Select]

A1: Apple, Apple                            # So we set $var2's value to $var1's value
A0: SCALAR(0x1829b2c), SCALAR(0x1829b4c)    # But $var1 and $var2 are in different locations
B1: Chocolate, Apple                        # We've reset $var1
B0: SCALAR(0x1829b2c), SCALAR(0x1829b4c)    # And $var1 and $var2 are in the /same/ different locations

Apple='Apple'@SCALAR(0x1845f2c), Orange='Orange'@SCALAR(0x1845f0c), Chocolate='Chocolate'@SCALAR(0x1845eec)
                                            # Contents of $Apple is 'Apple' at SCALAR(...), etc;
C1: SCALAR(0x1845f2c), SCALAR(0x1845f2c)    # This time we're using references, so var2 is pointing to the same as var1
C2: Apple, Apple                            # And they're the same because they're the same end
C1: SCALAR(0x1845f2c), SCALAR(0x1845f2c)    # Also provable by changing what $var1 pointed at (and $var2 also does)
C2: Apple2, Apple2                          # ...and giving them the same alteration
D1: SCALAR(0x1845eec), SCALAR(0x1845f2c)    # Now we point $var1 at somewhere new
D2: Chocolate, Apple2                       #
Apple='Apple2'@SCALAR(0x1845f2c), Orange='Orange'@SCALAR(0x1845f0c), Chocolate='Chocolate'@SCALAR(0x1845eec)
                                            # Contents of $Apple is 'Apple2' at (same) SCALAR(...), etc;


Code: (Python) [Select]

>>> var1 = ['apple', 'orange', 'banana']
>>> var2 = var1
>>> var1.remove('banana')
>>> var1, var2
(['apple', 'orange'], ['apple', 'orange'])

This also works well in Perl, when explicitly using the referencing form of variables.

Code: (Perl) [Select]

my ($var1h, $var1a, $var2h, $var2a); # Just setting these up (uninitialised), again
$var1h = {apple=>1, orange=>1, banana=>1}; # Here using a hash structure, because it's easier to ".remove" an item.
$var1a = ['apple', 'orange', 'banana'];    # This is the array version, and I'll use something less specific on it
print "Var1h: $var1h;\tVar1a: $var1a;\n";     # Just to show that references are held.
print "H1: ".join(", ",map {$_."=>".$$var1h{$_}} keys %$var1h)."\n";   # Prints the hash items referenced by $var1h
print "A1: ".join(", ",@$var1a)."\n";   # Prints the list referenced by $var1a

$var2h = $var1h;
$var2a = $var1a;
print "Var2h: $var2h;\tVar2a: $var2a;\n";     # Just to show the references that are held.
print "H2: ".join(", ",map {$_."=>".$$var2h{$_}} keys %$var2h)."\n";   # Prints the hash items referenced by $var2h
print "A2: ".join(", ",@$var2a)."\n";   # Prints the list referenced by $var2a

delete $$var1h{banana}; # Remove the 'banana' item explicitly from the referenced hash
pop @$var1a;          # Remove the last item (happens to be 'banana') from the array
print "Var1h: $var1h;\tVar1a: $var1a;\n";     # Just to show the references that are held.
print "Var2h: $var2h;\tVar2a: $var2a;\n";     # Just to show the references that are held.
print "H1: ".join(", ",map {$_."=>".$$var1h{$_}} keys %$var1h)."\n";   # Prints the hash items referenced by $var1h
print "A1: ".join(", ",@$var1a)."\n";   # Prints the list referenced by $var1a
print "H2: ".join(", ",map {$_."=>".$$var2h{$_}} keys %$var2h)."\n";   # Prints the hash items referenced by $var2h
print "A2: ".join(", ",@$var2a)."\n";   # Prints the list referenced by $var2a


Code: (Output, etc) [Select]

Var1h: HASH(0x239b94);  Var1a: ARRAY(0x239cd4);    # One hash and one array set up, as references
H1: banana=>1, apple=>1, orange=>1                 # Here's what's in the referenced hash (order is indeterminate)
A1: apple, orange, banana                          # Here's what's in the referenced array (order maintained)
Var2h: HASH(0x239b94);  Var2a: ARRAY(0x239cd4);    # New variables copy references from old ones
H2: banana=>1, apple=>1, orange=>1                 # Hash contents, again
A2: apple, orange, banana                          # Array contents, again
Var1h: HASH(0x239b94);  Var1a: ARRAY(0x239cd4);    # After 'banana' has been removed, from both structures
Var2h: HASH(0x239b94);  Var2a: ARRAY(0x239cd4);    # ...and of course everything's still pointing at the same places
H1: apple=>1, orange=>1                            # Yes, we have no bananas,
A1: apple, orange                                  #  We have no bananas today,
                                                   # We've broad beans like bunions, cabbbahges and honions
                                                   #  And all kinds of fruit and say
                                                   # We' have an old fashioned tomahto, a nice Jersey potahto
H2: apple=>1, orange=>1                            # But yes, we have no bananas,
A2: apple, orange                                  #  We have no bananas today!
(With apologies for the Music-hall lyrics. )

I hope that helps the confusion, though it's probably easier to understand than my explanations make it.  Though there are some weird aspects to it, Python makes sense once one gets used to it.  If I can learn to use it, anyone here can.[/size][/spoiler]

Well, what I took away from that is that working with references in Python is a whole lot less involved, because it's by default (and probably integrated with a better memory-handling/garbage-collection structure), and doesn't need loads of dereferencing/re-referencing code because it's made for an OO-context where most things are supposed to work on (object) references, regardless of what the user considers they may be.  But some of the awkward printing things (e.g. the printing of hash items, or the specific splicing out of an array item) I would normally have written out once and set as a function call.

And I thought Perl was loose with types[1], looks like Python is really far out on that field, man...


Anyway, I may find some time to poke into Python...  Just need to get out of Function-Orientated and Data-Orientated mode, as I always end up when I do much of anything with Perl, and embrace Python's brand of Object-Orientation more fully!



[1] $scalar, @array, %hash, &code and *glob, but with the added 'benefit' that any $scalar (including a $scalar that is an $array[$index] or $hash{item} singularity...  and as for *globs, that's a lot more explaining!) could be a reference to anything, including further $scalars, @arrays, %hashes, &codefragments or *globs...