Home IT Linux Windows Database Network Programming Server Mobile  
           
  Home \ Programming \ Python interview must look at 15 questions     - GAMIT10.5 install and update failed Solution (Linux)

- To achieve Linux Security (Linux)

- Ceph performance optimization summary (v0.94) (Server)

- Let Linux boot methods to enter characters interface and set FrameBuffer resolution methods (Linux)

- Using C ++ Container Templates in Shared Memory (Programming)

- Oracle large table to clean truncate .. reuse storage (Database)

- Ubuntu prompt / lack of boot space solutions (Linux)

- Iptables small summary (Linux)

- Linux environment variables inside (Linux)

- RHEL / CentOS / Fedora Install Nagios 4.0.1 (Linux)

- Android project using the command to create and install the package (Programming)

- C ++ function object (Programming)

- awk Programming Model (Programming)

- MySQL use the integer type (Database)

- 12 kinds of detection of CPU information on a Linux system tools (Linux)

- grep command usage (Linux)

- CentOS installation pycurl (Linux)

- Ubuntu 14.10 / 14.04 / 12.04 How to install Kodi 14.0 RC3 (Linux)

- Linux system commands to view hardware information (Linux)

- ElasticSearch basic usage and cluster structures (Server)

 
         
  Python interview must look at 15 questions
     
  Add Date : 2018-11-21      
         
       
         
  Question 1

In the end what is Python? You can compare the answer with other technologies (also encouraged to do so).

answer

Here are some key points:

Python is an interpreted language. That is to say, the language derived from C and C language is different, you do not need to compile before Python code at runtime. Other interpreted languages ​​also include PHP and Ruby.
Python is a dynamically typed language, referring to when you declare a variable, the variable type does not require explanation. You can write similar x = 111 and x = "I'm a string" this code, the program does not complain.
Python is ideal for object-oriented programming (OOP), as it supports through a combination (composition) succession (inheritance) and a way to define classes (class). Python is no access specifier (access specifier, similar to C ++ in public and private), based on such a design is that "we are adults."
In the Python language, functions are first-class objects (first-class objects). This means that they can be assigned to a variable, function return both function types to be accepted as an input function. Class (class) are also first-class objects.
Python code to write fast, but the speed is usually slower than compiled languages. Fortunately, Python allowed to join the extended C-based language, so we can optimize the code, eliminate bottlenecks, this can usually be achieved. numpy is a good example, its speed is really very fast, because a lot of arithmetic is not really implemented by Python.
Python uses a very wide - network applications, automation, scientific modeling, large data applications, and so on. It is also often used as a "glue language" to help improve other languages ​​and assembly operation.
Python make difficult things easy, so that programmers can focus on the design of algorithms and data structures, but not the details of the underlying process.
Why ask this question:

If you are applying for a job Python developer, you should know what kind of language is the door, and why it is so cool. And where it is not good.

Question 2

Fill in missing codes

def print_directory_contents (sPath):
    "" "
    This function takes the name of the folder as an input parameter,
    Returns the file path in the folder,
    And comprising a path to the file in the folder.

    "" "
    Supplementary code #
answer

def print_directory_contents (sPath):
    import os
    for sChild in os.listdir (sPath):
        sChildPath = os.path.join (sPath, sChild)
        if os.path.isdir (sChildPath):
            print_directory_contents (sChildPath)
        else:
            print sChildPath
With particular attention to the following points:

To unify naming conventions. If the sample code can be seen that the naming convention, in accordance with its existing norms.
Recursive function needs a recursive and terminates. Make sure you understand the principle, or else you will face endless call stack (callstack).
We use the os module interacts with the operating system, and can do interactive cross-platform. You can put the code written sChildPath = sPath + '/' + sChild, but this would be an error on a Windows system.
Familiar with the basic module is very valuable, but do not back down Xiangponaodai all, remember that Google is your job mentor.
If you do not understand the intended function of the code, the bold questions.
Adhere to the KISS principle! Keep it simple, but the brain can understand!
Why ask this question:

Interviewer to explain the basics of the operating system and interacting
Recursive really good friends with
Question 3

Read the following code to write the final value A0, A1 to An.

A0 = dict (zip (( 'a', 'b', 'c', 'd', 'e'), (1,2,3,4,5)))
A1 = range (10)
A2 = [i for i in A1 if i in A0]
A3 = [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]
answer

