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('
')
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 esta.txt"
pathvar = r"E:chuan est"
res = getallsize(pathvar)
print(res)
方法二
import os
os.walk() => 生成器
pathvar = r"E:chuan est"
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的时候,<.>和<.?>有什么区别?
<.> 除了
的任意字符 , 个数必须是一个
<.?> 除了
的任意字符 , 个数必须是一个 或者 0个
. 除了 的任意字符
- ? + {3,10} 都是量词
.? 除了 的任意字符 匹配到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()