hx计算机基础

参考：http://python.jobbole.com/82294/

　　　https://www.jianshu.com/p/aed6067eeac9

1. 操作系统基础题

1）在32位操作系统下，系统会为每个进程预留4GB内存空间，而某机器的物理内存可能只有2GB。请解释OS是如何处理这种”矛盾”的。

　　答：操作系统采用虚拟内存的方法以达到医用外存扩大内存的作用。

2）请解释进程和线程的区别 。

　　答：进程：操作系统进行资源分配的基本单位。一个进程可以包含多个线程，所有线程共享进程资源。

　　　　线程：CPU调度的基本单位。线程是轻量级的进程。它的创建和销毁比进程小的很多。

2.语法基础题：

1）请解释Python的变量作用域查找规则：

　　答：局部作用域  -->函数范围作用域）-->全局作用域--->内建对象作用域

 

2）请解释Python中generator的语法行为，并说明generator的适用场合。 

　　答：简单的生成器：把一个列表生成式[ ]变为( ) ，就变成一个generator。generator也是可迭代对象。

　　　　　　　　　　    我们可以一次性打印generator的内容，如果要一个一个打印，可以通过generator的next()方法：g.next()。这样太麻烦，一般直接通过for循环打印。

　　　　generator保存的是算法，每次调用next()，就计算出下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

 

　　　　带yield语句的生成器：如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator。

　　　　　　　　　　　　　　一般函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，                                                    再次执行时从上次返回的yield语句处继续执行。

3)请解释shallow-copy和deep-copy的区别，并用代码说明如何实现deep copy。

　　答：

对象赋值：

Python中，对象的赋值都是进行对象引用（内存地址）传递

 will = ["Will", , ["Python", "C#", "JavaScript"]]
 wilber = will
 print id(will)
 print will
 print [id(ele) for ele in will]
 print id(wilber)
 print wilber
 print [id(ele) for ele in wilber]

 will[] = "Wilber"
 will[].append("CSS")
 print id(will)
 print will
 print [id(ele) for ele in will]
 print id(wilber)
 print wilber
 print [id(ele) for ele in wilber]

这里需要注意的一点是，str是不可变类型，所以当修改的时候会替换旧的对象，产生一个新的地址39758496

浅拷贝：

 import copy

 will = ["Will", , ["Python", "C#", "JavaScript"]]
 wilber = copy.copy(will)

 print id(will)
 print will
 print [id(ele) for ele in will]
 print id(wilber)
 print wilber
 print [id(ele) for ele in wilber]

 will[] = "Wilber"
 will[].append("CSS")
 print id(will)
 print will
 print [id(ele) for ele in will]
 print id(wilber)
 print wilber
 print [id(ele) for ele in wilber]

浅拷贝会创建一个新的对象，这个例子中”wilber is not will”
但是，对于对象中的元素，浅拷贝就只会使用原始元素的引用（内存地址），也就是说”wilber[i] is will[i]”

由于list的第一个元素是不可变类型，所以will对应的list的第一个元素会使用一个新的对象39758496
但是list的第三个元素是一个可变类型，修改操作不会产生新的对象，所以will的修改结果会相应的反应到wilber上

总结一下，当我们使用下面的操作的时候，会产生浅拷贝的效果：

• 使用切片[:]操作
• 使用工厂函数（如list/dir/set）
• 使用copy模块中的copy()函数

深拷贝：

 import copy

 will = ["Will", 28, ["Python", "C#", "JavaScript"]]
 wilber = copy.deepcopy(will)

 print id(will)
 print will
 print [id(ele) for ele in will]
 print id(wilber)
 print wilber
 print [id(ele) for ele in wilber]

 will[0] = "Wilber"
 will[2].append("CSS")
 print id(will)
 print will
 print [id(ele) for ele in will]
 print id(wilber)
 print wilber

跟浅拷贝类似，深拷贝也会创建一个新的对象，这个例子中”wilber is not will”
但是，对于对象中的元素，深拷贝都会重新生成一份（有特殊情况，下面会说明），而不是简单的使用原始元素的引用（内存地址）
例子中will的第三个元素指向39737304，而wilber的第三个元素是一个全新的对象39773088，也就是说，”wilber[2] is not will[2]”

 

• 当对will进行修改的时候

由于list的第一个元素是不可变类型，所以will对应的list的第一个元素会使用一个新的对象39758496
但是list的第三个元素是一个可不类型，修改操作不会产生新的对象，但是由于”wilber[2] is not will[2]”，所以will的修改不会影响wilber

 

 

拷贝的特殊情况：

其实，对于拷贝有一些特殊情况：

• 对于非容器类型（如数字、字符串、和其他’原子’类型的对象）没有拷贝这一说

