Python for philosophers

[Citizen Kant]

Thank you very much for your answers.

I'm afraid that, at this stage, I must prevent myself from "knowing too
much" about the subject. My idea here is trying to fill the gaps, mostly,
using intuition. What I do here is to try to "understand". That's different
from just knowing. Knowledge growth must be consequence of understanding's
increasing. As the scope of my understanding increases, the more I look for
increasing my knowledge. Never vice versa, because, knowing isn't like to
be right, it's just knowing.

Greg: your point is that
-------------------------------------
>>> 12**34
492223524295202670403711324312
2008064L

The input is 6 characters long, and the output
is 37 characters long. Is that more "economical"?
--------------------------------------------------------------------------

and that's a good one. But take in account that with "shortening" I refer
to "according to Python's axiomatic parameters". What's "shorten" if
expressed in Python? For example: I'm plainly aware that the word "python"
looks shorten than "01110000 01111001 01110100 01101000 01101111 01101110".
But it's shorten just for me and you and maybe for every single human, not
for the computer. You type "python", and the language (so to speak) thinks
"in my opinion you're not being economical enough coz with this you mean
01110000 01111001 01110100 01101000 01101111 01101110", and then mirrors
the supposedly result in its particular context. My "shorten" points to
what's shorten during and inside Python's runtime.

Maybe It'd be good if I explain myself a bit more. What I'm trying here is
to grasp Python from the game's abstraction point of view, as if it were,
for example, chess. That's why I need a real_player to point me to: (so to
speak, I wish I could express the ideas according to the python's syntax
but that's out of my scope by now)

games.python.board(like the chessboard but in abstract)  # with board I'm
not necessarily referring to the black on Python's command line or any
other substitutes for that, but to its axiomatic context. Which are those
unchangeable things that limit so firmly the dynamics of the game, and that
in this context must be considered like hardware, the most material part of
Python. Coz (in my neophyte opinion) these are the things that (in a more
or less obvious way) limit "the dynamic of any attempt to introduce a
change in this game".

games.python.pieces(a finite number of named elements)   # one example of
what in Python (unless for me) seems to look like pieces are
python.keywords(python2). Might be more entities that can be considered
like pieces...

games.python.start(the position that each piece must assume over the given
board in order to conform "the sign of this kind of game's starting
point")   # following the example of the only pieces I've recognized so
far, I would drive myself to think about the state of python.keywords
Of course with "state" I could be referring to any kind of state. The only
clue is that, as far I can see, is expected that those hypothetical states
come in pairs, like state(available, unavailable)

games.python.end(game's final point or highest achievement)  #I never
forget that checkmate is just a sign that can be observed looking at the
board or "axiomatic structure that in the game remains static". That
end_sign usually is, no more nor less than a transformation of the
start_sign, transformation that, sometimes, shorten it.

games.python.pieces.behavior(the legal or non erroneous modifications that
can be made to the start_sign in order to convert it to end_sign)

games.python.player.rear.avoid(what it must be avoided by any legal -non
erroneous- means)  # seems to be that the kind of things to be avoided are
not precisely making errors, since Python will tell. Making errors is just
something that's so illegal that simply doesn't take place. With "avoid" I
mean what happens when you get checked by running code that doesn't lead to
any error messages but at the same time doesn't give the expected result.

My goal right now is to produce one or more abstracts that explain (mainly
for myself but extensive to others) about how I deal with some problems
related to our "search for emphaty" nature at the time of what we tend to
consider "interaction" (learning to write in Python in interactive mode, or
just programming, is one of that cases). In essence, due to Python's lack
of empathy, one must adopt its shape and ways to (so to speak) "interact"
with it. Python could be considered like a solitary game, and in my opinion
could be taken as it is from the beginning, in order to properly understand
what one exactly is doing. That seems to be the best way to properly
"understand" Python; then knowledge will come, naturally as a perfect
search of, exactly, the things that "understanding" needs.

Any clue about this would be highly appreciated.


2013/5/11 Citizen Kant <citizenkant at gmail.com>

> Hi,
> this could be seen as an extravagant subject but that is not my original
> purpose. I still don't know if I want to become a programmer or not. At
> this moment I'm just inspecting the environment. I'm making my way to
> Python (and OOP in general) from a philosophical perspective or point of
> view and try to set the more global definition of Python's core as an
> "entity". In order to do that, and following Wittgenstein's indication
> about that the true meaning of words doesn't reside on dictionaries but in
> the use that we make of them, the starting question I make to myself about
> Python is: which is the single and most basic use of Python as the entity
> it is? I mean, beside programming, what's the single and most basic result
> one can expect from "interacting" with it directly (interactive mode)? I
> roughly came to the idea that Python could be considered as an *economic
> mirror for data*, one that mainly *mirrors* the data the programmer types
> on its black surface, not exactly as the programmer originally typed it,
> but expressed in the most economic way possible. That's to say, for
> example, if one types >>>1+1 Python reflects >>>2. When data appears
> between apostrophes, then the mirror reflects, again, the same but
> expressed in the most economic way possible (that's to say without the
> apostrophes).
>
> So, would it be legal (true) to define Python's core as an entity that
> mirrors whatever data one presents to it (or feed it with) showing back the
> most shortened expression of that data?
>
> Don't get me wrong. I can see the big picture and the amazing things that
> programmers write on Python, it's just that my question points to the
> lowest level of it's existence.
>
> Thanks a lot for your time.
>



-- 
------------------------------------------------------------------
¿Has leído «Las Novelas Prohibidas» <http://lasnovelasprohibidas.com/>?
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-list/attachments/20130512/f390f3c0/attachment.html>