Shulou(Shulou.com)06/01 Report--

Most people don't understand the knowledge points of this article "how to apply python underline", so Xiaobian summarizes the following contents for everyone. The contents are detailed, the steps are clear, and they have certain reference value. I hope everyone can gain something after reading this article. Let's take a look at this article "how to apply python underline".

1._Used for temporary variables

Single underscores are generally used to represent temporary variables and are common in scenarios such as REPL, for loops, and tuple unpacking.

1.1 REPL

A single underscore is associated in REPL with the non-None result of the last computation.

>>> 1+12>>> _2>>> a=2+2>>> _2

1+1, the result is 2, assigned to_; while the assignment expression a=2+2a is 4, but the whole expression results in None, so it is not associated with_. This is a bit similar to the ANS button in the calculator that we use every day, which directly saves the last calculation result.

1.2 for_in loop

For loop_is used as a temporary variable. Underlines are used to denote variables that don't make sense. For example, in the following function, we can use_as a parameter when we only care about the number of times the function is executed, not the specific order.

nums = 13for _ in range(nums): fun_oper()_in 1.3-tuple unpacking

The third usage is tuple unpacking, which can be assigned with_to indicate skipped content. The following code ignores the population of Beijing City and only gets the name and area code.

>>> city,_,code = ('Beijing',21536000,'010')>>> print(city,code)Beijing 010

If more than one content needs to be skipped, you can use the * parameter to indicate that multiple content is omitted. The following code ignores area and population, only gets name and area code

city,*_,code =('Beijing ', 21536000,16410.54,' 010') 1.4 Internationalization function

In some international programming,_is often used to represent the name of a translation function. For example, when gettext packages are used:

import gettextzh = gettext.tranlation('dict','locale',languages=['zh_CN'])zh.install()_('hello world')

According to the set dictionary file, it returns the corresponding Chinese character "Hello World."

1.5 Large number representation

_can also be used to divide numbers, which is often used when numbers are long.

>>> a = 9_999_999_999>>> a9999999999

The value of a automatically ignores underscores. In this way, dividing numbers with_is conducive to reading larger numbers easily.

var_is used to resolve naming conflicts

A variable is followed by an underscore. It is mainly used to solve naming conflicts. In metaprogramming, this mechanism can be used when Python reserves keywords and needs to temporarily create a copy of a variable.

def type_obj_class(name,class_): passdef tag(name,*content,class_): pass

The class that appears in the above code is a Python reserved keyword, which is directly used to report an error, and the problem is solved by using the underscore suffix.

_var is used to protect variables

An underscore followed by a variable is an internal-only "protected variable." Such as functions, methods, or properties.

This protection is not mandatory, but rather a programmer's convention that the interpreter does not do access control. Generally speaking, these properties are as implementation details and do not need to be concerned by the caller. They may change at any time. Although we can access them when programming, we do not recommend accessing them.

This attribute can only be used for protection when imported. And it must be from XXX import * to play a protective role.

Using from XXX import * is a wildcard import, which is not recommended by the Python community because you don't know exactly what attributes and methods you're importing, and you're likely to mess up your own namespace. The recommended import method for PEP8 is from XXX import aVar , b_func , c_func.

For example, the "protection attributes" defined in the following garage function tools.py: engine model and tire model are implementation details that need not be exposed to the user. When we call it with the from tools import * statement, it doesn't actually import all of the attributes that start with_, just the normal drive method.

_moto_type = 'L15b2'_wheel_type = 'michelin'def drive(): _start_engine() _drive_wheel()def _start_engine(): print('start engine %s'%_moto_type) def _drive_wheel(): print('drive wheel %s'%_wheel_type)

Looking at the command space print(vars()), you can see that only the drive function is imported, and the other "private properties" that start with underscores are not imported.

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__':{}, '__builtins__': , '__file__': '.\ xiahuaxian.py', '__cached__': None, 'walk': , 'root': '.\__ pycache__','_':[21536000, 16410.54], ' dirs':<$'tools.cpython-38.pyc'], 'city':' Beijing','code':' 010','drive':}3.1 Breakthrough Protection Properties

"Protected" isn't "private" because Python doesn't provide an interpreter mechanism to control access. We can still access these properties:

