gmane.comp.python.general

Re: Scoping Issues

Dave Angel — 2012-05-25T03:36:21

I configure my editor(s) to always use spaces for indentation.  So a
file that currently uses tabs is unusable to me.  You of course are
right that tabs are syntactically correct, but until I find another
editor that makes tabs visible (like the one I used 20 years ago)
they're unacceptable to me.

Re: Help doing it the "python way"

Terry Reedy — 2012-05-25T03:27:59

Hi, welcome to Python. I came here from C also.


The Python way, especially the Python 3 way, is to not make the new 
sequence into a concrete list unless you actually need a list to append 
or sort or otherwise mutate. In many use cases, that is not necessary.

Is there a custom fields plugin or component of django

kevon wang — 2012-05-25T02:53:48

I want to find a plugin of django what it can custom fields in the form. The functions include custom fields in web page and create the fields in database.

plugin's flow like these:
1.we can define fields in web page  

 --> 2.create the table in database(table includes all custom fields)

--> 3.generate CURD operations in web server 

--> 4.we can CURD records in web pages.

I want to know whether there is a plugin or component of django, If there is please tell me. Maybe there is the other plugin like this as well.

Re: Namespace hack

Steven D'Aprano — 2012-05-25T02:47:11

Pardon me for breaking threading, but Daniel's response is not available 
on my ISP's news server, and I only discovered it by accident.

On Thu May 24 15:04:34 CEST 2012, Daniel Fetchinson <fetchinson at 
googlemail.com> wrote:

[...]


Do you object to the ability to write standard Python modules?

# module.py
def spam(obj, n):
    return len(obj) + n

def ham(obj):
    return spam(obj, 23)


By your apparent misunderstanding of the Zen, you think that this should 
be written with oodles of more explicitness, 'cos explicit is always 
better, right?

keyword.def globals.spam(locals.obj, locals.n):
    keyword.return builtin.len(locals.obj) + locals.n

keyword.def globals.ham(locals.obj):
    keyword.return globals.spam(locals.obj, 23)


Python, like most (all?) non-trivial languages, has scoping rules so that 
you can refer to names without explicitly specifying which namespace they 
are in. So long as this is unambiguous, Explicit vs Implicit is 
irrelevant if not outright wrong.

My namespace decorator simply applies a slightly different set of scoping 
rules to the ones you are already used to in modules. It's no worse than 
nested functions (hardly a surprise, because it is built on nested 
functions!) or module-level scoping rules.

Re: Scoping Issues

Andrew Berg — 2012-05-25T02:27:31

Not to start another tabs-vs.-spaces discussion, but tabs are perfectly
legal indentation in Python. That exception is raised when the
interpreter can't determine how much a line is indented because tabs and
spaces are both used.

Re: Email Id Verification

Chris Angelico — 2012-05-25T01:56:40

But why do you want to validate the email address? That's the
question. Usually it's because you're going to be sending emails to
that address, in which case you not only want to ensure that it's a
real address, you want to ensure that the person who keyed it in is
legitimately allowed to do so - the usual implementation of that being
"please check your emails for the confirmation code".

There are, however, ways of not-quite-sending an email. For instance,
you can connect to the domain's MX, give your HELO, MAIL FROM, and
RCPT TO commands, and then quit before sending any DATA. That won't
give a 100% guarantee, but it'll certainly tell you about a lot of
failures (most of them in that first megastep of looking up the domain
in DNS to find its MX record, and then attempting a connection).

Now, if your goal is to recognize email addresses in plain text (eg to
make them clickable), then you probably don't want true validation -
you want more of a DWIM setup where common "tails" aren't included
[for instance, an email address followed by a close bracket, like
foo< at >bar.com]. That's completely different.

ChrisA

Re: Scoping Issues

Dave Angel — 2012-05-25T01:59:50

Guess that depends on what you mean by work.  First, it gets a syntax
error on the print function call, because you omitted the parens.  When
I fixed that, I got
   UnboundLocalError: local variable 's' referenced before assignment

