Python面试重点（基础篇）

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

 

Python是一门动态的解释型的强类型定义语言

解释性语言是指它常用的执行机制是使用一个“解释器”来执行，解释器对于程序是一句一句“翻译”成机器语言来执行，例如shell脚本语言。

编译型语言是指它常用的执行机制是使用一个“编译器”来编译成机器语言，然后你就可以直接运行（执行）这个编译成的“可执行文件”。例如C语言

2.列举Python2和Python3的区别？

   　1、print

            在python2中，print被视为一个语句而不是一个函数，python3中，print()被视为一个函数

        2、整数的除法

            在python2中，键入的任何不带小数的数字，将被视为整数的编程类型。比如5/2=2，解决方法：5.0/2.0=2.5

            在python3中，整数除法变得更直观 5/2=2.5

         3、Unicode

            Python 2 默认使用 ASCII 字母表；Python 3 默认使用 Unicode

　      4.　Python2中存在老式类和新式类的区别，Python3统一采用新式类。新式类声明要求继承object，必须用新式类应用多重继承。

3.看代码写结果

v1 = 1 or 2     v1=1

v2 = 3 and 7 or 9 and 0   v2 = 7

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

v1 = [1,2,3]
v2 = [(1),(2),(3)]
v3 = [(1,),(2,),(3,)]

v3中的元素是元组

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

a = 1
b = 2

a,b=b,a

6.Python中单引号、双引号、三引号的区别？

单引号和双引号用法区别不大，双引号里可以嵌套单引号，三引号可以用来注释

7.is和==的区别？

is表示判断两边内存地址是否相同，==表示判断两边值是否相等

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

#list to tuple
lis=[1,2,3,4,5,6]
x=tuple(lis)
print(type(x),x)

#tuple to list
tup=(1,2,3,4,5,6)
y=list(tup)
print(type(y),y)

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

print(name[::-1])

10.两个set如何获取交集、并集、差集？

　　
　    x=set('sixbobo')

　　y=set('googlebb') 

　　交集 print(x&y)

　　取并集 print(x|y)

　　取差集 print(x-y)

11.那些情况下, y != x - (x-y)会成立?

非空集合且不为子父关系的两个集合

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

   赋值（=）

lst1 = [1, 2, 3]
lst2 = lst1[:]
lst1.append(4)
print(lst2)

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

对象的赋值就是简单的引用

浅拷贝会创建新的对象

深拷贝只是一种形式,copy模块中的deepcoopy()函数,深拷贝拷贝了对象的所有元素,包括多层嵌套的元素

赋值   : 将变量和值在内存中形成映射指向关系
 浅拷贝 : 只拷贝第一级里所有的元素 copy.copy
 深拷贝 : 为所有层级的元素都单独开辟新空间 copy.deepcopy() (地址:原不可变数据只是暂时的指向,可变的数据独立开辟新空间)

14.pass的作用？

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)

[1, 2, 4, 5, ['b', 'c', 'd'], 5]

[1, 2, 4, 5, ['b', 'c', 'd']]

[1, 2, 4, 5, ['b', 'c', 'd'], 5]

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

　

 

 

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

 

# 方法一
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


# 方法三
def fib(n):
    if n <= 2:
        return 1
    # 上一个值 + 上上个值
    return fib(n - 1) + fib(n - 2)


print(fib(6))

 

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

先将列表转换为set，在转换回来 

list(set(lst))

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

with open("./data/log.txt",encoding='utf8') as f:
    for line in f:
        print(line)

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}

21.lambda关键字的作用？

lambda 匿名函数: 用一句话表达只有返回值的无名函数
lambda 参数: 返回值

22.*arg和**kwarg作用?

# *arg   普通收集参数 :   收集多余的没人要的普通实参
# **kwarg 关键字收集参数: 收集多余的没人要的关键字实参

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

　　

def func():
    global a
    a = 90


func()
print(a)

24.filter、map、reduce的作用？

filter主要作用是过滤掉序列中不符合函数条件的元素，当序列中要删、减元素时，可以使用filter函数。

