What is `related_name` used for in Django?

by ⋅ Link

What is `related_name` used for in Django?

What is the related_name argument useful for on ManyToManyField and ForeignKey fields? For example, given the following code, what is the effect of related_name='maps'?

class Map(db.Model):
    members = models.ManyToManyField(User, related_name='maps',
                                     verbose_name=_('members'))

The related_name attribute specifies the name of the reverse relation from the User model back to your model.

If you don’t specify a related_name, Django automatically creates one using the name of your model with the suffix _set, for instance User.map_set.all().

If you do specify, e.g. related_name=maps on the User model, User.map_set will still work, but the User.maps. syntax is obviously a bit cleaner and less clunky; so for example, if you had a user object current_user, you could use current_user.maps.all() to get all instances of your Mapmodel that have a relation to current_user.

The Django documentation has more details.

what does this django regex mean? `?P` – Stack Overflow

by ⋅ Link

what does this django regex mean? `?P` – Stack Overflow

(?Pregex) – Round brackets group the regex between them. They capture the text matched by the regex inside them that can be referenced by the name between the sharp brackets. The name may consist of letters and digits.

(?P…) Similar to regular parentheses, but the substring matched by the group is accessible within the rest of the regular expression via the symbolic group name name. Group names must be valid Python identifiers, and each group name must be defined only once within a regular expression. A symbolic group is also a numbered group, just as if the group were not named. So the group named id in the example below can also be referenced as the numbered group 1.

Python Regular Expressions

by ⋅ Link

Python Regular Expressions

A regular expression is a special sequence of characters that helps you match or find other strings or sets of strings, using a specialized syntax held in a pattern. Regular expressions are widely used in UNIX world.

The module re provides full support for Perl-like regular expressions in Python. The re module raises the exception re.error if an error occurs while compiling or using a regular expression.

We would cover two important functions, which would be used to handle regular expressions. But a small thing first: There are various characters, which would have special meaning when they are used in regular expression. To avoid any confusion while dealing with regular expressions, we would use Raw Strings as r’expression’.

The match Function

This function attempts to match RE pattern to string with optional flags.

Here is the syntax for this function −

re.match(pattern, string, flags=0)

Here is the description of the parameters:

ParameterDescription

patternThis is the regular expression to be matched.

stringThis is the string, which would be searched to match the pattern at the beginning of string.

flagsYou can specify different flags using bitwise OR (|). These are modifiers, which are listed in the table below.

The re.match function returns a match object on success, None on failure. We usegroup(num) or groups() function of match object to get matched expression.

Match Object MethodsDescription

group(num=0)This method returns entire match (or specific subgroup num)

groups()This method returns all matching subgroups in a tuple (empty if there weren’t any)

Example

#!/usr/bin/python
import re

line = "Cats are smarter than dogs"

matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)

if matchObj:
   print "matchObj.group() : ", matchObj.group()
   print "matchObj.group(1) : ", matchObj.group(1)
   print "matchObj.group(2) : ", matchObj.group(2)
else:
   print "No match!!"

When the above code is executed, it produces following result −

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

The search Function

This function searches for first occurrence of RE pattern within string with optional flags.

Here is the syntax for this function:

re.search(pattern, string, flags=0)

Here is the description of the parameters:

ParameterDescription

patternThis is the regular expression to be matched.

stringThis is the string, which would be searched to match the pattern anywhere in the string.

flagsYou can specify different flags using bitwise OR (|). These are modifiers, which are listed in the table below.

The re.search function returns a match object on success, none on failure. We use group(num) or groups() function of match object to get matched expression.

Match Object MethodsDescription

group(num=0)This method returns entire match (or specific subgroup num)

groups()This method returns all matching subgroups in a tuple (empty if there weren’t any)

Example

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)

if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"

When the above code is executed, it produces following result −

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

Matching Versus Searching

Python offers two different primitive operations based on regular expressions:match checks for a match only at the beginning of the string, while searchchecks for a match anywhere in the string (this is what Perl does by default).

Example

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print "match --> matchObj.group() : ", matchObj.group()
else:
   print "No match!!"

searchObj = re.search( r'dogs', line, re.M|re.I)
if searchObj:
   print "search --> searchObj.group() : ", searchObj.group()
else:
   print "Nothing found!!"

When the above code is executed, it produces the following result −

No match!!
search --> matchObj.group() :  dogs

Search and Replace

One of the most important re methods that use regular expressions is sub.

Syntax

re.sub(pattern, repl, string, max=0)

This method replaces all occurrences of the RE pattern in string with repl, substituting all occurrences unless max provided. This method returns modified string.

Example

