面试题汇总(一)

1.有一个整数列表，对于每一个键值，计算除它本身之外的其余的数的乘积，编写一个函数，get_product_at_index()，输入一个整数数组并返回一个乘积列表。例如，给你：[1, 7, 3, 4]，你将得到返回：[84, 13, 28, 21]，由于[7* 3 *4, 1 * 3 * 4, 1 * 7 * 4, 1 * 7 * 3]

# 不使用除法
def get_product_at_index(nums):
    output = []
    out = 1
    for i in range(len(nums)):
        if i == 0:
            output.append(1)
        else:
            out = out * nums[i-1]
            output.append(out)
    middle = 1
    for i in range(len(nums)-1, -1, -1):
        output[i] = output[i] * middle
        middle = middle * nums[i]
    return output 
​
# 使用除法
def abc(nums):
    a = 1
    for i in nums:
        a*=i
    output = [int(a/i) for i in nums]
    return output

2.假如你知道明天久其公司的股票状况，股票的价格经过一个整数数组提供，表示的是每一个时间段的股价。请编写一个程序，计算当只进行一次买入和卖出股票操做，可以得到最大利益。

例如：

stork_price = [10, 7, 5, 8, 11, 9]

get_max_profit(stork_price)

你将得到返回：6

由于你在5元的时候买入，在11元的时候卖出

注意，你必须先买入以后才能卖出。并且你不能再同一时间买入卖出操做

def maxProfit(prices):
    if not prices:
        return 0
    len_prices = len(prices)
    buy1, sell1, buy2, sell2 = -prices[0], 0, -prices[0], 0
    
​
    for i in range(1, len_prices):
        buy1 = max(buy1, -prices[i])
        sell1 = max(sell1, buy1 + prices[i])
        buy2 = max(buy2, sell1 - prices[i])
        sell2 = max(sell2, buy2 + prices[i])
    return sell2

3.假设存在个已知列表aDict，由整数映射组成，编写一个函数，返回一个KeyList，List中的Key在aDict中映射Value为惟一值。返回的List应按递增顺序排序。

例如aDict = {

1 : 'a',

2 : 'a',

3 : 'c'

}

uniqueValues(aDict) = [3]

 

def a(dict):
    result = []
    for key in dict.keys():
        result.append(key)
        result.append(dict[key])
    return result

 

4.使用递归，实现符合如下规范的功能：

max_val((5, [1, 2], [[1, 3, 2, 4], 1])) return 5

max_val([5, [1, 2], [[1],[9]]]) return 9

def max_value(ls, rs):
    for l in ls:
        if type(l) == list:
            rs = max_value(l, rs)
            continue
        if l > rs:
            rs = l
    return rs
​
# 调用
max_value((5, [1, 2], [[1, 3, 2, 4], 1]), 0)

 

5.手写冒泡排序

a = [1, 34432, 54, 6, 56, 54, 7, 65, 7, 58, 76, 8, 67, 8, 35, 32, 5432, 4, 32, 432, 0]
for i in range(len(a) - 1):
    flag = 0
    for j in range(len(a) - 1 - i):
        flag = 1
        if a[j] > a[j + 1]:
            a[j], a[j + 1] = a[j + 1], a[j]
    if flag == 0:
        break

 

6.写出代码的输出结果

def f1(a):
    a = 1
def f2(a):
    a = [10]
def f3(a):
    a.append(2)
aa = 0
f1(aa)
print(aa)   # 输出结果为：0
bb = [1]
f2(bb)
print(bb)   # 输出结果为：[1]
cc = [1]
f3(cc)
print(cc)   # 输出结果为：[1,2]

七、写出代码的输出结果

alist = [1, 2, 3, ['a', 'b']]
b = alist
alist[3].append('c')
print(alist) #输出结果为：[1, 2, 3, ['a', 'b', 'c']]
print(b)     #输出结果为：[1, 2, 3, ['a', 'b', 'c']]

八、写出代码的输出结果

import copy
​
alist = [1, 2, 3, ['a', 'b']]
c = copy.copy(alist)
alist.append(4)
alist[3].append('c')
print(c)    #输出结果为：[1, 2, 3, ['a', 'b', 'c']]
print(alist)    #输出结果为：[1, 2, 3, ['a', 'b', 'c'], 4]

九、写出代码的输出结果

import copy
​
alist = [1, 2, 3, ['a', 'b', 'c']]
c = copy.deepcopy(alist)
alist.append(4)
alist[3].append('d')
print(c)  #输出结果为：[1, 2, 3, ['a', 'b', 'c']]
print(alist)     #输出结果为：[1, 2, 3, ['a', 'b', 'c', 'd'], 4]

十、*arg和**dwarg做为参数的区别

# 在python中，这两个是python中的可变参数，*arg表示任意多个无名参数，类型为tuple，**kwargs表示关键字参数，为dict

十一、filter、map、reduce函数的做用，每一个举一例