map主要作用是求一个序列或者多个序列进行函数映射之后的值。

reduce是对一个序列进行压缩运算，得到一个值。

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))

"""

# 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))

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

关键字lambda表示匿名函数，因为函数没有名字，不必担心函数名冲突

lambda 匿名函数: 用一句话表达只有返回值的无名函数
lambda 参数: 返回值

26.Python递归的最大层数？

998

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

具有__iter__() 和 __next__()这两个方法的是迭代器
# 具有__iter__()方法就是可迭代对象

28.什么是生成器？

有yield的就是生成器

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

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

装饰器就是用来修饰某个函数，在不改变原来方法代码的前提下，额外的附加其他的功能和属性

只要是你不想改变原来的代码，又想添加额外的功能，都可以使用装饰器来完成。

装饰器的本质就是闭包
# 在不修改原有代码的前提下,额外增加新功能就是装饰器
# 应用:登录认证,property类,框架(django,flask,@app.route("/",methdos=["GET","POST"]))

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

通过字符串去操作类对象 或者 模块中的属性方法

hasattr
getattr
setattr
delattr

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

 

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

def outer(n):
    def wrapper(func):
        def inner1(*args, **kwargs):
            res = func(*args, **kwargs)
            print("我是大王")
            return res

        def inner2(*args, **kwargs):
            res = func(*args, **kwargs)
            print("大王叫我来巡山")
            return res

        if n == "alex":
            return inner1
        else:
            return inner2

    return wrapper


@outer("alex123")  # outer("alex123") => wrapper =>@wrapper
def func():
    print("i am fine 3q")


func()

33.求结果

【6，6，6，6】

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

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

第一次实例化了一个列表以后每次都用第一次的

"""
默认参数: 
   如果调用时,用户给实参了,那么使用用户的
   如果调用时,用户没给实参,那么使用默认的(早已存在内存中的这个列表)
   
