三、企业面试题

1.python新式类和经典类的区别？
a. 在python里凡是继承了object的类，都是新式类
b. Python3里只有新式类
c. Python2里面继承object的是新式类，没有写父类的是经典类
d. 经典类目前在Python里基本没有应用
e. 保持class与type的统一对新式类的实例执行a.class与type(a)的结果是一致的，对于旧式类来说就不
一样了。
f.对于多重继承的属性搜索顺序不一样新式类是采用广度优先搜索，旧式类采用深度优先搜索。

2.python中内置的数据结构有几种？
a. 整型 int、 长整型 long、浮点型 float、 复数 complex
b. 字符串 str、 列表 list、 元祖 tuple
c. 字典 dict 、 集合 set
d. Python3 中没有 long，只有无限精度的 int

3.python如何实现单例模式?请写出两种实现方式?

4.反转一个整数，例如-123—>-321

class Solution(object):
    def reverse(self,x):
        if -10<x<10:
            return x
        str_x = str(x)
        if str_x[0] !="-":
            str_x = str_x[::-1]
            x = int(str_x)
        else:
            str_x = str_x[1:][::-1]
            x = int(str_x)
            x = -x
        return x if -2147483648<x<2147483647 else 0
if __name__ == '__main__':
    s = Solution()
    reverse_int = s.reverse(-120)
    print(reverse_int)

知识点：
1.if else判断传入参数是正整数还是负整数
2.字符串切片方式，反转字符串[::-1]，输入参数若是负整数，则从索引1开始切片转换成正整数，再用[::-1]反转字符串
3.最后将字符串转换成int，最后转换成负整数
4.三目运算符用法：x if -2147483648exp1 if contion else exp2：
condition 是判断条件，exp1 和 exp2 是两个表达式。如果 condition 成立（结果为真），就执行 exp1，并把 exp1 的结果作为整个表达式的结果；如果 condition 不成立（结果为假），就执行 exp2，并把 exp2 的结果作为整个表达式的结果。

5.设计实现遍历目录与子目录，抓取.pyc文件

import os 
def get_files(dir,suffix): 
    res = [] 
    for root,dirs,files in os.walk(dir): 
        for filename in files: 
            name,suf = os.path.splitext(filename) 
            if suf == suffix: 
                res.append(os.path.join(root,filename)) 
    print(res) 
get_files("./",'.pyc')

知识点：
1.os.walk(top)方法遍历目录，top为所有遍历的目录的地址，也就是该方法的参数dir；遍历后返回的是一个三元组(root,dirs,files)
root 所指的是当前正在遍历的这个文件夹的本身的地址
dirs 是一个 list ，内容是该文件夹中所有的目录的名字(不包括子目录)
files 同样是 list , 内容是该文件夹中所有的文件(不包括子目录)
2.os.path.splitext(path)方法拆分文件，(文件名，后缀名)
例如：’E:\test\6.txt’ 会拆分成(‘E:\test\x06’, ‘.txt’)
3.参数suffix为后缀名，if suf == suffix，如果拆分的后缀名等于.pyc则往res列表里去加元素(os.path.join(root,filename)把路径拼接上)

import os 
def pick(obj): 
    if obj.endswith(".pyc"): 
        print(obj) 
def scan_path(ph): 
    file_list = os.listdir(ph) 
    for obj in file_list: 
        if os.path.isfile(obj): 
            pick(obj) 
        elif os.path.isdir(obj): 
            scan_path(obj) 
if __name__=='__main__': 
    path = input('输入目录') 
    scan_path(path)

知识点：
1.obj.endswith(“”)用于判断字符串是否以指定字符或字符串结尾，常用于判断文件类型
例如本题用法是判断是否为”.pyc”结尾
2.os.lisdir(path)，该方法返回一个列表，其中包含指定路径下的目录和文件的名称
3.os.path.isfile()，参数为绝对路径，判断对象是否为文件
4.os.path.isdir()，参数为绝对路径，判断对象是否为目录