filter(function, sequence)：对sequence中的item依次执行function(item)，将执行结果为True的item组成一个List/String/Tuple（取决于sequence的类型）。 filter(function or None, sequence) -> list, tuple, or string：入参为函数和列表/元组/字符串，返回值为item列表/元组/字符串。 map(function, sequence) ：对sequence中的item依次执行function(item)，将执行结果function(item)组成一个List返回。 map(function, sequence[, sequence, ...]) -> list：入参是为函数和列表/元组/字符串，返回值为function(item)列表。 reduce(function, sequence, starting_value)：对sequence中的item顺序迭代调用function，若是有starting_value，还能够做为初始值调用。function接收的参数个数只能为2，先把sequence中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给function，而后只返回一个结果。 reduce(function, sequence[, initial]) -> value：入参是为函数和列表/元组/字符串和初始值，返回值为数值。

#2.filter用法:返回执行结果为TRUE的入参（入参是列表字符元组）
print filter(lambda x:x*x-4,range(10))
#结果：[0, 1, 3, 4, 5, 6, 7, 8, 9]
​
#3.map的用法：对列表入参依次执行函数。入参为列表，有多少个列表，就应该有多少个入参。
print map(lambda x:x*x-4,range(10))
#结果：[-4, -3, 0, 5, 12, 21, 32, 45, 60, 77]
print map(lambda x,y:x*y-4,range(3),[8,9,10])
#结果：[-4, 5, 16]
​
#4.reduce用法：先把sequence中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给fuction,最终返回一个结果值
#接收的入参个数只能为2
print reduce(lambda x,y:x*y-4,range(4))
#结果：-40
#计算0到100的和
print reduce(lambda x,y:x+y, range(101))
#结果：5050
print reduce(lambda x,y:x+y, range(101),100)
#结果：5150

十二、写一个父类和子类，有初始化函数，有销毁函数，有子类继承父类的函数便可

class Pre:
    def __init__(self,name,sex):
    self.name = name
    self.sex = sex
        
    def __del__(self):
        print('对象:{}已被删除'.format(self.name))
​
        
class Stu(Pre):
    def __init__(self, name, sex, age):
        super().__init__(name, sex)
        self.age = age

1三、班级表class(id,name),学生表student(id,name,classid,score)

(1) 写SQL语句建立表

CREATE TABLE `class` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(255) NOT NULL,
 PRIMARY KEY (`id`)
);
CREATE TABLE `student` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(255) NOT NULL,
 `classid` int(11) NOT NULL,
 `score` varchar(255) NOT NULL,
 PRIMARY KEY (`id`),
 KEY `keys()` (`classid`),
 CONSTRAINT `keys()` FOREIGN KEY (`classid`) REFERENCES `class` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
);

(2)写SQL语句，插入2个班级，2个学生

INSERT INTO class VALUES(1, 1001),(2, 1002);
INSERT INTO student VALUES(1, '张三', 1, 100),(2, "李四", 2, 99);

(3)写SQL语句:分组查询每一个班级的平均分，并按降序排序，输出，班级编号，班级名，平均分数

SELECT class.id,class.name,avg(student.score) FROM class,student WHERE class.id=student.classid GROUP BY class.id;

###Sqlalchemy的ORM相关

(1) 用Sqlalchemy写出多条件查询(A=1 and B=2) or (C=3)代码

from django.db.models import Q
​
Sqlalchemy.objects.filter((Q(A=1) & Q(B=2)) | Q(C=3))

(2)用Sqlalchemy写出table1和table2表关联, 而且有条件table1.A=table2.B代码

models.ForeignKey(table2, models.CASCADE)

 

 

1四、@classmethod,@staticmethod有什么区别？什么状况下用@classmethod,什么状况下用@staticmethod？

• @staticmethod不须要表示自身对象的self和自身类的cls参数，就跟使用函数同样。

• @classmethod也不须要self参数，但第一个参数须要是表示自身类的cls参数。

 

1五、dict的items() 方法与iteritems() 方法的不一样？

字典的items方法做用：是能够将字典中的全部项，以列表方式返回。由于字典是无序的，因此用items方法返回字典的全部项，也是没有顺序的。

字典的iteritems方法做用：与items方法相比做用大体相同，只是它的返回值不是列表，而是一个迭代器。

（1）在Python2.x中，iteritems() 用于返回自己字典列表操做后的迭代器【Returns an iterator on all items(key/value pairs) 】，不占用额外的内存。

（2）在Python 3.x 里面，iteritems()方法已经废除了。在3.x里用 items()替换iteritems() ，能够用于 for 来循环遍历。

 

1六、什么是lambda函数？下面这段代码输出是什么？

nums = range(2,20)
for i in nums:
    nums = filter(lambda x:x==i or x % i, nums)
print(nums)
# <filter object at 0x00000163EA643EB8>

（一）什么是lambda函数：

Python支持一种有趣的语法，它容许你快速定义单行的最小函数。这些叫作lambda的函数是从Lisp中借用来的，能够被用在任何须要函数的地方。

lambda 函数是一个能够接收任意多个参数（包括可选参数）而且返回单个表达式值的匿名函数。 （注意：lambda 函数不能包含命令，它们所包含的表达式也不能超过一个）