默认值会提前在内存中驻留,在使用时,才能调取,在定义函数的时候就提前开辟了空间
"""

35.

[1, 3]

[10, 20, 2]

[1, 3]

36.

[1]
[10, 20, 2]
[1, 3]

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

# 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
def getallsize(pathvar):
　　size = 0
　　lst = os.listdir(pathvar)
　　print(lst)
　　for i in lst:
　　　　pathvar2 = os.path.join(pathvar,i)
　　　　print(pathvar2)

　　　　# 判断是否是文件
　　　　if os.path.isfile(pathvar2):
　　　　size += os.path.getsize(pathvar2)
　　　　# 判断是否是文件夹
　　　　elif os.path.isdir(pathvar2):
　　　　　　size += getallsize(pathvar2)

　　　　　　print(size)

　　return size

# "E:\串讲基础\day2\test\1.txt"
pathvar = r"E:\串讲基础\day2\test"
res = getallsize(pathvar)
# print(res)

# 方法二
import os 
# os.walk() => 生成器
pathvar = r"E:\串讲基础\day2\test"
gen = os.walk(pathvar)

for root,dirs,files in gen:
　　for name in files:
　　　　pathvar = os.path.join(root,name)
　　　　print(pathvar)

 

 

39.求结果

# floor ceil round
import math
print(math.floor(5.5))

# round n.5 奇进偶不进
print(round(4.5))
print(round(5.5))
print(round(4.52))

 

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

from functools import reduce
# 在装饰器中使用,如果想要保留原来函数的属性,加上wraps
from functools import wraps

def wrapper(func):
    @wraps(func)
    def inner(*args,**kwargs):
        res = func(*args,**kwargs)
        print("and you")
        return res
        
    return inner

@wrapper
def func():
    print("i am fine 3q")

func()
print(func)

# def abc():
    # pass
# print(abc)

 

41.re的match和search区别？

search 从字符串中任意位置进行匹配查找到一个就停止了,返回的是一个对象. 获取匹配的内容必须使用.group()进行获取

match 从字符串开始位置进行匹配

"""
match : 必须从字符串的开头进行匹配
search: 从任意位置开始匹配,匹配到就返回
只匹配一个
"""

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

. 除了\n的任意字符
* 量词,代表匹配0次或者多次,任意个
.* 贪婪匹配
.*? 非贪婪匹配

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

import random
random.random    随机获取 0<= x < 1
random.randrange 随机获取指定范围中的整数,用法上同range
random.uniform   随机获取指定范围中的小数

 

44.super的作用？

# 用来解决多继承之间复杂的调用关系使用super
在多继承中,如果出现了多个同名方法
super在调用的时候,会按照mro列表的继承顺序依次调用
类.mro() = > lst

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

"单下划线" 开始的成员变量叫做保护变量，意思是只有类对象和子类对象自己能访问到这些变量；

"双下划线" 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数

据。

class MyClass():
    __abc = 90
    _ppp = 100
"""
封装: 公有public 私有private 受保护的protected
私有: 只能在当前这个类里面使用,不能再子类或者在类外使用
受保护的: 可以在当前这个类或者子类里使用,不能再类外使用
约定俗成在该变量前面加上一个下划线_ , 就表示受保护了
"""

 

46.@staticmethod和@classmethod的区别？

 

一个静态方法,一个类方法
一个静态方法:(无论是对象还是类,都可以调用,不会默认传递任何参数)
一个类方法 :(无论是对象还是类,都可以调用,会默认传递类这个参数)

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

 

# 单例模式:这个类无论实例化多少次,都有且只有一个对象
from threading import Lock
class MyClass(object):
    __obj = None
    lock = Lock()
    def __new__(cls,*args,**kwargs):
        with cls.lock:
            if not cls.__obj:
                cls.__obj = object.__new__(cls)
            return cls.__obj
obj1 = MyClass()
obj2 = MyClass()
print(obj1,obj2)

48。
栈 : 先进后出,或者 后进先出
队列: 先进先出

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

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

 

50.参考下面代码片段

class Context:
　　pass

with Content() as ctx:
　　ctx.do_something()
请在Context类下添加代码完成该类的实现

# 面向对象的上下文管理是with语法的具体实现
class Context():
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        # 相当于在最后,执行了文件的关闭操作,fp.close()
        print("abc123")
    def do_something(self):
        print(1111)

with Context() as ctx:
    ctx.do_something()
    print(ctx)

# 自动实现了关闭操作
# with open("文件") as fp:
#     res = fp.read()

# ### 第二大题

1.如何获取列表中第二大的值？
# (1) 所有的容器类型数据都可以通过 sorted (sort只局限于列表进行排序)
# 去重
lst = set([98,1,100,3,-100,50,100,100])
res = sorted(lst)
res_new = res[-2]
print(res_new)

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

# (2) 内存管理机制
计数器,垃圾回收,内存池
# 一.计数器
特点:引用技术如果是0,把这个值从内存中释放掉
a = 100
b = a
print(b)
del b
缺点:在维护引用计数时,又可能数据产生循环引用,造成数据不能删除,造成内存泄漏
lst1 = [1,2]
lst2 = [5,6]
lst1.append(lst2)
lst2.append(lst1)
del lst1
print(lst1)
print(lst2)
# print(lst1)
# print(lst2)

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

# 垃圾回收:引用计数为主,标记清除和分带回收为辅
标记清除 : 检测标记该对象,避免出现循环引用不能删除的现象
分带回收 :
把内存中的数据分成三个区域: 新生代0,老年代1,永久代2
新生代0数据超过700 , 或者老年代1,永久代2数据超过10,自动触发内存中的垃圾回收机制
新生代0触发将清除所有三代的区域
老年代1触发会清理1,2代
永久代2触发只会清理自己

# 三.内存池
# 在同一个文件当中 (python3.6)
# -->Number 部分
1.对于整型而言，-5~正无穷范围内的相同值 id一致
2.对于浮点数而言，非负数范围内的相同值 id一致
3.布尔值而言,值相同情况下，id一致
4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)
# -->容器类型部分
5.字符串 和 空元组 相同的情况下，地址相同
6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]
# 在不同的文件当中
小数据池 ; 比如整型默认开辟 -5~256 这么多数据提前在内存中驻留