Python-NNN-问

最新推荐文章于 2024-06-01 13:00:35 发布

原创最新推荐文章于 2024-06-01 13:00:35 发布 · 382 阅读

1 ·

CC 4.0 BY-SA版权

——本篇为在学习Python的时候从网上顺手迁来的Python n 个问。
本博客持续更新==>>>

简述解释型和编译型编程语言？
解释型：在执行程序时，计算机才一条条的将代码解释成机器语言给计算机来执行
编译型：是把源程序的每一条语句都编译成机器语言，并保存成二进制文件，这样计算机运行该程序时可以直接以机器语言来运行此程序，运行速度很快

Python解释器种类以及特点？

Cpython，IPython，Jpython，pypy，Ironpython

Python是一门解释器语言，代码想运行，必须通过解释器执行，Python存在多种解释器，分别基于不同语言开发，每个解释器有不同的特点，但都能正常运行Python代码，以下是常用的五种Python解释器：

CPython：当从Python官方网站下载并安装好Python2.7后，就直接获得了一个官方版本的解释器：Cpython，这个解释器是用C语言开发的，所以叫 CPython，在命名行下运行python，就是启动CPython解释器，CPython是使用最广的Python解释器。

IPython：IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的，好比很多国产浏览器虽然外观不同，但内核其实是调用了IE。

PyPy：PyPy是另一个Python解释器，它的目标是执行速度，PyPy采用JIT技术，对Python代码进行动态编译，所以可以显著提高Python代码的执行速度。

Jython：Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。

IronPython：IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

在Python的解释器中，使用广泛的是CPython，对于Python的编译，除了可以采用以上解释器进行编译外，技术高超的开发者还可以按照自己的需求自行编写Python解释器来执行Python代码，十分的方便！

位和字节的关系？
一个字节 == 8位

b、B、KB、MB、GB的关系？
1B(字节) == 8b(位)
1KB == 1024B
1MB == 1024KB
1GB == 1024MB

通过代码实现如下转换：

v = '0b1111011'
print(int(v,2))
v = 18 
print(bin(v))
v = '011'
print(int(v,8))
v = 30 
print(oct(v))
v = '0x12'
print(int(v,16))
v = 87 
print(hex(v))

请编写一个函数实现将IP地址转换成一个整数
如 10.3.9.12 转换规则为
10 00001010 3 00000011 9 00001001 12 00001100
再将上面二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？

def exchange(sor):
    sor = sor.strip().split('.')
    lis = [bin(int(i)) for i in sor]
    lis2 = [i.replace('0b',(10 - len(i)) * '0') for i in lis]
    return int(''.join(lis2),2)
ret = exchange('10.3.9.12')
print(ret)

Python 递归的最大层数？
一般计算机默认的最大递归深度在1000左右，python最大递归深度一般在4000左右，跟计算机的性能有关，这个数不是一个定数，可以通过下面方法测试一下

import sys
<br style="margin: 0px; padding: 0px;">print(sys.getrecursionlimit())
<br style="margin: 0px; padding: 0px;">print(sys.setrecursionlimit(10000))

求结果

v1 = 1 or 3 ------------------> 1
v2 = 1 and 3 -----------------> 3
v3 = 0 and 2 and 1 -----------> 0
v4 = 0 and 2 or 1 ------------> 1
v5 = 0 and 2 or 1 or 4 -------> 1
v6 = 0 or Flase and 1 --------> False

ascii、unicode、utf-8、gbk 区别？
ASCII码：使用一个字节编码，所以它的范围基本是只有英文字母、数字和一些特殊符号，只有256个字符。
Unicode：能够表示全世界所有的字节
GBK：是只用来编码汉字的，GBK全称《汉字内码扩展规范》，使用双字节编码。
UTF-8：是一种针对Unicode的可变长度字符编码，又称万国码。