6.一行代码实现1-100之和

count = sum(range(0, 101))
print(count)

7.Python-遍历列表时删除元素的正确做法

a = [1,2,3,4,5,6,7,8] 
print(id(a)) 
print(id(a[:])) 
for i in a[:]: 
    if i>5:
        ass 
    else:
        a.remove(i) 
        print(a) 
print('-----------') 
print(id(a))

8.可变类型与不可变类型
1.可变类型有list, dict不可变类型有string, number, tuple
2.当进行修改操作时，可变类型传递的是内存中的地址，也就是说，直接修改内存中的值，并没有开辟新的内存
3.当不可变类型被改变时，并没有改变原内存地址中的值，而是开辟一块新的内存，将原地址中的值复制过去，对这块新开辟的内存中的值进行操作。
9.is和==有什么区别？
is：比较的是两个对象的id值是否相等，也就是比较俩对象是否为同一个实例对象。是否指向同一个内
存地址
== ： 比较的两个对象的内容/值是否相等，默认会调用对象的eq()方法

10. 求出列表所有奇数并构造新列表

a = [1,2,3,4,5,6,7,8,9,10] 
res = [ i for i in a if i%2==1] 
print(res)

列表推岛式创建新列表，先遍历列表a，循环i%2==1，余数为1为奇数，最后打印新列表res
11.用一行python代码写出1+2+3+10248

print(sum[1,2,3,10248])

from functools import reduce 
num1 = reduce(lambda x,y :x+y,[1,2,3,10248])
print(num1)

reduce函数用法：
1.对列表中的所有元素执行function的进行累积计算，返回最终计算结果，reduce(function, iterable[, initializer])，function — 函数的引用；iterable — 列表或者可迭代对象
function参数是一个有两个参数的函数，reduce依次从iterable中取一个元素，和上一次调用function的结果做参数再次调用function。
第一次调用function时，如果提供initial参数，会以iterable中的第一个元素和initial作为参数调用function，否则会以序列iterable中的前两个元素做参数调用function。
12.Python中变量的作用域？（变量查找顺序)
函数作用域的LEGB顺序
1.什么是LEGB?
L： local 函数内部作用域
E: enclosing 函数内部与内嵌函数之间
G: global 全局作用域
B： build-in 内置作用
python在函数里面的查找分为4种，称之为LEGB，也正是按照这是顺序来查找的
13. python代码实现删除一个list里面的重复元素

def disFunc1(a):
    """使用集合去重"""
    a = list(set(a))
    print(a)
def disFun2(a):
    list = []
    for i in a:
        if i not in list:
            list.append(i)
    list.sort()
    print(list)
def disFun3(a):
    b = {}
    b = b.fromkeys(a)
    c = list(b.keys())
    print(c)
if __name__ == "__main__":
    a = [1,2,4,2,4,5,7,10,5,5,7,8,9,0,3] 
    disFun1(a) 
    disFun2(a) 
    disFun3(a)

知识点：
1.dict.fromkeys(seq[, value]) 以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值，若不传value，则value为None，且字典不支持重复键，该方法返回一个新字典。
2.c = list(b.keys())，取该字典中的key作为列表的元素。
14. 统计一个文本中单词频次最高的10个单词？

import re 
# 方法一 
def test(filepath): 
    distone = {} 
    with open(filepath) as f: 
        for line in f: 
            line = re.sub("\W+", " ", line) 
            lineone = line.split() 
            for keyone in lineone: 
                if not distone.get(keyone): 
                    distone[keyone] = 1 
                else:
                    distone[keyone] += 1 
    num_ten = sorted(distone.items(), key=lambda x:x[1], reverse=True)[:10] 
    num_ten =[x[0] for x in num_ten] 
    return num_ten

15.请写出一个函数满足以下条件
该函数的输入是一个仅包含数字的list,输出一个新的list，其中每一个元素要满足以下条件：
1、该元素是偶数
2、该元素在原list中是在偶数的位置(index是偶数)