#!/usr/bin/python
import re

phone = "2004-959-559 # This is Phone Number"

# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num

# Remove anything other than digits
num = re.sub(r'D', "", phone)    
print "Phone Num : ", num

When the above code is executed, it produces the following result −

Phone Num :  2004-959-559
Phone Num :  2004959559

Regular Expression Modifiers: Option Flags

Regular expression literals may include an optional modifier to control various aspects of matching. The modifiers are specified as an optional flag. You can provide multiple modifiers using exclusive OR (|), as shown previously and may be represented by one of these −

ModifierDescription

re.IPerforms case-insensitive matching.

re.LInterprets words according to the current locale. This interpretation affects the alphabetic group (w and W), as well as word boundary behavior (b and B).

re.MMakes $ match the end of a line (not just the end of the string) and makes ^ match the start of any line (not just the start of the string).

re.SMakes a period (dot) match any character, including a newline.

re.UInterprets letters according to the Unicode character set. This flag affects the behavior of w, W, b, B.

re.XPermits “cuter” regular expression syntax. It ignores whitespace (except inside a set [] or when escaped by a backslash) and treats unescaped # as a comment marker.

Regular Expression Patterns

Except for control characters, (+ ? . * ^ $ ( ) [ ] { } | ), all characters match themselves. You can escape a control character by preceding it with a backslash.

Following table lists the regular expression syntax that is available in Python −

PatternDescription

^Matches beginning of line.

$Matches end of line.

.Matches any single character except newline. Using m option allows it to match newline as well.

[…]Matches any single character in brackets.

[^…]Matches any single character not in brackets

re*Matches 0 or more occurrences of preceding expression.

re+Matches 1 or more occurrence of preceding expression.

re?Matches 0 or 1 occurrence of preceding expression.

re{ n}Matches exactly n number of occurrences of preceding expression.

re{ n,}Matches n or more occurrences of preceding expression.

re{ n, m}Matches at least n and at most m occurrences of preceding expression.

a| bMatches either a or b.

(re)Groups regular expressions and remembers matched text.

(?imx)Temporarily toggles on i, m, or x options within a regular expression. If in parentheses, only that area is affected.

(?-imx)Temporarily toggles off i, m, or x options within a regular expression. If in parentheses, only that area is affected.

(?: re)Groups regular expressions without remembering matched text.

(?imx: re)Temporarily toggles on i, m, or x options within parentheses.

(?-imx: re)Temporarily toggles off i, m, or x options within parentheses.

(?#…)Comment.

(?= re)Specifies position using a pattern. Doesn’t have a range.

(?! re)Specifies position using pattern negation. Doesn’t have a range.

(?> re)Matches independent pattern without backtracking.

wMatches word characters.

WMatches nonword characters.

sMatches whitespace. Equivalent to [tnrf].

SMatches nonwhitespace.

dMatches digits. Equivalent to [0-9].

DMatches nondigits.

AMatches beginning of string.

ZMatches end of string. If a newline exists, it matches just before newline.

zMatches end of string.

GMatches point where last match finished.

bMatches word boundaries when outside brackets. Matches backspace (0x08) when inside brackets.

BMatches nonword boundaries.

n, t, etc.Matches newlines, carriage returns, tabs, etc.

1…9Matches nth grouped subexpression.

10Matches nth grouped subexpression if it matched already. Otherwise refers to the octal representation of a character code.

Regular Expression Examples

Literal charactersExampleDescription

pythonMatch “python”.

Character classes

ExampleDescription

[Pp]ythonMatch “Python” or “python”

rub[ye]Match “ruby” or “rube”

[aeiou]Match any one lowercase vowel

[0-9]Match any digit; same as [0123456789]

[a-z]Match any lowercase ASCII letter

[A-Z]Match any uppercase ASCII letter

[a-zA-Z0-9]Match any of the above

[^aeiou]Match anything other than a lowercase vowel

[^0-9]Match anything other than a digit

Special Character Classes

ExampleDescription

.Match any character except newline

dMatch a digit: [0-9]

DMatch a nondigit: [^0-9]

sMatch a whitespace character: [ trnf]

SMatch nonwhitespace: [^ trnf]

wMatch a single word character: [A-Za-z0-9_]

WMatch a nonword character: [^A-Za-z0-9_]

Repetition Cases

ExampleDescription

ruby?Match “rub” or “ruby”: the y is optional

ruby*Match “rub” plus 0 or more ys

ruby+Match “rub” plus 1 or more ys

d{3}Match exactly 3 digits

d{3,}Match 3 or more digits

d{3,5}Match 3, 4, or 5 digits

Nongreedy repetition

This matches the smallest number of repetitions −

ExampleDescription

<.*>Greedy repetition: matches “<python>perl>”

<.*?>Nongreedy: matches “<python>” in “<python>perl>”

Grouping with Parentheses

ExampleDescription

Dd+No group: + repeats d

(Dd)+Grouped: + repeats Dd pair

([Pp]ython(, )?)+Match “Python”, “Python, python, python”, etc.

Backreferences

This matches a previously matched group again −

ExampleDescription

([Pp])ython&1ailsMatch python&pails or Python&Pails

([’“])[^1]*1Single or double-quoted string. 1 matches whatever the 1st group matched. 2 matches whatever the 2nd group matched, etc.

Alternatives

ExampleDescription

python|perlMatch "python” or “perl”

rub(y|le))Match “ruby” or “ruble”