A0 = { 'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4}
A1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
A2 = []
A3 = [1, 3, 2, 5, 4]
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]]
Why ask this question:

List comprehension (list comprehension) out to save time, for many people is a big learning disabilities.
If you read the code, it may be possible to write correctly value.
Some of the code intentionally written strange. Because among the people you work with will have a weirdo.

Question 4

Python and multi-threaded (multi-threading). This is a good idea to code? Let listed some Python code running in parallel approach.

answer

Python does not support multi-threading in the true sense. Python provides a multi-threading package, but if you want to improve the speed of multi-threaded code, the use of multi-threading package is not a good idea. Python has a program called Global Interpreter Lock (GIL) things, it will ensure that any time you multiple threads, only one is executed. Thread execution speed is very fast, and you will mistake threads are executed in parallel, but in fact turns executed. After this hurdle GIL process will increase the cost of execution. This means that if you want to improve the speed of code, threading package is not a good way.

However, there are still many reasons prompted us to use threading package. If you want to perform a number of tasks simultaneously, and does not consider the efficiency, then the use of this package is not in question, but also very convenient. But in most cases, is not such a thing, you will want to outsource part of the multi-threaded operating system to complete (by opening multiple processes), or some call an external program of your Python code (such as Spark or hadoop), or is the other code of your Python code calls (for example, you can call C functions in Python, for a large multi-threaded processing overhead work).

Why ask this question

Because GIL is a darn thing (A-hole). Many people spend a lot of time trying to find their own multi-threaded code bottlenecks, until they understand that the presence of the GIL.

Question 5

How do you manage different versions of the code?

answer:

Version management! Asked this question, you should be very excited about the performance, they even tell you how to use Git (or your other favorite tool) to track correspondence and his own grandmother. I tend to use Git as a version control system (VCS), but there are other options, such as subversion (SVN).

Why ask this question:

Because no code version control, as there is no cup of coffee. Sometimes we need to write a one-time, can be discarded script, in which case it does not matter without version control. But if you are faced with a lot of code, use version control system is advantageous. Version control can help you track who did what code base operations; discover what the newly introduced bug; manage your different software versions and releases; sharing source code among team members; and other automated deployment process. It allows you to roll back to a problem with the previous version, this alone is particularly the bar. There are other good features. How a stick Zile!

Question 6

What the code below will output:

def f (x, l = []):
    for i in range (x):
        l.append (i * i)
    print l

f (2)
f (3, [3,2,1])
f (3)
answer:

[0, 1]
[3, 2, 1, 0, 1, 4]
[0, 1, 0, 1, 4]
Uh?

The first function call is very clear, for loop has the 0 and 1 was added to the empty list - l. l is the name of the variable, pointing to a list stored in memory. The second function call in a new memory created a new list. l At this point a new list that is generated. Beyond the new list after adding 0,1,2 and 4. Great bar. The third result of the function call a bit strange. It uses the old list before the memory address stored. That's why it's the first two elements are 0 and 1 up.

Do not understand, then I try to run the following code in it:

l_mem = []

l = l_mem # the first call
for i in range (2):
    l.append (i * i)

print l # [0, 1]

l = [3,2,1] # the second call
for i in range (3):
    l.append (i * i)

print l # [3, 2, 1, 0, 1, 4]

l = l_mem # the third call
for i in range (3):
    l.append (i * i)

print l # [0, 1, 0, 1, 4]
Question 7

"Monkey Patch" (monkey patching) refers to what? This practice right?

answer:

"Monkey patch" means, after the function or object has been defined, go back and change their behavior.

for example:

import datetime
datetime.datetime.now = lambda: datetime.datetime (2012, 12, 12)
In most cases, this is a kind of very good practice - because the behavior of the function in the code library preferably are consistent. Playing the "monkey patch" may be due to testing. mock package for this purpose helpful.

Why ask this question?

Answer this question shows that you're unit testing methods have a certain understanding. If you mentioned the need to avoid "monkey patch", you can show that you are not the kind of bells and whistles like the code programmer (the company had such people, working with them is bad enough), but more emphasis on maintainability. Remember the KISS principle code? This question also answer some of the ways to show that you understand the operation of the underlying Python function is actually how to store, call and so on.

Also: If you have not read mock module, it is really worth the time to read. This module is very useful.

Question 8

What is the meaning of these two parameters: * args, ** kwargs? Why should we use them?

answer

