基础面试题day01

1.简述了解的编程语言及语言间的区别

1. python，go语言，二者的区别在于python是动态解释类的语言，而go是静态解释类型的语言，python在处理作用域的时候用的是缩进，而go对缩进并不敏感，使用的是像C语言的花括号

2.列举python2，python3的区别、

1. python3支持Unicode字符，python2使用的是ASCII编码，使得python2中的string有str和Unioncode两种形式
2. python2中有老式类和新式类的概念，而python3中只有新式类
3. python2 的不等于<>变成了!=
4. python中的xrange被弃用，python3中使用range

3.看代码写结果

逻辑运算符优先级()>not>and>or

True or 表达式 => True
False and 表达式 => False
这种情况被称为逻辑短路，因为and 全真则真,一假则假，or 一真则真,全假则假

v1 = 1 or 2
v2 = 3 and 7 or 9 and 0

v1 = 1
v2 = 7

数据类型:
Number(int , float , complex , bool)
容器:str list tuple set dict

复数 : 用在数据分析,人工智能中

complexvar = 3 + 4j
3 : 实数
4j: 虚数
j: 如果有一个数,他的平方等于-1 ,那么这个数就是j,科学家认为有,表达高精度类型

4.比较以下值有什么不同

v1 = [1,2,3] #列表中的元素均为int
v2 = [(1),(2),(3)] #列表中的元素均为int
v3 = [(1,),(2,),(3,)] #列表中的元素均为tuple

5.用一行代码实现数值交换

#非通用方式
a = 1
b = 2
a,b = b,a
#通用方式
tmp = a
a = b
b = tmp

6.python中单引号双引号和三引号的标记

• 单双引号标记的都是字符串
• 三引号标记的是多行注释

7.is和==的区别

1. ==判断的是值相等
2. is判断的是地址是否相同

8.python如何实现tuple和list的转化

1. 使用list函数进行转换

tp1 = (1,2,3,4,5)
lst = list(tp1)

2. 可以遍历tuple向list中添加元素

tp1 = (1,2,3,4,5)
lst = []
for i in tp1:
    lst.append(i)

9.如何实现字符串name='老男孩'的反转

name='老男孩'

anti_name = name[::-1]

10.两个set如何求交集并集和差集

set1 & set2 交集
set1 | set2 并集
set1 - set2 差集

11.哪些情况下,y!=x-(x-y)

x,y是两个非空集合且不为父子关系

12. Python中如何拷贝一个对象？

import copy
lst=[1,2,3,4,[1,2]]

# 复制列表lst,命名lst2
lst2 = lst1[:]

lst2=copy.copy(lst)
print(f'这是lst3:{lst2}')

# 深拷贝
lst3=copy.deepcopy(lst)
print(f'这是lst3:{lst3}')

13. 简述 赋值、浅拷贝、深拷贝的区别？

    • 赋值：将a 的引用 复制一份给 b 两个引用指向同一个内存地址

    • copy.copy 浅拷贝，只拷贝第一级里所有的元素 copy.copy

    • copy.deepcopy 深拷贝，为所有层级的元素都单独开辟新空间
      (地址:原不可变数据只是暂时的指向,可变的数据独立开辟新空间)

14. pass的作用？

    • 占位，什么都不做

15. 阅读代码写结果。

    import copy
    a = [1,2,4,5,['b','c']]
    b = a
    c = copy.copy(a)
    d = copy.deepcopy(a)
    
    a.append(5)
    a[4].append('d')
    
    print(b)
    print(c)
    print(a)
    
    b = [1,2,4,5,['b','c','d'],5]
    c = [1,2,4,5,['b','c','d']]
    a = [1,2,4,5,['b','c','d'],5]
    

16. 用Python实现9 * 9 乘法表。

for i in range(1,10):
    for j in range(1,i+1):
        print(f'{i}*{j}={i*j}',end=' ')
    print(' ')

while i<= 9:
    j = 1
    while j <= i:
        print(f'{i}*{j}={i*j}',end=' ')
        j += 1
    print(' ')
    i+=1

17. 用Python显示一个斐波那契数列。