Python(!+|?)“Python” followed by one or more ! or one ?

Anchors

This needs to specify match position.

ExampleDescription

^PythonMatch “Python” at the start of a string or internal line

Python$Match “Python” at the end of a string or line

APythonMatch “Python” at the start of a string

PythonZMatch “Python” at the end of a string

bPythonbMatch “Python” at a word boundary

brubBB is nonword boundary: match “rub” in “rube” and “ruby” but not alone

Python(?=!)Match “Python”, if followed by an exclamation point.

Python(?!!)Match “Python”, if not followed by an exclamation point.

Special Syntax with Parentheses

ExampleDescription

R(?#comment)Matches “R”. All the rest is a comment

R(?i)ubyCase-insensitive while matching “uby”

R(?i:uby)Same as above

rub(?:y|le))Group only without creating 1 backreference

Python’s use of __new__ and __init__? – Stack Overflow

by ⋅ Link

Python’s use of __new__ and __init__? – Stack Overflow

Use __new__ when you need to control the creation of a new instance. Use __init__ when you need to control initialization of a new instance.

__new__ is the first step of instance creation. It’s called first, and is responsible for returning a new instance of your class. In contrast, __init__ doesn’t return anything; it’s only responsible for initializing the instance after it’s been created.

In general, you shouldn’t need to override __new__ unless you’re subclassing an immutable type like str, int, unicode or tuple.

Python descriptors made simple – SmallSureThing

by ⋅ Link

Python descriptors made simple – SmallSureThing

Descriptors, introduced in Python 2.2, provide a way to add managed attributes to objects. They are not used much in everyday programming, but it’s important to learn them to understand a lot of the “magic” that happens in the standard library and third-party packages.

The problem

Imagine we are running a bookshop with an inventory management system written in Python. The system contains a class called Book  that captures the author, title and price of physical books.

Python12345678class Book(object):    def __init__(self, author, title, price):        self.author = author        self.title = title        self.price = price     def __str__(self):        return “{0} – {1}”.format(self.author, self.title)

Our simple Book class works fine for a while, but eventually bad data starts to creep into the system. The system is full of books with negative prices or prices that are too high because of data entry errors. We decide that we want to limit book prices to values between 0 and 100. In addition, the system contains a Magazine class that suffers from the same problem, so we want our solution to be easily reusable.

The descriptor protocol

The descriptor protocol is simply a set of methods a class must implement to qualify as a descriptor. There are three of them:

  • __get__(self, instance, owner)
  • __set__(self, instance, value)
  • __delete__(self, instance)

__get__ accesses a value stored in the object and returns it.

__set__ sets a value stored in the object and returns nothing.

__delete__ deletes a value stored in the object and returns nothing.

Using these methods, we can write a descriptor called Price that limits the value stored in it to between 0 and 100.

Python1234567891011121314151617from weakref import WeakKeyDictionary class Price(object):    def __init__(self):        self.default = 0        self.values = WeakKeyDictionary()     def __get__(self, instance, owner):        return self.values.get(instance, self.default)     def __set__(self, instance, value):        if value < 0 or value > 100:            raise ValueError(“Price must be between 0 and 100.”)        self.values[instance] = value     def __delete__(self, instance):        del self.values[instance]

A few details in the implementation of Price deserve mentioning.

An instance of a descriptor must be added to a class as a class attribute, not as an instance attribute. Therefore, to store different data for each instance, the descriptor needs to maintain a dictionary that maps instances to instance-specific values. In the implementation of Price, that dictionary is self.values.

A normal Python dictionary stores references to objects it uses as keys. Those references by themselves are enough to prevent the object from being garbage collected. To prevent Book instances from hanging around after we are finished with them, we use the WeakKeyDictionary from the weakref standard module. Once the last strong reference to the instance passes away, the associated key-value pair will be discarded.