If we are not sure how many parameters to be passed to the function, or we want to function in the form of lists and tuples pass parameters, it makes use * args; if we do not know how many passed to the function a keyword arguments, or want the dictionary when values ​​passed as keyword arguments, it would have to use ** kwargs. args and kwargs two identifiers are acceptable usage, of course you can also use * bob and ** billy, but not quite so tall.

The following are specific examples:

def f (* args, ** kwargs): print args, kwargs

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

f ()
f (1,2,3) # (1, 2, 3) {}
f (1,2,3, "groovy") # (1, 2, 3, 'groovy') {}
f (a = 1, b = 2, c = 3) # () { 'a': 1, 'c': 3, 'b': 2}
f (a = 1, b = 2, c = 3, zzz = "hi") # () { 'a': 1, 'c': 3, 'b': 2, 'zzz': 'hi'}
f (1,2,3, a = 1, b = 2, c = 3) # (1, 2, 3) { 'a': 1, 'c': 3, 'b': 2}

f (* l, ** d) # (1, 2, 3) { 'a': 7, 'c': 9, 'b': 8}
f (* t, ** d) # (4, 5, 6) { 'a': 7, 'c': 9, 'b': 8}
f (1,2, * t) # (1, 2, 4, 5, 6) {}
f (q = "winning", ** d) # () { 'a': 7, 'q': 'winning', 'c': 9, 'b': 8}
f (1,2, * t, q = "winning", ** d) # (1, 2, 4, 5, 6) { 'a': 7, 'q': 'winning', 'c': 9, 'b': 8}

def f2 (arg1, arg2, * args, ** kwargs): print arg1, arg2, args, kwargs

f2 (1,2,3) # 1 2 (3,) {}
f2 (1,2,3, "groovy") # 1 2 (3, 'groovy') {}
f2 (arg1 = 1, arg2 = 2, c = 3) # 1 2 () { 'c': 3}
f2 (arg1 = 1, arg2 = 2, c = 3, zzz = "hi") # 1 2 () { 'c': 3, 'zzz': 'hi'}
f2 (1,2,3, a = 1, b = 2, c = 3) # 1 2 (3,) { 'a': 1, 'c': 3, 'b': 2}

f2 (* l, ** d) # 1 2 (3,) { 'a': 7, 'c': 9, 'b': 8}
f2 (* t, ** d) # 4 5 (6,) { 'a': 7, 'c': 9, 'b': 8}
f2 (1,2, * t) # 1 2 (4, 5, 6) {}
f2 (1,1, q = "winning", ** d) # 1 1 () { 'a': 7, 'q': 'winning', 'c': 9, 'b': 8}
f2 (1,2, * t, q = "winning", ** d) # 1 2 (4, 5, 6) { 'a': 7, 'q': 'winning', 'c': 9, 'b': 8}
Why ask this question?

Sometimes, we need to pass an unknown number of arguments or keyword arguments to the function. Sometimes, we also hope to parameters or keyword parameters stored, for later use. Sometimes, just to save time.

Question 9

Here what these are: @classmethod, @staticmethod, @property?

Answer Background

These are the decorator (decorator). Decorator is a special function that accepts either function as an input parameter and returns a function that accepts either a class as an input parameter and returns a class. @ Mark syntactic sugar (syntactic sugar), it allows you to have a simple way to read decorative audiences.

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

def my_func (stuff):
    do_things

my_func = my_decorator (my_func)
You can find presentation materials decorator works on this site.

The real answer

@classmethod, @staticmethod and three @property decorator is a function of the use of objects in the class definition. The following example shows their usage and behavior:

class MyClass (object):
    def __init __ (self):
        self._some_property = "properties are nice"
        self._some_other_property = "VERY nice"
    def normal_method (* args, ** kwargs):
        print "calling normal_method ({0}, {1})". format (args, kwargs)
    @classmethod
    def class_method (* args, ** kwargs):
        print "calling class_method ({0}, {1})". format (args, kwargs)
    @staticmethod
    def static_method (* args, ** kwargs):
        print "calling static_method ({0}, {1})". format (args, kwargs)
    @property
    def some_property (self, * args, ** kwargs):
        print "calling some_property getter ({0}, {1}, {2})". format (self, args, kwargs)
        return self._some_property
    @ Some_property.setter
    def some_property (self, * args, ** kwargs):
        print "calling some_property setter ({0}, {1}, {2})". format (self, args, kwargs)
        self._some_property = args [0]
    @property
    def some_other_property (self, * args, ** kwargs):
        print "calling some_other_property getter ({0}, {1}, {2})". format (self, args, kwargs)
        return self._some_other_property

