Python基础题

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

编译型: 一次性全部编译成二进制码,然后运行
解释型:编译一行,运行一行
1.python  解释型,间接高效,容易上手,各个方向百花齐放
2.java    混合型(JVM,JIT编译器),开发周期慢,web方向
3.c       编译型 属于底层开发,只有面向过程,没有面向对象
4.c++	  编译型 属于底层开发,既有面向过程,还有面向对象
5.go      编译型 应用在区块链,高并发高可用,游戏方向

2、列举Python2和Python3的区别？

Python2中print是语句不需要括号即可输出，Python3print是函数需要
Python2默认ASCII，Python3默认Unicode
Python2中存在经典类和新式类，Python3中统一采用新式类
Python2有long，Python3没有long
Python2中数值比较大时，出现long类型，Python3中所有整数都是int类型，不存在long类型
Python2除法取整数，Python3除法获取的是浮点数
Python2可带可不带引号，Python3必须带引号
Python2中raw_input获取的内容都是字符串，input获取的是int,float，Python3去除了raw_input，保留了input函数，任意输入都是返回的是字符串
Python2打印range获取的是列表，Python3打印range获取的就是range本身

3、看代码写结果

and:真真取后真，假假取前假，真假取假
or:真真取前真，假假取后假，真假取真

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

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

v1 = [1,2,3]
v2 = [(1),(2),(3)]
v3 = [(1,),(2,),(3,)]
#v1，v2列表中的元素类型是数字，v3中的元素类型是元组

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

a = 1
b = 2
a,b=b,a

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

单引号和双引号中间是字符串，三引号中间是注释
单双引号没有区别,三引号可以支持跨行在互相嵌套时需注意:里外不能使用相同的引号

7、is和==的区别？

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

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

a= (1,2)
list(a)
tuple(a)

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

name[::-1]

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

a ={1,2,3,4}
b = {2,3,5,6}	
print(a&b)		#交集a.intersection(b)
print(a|b)		#并集a.union(b)
print(a-b)		#差集a.difference(b)

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

#非空集合且不为子父关系的两个集合
y != x-(x-y)
x = {“a”,“b”,“c”}
y = {“b”,“d”}
if y != x-(x-y):
	print(“ok”)

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

1.copy.copy 
2.lst.copy 
3.切片[:]或[::]

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

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

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) #[1,2,4,5,['b','c','d'],5]
print(c) #[1,2,4,5,['b','c','d']]
print(a) #[1,2,4,5,['b','c','d'],5]

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

#1
for i in range(1,10):
    for j in range(1,i+1):
        print("%d*%d=%2d" % (i,j,i*j),end=" ")
    print('\n')
# 2
i = 1
while i<=9:
	j = 1
	while j<= i:
		print("%d*%d=%2d" % (i,j,i*j),end=" ")
		j+=1
	print()	
	i+=1

17、用Python显示一个斐波那契数列0，1，1，2，3，5，8，13……。

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


#代码：
def func(a):
    if a<=1:
        return a
    return func(a-1)+func(a-2)
for i in range(10):
    print(func(i))

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

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

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

# 第一种
with open("文件",mode = "r",encoding="utf-8") as fp:
	# 一次最多读取100个字符
	res = fp.read(100)
	while res:
		print(res)
		res = fp.read(100)

# 第二种
f = open(文件,mode="r",encoding="utf-8")
for line in f:
	# f是迭代器,遍历时,默认按照一行一行进行读取
	print(line)

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

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

21、lambda关键字的作用？

匿名函数

22、*arg和**kwarg作用?

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

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

global

24、filter、map、reduce的作用？

filter 过滤元素，返回一个迭代器对象
map 映射
reduce 会对元素进行累计算

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

使用lambda表示匿名函数
不需要显示的定义函数，方便

26、Python递归的最大层数？

官方说法1000 , 实际测试 994 ~ 1000
import sys
sys.setrecursionlimit(100000)

def foo(n):
    print(n)
    n += 1
    foo(n)
        