def fib(n):
    # 第一位和第二位都是1
    if n == 1 or n == 2:
        return 1
    else:
        # 从第三位开始  返回上一个数加上上一个数
        return func(n-1) + func(n-2)
        
res = func(20)
print(res)

lst = [1,1]
for i in range(10):
	lst.append(lst[-1] + lst[-2])
print(lst)

a,b = 0,1
for i in range(10):
	print(b)
	a,b = b,a+b

18. 如何删除列表中重复的值？

lst = [1,1,2,2,3,4]
lst2 = list(set(lst))

lst3 = []
for i in lst:
    if i not in lst3:
        lst3.append(i)
print(lst2,lst3)

19. 一个大小为100G的文件etl_log.txt, 要读取文件中的内容, 写出具体过程代码？

def read_file(file_path)
    file_block = 1024
    with open(file_path,'r',encoding='utf-8') as f
        while True：
            block = f.read(file_block)
        if block:
            yield block
        else:
            return
file_path = '../et1_log.txt'
for content in read_file(file_path)
    print(content)

20. a = dict(zip(("a","b","c","d","e"),(1,2,3,4,5))) 请问a是什么？

a = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

#强转字典的条件:等长的二级容器,配合强转字典的两个函数 zip , enumerate

a = dict( enumerate( ["a","b"] ,start = 10 ))
print(a)

21. lambda关键字的作用？

    • lambda就是用来定义一个匿名函数，实现一些不复杂的功能
    • lambda 参数 : 返回值

22. *arg和**kwarg作用?

    • *arg 为动态位置参数，用于接收多个默认参数
    • **kwargs 为动态关键字参数，用于接收多个关键字参数

23. 如何在函数中设置一个全局变量 ?

    • 使用global 关键字,有该全局变量,修改当前变量,没有改全局变量,定义一个全局变量

24. filter、map、reduce的作用？

    • map是用同样方法把所有数据都改成别的..字面意思是映射..比如把列表的每个数都换成其平方.

    • reduce是用某种方法依次把所有数据丢进去最后得到一个结果..字面意思是化简..比如计算一个列表所有数的和的过程,就是维持一个部分和然后依次把每个数加进去..

    • filter是筛选出其中满足某个条件的那些数据..字面意思是过滤..比如挑出列表中所有奇数..

    # map -> 处理(映射)数据
    map(func,iterable) => #返回迭代器
    
    lst = [1,2,3]
    it = map(lambda x : x*3 , lst)
    print(list(it))
    
    # reduce -> 计算数据
    from functools import reduce
    # reduce(func,iterable) => 最后计算的值
    # [5,4,8,8] => 5488
    lst = [5,4,8,8]
    res = reduce(lambda x,y : x*10 + y ,lst )
    print(res , type(res))
    
    #三目(元)运算符  True   if 条件表达式 else False
    '''
    filter => 过滤数据
    iterable : 可迭代对象(range ,容器类型数据 , 迭代器)
    filter(func,iterable)  => 返回迭代器
    '''
    
    
    lst = [1,2,3,4,5]
    it = filter(lambda x : True   if x % 2 == 0 else False , lst )
    print(list(it))
    
    

25. 什么是匿名函数？匿名函数有什么作用？

    • 以关键字lambda声明的函数
    • 用于简化代码
    • 可以作为函数的参数

26. Python递归的最大层数？

    • 大概是970-998

    import sys
    sys.setrecursionlimit(999999) # 修改递归的最大深度
    

27. 什么是迭代器？什么是可迭代对象？

    • 具有__iter__() 和 next()这两个方法的是迭代器
    • 具有__iter__()方法就是可迭代对象
    • dir(数据) 可以查看该数据的内部系统成员
    • 可迭代对象 => 迭代器 把不能直接被next获取 => 可直接获取到该数据的一个过程

28. 什么是生成器？

    • 生成器的本质就是迭代器,可以自定义迭代的逻辑
      创建方式两种:
      1. 生成器表达式 (推导式) (i for i in range(3))
      2. 生成器函数 (含有yield关键字)