o = MyClass ()
# Undecorated method or normal behavior, needs of the current class instance (self) as the first parameter.

o.normal_method
# >

o.normal_method ()
# Normal_method ((<__ main __. MyClass instance at 0x7fdd2537ea28>,), {})

o.normal_method (1,2, x = 3, y = 4)
# Normal_method ((<__ main __ MyClass instance at 0x7fdd2537ea28.>, 1, 2), { 'y': 4, 'x': 3})

The first parameter # class method is always the class

o.class_method
# >

o.class_method ()
# Class_method ((,), {})

o.class_method (1,2, x = 3, y = 4)
# Class_method ((, 1, 2), { 'y': 4, 'x': 3})

# Static method (static method) in addition to the incoming parameters when you call, no other parameters.

o.static_method
#

o.static_method ()
# Static_method ((), {})

o.static_method (1,2, x = 3, y = 4)
# Static_method ((1, 2), { 'y': 4, 'x': 3})

# @property Is a way to achieve getter and setter methods. Call them directly wrong.
# "Read only" attribute can define only getter method does not define setter methods.

o.some_property
# Some_property call the getter (<__ main __. MyClass instance at 0x7fb2b70877e8>, (), {})
# 'Properties are nice'
# "Property" is a good feature

o.some_property ()
# Calling some_property getter (<__ main __. MyClass instance at 0x7fb2b70877e8>, (), {})
# Traceback (most recent call last):
# File "", line 1, in
# TypeError: 'str' object is not callable

o.some_other_property
# Calling some_other_property getter (<__ main __. MyClass instance at 0x7fb2b70877e8>, (), {})
# 'VERY nice'

# O.some_other_property ()
# Calling some_other_property getter (<__ main __. MyClass instance at 0x7fb2b70877e8>, (), {})
# Traceback (most recent call last):
# File "", line 1, in
# TypeError: 'str' object is not callable

o.some_property = "groovy"
# Calling some_property setter (<__ main __. MyClass object at 0x7fb2b7077890>, ( 'groovy',), {})

o.some_property
# Calling some_property getter (<__ main __. MyClass object at 0x7fb2b7077890>, (), {})
# 'Groovy'

o.some_other_property = "very groovy"
# Traceback (most recent call last):
# File "", line 1, in
# AttributeError: can not set attribute

o.some_other_property
# Calling some_other_property getter (<__ main __. MyClass object at 0x7fb2b7077890>, (), {})

Question 10

Read the following code, what its output is?

class A (object):
    def go (self):
        print "go A go!"
    def stop (self):
        print "stop A stop!"
    def pause (self):
        raise Exception ( "Not Implemented")

class B (A):
    def go (self):
        super (B, self) .go ()
        print "go B go!"

class C (A):
    def go (self):
        super (C, self) .go ()
        print "go C go!"
    def stop (self):
        super (C, self) .stop ()
        print "stop C stop!"

class D (B, C):
    def go (self):
        super (D, self) .go ()
        print "go D go!"
    def stop (self):
        super (D, self) .stop ()
        print "stop D stop!"
    def pause (self):
        print "wait D wait!"

class E (B, C): pass

a = A ()
b = B ()
c = C ()
d = D ()
e = E ()

# Description The output of the following code

a.go ()
b.go ()
c.go ()
d.go ()
e.go ()

a.stop ()
b.stop ()
c.stop ()
d.stop ()
e.stop ()

a.pause ()
b.pause ()
c.pause ()
d.pause ()
e.pause ()
answer

The output in the form of comments, said:

a.go ()
# Go A go!

b.go ()
# Go A go!
# Go B go!

c.go ()
# Go A go!
# Go C go!

d.go ()
# Go A go!
# Go C go!
# Go B go!
# Go D go!

e.go ()
# Go A go!
# Go C go!
# Go B go!

a.stop ()
# Stop A stop!

b.stop ()
# Stop A stop!

c.stop ()
# Stop A stop!
# Stop C stop!

d.stop ()
# Stop A stop!
# Stop C stop!
# Stop D stop!

e.stop ()
# Stop A stop!

a.pause ()
# ... Exception: Not Implemented

b.pause ()
# ... Exception: Not Implemented

c.pause ()
# ... Exception: Not Implemented

d.pause ()
# Wait D wait!