也就是说，对于这些类型，”obj is copy.copy(obj)” 、”obj is copy.deepcopy(obj)”

• 如果元祖变量只包含原子类型对象，则不能深拷贝，看下面的例子

 

 

总结

本文介绍了对象的赋值和拷贝，以及它们之间的差异：

• Python中对象的赋值都是进行对象引用（内存地址）传递
• 使用copy.copy()，可以进行对象的浅拷贝，它复制了对象，但对于对象中的元素，依然使用原始的引用.
• 如果需要复制一个容器对象，以及它里面的所有元素（包含元素的子元素），可以使用copy.deepcopy()进行深拷贝
• 对于非容器类型（如数字、字符串、和其他’原子’类型的对象）没有被拷贝一说
• 如果元祖变量只包含原子类型对象，则不能深拷贝。

3. 数据结构&算法基础题（3选1）
1）请实现一个双向列表的数据结构。并实现插入。

 #双向链表
 '节点类'
 class Node(object):
     def __init__(self,data = None):
         self.data = data
         self.pre = None
         self.next = None

 class Linklist(object):
     def __init__(self):
         self.head = None

     def is_Empty(self):
         return self.head==None

     def length(self):
         cur = self.head
         count = 0
         while cur != None:
             count += 1
             cur = cur.next
         return count
     #前面插节点
     def add(self,item):
         node = Node(item)
         if self.is_Empty():
             self.head = node

         else:
             node.next = self.head
             self.head.pre = node
             self.head = node
     #后面插节点
     def append(self,item):
         node = Node(item)
         if self.is_Empty():
             self.head = node

         else:
             cur = self.head
             while cur.next != None:
                 cur = cur.next
             cur.next = node
             node.pre = cur
     #查找
     def search(self,item):
         node = Node(item)

         cur = self.head
         while cur!= None:
             if cur.data == item:
                 return True
             cur = cur.next
         return False

     def insert(self,pos,item):
         """在指定位置添加节点"""
         if pos <= 0:
             self.add(item)
         elif pos > (self.length()-1):
             self.append(item)
         else:
             node = Node(item)
             cur = self.head
             count = 0
             while count < (pos-1) :
                 count += 1
                 cur = cur.next
             node.pre = cur
             node.next = cur.next
             cur.next.pre = node
             cur.next = node
     #移除某个元素
     def remove(self,item):

         if self.is_Empty():
             return
         else:
             cur = self.head
             if cur.item == item:        #第一个就是要找的
                 if cur.next == None:    #只有一个头结点
                     self.head = None
                 else:
                     cur.next.pre = None
                     self.head = cur.next
                 return
             while cur != None:
                 if cur.item == item:
                     cur.pre.next = cur.next
                     cur.next.pre = cur.pre
                     break

                 cur = cur.next

 4）请解释同步/异步、阻塞/非阻塞这几个网络编程中的常用概念 

答：

　　参考：https://www.jianshu.com/p/aed6067eeac9

 

　　有人也许会把阻塞调用和同步调用等同起来，实际上它们是不同的。

　　1.对于同步调用来说，很多时候当前线程可能还是激活的，只是从逻辑上当前函数没有返回而已，此时，这个线程可能也会处理其他的消息。

　　　　(a) 如果这个线程在等待当前函数返回时，仍在执行其他消息处理，那这种情况就叫做同步非阻塞；

　　　　b) 如果这个线程在等待当前函数返回时，没有执行其他消息处理，而是处于挂起等待状态，那这种情况就叫做同步阻塞；

2.对于阻塞调用来说，则当前线程就会被挂起等待当前函数返回；

5. 编程应用题
 
现有1份用户访问日志，文件名为access.log，每行记录包含3列数据（'\t'分割）：IP地址（点分格式的字符串）、URL（用户访问的URL链接）、时间戳（Unix Timestamp格式）。请实现如下数据处理需求。
备注：尽量写出可直接运行的源码，Java/C/Python均可。
1）统计该日志中所有URL的热度，并按热度降序输出TOP 5
2）统计今天凌晨3点至凌晨5点30分期间内，用户访问最频繁的5个URL（假设那段时间内的用户访问记录包含在access.log中）
3）把点分格式字符串表示的IP地址转换成其整数表示
4）如果文件太大导致单机无法直接处理，有哪些解决思路？

答：

1.

2.

3.

 ip2num = lambda x:sum([**j*int(i) for j,i in enumerate(x.split('.')[::-])])
 ip2num('192.168.0.1')
3232235521

4. 将文件分为若干个小文件

通过一个hash函数，将URL散列到不同的文件之中，字符串映射到整型数

通过哈希，根据余数将url分配到小文件中

　 统计每一个txt文件中的URL出现的频次，存入数组中

最后统计数组。