29. 什么是装饰器及应用场景？

    • 装饰器本身是一个闭包，可以在不修改原有代码的情况下增加新的功能
    • 应用：
      • 计算程序执行时间
      • 判断权限
      • 添加日志
      • property类,框架(django,flask,@app.route("/",methdos=["GET","POST"]))

30. 什么是反射及应用场景？

    • 反射就是用字符串操类对象，或者模块中的方法
    • hasattr getattr setattr delattr
    • 可以配合用户的操作或者输入,调用其中的成员,api接口中

31. 写一个普通的装饰器。

def wapper(func):
    print('我wapper执行')
    def inner(*args,**kwargs):
        print('inner被执行')
        func(*args,**kwargs)
    return inner

@wapper
def func(*args,**kwargs):
    print('我func被执行了')
func()

32. 写一个带参数的装饰器。

import time
def time_logger(flag = 0):
    def showtime(func):
        def wrapper(a, b):
            start_time = time.time()
            func(a,b)
            end_time = time.time()
            print('spend is {}'.format(end_time - start_time))
            
            if flag:
                print('将此操作保留至日志')
 
        return wrapper
 
    return showtime
 
@time_logger(2)  
def add(a, b):
    print(a+b)
    time.sleep(1)

add(1,2)

33. 求结果

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

[6, 6, 6, 6]

"""
def出现的位置是函数的定义处
函数() 出现的位置是函数的调用处
(1)调用的时候,才会把函数中的代码,从上到下执行一遍,否则不执行
(2)里面的func是一个闭包函数,延长了当前变量i的生命周期,最后一次i的值3,所以再去调用时候拿的3
"""

34. def(a, b=[])这种写法有什么陷阱？

    • b身上的默认值是列表,如果使用原来默认的参数,调用func函数
      会把几次调用的值都存放在同一个默认列表里

    • 默认参数:

      • 如果调用时,用户给实参了,那么使用用户的
      • 如果调用时,用户没给实参,那么使用默认的(早已存在内存中的这个列表)

    • 默认值会提前在内存中驻留,在使用时,才能调取,在定义函数的时候就提前开辟了空间

35. 看代码写结果

def func(a,b=[]):
b.append(a)
return b

v1 = func(1)
v2 = func(2,[10,20])
v3 = func(3)
print(v1,v2,v3)

v1 = [1,3]
v2 = [10,20,3]
v3 = [1,3]

36. 看代码写结果

def func(a,b=[]):
    b.append(a)
    return b

v1 = func(1)
print(v1)
v2 = func(2,[10,20])
print(v2)
v3 = func(3)
print(v3)
v1 = [1]
v2 = [10,20,3]
v3 = [1,3]

37. 请编写一个函数实现将IP地址转换成一个整数。

"""
如 10.3.9.12 转换规则为：
        10           00001010
        3            00000011
        9            00001001
        12           00001100
        
再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？
"""
# ljust   原字符串居左,填充符号
# rjust   原字符串居右,填充符号
# 方法一
ip = "10.3.9.12"
strvar = ""
for i in ip.split("."):
	bin_str = str(bin(int(i)))[2:]
	# 总长度是8 原字符串居右
	strvar += bin_str.rjust(8,"0")
print(strvar)
	
# 把二进制字符串转换成十进制,默认转换时,是十进制
print(int(strvar,2))

# 方法二
ip = "10.3.9.12"
strvar = ""
for i in ip.split("."):
	# format 将整型转化成二进制,不够8位的拿0补位
	strvar += format(int(i) , "08b")
print(int(strvar,2))

38. 请查找一个目录下的所有文件（可能存在文件嵌套）。

import os
path = 'abc'
path_read = []   
def check_if_dir(file_path):
    temp_list = os.listdir(file_path)  
    for temp in temp_list:
        if os.path.isfile(file_path + '/' + temp):
            temp_path = file_path + '/' + temp
            if os.path.splitext(temp_path)[-1] == '.log':    
                path_read.append(temp_path)
            else:
                continue
        else:
            check_if_dir(file_path + '/' + temp_list)    

check_dir(path)

39. 求结果

    import math
    print (math.floor(5.5))
    5
    