Using descriptors

As we saw in the last section, descriptors are linked to classes, not to instances, so to add a descriptor to the Book class, we must add it as a class variable.

Python12345678910class Book(object):    price = Price()     def __init__(self, author, title, price):        self.author = author        self.title = title        self.price = price     def __str__(self):        return “{0} – {1}”.format(self.author, self.title)

The price constraint for books is now enforced.

Python1234567891011121314151617>>> b = Book(“William Faulkner”, “The Sound and the Fury”, 12)>>> b.price12>>> b.price = -12Traceback (most recent call last):  File “<pyshell#68>”, line 1, in <module>    b.price = -12  File “<pyshell#58>”, line 9, in __set__    raise ValueError(“Price must be between 0 and 100.”)ValueError: Price must be between 0 and 100.>>> b.price = 101Traceback (most recent call last):  File “<pyshell#69>”, line 1, in <module>    b.price = 101  File “<pyshell#58>”, line 9, in __set__    raise ValueError(“Price must be between 0 and 100.”)ValueError: Price must be between 0 and 100.

How descriptors are accessed

So far we’ve managed to implement a working descriptor that manages the priceattribute on our Book class, but how it works might not be clear. It all feels a bit too magical, but not to worry. It turns out that descriptor access is quite simple:

  • When we try to evaluate b.price and retrieve the value, Python recognizes that price is a descriptor and calls Book.price.__get__.
  • When we try to change the value of the price attribute, e.g. b.price = 23 , Python again recognizes that price is a descriptor and substitutes the assignment with a call to Book.price.__set__.
  • And when we try to delete the price attribute stored against an instance ofBook, Python automatically interprets that as a call to Book.price.__delete__.

The number 1 descriptor gotcha

Unless we fully understand the fact that descriptors are linked to classes and not to instances, and therefore need to maintain their own mapping of instances to instance-specific values, we might be tempted to write the Price descriptor as follows:

Python1234567891011121314class Price(object):    def __init__(self):        self.__price = 0     def __get__(self, instance, owner):        return self.__price     def __set__(self, instance, value):        if value < 0 or value > 100:            raise ValueError(“Price must be between 0 and 100.”)        self.__price = value     def __delete__(self, instance):        del self.__price

But once we start instantiating multiple Book instances, we’re going to have a problem.

Python123456>>> b1 = Book(“William Faulkner”, “The Sound and the Fury”, 12)>>> b1.price12>>> b2 = Book(“John Dos Passos”, “Manhattan Transfer”, 13)>>> b1.price13

The key is to understand that there is only one instance of Price for Book, so every time the value in the descriptor is changed, it changes for all instances. That behaviour in itself is useful for creating managed class attributes, but it is not what we want in this case. To store separate instance-specific values, we need to use theWeakRefDictionary.

The property built-in function

Another way of building descriptors is to use the property built-in function. Here is the function signature:

Python1property(fget=None, fset=None, fdel=None, doc=None)

fget, fset and fdel are methods to get, set and delete attributes, respectively. docis a docstring.

Instead of defining a single class-level descriptor object that manages instance-specific values, property works by combining instance methods from the class. Here is a simple example of a Publisher class from our inventory system with a managedname property. Each method passed into property has a print statement to illustrate when it is called.

Python1234567891011121314151617class Publisher(object):    def __init__(self, name):        self.__name = name     def get_name(self):        print(“getting name”)        return self.__name     def set_name(self, value):        print(“setting name”)        self.__name = value     def delete_name(self):        print(“deleting name”)        del self.__name     name = property(get_name, set_name, delete_name, “Publisher name”)

If we make an instance of Publisher and access the name attribute, we can see the appropriate methods being called.

Python12345678>>> p = Publisher(“Faber & Faber”)>>> p.namegetting name’Faber & Faber’>>> p.name = “Random House"setting name>>> del p.namedeleting name

That’s it for this basic introduction to descriptors. If you want a challenge, take what you have learned and try to reimplement the @property decorator. There is enough information in this post to allow you to figure it out.

old-style and new-style classes in Python 2.7? – Stack Overflow

by ⋅ Link

old-style and new-style classes in Python 2.7? – Stack Overflow

You should always use new style classes. New-style classes are part of an effort to unify built-in types and user-defined classes in the Python programming language.

New style classes have several things to offer such as:

Properties: Attributes that are defined by get/set methods
Static methods and class methods
The new getattribute hook, which, unlike getattr, is called for every attribute access, not just when the attribute can’t be found in the instance
Descriptors: A protocol to define the behavior of attribute access through objects
Overriding the constructor new
Metaclasses