1.简述列举了解的编程语言，语言间的区别是什么?

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

2.python2和python3有什么区别?

python2

1.print "123"
2.range 返回list
3.ascii
4.两种类: 经典类 和 新式类
	class Car(): pass        经典类(多继承当中搜索成员时,采用深度优先原则)
	class Car(object): pass  新式类(多继承当中搜索成员时,采用广度优先原则)
5.除法 / : 结果是整数
6.int long(长整型)
7.raw_input

python3

1.print("123")
2.range 返回的是可迭代的对象(容器类型数据,range对象,迭代器)
3.默认utf-8
4.都是新式类
5.除法 / :结果是小数
6.int 
7.input

3.看代码写结果

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

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

逻辑短路

True or 表达式
False and 表达式
True or True => True
True or False = True
False and False => False
False and True => False

and 全真则真,一假则假
or 一真则真,全假则假

布尔值为假的十种情况:

0,0.0,False,‘‘,(),[],set(),{},0j,None

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

Number ( int , float , bool , complex )

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

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

结果
v1 = 1
v2 = 7

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

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

元组:逗号是区分元组的标识符

a = 1,2,3
print(a, type(a))
a = () # 空元组
a = (1) # 整型
a = ("abc") # 字符串

v1 = [1,2,3] # 列表
v2 = [(1),(2),(3)] # [int, int,int]
v3 = [(1,),(2,),(3,)] # [tuple,tuple,tuple]

a = 1 # 整型
a = 1,# 元组
print(a,type(a))

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,ij),end=" ")
print(‘\n‘)

2

i = 1
while i<=9:
j = 1
while j<= i:
print("%d%d=%2d" % (i,j,ij),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("ok")
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()

python面试题(基础篇)

原文：https://www.cnblogs.com/biyunfeng/p/13228161.html