普罗森有什么好处？ [英] What is good about Prothon?

问题描述

我很关心所有关注obj $ func绑定，& closures，

以及Prothon的其他不那么漂亮的细节，我们错过了什么

非常好 - 类的简化。这种简化有很多方面，但对我而言，方法的统一

和功能是最大的好处。


所有方法看起来都像函数（学生已经理解）。

原型（类）看起来像模块。这将使教学OOP

变得更加简单，特别是对于我最关心的学生和专业工程师

（非CIS）。我教电子设计

工具，而非编程。目前的计划是包括一些基本的
Python，没有OOP。如果我可以在另外4个小时内添加OOP，我会这样做。


我写了一个关于原型语法的提案，我相信它已经捕获了

对于Prothon的优点是什么，而不是从Python中彻底离开了
。请参阅PrototypeSyntax.htm
http://ece.arizona.edu / ~edatools / Prothon / 我想从Python专家那里得到关于这个

语法潜在问题的反馈
。主要问题是将现有的Python

程序自动转换为新语法。我是其中一个用户不会在Python中使用现有的库提供
，无论一些

替代语言有多好。


我还希望得到用户对他们喜欢的内容的反馈，或者

不喜欢这个提议。我将在

优点和缺点中总结这些反馈。提案部分。


以下是语法提案的一些摘录。请参阅上面的链接

以获得更好的格式化。


- Dave


建议的原型语法

=========================

< snip>


简化类的示例（原型）

==================== ========================


动物 - >哺乳动物 - >猫科动物 - >猫

------- ------- ------- -------

numAnimals numMammals numFelines numCats < br $> b $ b home home

__init __（）__ init __（）__ init __（）__ init __（）

.sound .sound

。名字

show（）show（）show（）show（）

talk（）talk（）

proto Animal（对象）：＃继承原始对象。

numAnimals = 0

home =" Earth"

....

<参见OOP章节在 http://ece.arizona.edu/~edatools/Prothon/

完整示例。>

....

proto Cat（猫）：

numCats = 0