so I fixed that, and got
     inconsistent use of tabs and spaces in indentation

because you mistakenly used tabs for indentation. Then I got the output
    <built-in function sum> <built-in function sum>

because sum is a built-in function.  Presumably you meant to return s,
not sum.

Here's what I end up with, and it seems to work fine in Python 3.2 on Linux:

def adder():
    s = 0
    def a(x):
        nonlocal s
        s += x
        return s
    return a

pos, neg = adder(), adder()
for i in range(10):
    print (pos(i), neg(-2*i))

.....
Output is:

0 0
1 -2
3 -6
6 -12
10 -20
15 -30
21 -42
28 -56
36 -72
45 -90

Re: Embedding Python27 in C++ on Windows: CRT compatibility issueswith VS2010?

Mark Hammond — 2012-05-25T01:53:59

It depends on the APIs you use.  eg, some APIs take a "FILE *" and some 
may take ownership of memory - such APIs needs to use the same CRT. 
APIs that don't attempt to share CRT "objects" should be fine.

Mark

Re: Scoping Issues

Chris Rebert — 2012-05-25T01:56:53

Add a "nonlocal s" declaration right here.
See http://www.python.org/dev/peps/pep-3104/


Python doesn't have a C-like variable declaration scheme. So without a
`global` or `nonlocal` declaration, you can only assign to names which
reside in the innermost scope.


You mean slide #38 ("And functions are full closures.").


