Python基础面试编程知识-杂

文章目录

• • [1、 循环 1-100求和](#1、 循环 1-100求和)
  • [2、删除字典键 del](#2、删除字典键 del)
  • 3、合并字典update
  • 4、列表去重
  • [5、函数中 (*args,**kwargs)的意义](#5、函数中 (*args,**kwargs)的意义)
  • 6、python2和python3中的range函数区别
  • 7、什么样的语言能够用装饰器
  • 8、python内建数据类型
  • 9、init,new
  • [10、with 方法](#10、with 方法)
  • [11、python 中可变数据类型和不可变数据类型，并简述原理](#11、python 中可变数据类型和不可变数据类型，并简述原理)
  • [12、lambda 函数相乘](#12、lambda 函数相乘)
  • 13、正则
  • 14、求出列表所有奇数并构造新列表
  • 15、列表合并
  • 16、python删除文件和linux命令删除文件方法
  • 17、处理时间格式
  • 18、自定义异常
  • 19、贪婪和非贪婪匹配
  • 20、列表推导式--列表展开
  • [21、join 操作字符串 x.join(y),x.join(z)](#21、join 操作字符串 x.join(y),x.join(z))
  • 22、冒泡排序
  • 23、选择排序
  • [24、TCP UDP](#24、TCP UDP)
  • 25、统计字符中出现字符出现的次数
  • 26、交换数组中的min和max
  • 27、字符串翻转
  • 28、list升序降序后输出不带空格的新字符串
  • 29、死锁是什么

a = {"name": "张三", "性别": "男", "年龄": 18}

b = {"籍贯": "广东", "地址": "崂山"}

x = 0

1、 循环 1-100求和

for i in range(0,100):  # 循环 1-100求和
    x += i
print(x)

 #sum 参数 iterable,[x,start] 可迭代对象，数组，列表，元祖，start默认为0
print(sum(range(1,100)))

2、删除字典键 del

del a["name"]
print(a)  # {'性别': '男', '年龄': 18}

3、合并字典update

a.update(b)
print(a)
# {'性别': '男', '年龄': 18, '籍贯': '广东', '地址': '崂山'}

4、列表去重

c = [1, 1, 1, 2, 3, 4, 4, 5, 6]
c1 = set(c)
print(c1)
# {1, 2, 3, 4, 5, 6}

5、函数中 (*args,**kwargs)的意义

参数的数量不定

def demo(args_f, *args_v):
    print(args_f)
    for i in args_v:
        print(i)

# 这里传入几个参数，就处理多少参数
demo("a", "b", "c", "d")  
# a
# b
# c
# d

6、python2和python3中的range函数区别

python2 return list

python return interable(迭代器),更节约内存

7、什么样的语言能够用装饰器

函数可以作为参数传递的语言可以使用装饰器

8、python内建数据类型

int 整数

bool 布尔

st 字符串

list 列表

tuple 元祖

dict 字典

9、init ,new

init是初始化方法，创建对象后，会立刻被调用，可以接收参数，init有个self参数

new 至少要有一个参数cls,用来代表当前的类,此参数在实例化时由python解释器自动识别

10、with 方法

file = open("a.txt", "wb")
try:
    file.write("hello world")
    print("写入成功")
except:
    pass
finally:
    file.close()

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

不可变数据类型：数值型、字符串型 string 和元组 tuple

如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象（一个地址）

字符串去重并排序,去重并从小到大输出

e = "aaddssjkljklfajlsfjalkdsfasafadsfafffdsssfdss"
print(set(e))
# {'l', 'a', 'j', 'k', 'd', 'f', 's'}

12、lambda 函数相乘

g = 10
h = 2
sum = lambda g, h: g * h
print(sum(g, h))
# 20

13、正则

import re

j = "not fount 404 张三 18 北京"
list = j.split(" ")
print(list)  # ['not', 'fount', '404', '张三', '18', '北京']

res1 = re.findall('\d+|[a-zA-Z]+', j)
for i in res1:
    if i in list:
        list.remove(i)

new_str = " ".join(list)
print(res1)  # ['not', 'fount', '404', '18']
print(new_str)  # 张三 北京

14、求出列表所有奇数并构造新列表

a1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


def fn(a1):
    return a1 % 2 == 1


newlist = filter(fn, a1)
newlist = [i for i in newlist]
print(newlist)

# 列表推导式 求奇数并构造新列表
res2 = [i for i in a1 if i % 2 == 1]
print(res2)

15、列表合并

a_list = [1, 3, 5, 7, 9]
b_list = [2, 4, 6, 8, 10]
a_list.extend(b_list)
print(a_list) # [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

a_list.sort(reverse=False)
print(a_list) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

16、python删除文件和linux命令删除文件方法

# python
os.remove(filename)

# linux
rm filename

17、处理时间格式

import datetime

a_time = str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") + ' 星期 ' + str(datetime.datetime.now().isoweekday()))
print(a_time) # 2024-03-06 16:52:13 星期 3

18、自定义异常

def fn1(num):
    try:
        for i in range(num):
            if i > 2:
                raise Exception("当前数字大于2")
    except Exception as ret:
        print(ret)


fn1(10)  # 调用函数了  当前数字大于2

19、贪婪和非贪婪匹配

1、贪婪：会把满足正则的尽可能多的往后匹配 (.*)

2、非贪婪：会把满足正则的尽可能少匹配 (.*?)

a_str = "<a>哈哈哈</a><a>嘿嘿</a>"
import re

res_tl = re.findall("<a>(.*)</a>", a_str)
print("贪婪匹配结果:", res_tl)
# 贪婪匹配结果: ['哈哈哈</a><a>嘿嘿']

res_ftl = re.findall("<a>(.*?)</a>", a_str)
print("非贪婪匹配结果:", res_ftl)
# 非贪婪匹配结果: ['哈哈哈', '嘿嘿']

20、列表推导式--列表展开

# 法一
td_list = [[1, 2], [3, 4], [5, 6]]
new_td_list = [j for i in td_list for j in i]
print(new_td_list)

# 法二
import numpy as np

bp = np.array(td_list).flatten().tolist()
print(bp)
# [1, 2, 3, 4, 5, 6]

21、join 操作字符串 x.join(y),x.join(z)

x_str = "abc"
y_str = "def"
z_dic = ["d", "e", "f"]

y_join_x = x_str.join(y_str)
x_join_z = x_str.join(z_dic)
print(y_join_x) # dabceabcf
print(x_join_z) # dabceabcf

22、冒泡排序

def bubbleSort(arr):
    for i in range(1, len(arr)):
        for j in range(0, len(arr) - i):
            if arr[j] > arr[j + 1]:  # 大于是升序，小于是降序
                arr[j], arr[j + 1] = arr[j + 1], arr[j]  # 互换位置
    return arr

23、选择排序

def selectionSort(arr):
    for i in range(len(arr) - 1):
        # 记录最小数的索引
        minIndex = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[minIndex]:
                minIndex = j
        # i 不是最小数时，将 i 和最小数进行交换
        if i != minIndex:
            arr[i], arr[minIndex] = arr[minIndex], arr[i]
    return arr

24、TCP UDP

（Transmission Control Protocol，传输控制协议）,是面向连接的协议，也就是说，在收发数据前，必须和对方建立可靠的连接,一个 TCP 连接必须要经过三次 "对话" 才能建立起来
（User Data Protocol，用户数据报协议）,UDP 是一个非连接的协议，传输数据之前源端和终端不建立连接， 当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。

25、统计字符中出现字符出现的次数

# 办法1
a = "helloworld"
print("统计a中各项的个数，办法1（字典）：")
dicta = {}
for i in a:
    dicta[i] = a.count(i)
print(dicta)
{'h': 1, 'e': 1, 'l': 3, 'o': 2, 'w': 1, 'r': 1, 'd': 1}


# 办法2
print("统计a中各项的个数，办法2（collections的counter）：")
from collections import Counter
print(Counter(a))
# Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, 'w': 1, 'r': 1, 'd': 1})

# 办法3
print("统计a中各项的个数，办法3（count方法）：")
for i in a:
    print("%s:%d" % (i, a.count(i)))  # 用count方法计算各项数量，简单打印出来而已
# h:1
# e:1
# l:3
# l:3
# o:2
# w:1
# o:2
# r:1
# l:3
# d:1

26、交换数组中的min和max

a = [3, 4, 5, 2, 1]
a[a.index(max(a))], a[a.index(min(a))] = min(a), max(a)

27、字符串翻转

a = "asdf1fdsa"
b = "asdfgh123"

if a == a[::-1]:
    print("可以")
else:
    print("不可以")

28、list升序降序后输出不带空格的新字符串

from numpy import sort

a = [99, 11, 22, 33, 44, 66, 33]
print(sort(a)) # [11 22 33 33 44 66 99]

for i in sort(a):
    print(i, end="")  # 11223333446699

29、死锁是什么

死锁是指在多线程或多进程环境下，两个或多个进程或线程因争夺系统资源而陷入一种互相等待的状态，导致它们无法继续执行下去，同时也无法释放自己所占用的资源，从而造成系统无法正常运行的情况