https://heytech.tistory.com/320

https://kodorricoding.tistory.com/16

4 Powerful Python Destructuring Features

Unpacking iterable, avoid indices, omit elements and more

Anupam Chugh

Jul 12, 2020·4 min read

Photo byAlmos BechtoldonUnsplash
　
Python is the most popular programming language largely owing to its pseudo-code like syntax.
　
It has some mighty powerful features and the fairly easy learning curve makes it the first choice language for developers all over the globe.
　
While list comprehensions are still the shiniest tool, destructuring is where the power lies.
　
Destructuring assignments are a shorthand syntax for mapping one or more variables from the left-hand side to the right-hand side counterparts. It’s handy in unpacking values as we shall see shortly.

Swapping And Updating Two Or More Values

Interchanging underlying values of variables is the most basic form of destructuring and it works in the following way:

a, b = b, a

Though at a high level it may seem that both the statementsa = bandb = aare only running simultaneously, there’s actually more going on under the hood.
　
Essentially, the right-hand side is evaluated first, convertingb,ainto a tuple. Subsequently, the tuple is unpacked and assigned to the left-hand side in the order left to right.
　
Consider the following snippet that updates the values ofaandb.

a = 1  
b = 2  
a, b = a + b, a

Itwon’tgive you a value 3 for bothaandb. Instead, the value ofbafter the assignment would be 1 whileabecomes 3.
　
The destructuring assignment allows us to swap more than two variables as well:

a,b,c = c,a,b

Unpacking Tuples And Iterables

Now, from what we’ve explored in the previous section, multiple assignments are fairly straightforward in Python. We can do it in a few ways:

a = b = c = 10  
a, b = 2, 3

The latter one is a destructuring assignment that works by creating a tuple of the right-hand side.
　
So, taking a cue from it we can opt to unpack values by using a tuple on the left-hand side as shown below:

a, b = (2, 3)  
(a, b) = 2, 3

xy = 1, 2  
a, b = xy

Destructuring assignment isn’t just restricted to tuples. In fact, you could use it on lists, strings, and pretty much any iterable.

a, b = [2,3]
names = "How are you?"  
a,b,c = names.split()

Using destructuring to split a string is really powerful but you need to ensure that the number of values on the left side must exactly match the number of values on the right side to avoidValueError

Recursive unpacking to access nested elements

We can unpack nested elements from lists or tuples with the same destructuring assignment syntax.

(a, b) = ([1, 2, 3], [1, 2])
([a, b], c) = ([1, 2], 3)
[a, b] = [[1,2],[3,4]]

Trailing comma

Trailing commas are optional for two or more element tuples. In case you’re using a single element tuple or you need to unpack only one element you can use the trailing comma in the following ways:

x = (1) #prints 1
x = (1,) #prints (1,)
a, = 1,
a, = [1]
[a] = [1]
#all print a == 1
a, = [1,2]
#ValueError too many elements

While parentheses are just syntactic sugar, it’s the comma that actually tells Python that the data type is a tuple. At times trailing comma can be missed which makes[a] = myLista better bet in terms of readability.

Access Elements Without Indices

Another place where the destructuring assignment is incredibly useful is when accessing values from a list. Without destructuring, more often than not, you’d end up accessing elements using indexes which can be needless.
　
By using the destructuring syntax in theenumeratefunction below, we’re able to access elements in a way that’s more concise and easy to comprehend.

myList = ["a", "b", "c"]  

for i, element in enumerate(myList):  
print(counter, element)

By following the same approach we can destructure dictionaries into key-value pairs or a list of tuples as shown below.

listOfTuples = [(1,0),(0,1)]
for i, (p1, p2) in enumerate(listOfTuples):
      #do your magic here

Select Or Omit Certain Values

By using the * operator (introduced in Python 3), we can choose to pick an optional unknown number of elements as shown below:

*a, b = 1, 2, 3, 4
# a is [1,2,3]
#b is 4

The asterisk operator creates a new list of all but the last element and puts them ina. This is useful when you need to extract sublists in Python.
　
We can also use the asterisk operator for getting the first and last elements from a list or even packing values and pass them into a function — which helps us get rid of long parameter lists in functions.

def sum(a, b, c):
    return a + b + c

x = (1, 2, 3)
print(result(*x))

Note: Dictionary unpacking requires**.
　
On the contrary, if you’re looking to drop or ignore the value in destructuring assignments using the_syntax is the way to go.*_lets you omit an unknown number of values.

a, _ = [1, 2]
first, *_, last = "Hello"
#first is 'H'
#last is 'o'

Conclusion

So, we saw how destructuring syntax helps in swapping and multi-assignments as well as in unpacking tuples, iterable and accessing elements without indexes in a for a loop.
　
I hope you make good use of the destructuring syntax in Python.
　
That’s it for this one. Thanks for reading.

intro

This is a quick one about how to configure Python’s build in logging system using an ini file.
Our application needs to import logging and logging.config to be able to use ini files.

import logging, logging.config
    # set up logging
    logging.config.fileConfig("log.ini")
    logger = logging.getLogger('sLogger')

    # log something
    logger.debug('debug message')
    logger.info('info message')
    logger.warn('warn message')
    logger.error('error message')
    logger.critical('critical message')