字节码和机器码的区别？
机器码：是电脑CPU直接读取运行的机器指令，运行速度最快，但是非常晦涩难懂
字节码：是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。

列举布尔值为False的常见值？
0, [] , () , {} , ‘’ , False , None

字符串、列表、元组、字典每个常用的5个方法？

字符串：repleace,strip,split,reverse,upper,lower,join……
列表：append,pop,insert,remove,sort,count,index……
元组：index,count,len(),dir()
字典：get,keys,values,pop,popitems,clear,update,items……

pass的作用？
1、空语句 do nothing
2、保证格式完整
3、保证语义完整

is和==的区别？
is:判断内存地址是否相等
==：判断数值是否相等

Python垃圾回收机制？
python采用的是引用计数机制为主，标记-清除和分代收集(隔代回收、分代回收)两种机制为辅的策略
计数机制:
Python的GC模块主要运用了引用计数来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记-清除”
解决容器对象可能产生的循环引用的问题。通过分代回收以空间换取时间进一步提高垃圾回收的效率。
标记-清除：
标记-清除的出现打破了循环引用，也就是它只关注那些可能会产生循环引用的对象
缺点：该机制所带来的额外操作和需要回收的内存块成正比。
隔代回收:
原理：将系统中的所有内存块根据其存活时间划分为不同的集合，每一个集合就成为一个“代”，
垃圾收集的频率随着“代”的存活时间的增大而减小。也就是说，活得越长的对象，就越不可能是垃圾，就应该减少对它的垃圾收集频率。那么如何来衡量这个存活时间：通常是利用几次垃圾收集动作来衡量，如果一个对象经过的垃圾收集次数越多，可以得出：该对象存活时间就越长。

python的可变类型和不可变类型？
不可变类型（数字、字符串、元组、不可变集合）
可变类型（列表、字典、可变集合）

求结果：

v = dict.fromkeys([‘k1’,‘k2’],[])
v[‘k1’].append(666)
print(v)
v[‘k1’] = 777
print(v)

答案：{‘k1’:[666],‘k2’:[666]}
{‘k1’:777,‘k2’:[666]}
**解析：**formkeys()默认参数为可变数据类型时有坑

求结果：

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

答案：[6, 6, 6, 6]

解析：问题的本质在与python中的属性查找规则，LEGB（local，enclousing，global，bulitin），在上面的例子中，i就是在闭包作用域（enclousing），而Python的闭包是迟绑定，这意味着闭包中用到的变量的值，是在内部函数被调用时查询得到的

所以：[lambda x: i*x for i in range(4)]打印出来是含有四个内存地址的列表，每个内存地址中的i在本内存中都没有被定义，而是通过闭包作用域中的i值，当for循环执行结束后，i的值等于3，所以再执行[m(2) for m in num()]时，每个内存地址中的i值等于3，当x等于2时，打印出来的结果都是6，从而得到结果[6, 6, 6, 6]。

列举常见的内置函数？
map,filter,zip,len,bin,oct,hex,int,float,bool,sum,min,max,
str,list,tuple,dict,range,next,hash,help,id……

filter、map、reduce的作用？
filter(function，iterable)过滤函数
map(function，iterable)循环函数
reduce(function, iterable)累积函数

求结果：
a = [ i % 2 for i in range(10) ] =>[0,1,0,1,0,1,0,1,0,1]
b = ( i % 2 for i in range(10) )=>返回一个生成器的内存地址

求结果：
a = 1 or 2 =====> 1
b = 1 and 2 ====> 2
c = 1 < (22) > False ====> Ture
d = 1 < 2 == 2 > True ======>True

def func(a,b=[]) 这种写法有什么坑？

def fun(a,b=[]):
	b.append(a)
	print(b)
fun(3)
fun(2)

函数的第二个默认参数是一个list，当第一次执行的时候实例化了一个list，第二次执行还是用第一次执行的时候实例化的地址存储，以后每次实例化都是

