python

_ & *_ placeholders

if we define these functions:

def f():
	return 1,2,3
	
def g():
	return 1,2
	
def h():
	return 1,2,3,4

and we only want some of the outputs:

x,y,_=f()
x,y,_=g() #Error: not enough values to unpack(expected 3, got 2)
x,y,_=h() ＃Error：too many values to unpack(expected 3)

the second and third error can be avoided with:

x,y,*_=g()
print(_)
>>>[]

x,y,*_=h()
print(_)
>>>[3,4]

generator

the element in generator can be calculate according to some algorithm while all of the list element exist since the list are created.

L =[x*x for x in range(10)] #list
g=(x*x for x in range(10)) #generator

use next or loop to call generator

next(g)

for n in g:
	print(n)

super()

read more

• if we want to call the function in the parent class, we can use super(), for instance:

  class A:
  	def spam(self):
  		print('A.spam')
  	
  class B(A):
  	def spam(self):
  		print('B.spam')
  		super().spam # call parent spam()

• another common usage is to ensure that the father class is initialized correctly:

  class Base:
  	def __init__(self):
  		print('Base.init')
  
  class A(Base):
  	def __init__(self):
  		super().__init__()
  		print('A.init')

  notes: python 3 can replace super(class,self).xxx in python 2 with super().xxx

setattr & getattr & delattr

these three are default functions that are responsible for setting/getting/deleting attribute
https://zhuanlan.zhihu.com/p/62569340

enumerate

enumerate(sequence,[start=0]) returns a tuple containing a count(from start which defaults to 0) and the values obtained from iterating over iterable.
it allows us to loop over something and have an automatic counter.

normal loop

i=0
seq=['a','b','c']
for element in seq:
	print(i,seq[i])
	i=i+1
	
>>> 0 a
>>> 1 b
>>> 2 c

using enumerate

seq=['a','b','c']
for i, element in enumerate(seq):
	print(i,seq[i])
>>> 0 a
>>> 1 b
>>> 2 c

@property & @xxx.setter

@property can transform a method of the class to attribute of the class(which is read only). And the @xxx.setter is responsible for transforming the method to the setter.

class A:
	def __init__(self):
		self._x = 0
	@property
	def x(self):
		return self._x
		
	@x.setter
	def x(self, value):
		self._x= value
		
a= A()
print(a.x)
>>> 0
a.x=10
print(a.x)
>>> 10

notes: _x in code above can not be x, otherwise it will report error.read more

*args & **kwargs (positional argument and keyword argument)

you can pass argument of unknown numbers to the function. ‘unknown’ means that it doesn’t know how many arguments the users will pass.
the * is necessary, you can also write *a, **k

the differences between *args and **kwargs:

• *args is non keyword arguments, actually a tuple or list?
• **kwargs is keyword arguments, actually a dict
• *args must be in the front of **kwargs