import toolstools._ moto_type = 'EA211'tools.drive()

The above code to override the "protection attribute." There are also two ways to get around this limitation. One is to add "private properties" to the__all__list in the tool.py file, so that from tools import * imports these supposedly hidden properties as well.

__all__ = ['drive','_moto_type','_wheel_type']

The other is to specify a Protected Attribute name when importing.

from tools import drive,_start_engine_start_engine()

Even with import tools, protection limits can be easily breached. So,"protected attributes" are a simple hiding mechanism, provided by the interpreter only when from tools import *, but easily breached. This protection relies more on the programmer's consensus not to access or modify "protected properties." Is there a safer protection mechanism? Yes, there are private variables discussed in the next section.

__var is used for private variables

Private properties solve the problem of insufficient protection of the previous protection properties. Variable with two underscores in front of it, inside the class as a property name and method can be. Two underscore attributes are protected by Python's rewriting mechanism.

In the car example below, the brand is a generic attribute, the engine is a "protective attribute," and the wheel brand is a "private attribute."

class Car: def __init__(self): self.brand = 'Honda' self._ moto_type = 'L15B2' self.__ wheel_type = 'michelin' def drive(self): print('Start the engine %s,drive the wheel %s,I get a running %s car'% (self._ moto_type, self.__ wheel_type, self.brand))

Let's use var(car1) to see the specific attribute values,

['_Car__wheel_type', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_moto_type', 'brand', 'drive']

Thus, in instantiating car1, the common attribute self.brand and the protected attribute self._ Moto_type is saved, and the two underlined private attributes__wheel_type are gone. The_Car_wheel_type attribute is substituted. This is the Name mangling mechanism. Two underlined attributes are rewritten as variables with class name prefixes, so that it is difficult for subclasses to identify an attribute with such a complex name. Ensure that the property is not overloaded and that its privacy is guaranteed.

4.1 Breaking Private Attributes

The implementation of "private variables" here is a rewrite given at the interpreter level that protects private variables. But this mechanism is not absolutely safe, because we can still pass obj._ ClasssName__private to access__private private properties.

car1.brand = 'Toyota'car1._ moto_type = '6AR-FSE'car1._ Car__wheel_type = 'BRIDGESTONE'car1.drive()

results

Start the engine 6AR-FSE,

drive the wheel BRIDGESTONE,

I get a running Toyota car

It can be seen that although the protection of private variables rewritten by the rewriting mechanism has been strengthened, they can still be accessed and modified. But this modification is only a juggling operation and is not desirable.

5.__var__is used for magic methods

Variable with two underscores before and two underscores after. This is the magic method in Python, which is usually called by system programs. For example,__init__in the above example is the initialization magic method of the class, and there are__len__methods that support len functions,__enter__and__exit__methods that support the context manager protocol,__iter__methods that support the iterator protocol,__repr__and__str__methods that support formatted displays, and so on. Here we add the magic method__repr__to the Car class in the example above to support formatting.

def __repr__(self): return '***Car %s:with %s Engine,%sWheel***'% (self.brand,self._ moto_type,self.__ wheel_type)

Before adding the__repr__magic method, print(car1) results in, this result is confusing, after adding the repr magic method, the result is displayed as **Car Toyota:with 6AR-FSE Engine,BRIDGESTONE Wheel** Clear and clear, easy to debug. This is what magic methods do: support system calls, improve user class behavior, add protocol support, and make user classes behave more like system classes.

5.1 Python Magic Method Classification

All of the following magic methods require__before and after them, and these double underscores are omitted here.

Unary operator neg pos abs invert

conversion complex int float round inex

Arithmetic operations add sub mul truediv floordiv mod divmod pow lshift rshift and xor or

Arithmetic operations are preceded by r in addition to and to indicate inversion. In addition to dimod, preceded by i, indicates in-place operation.

Compare lt le eq ne gt ge

class attribute getattr getattribute setattr delattr dir get set delete

format bytes hash bool format

Init del new

list getitem

iterator iter next

Context Manager enter exit

The above is the content of this article about "how to apply python underline". I believe everyone has a certain understanding. I hope the content shared by Xiaobian will be helpful to everyone. If you want to know more relevant knowledge content, please pay attention to the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.