python interview questions

referce:python interview questions top 50

refercence:python interview questions top 15

summary

Q:
what is python?
A:

1. Python is an interpreted language. Python does not need to be compiled before it is run. Other interpreted languages include PHP and Ruby
2. Python is dynamically typed, this means that you don't need to state the types of variables when you declare them or anything like that.
3. Writing Python code is quick but running it is often slower than compiled languages. Fortunately， Python allows the inclusion of C based extensions so bottlenecks can be optimised away and often are. The numpy package is a good example of this, it's really quite quick because a lot of the number crunching it does isn't actually done by Python

Q: data type

A0 = dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))
A1 = range(10)
A2 = sorted([i for i in A1 if i in A0])
A3 = sorted([A0[s] for s in A0])
A4 = [i for i in A1 if i in A3]
A5 = {i:i*i for i in A1}
A6 = [[i,i*i] for i in A1]

A:

A0 = {'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4}  # the order may vary
A1 = range(0, 10) # or [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] in python 2
A2 = []
A3 = [1, 2, 3, 4, 5]
A4 = [1, 2, 3, 4, 5]
A5 = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
A6 = [[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81]]

Q:
Python and multi-threading
A:
Python doesn't allow multi-threading in the truest sense of the word. Python has a construct called the Global Interpreter Lock (GIL). The GIL makes sure that only one of your 'threads' can execute at any one time.

Q:
Version control
A:

Version Control helps with keeping track of who made what change to the code base; finding out when bugs were introduced to the code; keeping track of versions and releases of your software; distributing the source code amongst team members; deployment and certain automations. It allows you to roll your code back to before you broke it which is great on its own

Q:
What does this stuff mean: *args, **kwargs?
A:
Use *args when we aren't sure how many arguments are going to be passed to a function, or if we want to pass a stored list or tuple of arguments to a function. **kwargs is used when we dont know how many keyword arguments will be passed to a function, or it can be used to pass the values of a dictionary as keyword arguments. The identifiers args and kwargs are a convention.

def f(*args,**kwargs): print(args, kwargs)
l = [1,2,3]
t = (4,5,6)
d = {'a':7,'b':8,'c':9}
f(l)
f(d)
f(l,d)
f(*l,**d)

output:

([1, 2, 3],) {}
({'a': 7, 'b': 8, 'c': 9},) {}
([1, 2, 3], {'a': 7, 'b': 8, 'c': 9}) {}
(1, 2, 3) {'a': 7, 'b': 8, 'c': 9}

Q:
Decorator
A:

@my_decorator
def my_func(stuff):
    do_things
equivalent to
def my_func(stuff):
    do_things
my_func = my_decorator(my_func)

Q:
Python's garbage collection mechanism
A:

• Python maintains a count of the number of references to each object in memory. If a reference count goes to zero then the associated object is no longer live and the memory allocated to that object can be freed up for something else
• recently created objects are more likely to be dead. As objects are created, the garbage collector assigns them to generations. Each object gets one generation, and younger generations are dealt with first.

count run efficiency

import cProfile
cProfile.run("func('para')")

Q:
What is monkey patching in Python?
A:

# code at m.py
class MyClass:
def f(self):
print "f()"

import m
def monkey_f(self):
print "monkey_f()"
 
m.MyClass.f = monkey_f
obj = m.MyClass()
obj.f()

output:
monkey_f()
conclusion: the term monkey patch only refers to dynamic modifications of a class or module at run-time.