1、一行代码实现1-100的和
print(sum(range(1,101)))
5050
2、如何在一个函数内部修改全局变量
a=10
def func():
a=20
print(a)
func()
print(a)
执行结果：20，10
a=10
def func():
global a
a=20
print(a)
func()
print(a)
执行结果：20，20
3、列出5个python标准库
import os
import sys
import time
import datetime
import random
import re
4、字典如何删除键和合并2个字典
🌙删除键
方法一：使用pop()
方法二：使用del
dic = {'a': 1, 'b': 2}
dic1 = {'c': 3, 'd': 4}
dic.pop('b')
print(dic)
del dic1['c']
print(dic1)
🌙合并字典
update：可以实现字典之间的合并
dic = {'a': 1, 'b': 2}
dic1 = {'c': 3, 'd': 4}
dic.update(dic1)
print(dic)
执行结果：{‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4}
5、谈下python的GIL
进程中多线程执行任务是共享进程中的数据的，在单个cpu时间范围内，如果某个线程没有执行完毕，并且没有连续的cpu时间片段，此时后面的线程也开始执行任务，会出现数据混乱的现象，即线程不安全。解决方法：加锁，保证某一时间只有一个线程在执行任务。
6、2个列表实现列表去重
li=[2,3,4,5,6]
li1=[4,5,6,7,8]
li.extend(li1)
ll=list(set(li))
print(ll)
7、fun(*args,**kwargs)中的*args,**kwargs是什么意思
*args：接收实际参数中所有没有匹配到的位置参数**kwargs：接收实际参数中所有没有匹配到的关键字参数
8、一句话解释什么语言能够使用装饰器
可以将函数作为参数进行传参的
9、python内建类数据类型有那些？
str
int
float
bool
list
tuple
dict
set
10、简述面向对象中__new__和__init__区别
__new__：
a、用于创建对象，将创建的对象给__init__方法
b、至少传递一个参数cls，代表当前类
c、必须要有返回值，返回实例化出来的实例
__init__:
a、用于初始化对象，前提必须创建对象完成，对象创建完成后就立刻被默认调用了，可以接收参数。
b、第一个参数位self，就是这个__new__返回的实例；__init__在__new__的基础上可以完成一些其他初始化的动作
c、__init__不需要返回值
d、如果__new__创建的是当前类的实例，会自动调用__init__函数，通过return语句里面调用的__new__函数的第一个参数cls来保证是当前类实例；如果是其他类的类名，那么实际创建返回的是就是其他类的实例，其实就不会调用当前类的__init__函数，也不会调用其他类的__init__函数。
11、简述with方法打开处理文件帮我们做了什么？
如果使用常规的f.open()写法，我们需要try、except、finally，做异常判断，并且文件最终不管遇到什么情况，都要执行finally f.close()关闭文件。
f=open('./1.txt','w')
try:
f.write("hello")
except:
pass
finally:
f.close()
使用with方法
with open('a.txt') as f:
print(f.read())
执行with这个结构之后。f会自动关闭。相当于自带了一个finally。
但是with本身并没有异常捕获的功能，但是如果发生了运行时异常，它照样可以关闭文件释放资源。
12、列表[1,2,3,4,5]，请使用map()函数输出[1,4,9,16,25]，并且使用列表推导式提取出大于10的数，最终输出[16,25]
方法一：
a=[1,2,3,4,5]
def func1(x):
return x**2
aa=map(func1,a)
new_aa=[i for i in aa if i>10]
print(new_aa)
方法二：
l=[1,2,3,4,5]
ll=list(map(lambda x:x*x,l))
lll=[i for i in ll if i>10]
print(lll)
13、python中生成随机整数、随机小数、0-1之间的小数
random.random()：随机生成0到1之间的小数
:.3f：保留3位有效数字
import random
num=random.randint(1,6)
num1=random.random()
print(num)
print(num1)
print('{:.3f}'.format(num1))
14、python中断言方法举例
a=3
assert(a>1)
print(a) #3
a=3
assert(a>6)
print(a)
断言失败
Traceback (most recent call last):
File "D:\log\ceshi_log\face_1.py", line 64, in <module>
assert(a>6)
AssertionError
15、列出python中可变数据类型和不可变数据类型，并简述原理
历史博文有详细解答，按值赋值和引用赋值
16、去重并从小到大排序输出“adfjl”
🌙集合可以对字符串进行去重
s = 'ajldjlajfdljfddd'
s1=list(set(s))
s1.sort()
s2=''.join(s1)
print(s2)
🌙特别注意：不能使用split()方法
s1=s.split()
print(s1)
['ajldjlajfdljfddd']
17、用lambda函数实现两个数相乘
sum=lambda a,b:a*b
print(sum(3,4))
12
18、字典根据键从小到大排序
🌙dict1.items()：获取字典中的键值，并且键和值组合在一起成一个元组
字典生成式
d1=sorted(dict1.items(),key=lambda x:x[0])
d2={k:v for k,v in d1}
print(d2)
dict1={"name":"zs","city":"beijing","tel":1243124}
print(dict1.items())
dd=sorted(dict1.items(),key=lambda x:x[0])
print(dd)
new_dict={}
for item in dd:
new_dict[item[0]]=item[1]
print(new_dict)
19、利用collections库的Counter方法统计字符串每个单词出现的次数
🌙统计字符串每个单词出现的次数：
from collections import Counter
res=Counter(a)
from collections import Counter
a="werwerwegdfgerwewed;wer;wer;6"
from collections import Counter
res=Counter(a)
print(res)
执行结果：
Counter({‘e’: 8, ‘w’: 7, ‘r’: 5, ‘;’: 3, ‘g’: 2, ‘d’: 2, ‘f’: 1, ‘6’: 1})
20、filter方法求出列表所有奇数并构造新列表
print(list(filter(lambda x: x % 2 == 1, a)))
执行结果：
[1, 3, 5, 7, 9]
21、列表推导式求出列表所有奇数并构造新列表
a=[1,2,3,4,5,6,7,8,9,10]
aa=[i for i in a if i%2==1]
print(aa)
执行结果：
[1, 3, 5, 7, 9]
22、a=(1,) b=(1) c=(‘1’)分别是什么类型
a=(1,)
b=(1)
c=('1')
print(type(a))
print(type(b))
print(type(c))
执行结果：
<class ‘tuple’>
<class ‘int’>
<class ‘str’>
23、两个列表合并成一个列表
🌙列表相加：合并列表
extend
a=[1,3,4,5,6]
b=[1,3,56,7,7,5]
c=a+b
a.extend(b)
a.sort()
print(c)
print(a)
24、[[1,2],[3,4],[5,6]]展开得到[1,2,3,4,5,6]
列表生成式多层嵌套
aa=[j for i in a for j in i]
print(aa)
执行结果：
[1, 3, 5, 7, 9]
25、x=“abc”,y=“def” z=[“d”,“e”,“f”]，求x.join(y)，x.join(z)返回的结果
🌙join()：括号里面的是可迭代对象，x插入可迭代对象中间，形成字符串，结果一致
x = "abc"
y = "def"
z = ["d", "e", "f"]
x_1=x.join(y)
print(x_1)
x_2=x.join(z)
print(x_2)
26、举例说明异常模块中try except else finally的相关意义
🌙try except else 没有捕获到异常，执行else语句
try except finally 不管是否捕获到异常，都执行finally语句
27、python中交换2个数值
三种方法
a=12
b=24
a,b=b,a
a=12
b=24
c=a
a=b
b=c
print(a,b)
a=12
b=24
c=a+b
b=c-b
a=c-b
print(a,b)
28、举例说明zip函数的用法
a、zip()函数在运算时，会以一个或多个序列（可迭代对象）作为参数，返回一个元组的列表，同时将这些序列中并排的元素配对。
b、zip()函数可以接收任何类型的序列，同时也可以有2个以上的参数；当传入的参数不同时，zip能自动以最短序列为准进行截取，获取元组。
a=[1,2,3]
b=[5,6,7]
res=list(zip(a,b))
print(res)
a=(1,2,3)
b=(5,6,7)
res1=list(zip(a,b))
print(res1)
a=(1,2)
b=(5,6,7)
res2=list(zip(a,b))
print(res2)
执行结果：
[(1, 5), (2, 6), (3, 7)]
[(1, 5), (2, 6), (3, 7)]
[(1, 5), (2, 6)]
29、列表相加
print([1,2,3]+[4,5,6])
print([1,2,3]+[3,4,5,6])
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 3, 4, 5, 6]
30、提升python运行效率的方法
1、采用生成器，不使用列表和列表推导式，节省大量内存
2、多个if elif else 条件语句，把最有可能发生的条件写在最前面，这样可以减少程序判断的次数，提高效率。
3、循环代码优化，避免过多重复代码的执行
4、多进程、多线程、协程
31、简述mysql和redis区别
redis：内存型非关系数据库，数据保存在内存中，速度快
mysql：关系型数据库，数据保存在磁盘中，检索的话，会有一定的IO操作，访问速度相对慢
32、list=[2,3,5,4,9,6],从小到大排序，不许用sort，输出[2,3,4,5,6,9]
list1=[2,3,5,4,9,6]
def list_str(list):
num=len(list)
for i in range(num-1):
for j in range(num-1-i):
if list[j]>list[j+1]:
list[j],list[j+1]=list[j+1],list[j]
print(list)
list_str(list1)
[2, 3, 4, 5, 6, 9]
33、写一个单例模式
class Create_Object:
obj=None
def __new__(cls, *args, **kwargs):
if obj is None:
cls.obj=super().__new__(cls)
return cls.obj
object=Create_Object
object1=Create_Object
print(id(object))
print(id(object1))
2944204723184
2944204723184
34、实现保留2位小数
round(3.1415926，2)：2表示保留小数点后2位
num='{:.2f}'.format(3.4564564)
print(num)
num1=round(3.4564564,3)
print(num1)
3.46
3.456
35、求3个方法的打印结果
fn(“one”,1)：直接将键值传给字典
fn(“two”,2)：因为字典是可变数据类型，所以指向同一个内存地址，传入新的参数后，相当于给字典增加值
fn(“three”,3,{})：传入了一个新字典，所以不再是原先默认的字典
def fn(k,v,div={}):
div[k]=v
print(div)
fn("one",1)
fn("two",2)
fn("three",3,{})
{‘one’: 1}
{‘one’: 1, ‘two’: 2}
{‘three’: 3}
36、创建字典的方式
a=[("a",1),("b",2),("c",3),("d",4),("e",5)]
A=zip(("a","b","c","d","e"),(1,2,3,4,5))
print(dict(A))
B=dict([["name","zs"],["age",18]])
C=dict([("name","ls"),("age",20)])
print(B)
print(C)
37、深拷贝和浅拷贝
历史博文详细讲解
38、列出几种魔术方法并简要介绍用途
__init__：初始化对象__new__：创建对象__str__：返回对实例对象的描述__dict__：如果是类去调用，表示统计类中所有的类属性和方法；如果是对象去调用，统计的是实例属性__del__：删除对象执行的方法__next__：生成器对象去调用，不断的返回生成器中的数据
39、d=" sdf fg ",去除首尾空格
d=" sdf fg "
e=d.strip(' ')
print(e)
40、sort排序和sorted排序的区别
sort：对原列表进行排序，只能对列表进行排序
f=[1,4,6,3,2,4]
f.sort()
print(f)
[1, 2, 3, 4, 4, 6]
f1=(1,4,6,3,2,4)
f1.sort()
print(f1)
对元组排序报错
Traceback (most recent call last):
File “D:\log\ceshi_log\face_1.py”, line 249, in
f1.sort()
AttributeError: ‘tuple’ object has no attribute ‘sort’
sorted：对可迭代对象进行排序，排序后产生新的可迭代对象（列表）
f1=(1,4,6,3,2,4)
g=sorted(f1)
print(g,id(g))
print(f1,id(f1))
执行结果
[1, 2, 3, 4, 4, 6] 1646645367488
(1, 4, 6, 3, 2, 4) 1646643170272
41、使用lambda函数从从小到大排序
f=[1,2,4,6,3,-6,5,7,-1]
f1=sorted(f,key=lambda x:x)
print(f1)
不使用lambda函数对数据进行从小到大的排序
f=[1,2,4,6,3,-6,5,7,-1]
f1=sorted(f)
print(f1)
不使用lambda函数对数据进行从大到小的排序
f=[1,2,4,6,3,-6,5,7,-1]
f1=sorted(f,reverse=True)
print(f1)
42、使用lambda函数对list排序foo=[-5,8,0,4,9,-4,-20,-2,8,2,-4],正数从小到大，负数从大到小
foo=[-5,8,0,4,9,-4,-20,-2,8,2,-4]
foo1=sorted(foo,key=lambda x:(x<0,abs(x)))
print(foo1)
[0, 2, 4, 8, 8, 9, -2, -4, -4, -5, -20]
43、列表嵌套字典的排序
foo=[{'name':'zs','age':18},
{'name':'li','age':24},
{'name':'ww','age':25},]
按照姓名排序
foo1=sorted(foo,key=lambda x:x['name'])
print(foo1)
按照年领排序
foo2=sorted(foo,key=lambda x:x['age'],reverse=True)
print(foo2)
[{‘name’: ‘li’, ‘age’: 24}, {‘name’: ‘ww’, ‘age’: 25}, {‘name’: ‘zs’, ‘age’: 18}]
[{‘name’: ‘ww’, ‘age’: 25}, {‘name’: ‘li’, ‘age’: 24}, {‘name’: ‘zs’, ‘age’: 18}]
44、列表嵌套元组排序，分别对字母和数字进行排序
foo1=[('zs',19),('ls',18),('ww',20)]
foo2=sorted(foo1,key=lambda x:x[0])
print(foo2)
foo3=sorted(foo1,key=lambda x:x[1])
print(foo3)
[(‘ls’, 18), (‘ww’, 20), (‘zs’, 19)]
[(‘ls’, 18), (‘zs’, 19), (‘ww’, 20)]
45、列表嵌套列表排序，年领数字相同怎么办？
foo2=[['zs',19],['ls',18],['ww',20]]
a=sorted(foo2,key=lambda x:x[0])
b=sorted(foo2,key=lambda x:(x[1],x[0])) #数字相同按照字母排
print(a)
print(b)
[[‘ls’, 18], [‘ww’, 20], [‘zs’, 19]]
[[‘ls’, 18], [‘zs’, 19], [‘ww’, 20]]
46、根据键对字典排序
方法一：
dict1={"name":"zs","city":"beijing","tel":1243124}
dict1_1=sorted(dict1.items(),key=lambda x:x)
print(dict1_1) # [('city', 'beijing'), ('name', 'zs'), ('tel', 1243124)]
new_dict={}
for i in dict1_1:
new_dict[i[0]]=i[1]
print(new_dict)
{‘city’: ‘beijing’, ‘name’: ‘zs’, ‘tel’: 1243124}
方法二：
d1=sorted(dict1.items(),key=lambda x:x[0])
d2={k:v for k,v in d1}
print(d2)
47、根据字符串的长度进行排序
dt=["name1","zs","city","beijing","tel"]
dt1=sorted(dt,key=lambda x:len(x))
print(dt1)
[‘zs’, ‘tel’, ‘city’, ‘name1’, ‘beijing’]
48、递归求和
def func_sum(number):
if number>=1:
sum=number+func_sum(number-1)
else:
sum=0
return sum
print(func_sum(6))
21
49、求n的阶乘
def func_sum(number):
if number==1:
return 1
else:
sum=number*func_sum(number-1)
return sum
print(func_sum(7))
5040
50、用2种方法去掉空格
方法1：
st=" re rt ty"
st1=st.replace(' ','')
print(st1)
方法2：
st2=st.split(' ')
print(st2) #['', 're', 'rt', 'ty']
st3=''.join(st2)
print(st3)
rertty
rertty