如何实现 “1,2,3” 变成 [‘1’,‘2’,‘3’] ?

str = '1,2,3'
str = str.split(',')
print(str)

str = '1,2,3'
str = list(str.replace(',',''))
print(str)

如何实现[‘1’,’2’,’3’]变成[1,2,3] ?

lst = ['1','2','3']
lst = list(map(lambda x: int(x),lst))
print(lst)

比较：a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的区别？
a = [1,2,3]正常的列表
b = [(1),(2),(3)] 虽然列表的每个元素加上了括号，但是当括号内只有一个元素并且没有逗号时，其数据类型是元素本身的数据类型
b = [(1,),(2,),(3,)]列表中的元素类型都是元组类型

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

lst = [i**2 for i in range(1,11)]

一行代码实现删除列表中重复的值 ?

lst = [1, 1, 1, 23, 3, 4, 4]
newlst = [x for x in set(lst)]
newlst.sort(key = lst.index)
print(newlst)

简述生成器、迭代器、可迭代对象以及应用场景？
生成器：在 Python 中，一边循环一边计算的机制，称为生成器（generator），通过next()取值，两种表现形式
1、将列表生成式的 [] 改为 ()
2、含有yield关键字的函数
应用场景：优化代码，节省内存
迭代器：是访问集合元素的一种方式。迭代器同时实现了__iter__和_next_方法
可迭代对象：只要实现了__iter__方法的对象就是可迭代对象

谈谈你对闭包的理解？
在一个外部函数中定义了一个内部函数，内部函数里运用了外部函数的临时变量，并且外部函数的返回值是内部函数的引用。这样就构成了一个闭包。
一般情况下，在我们认知当中，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。
但是闭包是一种特殊情况，如果外部函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束

如何生成一个随机数？

import random
def rdm(n):
	lst = [str(random.randint(0,9)) for i in range(n)]
	s = ''.join(lis)
	return int(s)

print(rdm(5))

如何判断是函数还是方法？
函数和方法都封装了一些独立的功能，如果在类中定义的函数那就是方法，否则就是函数( 函数名()直接调用 )

1、2、3、4、5 能组成多少个互不相同且无重复的三位数

count = 0
for i in range(1,6):
	for j in range(1,6):    
		for k in range(1,6):
        	if (i != j) and (i != k) and (j != k):
            	count += 1
            if count % 6:
                print('{}{}{}'.format(i,j,k),end='|')
            else: 
                print('{}{}{}'.format(i,j,k))
print(count)

装饰器的写法以及应用场景

def wrapper(func):
    def inner(*args,**kwargs):
        '被装饰之前的操作' 
        ret = func(*args,**kwargs)
        '被装饰之后的操作'
        return ret
    return inner

装饰器的应用场景：
比如注册登录、插入日志，性能测试，事务处理，缓存等场景

异常处理写法以及如何主动跑出异常（应用场景）
异常处理的常规写法：

 try: 
    '执行的主体函数'
    except Exception as e: 
        print(str(e))

主动抛出异常：

raise TypeError('出现了不可思议的异常')#TypeError可以是任意的错误类型

isinstance作用以及应用场景？
isinstance作用是来判断一个对象是否是一个已知的类型
isinstance(obj,class_or_tuple)，返回布尔值

isinstance(6,str)
isinstance(6,(str,int,bool))

给定一个列表和一个目标数值，数值为列表内两元素的和，且列表内每个元素只能用一次，求目标数值是否可得？以及组成目标数值的两个元素的索引。

def func(li,target):
    for i in range(0,len(li)):
        num = target-li[i]
        if num in li:
            return [i,li.index(num)]
    else:
        return print('target is wrong')
        
func([2,7,11,15],13)

‘Item({!r})’.format(self.name) 中的 !r 的意思？

Three conversion flags are currently supported:
!s calls str() on the value
!r calls repr() on the value
!a calls ascii() on the value