def capper(list_one):
    return [i for i in list_one if i%2 == 0 and list_one.index(i)%2 == 0]
list_one = [0,1,2,3,4,5,6,7,8,9,10]
list_two = capper(list_one)
print(list_two)
n_list = [0,1,2,3,4,5,6,7,8,9,10]
def saber(n_list):
    m_list = []
    for i in n_list:
        if i % 2 == 0 and n_list.index(i) % 2 == 0:
            m_list.append(i)
            #return m_list
    print(m_list)
if __name__ == '__main__':
    saber(n_list)

1.index是偶数，利用列表的index方法得出元素的索引，list_one.index(i)
19.使用单一的列表生成式生成一个新的列表
该列表只包含满足以下条件的值，元素为原始列表中偶数切片

list_data = [1,2,5,8,10,3,18,6,20] 
res = [x for x in list_data[::2] if x % 2 == 0] 
print(res)

20.用一行代码生成 [1,4,9,16,25,36,49,64,81,100]

[x * x for x in range(1, 11)]

21.输入某年某月某日，判断这一天是这一年的第几天？

import datetime 
y = int(input("请输入4位数字的年份:")) 
m = int(input("请输入月份:")) 
d = int(input("请输入是哪一天")) 
targetDay = datetime.date(y,m,d) 
dayCount = targetDay - datetime.date(targetDay.year -1,12,31) 
print("%s是 %s年的第%s天。"%(targetDay,y,dayCount.days))

22. 两个有序列表，l1,l2，对这两个列表进行合并不可使用extend

def loop_merge_sort(l1, l2):
    tmp = []   #构造一个的新的列表
    while len(l1) > 0 and len(l2) > 0:
        if l1[0] < l2[0]:        #循环每次比较第一个元素
            tmp.append(l1[0])    #tmp添加元素
            del l1[0]            #l1删除一个，原有的元素自动向前移动一位
        else:
            tmp.append(l2[0])
            del l2[0]
    while len(l1) > 0:    #最后会剩下两个元素，参数是不固定的，所以不知道会剩下l1还是l2
        tmp.append(l1[0]) #需要再判断一下l1和l2的长度，接着把剩下的元素添加进去，最后返回新列表
        del l1[0]
    while len(l2) > 0:
        tmp.append(l2[0])
        del l2[0]
    return tmp
if __name__ == '__main__':
    L1=[23, 45, 67, 77, 78, 80, 90]
    L2=[4, 11, 26, 33, 42, 61, 80]
    new_list=loop_merge_sort(L1, L2)
    print(new_list)

L1=[23,45,67,77,78,80,90]
L2=[4,11,26,33,42,61,80]
L1.extend(L2)  #extend()是在另一个列表的尾部追加新的元素
print(L1)

23. 写一个函数找出一个整数数组中，第二大的数

def find_second_large_num(num_list): 
""" 找出数组第2大的数字 """ 
# 方法一 # 直接排序，输出倒数第二个数即可 
tmp_list = sorted(num_list) 
print("方法一\nSecond_large_num is :", tmp_list[-2])

24. 阅读一下代码他们的输出结果是什么？

def multi(): 
    return [lambda x : i*x for i in range(4)] 
print([m(3) for m in multi()])

解析：
正确答案是[9,9,9,9]，而不是[0,3,6,9]产生的原因是Python的闭包的后期绑定导致的，这意味着在闭包
中的变量是在内部函数被调用的时候被查找的，因为，最后函数被调用的时候，for循环已经完成, i 的
值最后是3,因此每一个返回值的i都是3,所以最后的结果是[9,9,9,9]
25. 统计一段字符串中字符出现的次数

def count_str(str_data): 
    """定义一个字符出现次数的函数""" 
    dict_str = {} 
    for i in str_data: 
        dict_str[i] = dict_str.get(i, 0) + 1 
        return dict_str 
    dict_str = count_str("AAABBCCAC") 
    str_count_data = "" 
    for k, v in dict_str.items(): 
        str_count_data += k + str(v) 
        print(str_count_data)