（二）使用lambda函数的好处：

一、lambda函数比较轻便，即用即扔，很适合须要完成某一项简单功能，可是这个简单的功能只在此一处使用，连名字都很随意的状况下；

二、lambda是匿名函数，通常用来给filter，map，reduce这样的函数式编程服务；（具体使用请参考本人的上一篇博文：http://www.javashuo.com/article/p-ycwwpapr-bt.html）

三、做为回调函数，能够传递给某些应用，好比消息处理等。

 

思考题：

一、对于多线程编程的理解，对于CPU密集型和IO密集型怎样使用多线程，说说线程池，线程锁的用法。

一）、对于多线程编程的理解：

1. 简单区分程序、进程和线程

程序是指一段静态的代码

进程是指正在执行的程序，将静态的代码运行起来

线程是指正在执行程序的小单元

---

2. 理解进程

理解线程以前，先简单理解一下进程。进程的三大特征：独立性、动态性、并发性。

独立性：指进程是系统中独立存在的实体，拥有独立的资源（eg：私有的地址空间）。

动态性：这是相对于程序而言的，程序是一段静态的代码，而进程是活动的，拥有本身的生命周期。

并发性：多个进程能够在单个处理器上并发执行，互不影响。

仍是上面那栗子，这个班级就是一个进程，他是一个总体，他拥有本身的教室，有本身的班级名字，这里能够体现出独立性。这个班级的全体人员按照的任务清单干活，直至把教室打扫干净（即完成任务），这里能够体现出动态性。并发性呢，首先这个班级不仅有一个，还有好多其余的班级，他们也能够打扫他们本身的教室，互不影响。

---

3. 理解线程

线程是进程的执行单元，在程序中，线程是独立的、并发的执行流。

线程的特色：

1. 每一个线程有本身的堆栈，本身程序计数器，本身的局部变量，这里体现了线程的独立性。

2. 相同父进程下的全部线程共享进程独立的内存单元（eg：代码段、进程的共有数据），为此能够实现线程间的相互通讯。

3. 多个线程之间也能够并发执行，互不影响。

---

4. 多线程 VS 多进程

5. 线程之间能够共享内存，而进程之间不能够。

6. 系统建立线程代价比较小，并且多线程是实现多任务并发比多进程的效率更高。

二）、CPU密集型和IO密集型怎样使用多线程

一个计算为主的程序（专业一点称为CPU密集型程序）。多线程跑的时候，能够充分利用起全部的cpu核心，好比说4个核心的cpu,开4个线程的时候，能够同时跑4个线程的运算任务，此时是最大效率。

可是若是线程远远超出cpu核心数量 反而会使得任务效率降低，由于频繁的切换线程也是要消耗时间的。

所以对于cpu密集型的任务来讲，线程数等于cpu数是最好的了。

若是是一个磁盘或网络为主的程序（IO密集型）。一个线程处在IO等待的时候，另外一个线程还能够在CPU里面跑，有时候CPU闲着没事干，全部的线程都在等着IO，这时候他们就是同时的了，而单线程的话此时仍是在一个一个等待的。咱们都知道IO的速度比起CPU来是慢到使人发指的。因此开多线程，比方说多线程网络传输，多线程往不一样的目录写文件，等等。

此时 线程数等于IO任务数是最佳的。

三）、线程池，线程锁的用法

 

二、若是有一个订单系统，包含订单信息，商品信息，价格信息，而且要维护一些状态，在设计系统时，你会提供哪些建议？

 

三、秒杀程序设计，大并发下如何不会超卖？

一）：加入队列，集中处理

二）：

前端：页面静态化，禁止重复提交。

• 页面静态化：将前端能够静态的资源静态化。

• 禁止重复提交：秒杀开始以后，能够对用户点击后响应前按钮置灰。

后端：可拓展，缓存，限流，削峰，异步处理

• 可拓展：服务的可扩展，能够水平添加机器将用户请求分担到不一样的机器上去。数据库可扩展，支持分库分表，对于用户的请求，映射到不一样的数据库，减小单台数据库的压力。

• 内存缓存：参加秒杀系统的商品是事先可知的，能够将参加秒杀的商品信息事先缓存到redis等缓存系统中，这样能够大大的提升系统的吞吐量，减小关系型数据库的读写压力。

• 限流： 一单秒杀开始，实际秒杀成功的用户只是库存的数量，在库存没有以后，将前端的秒杀入口关闭。

• 削峰：数据库削峰。对于秒杀系统瞬时会有大量用户涌入，因此在抢购一开始会有很高的瞬间峰值。对于关系型数据库而言，这个是致命的，是压垮系统很重要的缘由，因此如何把瞬间的高流量变成一段时间平稳的流量也是设计秒杀系统很重要的思路。实现削峰的经常使用的方法有利用缓存和消息中间件等技术。

• 异步处理：秒杀系统是一个高并发系统，采用异步处理模式能够极大地提升系统并发量，其实异步处理就是削峰的一种实现方式。