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

This article focuses on "how to implement the singleton pattern in Python". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn how to implement singleton pattern in Python.

Method 1: use the decorator to realize the singleton pattern.

From functools import wrapsdef singleton (cls):

"" Singleton class decorator ""

Instances = {}

@ wraps (cls)

Def wrapper (* args, * * kwargs):

If cls not in instances:

Instances [cls] = cls (* args, * * kwargs)

Return instances [cls]

Return wrapper@singleton

Class President:

Pass

Extension: decorator is a very distinctive syntax in Python, using one function to decorate another function or class, adding extra power to it. The functions that are usually realized through decoration are crosscutting concern functions, that is, functions that are not necessarily related to normal business logic and can be added or removed dynamically. The decorator can provide caching, proxy, context and other services for the code, which is the practice of the proxy pattern in the design pattern. When writing a decorator, the decorated function (the wrapper function in the above code) is usually decorated with wraps in the functools module. The most important function of this decorator is to dynamically add a _ _ wrapped__ attribute to the decorated class or function, which will retain the class or function before it is decorated, so that when we do not need the decorating function, we can use it to cancel the decorator. For example, you can use President = President.__wrapped__ to cancel singleton processing on the President class. I need to remind you that the above singleton is not thread-safe, and if you want to be thread-safe, you need to lock the code that created the object. In Python, the RLock object of the threading module can be used to provide locks, and the acquire and release methods of lock objects can be used to implement locking and unlocking operations. Of course, it is easier to use the with context syntax of the lock object for implicit locking and unlocking operations.

Method 2: use metaclass to implement singleton pattern.

Class SingletonMeta (type):

"" Custom singleton class ""

Def _ _ init__ (cls, * args, * * kwargs):

Cls.__instance = None

Super (). _ _ init__ (* args, * kwargs)

Def _ _ call__ (cls, * args, * * kwargs):

If cls.__instance is None:

Cls.__instance = super (). _ _ call__ (* args, * kwargs)

Return cls.__instanceclass President (metaclass=SingletonMeta):

Pass

Extension: Python is an object-oriented programming language. In the object-oriented world, everything is an object. Objects are created through classes, and classes themselves are objects, and objects such as classes are created through metaclasses. When we define a class, if we don't assign a parent class to a class, the default parent class is object, and if we don't assign a metaclass to a class, the default metaclass is type. Through a custom metaclass, we can change the default behavior of a class, just as in the above code, we changed the constructor of the President class through the _ _ call__ magic method of the metaclass.

With regard to the singleton model, you may also be asked about its application scenario in the interview. Usually, the state of an object is shared by other objects, so it can be designed as a singleton. For example, the database connection pool objects and configuration objects used in the project are usually singletons. Only in this way can we ensure that the database connection and configuration information obtained in all places is exactly the same. And because the object has only a unique instance, it fundamentally avoids the time and space overhead caused by the repeated creation of the object, as well as the multiple occupation of resources. For another example, log operations in a project usually use singleton mode because the shared log file is always open and only one instance can manipulate it, otherwise there will be confusion when writing to the log.

Topic 002: instead of using intermediate variables, exchange the values of two variables an and b.

Comments: typical headers, in other programming languages, do not use intermediate variables to exchange the values of two variables can use XOR operation, Python can also directly exchange the values of two variables through the built-in bytecode instruction.

Method 1:

A = a ^ b

B = a ^ b

A = a ^ b

Method 2:

A, b = b, a

Expansion: it should be noted that a, b = b, an is not really a tuple unpacking, although many people think so. The Python bytecode instruction has the ROT_TWO instruction to support this operation, and similarly ROT_THREE, for more than 3 elements, such as a, b, c, d = b, c, d, a, create tuples and tuple unpacks. To know the bytecode instructions for your code, use the dis function of the dis module in the Python standard library to disassemble your Python code.

Topic 003: write a function that removes duplicate elements from the list, requiring the relative position of the elements to remain unchanged.

Comments: this topic often appears in junior and intermediate Python job interviews, which comes from the 10th question in the first chapter of the book "Python Cookbook". Many interview questions are actually the original questions in this book, so I suggest you study this book carefully if you have time.