e.pause ()
# ... Exception: Not Implemented
Why ask this question?

Because object-oriented programming really, really important. Do not lie to you. Answer these questions to show that you understand the usage and Python inherits the super function.

Question 11

Read the following code, what its output is?

class Node (object):
    def __init __ (self, sName):
        self._lChildren = []
        self.sName = sName
    def __repr __ (self):
        return "". format (self.sName)
    def append (self, * args, ** kwargs):
        self._lChildren.append (* args, ** kwargs)
    def print_all_1 (self):
        print self
        for oChild in self._lChildren:
            oChild.print_all_1 ()
    def print_all_2 (self):
        def gen (o):
            lAll = [o,]
            while lAll:
                oNext = lAll.pop (0)
                lAll.extend (oNext._lChildren)
                yield oNext
        for oNode in gen (self):
            print oNode

oRoot = Node ( "root")
oChild1 = Node ( "child1")
oChild2 = Node ( "child2")
oChild3 = Node ( "child3")
oChild4 = Node ( "child4")
oChild5 = Node ( "child5")
oChild6 = Node ( "child6")
oChild7 = Node ( "child7")
oChild8 = Node ( "child8")
oChild9 = Node ( "child9")
oChild10 = Node ( "child10")

oRoot.append (oChild1)
oRoot.append (oChild2)
oRoot.append (oChild3)
oChild1.append (oChild4)
oChild1.append (oChild5)
oChild2.append (oChild6)
oChild4.append (oChild7)
oChild3.append (oChild8)
oChild3.append (oChild9)
oChild6.append (oChild10)

# Description The output of the following code

oRoot.print_all_1 ()
oRoot.print_all_2 ()
answer

oRoot.print_all_1 () will print the following results:

< Node 'root' >
< Node 'child1' >
< Node 'child4' >
< Node 'child7' >
< Node 'child5' >
< Node 'child2' >
< Node 'child6' >
< Node 'child10' >
< Node 'child3' >
< Node 'child8' >
< Node 'child9' >
oRoot.print_all_1 () will print the following results:

< Node 'root' >
< Node 'child1' >
< Node 'child2' >
< Node 'child3' >
< Node 'child4' >
< Node 'child5' >
< Node 'child6' >
< Node 'child8' >
< Node 'child9' >
< Node 'child7' >
< Node 'child10' >
Why ask this question?

Because the essence of the object lies in the combination (composition) and the object constructor (object construction). Objects need to have a combination of Composition, and to initialize some way. Here also relates to a recursive and generator (generator) used.

Builder is a great data types. You can only by constructing a very long list, and then print the contents of the list, you can get similar functionality with print_all_2. Builder there is a benefit, not to need to occupy a lot of memory.

One thing also worth noting, that will print_all_1 depth priority (depth-first) way to traverse the tree (tree), and print_all_2 is breadth-first (width-first). Sometimes A way to traverse a more suitable than others. But this depends on the specific circumstances of your application.

Question 12

A brief description of Python's garbage collection (garbage collection).

answer

Here we can say a lot. You should mention the following main points:

Python is stored in memory for each object reference count (reference count). If the count value becomes zero, then the corresponding object will be hours allocated to the object's memory will be released is used by him.
Occasionally reference cycle (reference cycle). The garbage collector will periodically look for this cycle, and recycling. For example, suppose you have two objects o1 and o2, and in accordance with o1.x == o2 and o2.x == o1 these two conditions. If o1 and o2 no other code references, then they should not continue to exist. But their reference count is 1.
Python is used in some of the heuristics (heuristics) to accelerate the garbage collection. For example, the object is more likely to be created later recovered. After the object is created, the garbage collector will assign generations they belong (generation). Each object is assigned a generation younger generations are assigned priority object to be processed.

Question 13

The following functions are executed in accordance with the level of efficiency of the sort. They have received the list from the digital constitute between 0-1 as input. This list can be very long. Enter a list of examples as follows: [random.random () for i in range (100000)]. How do you prove your answer is correct.

def f1 (lIn):
    l1 = sorted (lIn)
    l2 = [i for i in l1 if i <0.5]
    return [i * i for i in l2]

def f2 (lIn):
    l1 = [i for i in lIn if i <0.5]
    l2 = sorted (l1)
    return [i * i for i in l2]

def f3 (lIn):
    l1 = [i * i for i in lIn]
    l2 = sorted (l1)
    return [i for i in l1 if i <(0.5 * 0.5)]
