kennethreitz/python-guide
1
0
Fork 0
mirror of https://github.com/kennethreitz/python-guide.git synced 2026-06-05 23:00:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix minor spelling, grammar, and consistency errors in the Object-oriented programming section.

Browse Source 
The paragraph about context and side effects was very difficult to
parse and contained the word "decelable". I attempted to capture the
meaning of the paragraph in a way that was more readable.
This commit is contained in:
Jay Roberts
2012-05-11 14:37:56 -04:00
parent e79aa476a0
commit cca9272a7f
1 changed files with 22 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/writing/structure.rst
+22 -22
View File
@@ -176,8 +176,8 @@ repetition of `very.deep.module`.
Object-oriented programming Object-oriented programming
--------------------------- ---------------------------
Python is sometime described as an object-oriented programming language. This Python is sometimes described as an object-oriented programming language. This
can be somewhat misleading and need to be clarified. can be somewhat misleading and needs to be clarified.
In Python, everything is an object, and can be handled as such. This is what is In Python, everything is an object, and can be handled as such. This is what is
meant when we say that, for example, functions are first-class objects. meant when we say that, for example, functions are first-class objects.
@@ -188,46 +188,46 @@ object-oriented language.
However, unlike Java, Python do not impose object-oriented programming as the However, unlike Java, Python do not impose object-oriented programming as the
main programming paradigm. It is perfectly viable for a Python project to not main programming paradigm. It is perfectly viable for a Python project to not
be object-oriented, ie. to use no or very few class definitions, class be object-oriented, i.e. to use no or very few class definitions, class
inheritance, and any other mechanism that are specific to object-oriented inheritance, or any other mechanisms that are specific to object-oriented
programming. programming.
Moreover, as seen in the modules_ section, the way Python handles modules and Moreover, as seen in the modules_ section, the way Python handles modules and
namespaces gives directly to the developer a natural way to ensure namespaces gives the developer a natural way to ensure
encapsulation and separation of abstraction layers, both being the most common encapsulation and separation of abstraction layers, both being the most common
reasons to use object-orientation. Therefore, Python programmers have more reasons to use object-orientation. Therefore, Python programmers have more
latitude to not use object-orientation, when it is not required by the business latitude to not use object-orientation, when it is not required by the business
model to be constructed. model.
There are some reasons to avoid unnecessary object-orientation. Definining There are some reasons to avoid unnecessary object-orientation. Defining
custom classes is useful when we want to glue together some state and some custom classes is useful when we want to glue together some state and some
functionality. The problem, as pointed out by the discussions about functional functionality. The problem, as pointed out by the discussions about functional
programming, comes from the "state" part of the equation. programming, comes from the "state" part of the equation.
In some architectures, typically web applications, instances of Python In some architectures, typically web applications, multiple instances of Python
processes are spawned simultaneously to answer to external requests that can processes are spawned to respond to external requests that can
happen at the same time. In this case, holding some state into instanciated happen at the same time. In this case, holding some state into instantiated
objects, which means keeping some static information about the world, is prone objects, which means keeping some static information about the world, is prone
to concurrency problems or race-conditions: between the initialization of the to concurrency problems or race-conditions. Sometime between the initialization of the
state of an object, usually done with the __init__() method, and the actual use state of an object, usually done with the __init__() method, and the actual use
of the object state through one of its method, the world may have changed, and of the object state through one of its methods, the world may have changed, and
the retained state may be outdated. For example, a request may load an item in the retained state may be outdated. For example, a request may load an item in
memory and mark it as read by a user. If another request requires the deletion memory and mark it as read by a user. If another request requires the deletion
of this item at the same, it may happen that the deletion actually occur after of this item at the same, it may happen that the deletion actually occurs after
the first process loaded the item, and then we have to mark as read a deleted the first process loaded the item, and then we have to mark as read a deleted
object. object.
This and other issues led to the idea that using stateless functions is a This and other issues led to the idea that using stateless functions is a
better programming paradigm. better programming paradigm.
Another way to say the same thing is to propose to use functions and procedures Another way to say the same thing is to suggest using functions and procedures
with as few implicit context and side-effects as possible. A function's with as few implicit contexts and side-effects as possible. A function's
implicit context is decelable when the function body refers to some global implicit context is made up of any of the global variables or items in the persistence layer
variables or fetches data from the persistence layer. Side-effects are the that are accessed from within the function. Side-effects are the changes that a function makes
opposite: if a function body modifies the global context or save or delete data to it's implicit context. If a function saves or deletes data in a global variable or
on the persistence layer, it is said to have side-effect. in the persistence layer, it is said to have a side-effect.
Isolating carefully functions with context and side-effects from functions with Carefully isolating functions with context and side-effects from functions with
logic (called pure functions) allow the following benefits: logic (called pure functions) allow the following benefits:
- Pure functions are more likely to be deterministic: given a fixed input, - Pure functions are more likely to be deterministic: given a fixed input,
@@ -239,7 +239,7 @@ logic (called pure functions) allow the following benefits:
- Pure functions are easier to test with unit-tests: There is less - Pure functions are easier to test with unit-tests: There is less
need for complex context setup and data cleaning afterwards. need for complex context setup and data cleaning afterwards.
- Pure functions are easier to manipulate, decorate_, pass-around. - Pure functions are easier to manipulate, decorate_, and pass-around.
In summary, pure functions, without any context or side-effects, are more In summary, pure functions, without any context or side-effects, are more
efficient building blocks than classes and objects for some architectures. efficient building blocks than classes and objects for some architectures.