__init__ :( n =" unknown"，s =" Meow"）：

Feline .__ init __（）

Cat.numCats + = 1

.name = n＃设置实例变量。

.sound = s

show :(）：＃定义静态方法。

Feline.show（）

print" Cats："，Cat.numCats

talk :(）：

print"我的名字是..." .name

打印我是来自％s的％s ％（。genus，.home）

Mammal.talk（）＃调用未绑定的函数。

print __self__ ###诊断检查。

cat1 = Cat（）＃创建实例。
带有cat1的
：＃修改实例变量。

home =" Tucson"

genus =" feline"

name =" Garfield"

I''m concerned that with all the focus on obj$func binding, &closures,
and other not-so-pretty details of Prothon, that we are missing what
is really good - the simplification of classes. There are a number of
aspects to this simplification, but for me the unification of methods
and functions is the biggest benefit.

All methods look like functions (which students already understand).
Prototypes (classes) look like modules. This will make teaching OOP
much simpler, especially for the students and professional engineers
(non-CIS) that I am most concerned about. I teach electronic design
tools, not programming. Current plans are to include some basic
Python, no OOP. If I could add OOP with another 4 hours, I would do
it.

I''ve written a proposal for a prototype syntax that I believe captures
the essense of what is good in Prothon, while not departing too
radically from Python. see PrototypeSyntax.htm at
http://ece.arizona.edu/~edatools/Prothon/ I would like to get
feedback from Python experts on the potential problems with this
syntax. The major question is automatic translation of existing Python
programs to the new syntax. I''m one of those users who would not give
up the existing libraries in Python, no matter how good some
alternative language may be.

I would also like to get feedback from users on what they like or
dislike about this proposal. I will summarize this feedback in the
"Pros and Cons" section of the proposal.

Below are some excerpts from the syntax proposal. Please see the link
above for better formatting.

-- Dave

Proposed Prototype Syntax
=========================
< snip >

Example of Simplified Classes ( Prototypes )
============================================

Animal --> Mammal --> Feline --> Cat
------- ------- ------- -------
numAnimals numMammals numFelines numCats
home genus
__init__() __init__() __init__() __init__()
.sound .sound
.name
show() show() show() show()
talk() talk()
proto Animal(object): # Inherit from the primitive object.
numAnimals = 0
home = "Earth"
....
<see the "OOP Chapter" at http://ece.arizona.edu/~edatools/Prothon/
for the complete example.>
....
proto Cat(Feline):
numCats = 0
__init__ :( n = "unknown", s = "Meow" ):
Feline.__init__()
Cat.numCats += 1
.name = n # Set instance variables.
.sound = s
show :(): # Define a "static method".
Feline.show()
print " Cats:", Cat.numCats
talk :():
print "My name is ...", .name
print "I am a %s from %s" % (.genus, .home)
Mammal.talk() # Call an unbound function.
print __self__ ### Diagnostic check.

cat1 = Cat() # Create instance.
with cat1: # Modify instance variables.
home = "Tucson"
genus = "feline"
name = "Garfield"

cat1.talk（）
我的名字是......加菲猫

我来自图森的猫科动物

哺乳动物的声音：喵喵

< __ main__.Cat对象位于0x00A894B0>

cat1.talk() My name is ... Garfield
I am a feline from Tucson
Mammal sound: Meow
<__main__.Cat object at 0x00A894B0>

来自当前Python的更改

===== ======================

- 关键字类已更改为proto。

- 全部方法具有相同的形式，与简单的功能相同。

- 重新排列函数标题行。 def - > ：括号是

可选。

- self替换为一个前导点，并从arg

列表中删除。

- 当前实例可用，如果需要通过__self__

- 实例可以在with块中修改其属性。


的好处建议的语法

===========================

- 统一所有函数形式（绑定，未绑定，静态，类，

lambda）。所有都将具有与普通函数相同的形式

定义。这将使教学OOP变得更容易。学生将已经了解功能和模块
。 OOP是一个小小的进步。

原型看起来就像一个模块（除了实例

变量）。请参阅下面的原型和模块之间的相似之处。


- 使用显式的__self__变量可以避免神奇的第一个
参数，并且可以更容易地解释实例变量。请参阅下面的

部分，比较

Python中的实例变量与简化形式的简要说明。 OOP的完整演示，例如学习Python中的页面

295-390，第2版。

页面的数量可能是1/2。基本的演示不仅更简单，而且我们可以消除很多关于lambda函数，静态方法，

等的讨论。


- 原型的所有属性（包括数据和函数）将在一个整齐的列中显示为

，这样可以更轻松地查找特定属性

直观扫描一个程序。理解程序的结构

几乎和查看UML图一样快。


- Lambda关键字将消失。使用普通

函数语法的匿名函数可以非常紧凑。 （：x，y：x + y）


- 使用

__self__作为隐藏变量，方法定义不会变得混乱，减少打字。 />

- 更改实例的众多属性将更加方便。 （需要用例）


- 将Python程序迁移到Prothon将是自动的，并且b / b
可靠。 ???

建议语法的优点和缺点

==================== ================

无类别


Con：建议的语法不是纯粹无类别的。这很重要

因为...... ???


统一方法和功能


Pro1：更少学习。


Con1：专家不在乎。初学者不需要高级方法

语法。


Pro2：用标准函数语法替换lambda。


Con2：???


明确__self__


Pro1：允许统一方法和功能。


Con1：???


Pro2：实例变量的解释更简单。


Con2：使用__self__而不是特殊第一个参数更少

显式。


Pro3：方法定义中打字减少，杂乱少。


Con3 ：可以使用s或_而不是自我最小化打字和

杂乱。


" Assignment"函数定义的语法


Pro1：在一列中一目了然地查看所有变量。


Con1：???


Pro2：强调数据和函数之间的相似性

对象的属性。


Con2：???


符号代替def关键字


Pro：允许lambda函数包含在统一中。


Con：符号永远不会像关键字一样清晰。


带块


Pro：保存在每一行输入对象名称。 />

Con：在创建原型后很容易修改原型

创建将导致更多无纪律的编程。


与教学OOP相关的问题

===============================

原型和模块之间的平行

---------------------------------- ------

学生需要了解原型的百分之九十是

已经从他们对功能和模块的研究中得到了解。甚至

最好通过与模块的并行

情况进行比较来解释一些棘手的问题。

< snip>


Python中实例变量的说明

--------------------- ----------------------

"""类中函数内的一些变量有一个

self。字首。这是为了区分函数

中的局部变量和实例变量。通过搜索函数调用

的实例，可以在调用函数时找到这些实例变量

。这种方式的工作原理是从一个

实例调用该函数会导致该实例作为函数调用的第一个参数传递给

。因此，如果你调用cat1.talk（），那相当于

Cat.talk（cat1）如果你调用cat1.set_vars（" Garfield"，" Meow"），那就是

相当于Cat.set_vars（cat1，Garfield，Meow）


当前实例自动神奇地插入参数作为

第一个参数，在你可以提供的任何其他参数之前调用

调用一个绑定的方法。到一个实例。注意：

区分实例和类在这里很重要。如果你从一个类调用一个函数，那么该函数不会绑定到任何一个

实例，你必须在第一个显式提供实例。

参数（Cat.talk（cat1））


变量名称self只是一个约定。只要你把第一个参数中的

同名，就像在定义的正文中一样，它可以是self或s甚至_单个下划线很方便如果你想要最大限度地抑制混乱，那么
。 """


简化实例变量的说明

------------------- -------------------------

"""原型函数内部的一些变量有一个

前导点。这是为了区分函数

中的局部变量和实例变量。当一个函数从一个实例调用时，一个特殊的全局变量__self__自动分配给该实例（__ self__ = cat1）然后当函数

需要一个实例变量（.sound）它使用__self__就像你在
点击它前面那样（__ self __。sound）前导点

只是一个缩写，以避免在任何地方输入__self__。 """


========== END ==============

推荐答案

func绑定，& closures，

以及Prothon的其他不那么漂亮的细节，我们错过了什么

非常好 - 类的简化。这种简化有很多方面，但对我而言，方法的统一

和功能是最大的好处。


所有方法看起来都像函数（学生已经理解）。

原型（类）看起来像模块。这将使教学OOP

变得更加简单，特别是对于我最关心的学生和专业工程师

（非CIS）。我教电子设计

工具，而非编程。目前的计划是包括一些基本的
Python，没有OOP。如果我可以在另外4个小时内添加OOP，我会这样做。


我写了一个关于原型语法的提案，我相信它已经捕获了

对于Prothon的优点是什么，而不是从Python中彻底离开了
。请参阅PrototypeSyntax.htm
http://ece.arizona.edu / ~edatools / Prothon / 我想从Python专家那里得到关于这个

语法潜在问题的反馈
。主要问题是将现有的Python

程序自动转换为新语法。我是其中一个用户不会在Python中使用现有的库提供
，无论一些

替代语言有多好。


我还希望得到用户对他们喜欢的内容的反馈，或者

不喜欢这个提议。我将在

优点和缺点中总结这些反馈。提案部分。


以下是语法提案的一些摘录。请参阅上面的链接

以获得更好的格式化。


- Dave


建议的原型语法

=========================

< snip>


简化类的示例（原型）

==================== ========================


动物 - >哺乳动物 - >猫科动物 - >猫

------- ------- ------- -------

numAnimals numMammals numFelines numCats < br $> b $ b home home

__init __（）__ init __（）__ init __（）__ init __（）

.sound .sound

。名字

show（）show（）show（）show（）

talk（）talk（）

proto Animal（对象）：＃继承原始对象。

numAnimals = 0

home =" Earth"

....

<参见OOP章节在 http://ece.arizona.edu/~edatools/Prothon/

完整示例。>

....

proto Cat（猫）：

numCats = 0

__init__ :( n =" unknown"，s =" Meow"）：

Feline .__ init __（）

Cat.numCats + = 1

.name = n＃设置实例变量。

.sound = s

show :(）：＃定义静态方法。

Feline.show（）

print" Cats："，Cat.numCats

talk :(）：

print"我的名字是..." .name

打印我是来自％s的％s ％（。genus，.home）

Mammal.talk（）＃调用未绑定的函数。

print __self__ ###诊断检查。

cat1 = Cat（）＃创建实例。
带有cat1的
：＃修改实例变量。

home =" Tucson"

genus =" feline"

name =" Garfield"

func binding, &closures,
and other not-so-pretty details of Prothon, that we are missing what
is really good - the simplification of classes. There are a number of
aspects to this simplification, but for me the unification of methods
and functions is the biggest benefit.

All methods look like functions (which students already understand).
Prototypes (classes) look like modules. This will make teaching OOP
much simpler, especially for the students and professional engineers
(non-CIS) that I am most concerned about. I teach electronic design
tools, not programming. Current plans are to include some basic
Python, no OOP. If I could add OOP with another 4 hours, I would do
it.

I''ve written a proposal for a prototype syntax that I believe captures
the essense of what is good in Prothon, while not departing too
radically from Python. see PrototypeSyntax.htm at
http://ece.arizona.edu/~edatools/Prothon/ I would like to get
feedback from Python experts on the potential problems with this
syntax. The major question is automatic translation of existing Python
programs to the new syntax. I''m one of those users who would not give
up the existing libraries in Python, no matter how good some
alternative language may be.

I would also like to get feedback from users on what they like or
dislike about this proposal. I will summarize this feedback in the
"Pros and Cons" section of the proposal.

Below are some excerpts from the syntax proposal. Please see the link
above for better formatting.

-- Dave

Proposed Prototype Syntax
=========================
< snip >

Example of Simplified Classes ( Prototypes )
============================================

Animal --> Mammal --> Feline --> Cat
------- ------- ------- -------
numAnimals numMammals numFelines numCats
home genus
__init__() __init__() __init__() __init__()
.sound .sound
.name
show() show() show() show()
talk() talk()
proto Animal(object): # Inherit from the primitive object.
numAnimals = 0
home = "Earth"
....
<see the "OOP Chapter" at http://ece.arizona.edu/~edatools/Prothon/
for the complete example.>
....
proto Cat(Feline):
numCats = 0
__init__ :( n = "unknown", s = "Meow" ):
Feline.__init__()
Cat.numCats += 1
.name = n # Set instance variables.
.sound = s
show :(): # Define a "static method".
Feline.show()
print " Cats:", Cat.numCats
talk :():
print "My name is ...", .name
print "I am a %s from %s" % (.genus, .home)
Mammal.talk() # Call an unbound function.
print __self__ ### Diagnostic check.

cat1 = Cat() # Create instance.
with cat1: # Modify instance variables.
home = "Tucson"
genus = "feline"
name = "Garfield"

cat1.talk（）
我的名字是......加菲猫

我来自图森的猫科动物

哺乳动物的声音：喵喵

< __ main__.Cat对象位于0x00A894B0>

cat1.talk() My name is ... Garfield
I am a feline from Tucson
Mammal sound: Meow
<__main__.Cat object at 0x00A894B0>

来自当前Python的更改

===== ======================

- 关键字类已更改为proto。

- 全部方法具有相同的形式，与简单的功能相同。

- 重新排列函数标题行。 def - > ：括号是

可选。

- self替换为一个前导点，并从arg

列表中删除。

- 当前实例可用，如果需要通过__self__

- 实例可以在with块中修改其属性。


的好处建议的语法

===========================

- 统一所有函数形式（绑定，未绑定，静态，类，

lambda）。所有都将具有与普通函数相同的形式

定义。这将使教学OOP变得更容易。学生将已经了解功能和模块
。 OOP是一个小小的进步。

原型看起来就像一个模块（除了实例

变量）。请参阅下面的原型和模块之间的相似之处。


- 使用显式的__self__变量可以避免神奇的第一个
参数，并且可以更容易地解释实例变量。请参阅下面的

部分，比较

Python中的实例变量与简化形式的简要说明。 OOP的完整演示，例如学习Python中的页面

295-390，第2版。

页面的数量可能是1/2。基本的演示不仅更简单，而且我们可以消除很多关于lambda函数，静态方法，

等的讨论。


- 原型的所有属性（包括数据和函数）将在一个整齐的列中显示为

，这样可以更轻松地查找特定属性

直观扫描一个程序。理解程序的结构

几乎和查看UML图一样快。


- Lambda关键字将消失。使用普通

函数语法的匿名函数可以非常紧凑。 （：x，y：x + y）


- 使用

__self__作为隐藏变量，方法定义不会变得混乱，减少打字。 />

- 更改实例的众多属性将更加方便。 （需要用例）


- 将Python程序迁移到Prothon将是自动的，并且b / b
可靠。 ???

建议语法的优点和缺点

==================== ================

无类别


Con：建议的语法不是纯粹无类别的。这很重要

因为...... ???


统一方法和功能


Pro1：更少学习。


Con1：专家不在乎。初学者不需要高级方法

语法。


Pro2：用标准函数语法替换lambda。


Con2：???


明确__self__


Pro1：允许统一方法和功能。


Con1：???


Pro2：实例变量的解释更简单。


Con2：使用__self__而不是特殊第一个参数更少

显式。


Pro3：方法定义中打字减少，杂乱少。


Con3 ：可以使用s或_而不是自我最小化打字和

杂乱。


" Assignment"函数定义的语法


Pro1：在一列中一目了然地查看所有变量。


Con1：???


Pro2：强调数据和函数之间的相似性

对象的属性。


Con2：???


符号代替def关键字


Pro：允许lambda函数包含在统一中。


Con：符号永远不会像关键字一样清晰。


带块


Pro：保存在每一行输入对象名称。 />

Con：在创建原型后很容易修改原型

创建将导致更多无纪律的编程。


与教学OOP相关的问题

===============================

原型和模块之间的平行

---------------------------------- ------

学生需要了解原型的百分之九十是

已经从他们对功能和模块的研究中得到了解。甚至

最好通过与模块的并行

情况进行比较来解释一些棘手的问题。

< snip>


Python中实例变量的说明

--------------------- ----------------------

"""类中函数内的一些变量有一个

self。字首。这是为了区分函数

中的局部变量和实例变量。通过搜索函数调用

的实例，可以在调用函数时找到这些实例变量

。这种方式的工作原理是从一个

实例调用该函数会导致该实例作为函数调用的第一个参数传递给

。因此，如果你调用cat1.talk（），那相当于

Cat.talk（cat1）如果你调用cat1.set_vars（" Garfield"，" Meow"），那就是

相当于Cat.set_vars（cat1，Garfield，Meow）


当前实例自动神奇地插入参数作为

第一个参数，在你可以提供的任何其他参数之前调用

调用一个绑定的方法。到一个实例。注意：

区分实例和类在这里很重要。如果你从一个类调用一个函数，那么该函数不会绑定到任何一个

实例，你必须在第一个显式提供实例。

参数（Cat.talk（cat1））


变量名称self只是一个约定。只要你把第一个参数中的

同名，就像在定义的正文中一样，它可以是self或s甚至_单个下划线很方便如果你想要最大限度地抑制混乱，那么
。 """


简化实例变量的说明

------------------- -------------------------

"""原型函数内部的一些变量有一个

前导点。这是为了区分函数

中的局部变量和实例变量。当一个函数从一个实例调用时，一个特殊的全局变量__self__自动分配给该实例（__ self__ = cat1）然后当函数

需要一个实例变量（.sound）它使用__self__就像你在
点击它前面那样（__ self __。sound）前导点

只是一个缩写，以避免在任何地方输入__self__。 """


========== END ==============

" David MacQuigg" < dm*@gain.com>写道......

"David MacQuigg" <dm*@gain.com> wrote ...

我很担心所有关注obj

I''m concerned that with all the focus on obj

func binding

func binding

我想指出，作为技术细节，当你实施你的时，你会很快发现

。 Prothon，正如我在我的中所做的那样。 Prothon和Lenard

Lindstrom在Python的他的实现中做了Prothon，你必须

专注于对象的函数/方法绑定。这就是Prothon的无序与Python的分类之间的差异。


忽略调用祖先的问题使用相同的旧obj.func（）只是

的方法版本将无法正常工作。你不必使用obj的当前建议

I would like to point out, as a technical detail, you will quickly find out
when you implement "your" Prothon, as I did in "my" Prothon, and Lenard
Lindstrom did in his Python implementation of "his" Prothon, that you MUST
focus on function/method binding on objects. This is where the
classlessness of Prothon versus classfulness of Python exhibits its
differences.

Ignoring the problem of calling the ancestor''s version of a method by just
using the same old obj.func() will not work. You don''t have to use the
current suggestion of obj

这篇关于普罗森有什么好处？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！