1、一行代码实现1-100的和

print(sum(range(1,101)))
5050
1
2

2、如何在一个函数内部修改全局变量

a=10
def func():
    a=20
    print(a)
func()
print(a)
1
2
3
4
5
6

执行结果：20，10

a=10
def func():
    global a
    a=20
    print(a)
func()
print(a)
1
2
3
4
5
6
7

执行结果：20，20

3、列出5个python标准库

import os
import sys
import time
import datetime
import random
import re
1
2
3
4
5
6

4、字典如何删除键和合并2个字典

🌙删除键

方法一：使用pop()
方法二：使用del

dic = {'a': 1, 'b': 2}
dic1 = {'c': 3, 'd': 4}

dic.pop('b')
print(dic)

del dic1['c']
print(dic1)
1
2
3
4
5
6
7
8

🌙合并字典

update：可以实现字典之间的合并

dic = {'a': 1, 'b': 2}
dic1 = {'c': 3, 'd': 4}

dic.update(dic1)
print(dic)
1
2
3
4
5

执行结果：{‘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)
1
2
3
4
5

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()
1
2
3
4
5
6
7

使用with方法

with open('a.txt') as f:
	print(f.read())
1
2

执行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)

1
2
3
4
5
6
7
8

方法二：

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)
1
2
3
4

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))
1
2
3
4
5
6

14、python中断言方法举例

a=3
assert(a>1)
print(a)    #3

a=3
assert(a>6)
print(a)
1
2
3
4
5
6
7

断言失败

Traceback (most recent call last):
  File "D:\log\ceshi_log\face_1.py", line 64, in <module>
    assert(a>6)
AssertionError
1
2
3
4

15、列出python中可变数据类型和不可变数据类型，并简述原理

历史博文有详细解答，按值赋值和引用赋值

16、去重并从小到大排序输出“adfjl”

🌙集合可以对字符串进行去重

s = 'ajldjlajfdljfddd'

s1=list(set(s))
s1.sort()

s2=''.join(s1)
print(s2)
1
2
3
4
5
6
7

🌙特别注意：不能使用split()方法

s1=s.split()
print(s1)
['ajldjlajfdljfddd']
1
2
3

17、用lambda函数实现两个数相乘

sum=lambda a,b:a*b
print(sum(3,4))
12
1
2
3

18、字典根据键从小到大排序

🌙dict1.items()：获取字典中的键值，并且键和值组合在一起成一个元组

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)

1
2
3
4
5
6
7
8
9
10
11

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)
1
2
3
4
5

执行结果：
Counter({‘e’: 8, ‘w’: 7, ‘r’: 5, ‘;’: 3, ‘g’: 2, ‘d’: 2, ‘f’: 1, ‘6’: 1})

20、filter方法求出列表所有奇数并构造新列表

a=[1,2,3,4,5,6,7,8,9,10]
def func(x):
    return x%2==1
newlist=filter(func,a)
newlist=[i for i in newlist]
print(newlist)
1
2
3
4
5
6

执行结果：
[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
2
3

执行结果：
[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))
1
2
3
4
5
6
7

执行结果：
<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)

1
2
3
4
5
6
7
8

24、[[1,2],[3,4],[5,6]]展开得到[1,2,3,4,5,6]

l=[[1,2],[3,4],[5,6]]

new_list=[]
for item in l:
    for i in item:
        new_list.append(i)

print(newlist)
1
2
3
4
5
6
7
8

执行结果：
[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)
1
2
3
4
5
6
7
8

26、举例说明异常模块中try except else finally的相关意义

🌙try except else 没有捕获到异常，执行else语句
try except finally 不管是否捕获到异常，都执行finally语句

27、python中交换2个数值

a=12
b=23
a,b=b,a
print(a)
print(b)
1
2
3
4
5

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
2
3
4
5
6
7
8
9
10
11
12
13
14

执行结果：
[(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

[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)
1
2
3
4
5
6
7
8
9

[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))
1
2
3
4
5
6
7
8
9
10
11

2944204723184
2944204723184

34、实现保留2位小数

round(3.1415926，2)：2表示保留小数点后2位

num='{:.2f}'.format(3.4564564)
print(num)

num1=round(3.4564564,3)
print(num1)
1
2
3
4
5

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,{})
1
2
3
4
5
6

{‘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)

1
2
3
4
5
6
7
8
9

37、深拷贝和浅拷贝

历史博文详细讲解

38、列出几种魔术方法并简要介绍用途

__init__：初始化对象
__new__：创建对象
__str__：返回对实例对象的描述
__dict__：如果是类去调用，表示统计类中所有的类属性和方法；如果是对象去调用，统计的是实例属性
__del__：删除对象执行的方法
__next__：生成器对象去调用，不断的返回生成器中的数据

39、d=" sdf fg ",去除首位空格

d=" sdf fg "
e=d.strip(' ')
print(e)
1
2
3

40、sort排序和sorted排序的区别

sort：对原列表进行排序，只能对列表进行排序

f=[1,4,6,3,2,4]
f.sort()
print(f)
1
2
3

[1, 2, 3, 4, 4, 6]

f1=(1,4,6,3,2,4)
f1.sort()
print(f1)
1
2
3

对元组排序报错
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

执行结果
[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)
1
2
3

不使用lambda函数对数据进行从小到大的排序

f=[1,2,4,6,3,-6,5,7,-1]
f1=sorted(f)
print(f1)
1
2
3

不使用lambda函数对数据进行从大到小的排序

f=[1,2,4,6,3,-6,5,7,-1]
f1=sorted(f,reverse=True)
print(f1)

1
2
3
4

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)
1
2
3

[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)
1
2
3
4
5
6
7
8
9
10
11

[{‘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)
1
2
3
4
5
6
7

[(‘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)
1
2
3
4
5

[[‘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)
1
2
3
4
5
6
7
8

{‘city’: ‘beijing’, ‘name’: ‘zs’, ‘tel’: 1243124}

方法二：

dict1={"name":"zs","city":"beijing","tel":1243124}
dict1_1=list(zip(dict1.keys(),dict1.values()))
print(dict1_1)

dict1_2=sorted(dict1_1,key=lambda x:x[0])
new_dict={i[0]:i[1] for i in dict1_2}
print(new_dict)
1
2
3
4
5
6
7

47、根据字符串的长度进行排序

dt=["name1","zs","city","beijing","tel"]
dt1=sorted(dt,key=lambda x:len(x))
print(dt1)
1
2
3

[‘zs’, ‘tel’, ‘city’, ‘name1’, ‘beijing’]

48、递归求和

dt=["name1","zs","city","beijing","tel"]
dt1=sorted(dt,key=lambda x:len(x))
print(dt1)


def func_sum(number):
    if number>=1:
        sum=number+func_sum(number-1)
    else:
        sum=0
    return sum
print(func_sum(6))

1
2
3
4
5
6
7
8
9
10
11
12
13

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))
1
2
3
4
5
6
7
8

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)
1
2
3
4
5
6
7
8
9
10

rertty
rertty