I would suggest reading through the Python Language Reference
(http://docs.python.org/release/3.1.5/reference/index.html ) prior to
asking further questions, as it may well answer them for you.

Cheers,
Chris

Re: Scoping Issues

Steven D'Aprano — 2012-05-25T01:50:15


I think you mean "return s", not sum.



No, it shouldn't. When you have an assignment, such as "s += x", Python 
treats s as a local variable. Since s is local to the inner function a(), 
it has no initial value, and the += fails.

In Python 3, you can declare s to be a non-local variable with the 
nonlocal keyword:

def adder():
    s = 0
    def a(x):
        nonlocal s
        s += x
        return s
    return a


which now works the way you should expect:

1
3
8


But in Python 2, which you are using, there is no nonlocal keyword and 
you can only write to globals (declaring them with the global keyword) or 
locals (with no declaration), not nonlocals.

There are a number of work-arounds to this. One is to use a callable 
class:

class Adder:
    def __init__(self):
        self.s = 0
    def __call__(self, x):
        self.s += x
        return self.s


Another is to use an extra level of indirection, and a mutable argument. 
Instead of rebinding the non-local, you simply modify it in place:

def adder():
    s = [0]
    def a(x):
        s[0] += x
        return s[0]
    return a

Re: Email Id Verification

Steven D'Aprano — 2012-05-25T01:51:49


Ha, of course. I assumed that the OP actually has a valid reason for 
requesting an email address from the user.

Re: Scoping Issues

MRAB — 2012-05-25T01:51:58

If you bind to a name (assign to a variable) in a function, that name
is by default local to the function unless it's declared as "global" 
(which means "in this module's namespace") or "nonlocal" (which means
"in the enclosing function's namespace") (Python 3 only).

Re: Dynamic comparison operators

Paul Rubin — 2012-05-25T01:36:57

import operator

test(val1, val2, operator.ge)

Re: Email Id Verification

Paul Rubin — 2012-05-25T01:35:21

Of course spamming people will make them hate you even more.  Insisting
that people give you a valid email address (unless you have a
demonstrably legitimate use for it) is a variant of that.

Scoping Issues

SherjilOzair — 2012-05-25T01:23:18

def adder():
s = 0
def a(x):
    s += x
    return sum
return a

pos, neg = adder(), adder()
for i in range(10):
print pos(i), neg(-2*i)

This should work, right? Why does it not?

Checkout slide no. 37 of a Tour of Go to know inspiration. Just wanted to see if python was the same as Go in this regard. Sorry, if I'm being rude, or anything.

Re: Dynamic comparison operators

Steven D'Aprano — 2012-05-25T01:08:14


What is "a b.__name__ constant", and how will it be useful?

As for your solution using eval, please, please, PLEASE do not encourage 
newbies to write slow, insecure, dangerous code. There are enough 
security holes in software without you encouraging people to create more.

    * eval is slow.

    * eval is dangerous.

    * eval is using a 200lb sledgehammer to crack a peanut.

Any time you find yourself thinking that you want to use eval to solve a 
problem, take a long, cold shower until the urge goes away.

If you have to ask why eval is dangerous, then you don't know enough 
about programming to use it safely. Scrub it out of your life until you 
have learned about code injection attacks, data sanitation, trusted and 
untrusted input. Then you can come back to eval and use it safely and 
appropriately.

Today, your "test" function using eval is used only by yourself, at the 
interactive interpreter. Tomorrow, it ends up in a web application, and 
random hackers in China and script-kiddies in Bulgaria now have total 
control of your server. Any time you hear about some piece of malware or 
some virus infecting people's systems when they look at a PDF file, 
chances are high that it is a code injection attack.

To learn more, you can start here:

http://cwe.mitre.org/top25/index.html

Two of the top three most common vulnerabilities are code injection 
attacks, similar to the improper use of eval.

Here is the "eval injection" vulnerability:

http://cwe.mitre.org/data/definitions/95.html

Also google on "code injection" for many more examples.

Re: Email Id Verification

MRAB — 2012-05-25T00:48:45

Some regex implementations _can_ do recursion.


True, it's the wrong tool for the job.

Re: Email Id Verification

Steven D'Aprano — 2012-05-25T00:46:50


Why do you want to write buggy code that makes your users hate your 
program? Don't do it! Write good code, useful code! Validating email 
addresses is the wrong thing to do.

The only way to validate an email address is to ACTUALLY SEND AN EMAIL TO 
IT. That is all. Just because an address is syntactically valid doesn't 
mean it is deliverable.

You can't validate postal addresses. How would you even try? Even if you 
could, you wouldn't use a regex for it. That's the post office's job to 
decide whether mail can be delivered, not yours. Who are you to say that 
some address in Russia or Bolivia or Kuwait is "invalid"?

Email addresses are no different. It is the job of the mail server to 
decide whether email can be delivered, not yours.

http://northernplanets.blogspot.com.au/2007/03/how-not-to-validate-email-addresses.html

http://haacked.com/archive/2007/08/21/i-knew-how-to-validate-an-email-address-until-i.aspx

http://haacked.com/archive/2007/08/26/dont-be-a-validation-nazi.aspx

Re: Email Id Verification

Chris Angelico — 2012-05-24T23:48:05

Committed to an asylum or to source control?

Python is an asylum. Ruled by a Benevolent Inmate For Life. And yes,
it's a life sentence.

ChrisA

Re: Help doing it the "python way"

Emile van Sebille — 2012-05-24T23:12:34

On 5/24/2012 2:30 PM Paul Rubin said...


 >>> from itertools import chain
 >>> coord_list = zip(range(20,30),range(30,40))
 >>> a = [((x,y-1),(x,y+1)) for x,y in coord_list]
 >>> b = list(chain(((x,y-1),(x,y+1)) for x,y in coord_list))
 >>> a == b
True
 >>>

So, why use chain?  Is it a premature optimization?  Similar to the 
practice of using "".join(targets) vs targeta+targetb+...+targetn?

Emile

Re: Email Id Verification

Cameron Simpson — 2012-05-24T23:03:36

| Hello everyone..
| I am new to asp.net...

Time to run away fast before you're commited then:-)
You're aware this is a _python_ list/group, yes?

| I want to use Regular Expression validator in Email id verification..

You can't. Valid addresses including nesting comments. Regexps don't do
recursion.

| Can anyone tell me how to use this and what is the meaning of
| this
| \w+([-+.']\w+)*< at >\w+([-.]\w+)*\.\w+([-.]\w+)*

If you don't understand it, DON'T use it. And in any case, it is
simplistic (== wrong). As pointed out by others in this thread.