Def dedup (items):

No_dup_items = []

Seen = set ()

For item in items:

If item not in seen:

No_dup_items.append (item)

Seen.add (item)

Return no_dup_items

Of course, you can also transform the above function into a generator like the code in the "Python Cookbook" book.

Def dedup (items):

Seen = set ()

For item in items:

If item not in seen:

Yield item

Seen.add (item)

Extension: because the underlying collection in Python uses hash storage, the in and not in member operations of the collection perform much better than the list, so in the above code we use the collection to hold the elements that have already appeared. The element in the collection must be a hashable object, so the above code will fail when the list element is not a hashable object. To solve this problem, you can add a parameter to the function, which can be designed as a function that returns a hash code or hashable object.

Topic 004: assuming you are using the official CPython, state the running result of the following code.

Comments: the following program is of little significance to the actual development, but it is a big hole in CPython. This question is designed to see how much the interviewer knows about the official Python interpreter.

A, b, c, d = 1, 1, 1000, 1000

Print (an is b, c is d)

Def foo ():

E = 1000

F = 1000

Print (e is f, e is d)

G = 1

Print (g is a)

Foo ()

Results:

True False

True False

True

The result of an is b in the above code is True, but the result of c is d is False, which is really puzzling. This result is due to the fact that CPython caches frequently used integer objects with an object pool called small_ints for performance optimization. The integer value of the small_ints cache is set to the interval [- 5256], that is, if you use the CPython interpreter, you do not need to recreate the int object wherever these integers are referenced, but refer directly to the object in the cache pool. If integers are not in this range, two integers are different objects even if they have the same value.

The underlying CPython also makes a setting to further improve performance: for integers whose values are not within the scope of the small_ints cache in the same code block, if an integer object with the same value already exists in the same code block, it will be referenced directly, otherwise a new int object will be created. It should be noted that this rule applies to numeric values, but for strings, you need to consider the length of the string, which can be proved by yourself.

Extension: if you run the above code with PyPy (another Python interpreter implementation that supports JIT, improves the shortcomings of CPython and outperforms CPython in performance, but slightly less support for third-party libraries), you will find that all the output is True.

What is the title 005:Lambda function, an example of its application scenario.

Comments: the main purpose of this topic is to examine the application scenario of the Lambda function. The subtext is to ask if you have ever used the Lambda function in the project, and in what scenarios will you use the Lambda function to judge your ability to write code. Because Lambda functions are usually used in higher-order functions, the main function is to decouple the code by passing in or returning functions.

The Lambda function, also known as an anonymous function, is a small function that can be implemented with a single line of code. The Lambda function in Python can only write one expression, and the result of this expression is the return value of the function, without writing the return keyword. Because the Lambda function does not have a name, it will not have a naming conflict with other functions.

During the interview, you may also be tested to use the Lambda function to achieve some functions, that is, to use one line of code to achieve the required functions, such as: one line of code to achieve the factorial function, one line of code to achieve the maximum common divisor function and so on.

Fac = lambda x: _ _ import__ ('functools') .reduce (int.__mul__, range (1, x + 1), 1)

Gcd = lambda x, y: y% x and gcd (y% x, x) or x

In fact, the main purpose of Lambda function is to transfer one function to another higher-order function (such as filter, map, etc.) built-in in Python to decouple the function and enhance the flexibility and versatility of the function. The following example filters odd numbers from the list and squares them to form a new list by using the filter and map functions. Because higher-order functions are used, the rules for filtering and mapping data are passed in by the caller of the function through another function, so the filter and map functions are not coupled with specific rules for filtering and mapping data.

Items = [12,5,7,10,8,19]

Items = list (map (lambda x: X * * 2, filter (lambda x: X% 2, items)

Print (items) # [25,49,361]

Of course, it is easier to implement the above code with the generation of the list, as shown below.

Items = [12,5,7,10,8,19]

Items = [x * * 2 for x in items if x% 2]

Print (items) # [25,49,361] here, I believe you have a better understanding of "how to implement the singleton pattern in Python". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

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.