if __name__ == '__main__':
    foo(1)
# 修改递归的最大深度,得到的值在3925-3929之间浮动，这个是和计算机有关系的，不然也不会是一个浮动的数字了（数学逻辑讲求严谨）

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

实现了iter和next()方法的对象都是迭代器
实现了iter方法的对象叫做可迭代对象

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 warpper(f):
        def inner():
            f()
        return inner
    
    @warpper  
    def func():
        print("被装饰的函数")

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()def warpper(func):
        def inner(*args,**kwargs):
            func(*args,**kwargs)
        return inner
    
    @warpper
    def foo():
        print("被装饰的函数")

​

33、求结果

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

"""
刚开始定义的时候,没有去执行函数内部的内容,不存在i变量的赋值.
只有在调用的时候,才会去获取此时的i值
而调用时,此时的i值是3,由于遍历已经结束,而i的值处在闭包中,延长该变量的生命周期,可以获取到
return  i * x => return 3 * 2 => 6
由于是4个函数,所以是4个6;
"""

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)
# [1, 3] [10, 20, 2] [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)

[1] 

[10, 20, 2] 

[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(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:\chuan\test\a.txt"
pathvar = r"E:\chuan\test"
res = getallsize(pathvar)

print(res)

#方法二
import os 
os.walk() => 生成器
pathvar = r"E:\chuan\test"
gen = os.walk(pathvar)
for root,dirs,files in gen:
	for name in files:
		pathvar = os.path.join(root,name)
		print(pathvar)

39、求结果

import math
print(math.floor(5.5))
print(math.ceil(5.1))

# floor 地板    向下取整
# ceil  天花板  向上取整

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("雷霆嘎巴,无情哈拉少")
		return res
		
	return inner
	
@wrapper
def func():
	print(1111)
	return 123

41、re的match和search区别？

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

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

<.> 除了\n的任意字符 , 个数必须是一个
<.?> 除了\n的任意字符 , 个数必须是一个 或者 0个

. 除了\n的任意字符
* ? + {3,10} 都是量词
.? 除了\n的任意字符 匹配到0个或者1个
.*     贪婪匹配     默认向更多次匹配
.*?    非贪婪匹配   默认向更少次匹配
.??    非贪婪匹配   默认向更少次匹配

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

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

44、super的作用？

用来解决多继承之间复杂的调用关系使用super

类.mro() => 调用顺序列表(继承关系)
super调用父类相关成员时,参照mro列表中的继承顺序依次调用

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

class MyClass():
        	__abc = 90
        	_ppp = 100
        """
        封装: 公有public 私有private 受保护的protected
        私有:__ 2个下划线来表达 __sex
        受保护:在python 中有约定俗成的写法,在成员的前面加上一个下划线
        (可以在继承时使用该成员,无法在类外使用;) _sex

        魔术方法/属性: __doc__ __init__ ...
        """

46、@staticmethod和@classmethod的区别？

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

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

"""
目的: 节省内存空间,提高运行效率,应用在多人使用同一个操作类的场景
没生成一个对象,都在内存中占用空间,尤其在执行mysql操作类时
因为多人的使用,创建出多个对象,而对象本身不会额外增加新成员,只做单纯的成员调用
那么就可以使用单态模式;
"""
from threading import Lock
class SingleTon():
	# 防止类外直接调用__obj成员,对他进行保护,所以用私有
	__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 = SingleTon()
obj2 = SingleTon()
obj3 = SingleTon()
print( id(obj1) , id(obj2) , id(obj3)  )

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、参考下面代码片段

""" 面向对象的上下文管理, with语法的具体实现 """
class Context:
	# 在使用with语法时,自动触发,功能返回对象
	def __enter__(self):
		return self
		
	# 在执行完with语法之后,自动触发,用来做收尾操作
	def __exit__(self, exc_type, exc_val, exc_tb):
		print("关闭文件 f.close() ")

	def do_something(self):
		print("我是做点什么~")

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