log.ini

log.ini looks like this:

[loggers]
keys=root,sLogger

[handlers]
keys=consoleHandler,fileHandler

[formatters]
keys=fileFormatter,consoleFormatter

[logger_root]
level=DEBUG
handlers=consoleHandler

[logger_sLogger]
level=DEBUG
handlers=consoleHandler,fileHandler
qualname=sLogger
propagate=0

[handler_consoleHandler]
class=StreamHandler
level=WARNING
formatter=consoleFormatter
args=(sys.stdout,)

[handler_fileHandler]
class=FileHandler
level=DEBUG
formatter=fileFormatter
args=('logfile.log',)

[formatter_fileFormatter]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt=

[formatter_consoleFormatter]
format=%(levelname)s - %(message)s
datefmt=

output

This config will write warning or above out to stdout, whilst writing everything to a logfile. e.g.

$ python app.py
WARNING - warn message
ERROR - error message
CRITICAL - critical message

And in the logfile:

$ cat logfile.log
2015-11-18 15:23:39,071 - sLogger - DEBUG - debug message
2015-11-18 15:23:39,071 - sLogger - INFO - info message
2015-11-18 15:23:39,071 - sLogger - WARNING - warn message
2015-11-18 15:23:39,071 - sLogger - ERROR - error message
2015-11-18 15:23:39,071 - sLogger - CRITICAL - critical message

quatation

• https://michaelheap.com/using-ini-config-with-python-logger/

https://dojang.io/mod/page/view.php?id=2431

42.5 클래스로 매개변수와 반환값을 처리하는 데코레이터 만들기

class Trace:
    def __init__(self, func):    # 호출할 함수를 인스턴스의 초깃값으로 받음
        self.func = func         # 호출할 함수를 속성 func에 저장
 
    def __call__(self, *args, **kwargs):    # 호출할 함수의 매개변수를 처리
        r = self.func(*args, **kwargs) # self.func에 매개변수를 넣어서 호출하고 반환값을 변수에 저장
        print('{0}(args={1}, kwargs={2}) -> {3}'.format(self.func.__name__, args, kwargs, r))
                                            # 매개변수와 반환값 출력
        return r                            # self.func의 반환값을 반환
 
@Trace    # @데코레이터
def add(a, b):
    return a + b
 
print(add(10, 20))
print(add(a=10, b=20))

add(args=(10, 20), kwargs={}) -> 30
30
add(args=(), kwargs={'a': 10, 'b': 20}) -> 30
30

    def __call__(self, *args, **kwargs):    # 호출할 함수의 매개변수를 처리
        r = self.func(*args, **kwargs) # self.func에 매개변수를 넣어서 호출하고 반환값을 변수에 저장
        print('{0}(args={1}, kwargs={2}) -> {3}'.format(self.func.__name__, args, kwargs, r))
                                            # 매개변수와 반환값 출력
        return r                            # self.func의 반환값을 반환

class IsMultiple:
    def __init__(self, x):         # 데코레이터가 사용할 매개변수를 초깃값으로 받음
        self.x = x                 # 매개변수를 속성 x에 저장
 
    def __call__(self, func):      # 호출할 함수를 매개변수로 받음
        def wrapper(a, b):         # 호출할 함수의 매개변수와 똑같이 지정(가변 인수로 작성해도 됨)
            r = func(a, b)         # func를 호출하고 반환값을 변수에 저장
            if r % self.x == 0:    # func의 반환값이 self.x의 배수인지 확인
                print('{0}의 반환값은 {1}의 배수입니다.'.format(func.__name__, self.x))
            else:
                print('{0}의 반환값은 {1}의 배수가 아닙니다.'.format(func.__name__, self.x))
            return r               # func의 반환값을 반환
        return wrapper             # wrapper 함수 반환
 
@IsMultiple(3)    # 데코레이터(인수)
def add(a, b):
    return a + b
 
print(add(10, 20))
print(add(2, 5))

add의 반환값은 3의 배수입니다.
30
add의 반환값은 3의 배수가 아닙니다.
7

    def __init__(self, x):         # 데코레이터가 사용할 매개변수를 초깃값으로 받음
        self.x = x                 # 매개변수를 속성 x에 저장

    def __call__(self, func):      # 호출할 함수를 매개변수로 받음
        def wrapper(a, b):         # 호출할 함수의 매개변수와 똑같이 지정(가변 인수로 작성해도 됨)

    def __call__(self, func):      # 호출할 함수를 매개변수로 받음
        def wrapper(a, b):         # 호출할 함수의 매개변수와 똑같이 지정(가변 인수로 작성해도 됨)
            r = func(a, b)         # func를 호출하고 반환값을 변수에 저장
            if r % self.x == 0:    # func의 반환값이 self.x의 배수인지 확인
                print('{0}의 반환값은 {1}의 배수입니다.'.format(func.__name__, self.x))
            else:
                print('{0}의 반환값은 {1}의 배수가 아닙니다.'.format(func.__name__, self.x))
            return r               # func의 반환값을 반환
        return wrapper             # wrapper 함수 반환

@데코레이터(인수)
def 함수이름():
    코드

@IsMultiple(3)    # 데코레이터(인수)
def add(a, b):
    return a + b