40. 是否使用过functools中的函数？其作用是什么？

41. re的match和search区别？

42. 用Python匹配HTML tag的时候,<.>和<.?>有什么区别?

43. 如何生成一个随机数？

44. super的作用？

45. 双下划线和单下划线的区别？

46. @staticmethod和@classmethod的区别？

47. 实现一个单例模式（加锁）。

48. 栈和队列的区别？

49. 以下代码输出是什么? 请给出答案并解释。

    class Parent(object):
        x = 1
    
    class Child1(Parent):
        pass
    
    class Child2(Parent):
        pass
    
    print Parent.x, Child1.x, Child2.x
    1,1,1
    
    Child1.x = 2
    print Parent.x, Child1.x, Child2.x
    1,2,1
    
    Parent.x = 3
    print Parent.x, Child1.x, Child2.x
    3,2,3
    

50. 参考下面代码片段

    class Context:
        
        def do_something(self):
            print(nothing to do!!)
    
    
    with Content() as ctx:
        ctx.do_something()
    请在Context类下添加代码完成该类的实现
    

第二部分 可选题

1. 如何获取列表中第二大的值？
   通过max函数获取最大值，pop掉以后再次用max获取最大值
   通过sort函数从小到大排列，获取倒数第二个值

2. 简述Python内存管理机制。

3. 简述Python的垃圾回收机制。

4. 请用两个队列来实现一个栈。

       """
   

栈 : 先进后出,后进先出
队列 : 先进先出,后进后出
"""
from queue import Queue

class Stack():
def init(self):
self.master_queue = Queue()
self.minor_queue = Queue()

def push(self,val):
    # 入栈
    self.master_queue.put(val)

def pop(self):
    # 出栈
    # 如果队列中没有任何值,直接返回None
    if self.master_queue.qsize()  == 0 :
	return None

    while True:
    # 当队列总长度为1的时候,循环终止,把最后一个元素拿出来,为了满足栈后进先出的特点
	if self.master_queue.qsize() == 1:
	    value = self.master_queue.get()
	    break
		
	#  剩下还没有拿出来的元素,暂时放在2号队列中存储
	self.minor_queue.put(self.master_queue.get())
		"""
			minor_queue(1)
			master_queue(2 3 4)
			
			minor_queue(2)
			master_queue(3 4)

			minor_queue(3)
			master_queue(4)
		"""
	# 交换队列,重新循环,继续去最后一个值,如法炮制
	self.master_queue,self.minor_queue = self.minor_queue,self.master_queue
	return value

obj = Stack()
obj.push("a")
obj.push("b")
obj.push("c")

print(obj.pop()) # c
print(obj.pop()) # b
print(obj.pop()) # a
print(obj.pop()) # a

```

5. 请用Python实现一个链表。

       # 创建链表
       class Node():
           def __init__(self,value,next):
               self.value = value
               self.next = next
       head = Node("头",None)
       last = head
       for i in range(5): # 0 1 2 3 4
           node = Node("v%s" % i, None)
           last.next = node
           last = node
       
       # 链表的逆转
   
       def reverse_link_list(head):
           # 要是空的,或者None,直接返回head
           if not head or not head.next:
               return head
           # 获取上一个节点对象
           prev_node = None
           # 获取下一个节点对象
           next_node = head.next
           # 获取当前节点对象
           current_node = head
   
           while True:
               # 修改next,所指向的对象
               current_node.next = prev_node
               # 如果下一个阶段对象是None
               if not next_node:  # not None
                   break
               # 重新获取上一个对象,即把当前对象单独存一份,以准备第二次循环时插进next属性中
               prev_node = current_node
               # 重新获取当前对象 , 即把下一个对象单独存储起来(下个)
               current_node = next_node
               # 重新获取下一个对象,即把下一个对象单独存储起来,所指向的下个新对象赋值给next_node(下下个)
               next_node = current_node.next
           return current_node
   
       head = reverse_link_list(head)
   
       print(head.value)
       print(head.next.value)
       print(head.next.next.value)
       print(head.next.next.next.value)
       print(head.next.next.next.next.value)
       print(head.next.next.next.next.next.value)