answer

Press the efficiency from highest to lowest: f2, f1 and f3. To prove that this answer is correct, you should know how to analyze the performance of their own code. Python has a very good program analysis package to meet this demand.

import cProfile
lIn = [random.random () for i in range (100000)]
cProfile.run ( 'f1 (lIn)')
cProfile.run ( 'f2 (lIn)')
cProfile.run ( 'f3 (lIn)')
To be fully described to you the following, we give an output result of the analysis of the code:

>>> CProfile.run ( 'f1 (lIn)')
         4 function calls in 0.045 seconds

   Ordered by: standard name

   ncalls tottime percall cumtime percall filename: lineno (function)
        1 0.009 0.009 0.044 0.044 : 1 (f1)
        1 0.001 0.001 0.045 0.045 : 1 ()
        1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
        1 0.035 0.035 0.035 0.035 {sorted}


>>> CProfile.run ( 'f2 (lIn)')
         4 function calls in 0.024 seconds

   Ordered by: standard name

   ncalls tottime percall cumtime percall filename: lineno (function)
        1 0.008 0.008 0.023 0.023 : 1 (f2)
        1 0.001 0.001 0.024 0.024 : 1 ()
        1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
        1 0.016 0.016 0.016 0.016 {sorted}


>>> CProfile.run ( 'f3 (lIn)')
         4 function calls in 0.055 seconds

   Ordered by: standard name

   ncalls tottime percall cumtime percall filename: lineno (function)
        1 0.016 0.016 0.054 0.054 : 1 (f3)
        1 0.001 0.001 0.055 0.055 : 1 ()
        1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
        1 0.038 0.038 0.038 0.038 {sorted}
Why ask this question?

Positioning and to avoid bottlenecks in the code is a very valuable skill. Many want to write efficient code, common sense will eventually be answered up - in the above example, if the list is small, it is obviously to be sorted quickly, so if you can first be screened before sorting, it usually is good practice. Other non-obvious problems can still be positioned by appropriate tools. Therefore, understanding these tools are good.

Question 14

Have you ever had the experience of failure it?

Wrong answer

I have never failed!

Why ask this question?

Properly answer the question that you used to admit mistakes, take responsibility for their mistakes and to learn from their mistakes. If you want to be helpful to others, then, all of which it is of particular importance. If you really are a perfect, it's too bad, answer this question you may have a bit of creativity.

Question 15

Have you been to implement a personal project?

Really?

If you have made a personal project, which shows the update from their skill levels, the effort you are willing to pay more than the minimum requirement. If you have to maintain a personal project outside of work also insisted on coding, then your employer you are more likely to be regarded as the value of assets. Even if they do not ask this question, I think to talk about this topic helpful.

Epilogue

When I give these issues deliberately involve a number of areas. And the answer is purposely written in a more long-winded. In the interview program, you need to demonstrate your understanding of language, if you can briefly say clearly, then please be sure to do so. I try to provide answers in enough information, even if you never understood before these areas, you can also learn something from the answers. I hope this article will help you find a satisfactory job.
     
         
       
         
  More:      
 
- grep command Series: How to Use the grep command in Linux / UNIX (Linux)
- C ++ based foundation: the difference between C and C ++ (Programming)
- How to set up HTTPS policies for older browsers (Server)
- After the first remote installation GlassFish Web to remotely access their back office management system error solution appears (Server)
- CentOS 6.x Basic System Optimization after installation (Linux)
- Linux learning portal: CentOS 6.4 system kernel upgrade (Linux)
- The YUM package management under Linux (Linux)
- ElasticSearch - Basic Concepts (Server)
- Efficient Linux Shell - Shell special characters Summary (Linux)
- MySQL script incremental backups (innobackupex) (Database)
- Using C ++ Container Templates in Shared Memory (Programming)
- Install Apache streaming media services on CentOS 6.4 (Server)
- OpenSIPS offline messaging feature set (Server)
- Java Annotation Comments (Programming)
- Correlation Analysis: FP-Growth algorithm (Programming)
- OGG-01496 OGG-01031 Error Resolution (Database)
- Android using SVG vector graphics to create cool animation effects (Programming)
- Vim useful plugin: EasyGrep (Linux)
- AngularJS notes --- Data Binding (Programming)
- Packages with Snort intrusion monitoring light (Linux)
     
           
     
  CopyRight 2002-2016 newfreesoft.com, All Rights Reserved.