【Python基础面试】笔试题快速梳理

1.字符串查找

# 区分下左侧查找和右侧查找的不同即可
# find 从左往右查找到第一个匹配字符的索引（rfind相反）
strs = "I like python and java"
one = strs.find('n')
print(one)  # 12
two = strs.rfind('n')
print(two)  # 15

2.字符串去掉两端字符

strs = "abbacabb"
# 两端匹配到的a、b都会被去除
print(strs.strip("ab"))  # c
strs2 = "abbacabcabb"
# 两端匹配到的a、b都会被去除
print(strs2.strip("ab"))  # cabc

3.字符串列表处理

names = ["Andrea", "Aaslay", "Steven", "Job"]
lists = []
for name in names:
    # 名字包含a字符个数大于或等于2(要区分大小写)
    if name.count('a') >= 2:
        lists.append(name)
print(lists)  # ['Aaslay']

4.装饰器

def outer():
    def inner():
        print("innner", end=" ")
    print("outer", end=" ")
    return inner


# 此时调用outer方法，只会走outer方法体内容，并没有走inner方法
outer()  # outer

# 改写下, 此时相当于走outer方法体后再调用inner()方法
outer()()  # outer innner

5.函数传参问题

def atest(a, b, *args):
    print(a)
    print(b)
    print(args)
    print(type(args))


atest(11, 22, 33, 44, 55, 66, 77, 88, 99)
"""
11
22
(33, 44, 55, 66, 77, 88, 99)
<class 'tuple'>
"""

6.字典操作

# 考察字典fromkeys方法的用法
tmp = dict.fromkeys(['a', 'b'], 4)
print(tmp)  # {'a': 4, 'b': 4}

7.枚举考察

lists = [1, 2, 3, 4]
tmp = 0
# enumerate枚举 是遍历生成(索引，元素)
print([(i, j) for i, j in enumerate(lists)])  # [(0, 1), (1, 2), (2, 3), (3, 4)]
for i, j in enumerate(lists):
    tmp += i * j
print(tmp)  # 20

8.列表相关方法考察

lists = [1, 1, 2, 3, 4, 5, 6]
lists.remove(1)  # 删除首次出现的指定元素
lists.extend([7, 8, 9])  # 结尾逐一增加可遍历对象中的元素
print(lists)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

9.正则表达式考察

# (.*)：表示匹配任意字符（除换行符）零次或多次，贪婪匹配。
# on：表示匹配字母 "on"。
# (.*?)：表示匹配任意字符（除换行符）零次或多次，非贪婪匹配。
# .*：表示匹配任意字符（除换行符）零次或多次。
# re.M | re.I：使用了 re.M 表示多行模式，re.I 表示不区分大小写。
# str2.group(1)：获取匹配对象 str2 中第一个括号内匹配到的内容
import re
str1 = "Python's features"
str2 = re.match(r"(.*)on(.*?) .*", str1, re.M | re.I)
print(str2.group())  # Python's features
print(str2.group(1))  # Pyth
print(str2.group(2))  # 's

10.for range考察

# 包含10不包含1，每次减2获取
for i in range(10, 1, -2):
    print(i)
'''
10
8
6
4
2
'''

11.简述python作用域的划分

# Builtins内建作用域：我们用到的python系统函数、用到的包等，在有python环境的地方均可使用，范围最大
# Global全局作用域
# 函数作用域，有函数嵌套时的中间区域
# 局部作用域

a = 1  # 全局作用域


def fun():
    b = 2  # 函数作用域

    def fun2():
        c = 3  # 局部作用域


print(max)
# <built-in function max>
# 内建作用域

"""
注：
python中if elif else while for try except等关键字不会引入新作用域
只在方法、类、模块中引入新作用域
"""

12.解释型语言和编译型语言区别

"""
Python是一种解释型语言，它在运行时逐行地将源代码翻译成机器语言并执行。
Python解释器会逐行解释和执行源代码，这使得Python具有动态性和灵活性。

Java是一种编译型语言，它在执行之前需要先将源代码编译成字节码（即 `.class` 文件），
然后由Java虚拟机（JVM）加载和执行字节码。这种编译与解释结合的方式使得Java具有跨平台性和较好的性能
"""

"""
`.pyc` 文件和 `.class` 文件在某种程度上是类似的，因为它们都是编译后的中间形式文件，
可以由相应的解释器加载和执行。
然而，Python和Java的编译与执行方式略有不同，这导致了两者被归类为不同的语言类型。

Python的解释型特性：Python被称为解释型语言，主要是因为Python解释器在执行时会逐行解释和执行源代码。
当Python解释器在第一次执行一个`.py`文件时，它会将源代码转换为字节码，并保存为`.pyc` 文件。
这个过程虽然包含了编译的步骤，但整体上仍被认为是解释型的，因为字节码是在执行时动态生成的，
而且Python解释器会直接加载和执行这些字节码，而不是生成本地的机器码。

Java的编译型特性：Java被称为编译型语言，因为Java源代码首先需要被编译成字节码（即 `.class` 文件），
然后由Java虚拟机（JVM）加载和执行这些字节码。
在这个过程中，Java编译器将源代码全部编译成字节码文件，而且字节码并不是在执行时才生成的，
因此整体上被认为是编译型的语言。

虽然 Python 在执行时也会进行某种形式的编译（生成 `.pyc` 文件），
但由于它的执行方式更接近于逐行解释执行，因此通常被称为解释型语言。
与之相反，Java 则更符合传统编译型语言的特征。
"""

13.get请求和post请求的不同

14.python中正则表达式如何提取数据

"""
在Python中，使用正则表达式进行匹配通常需要使用re模块。以下是一些常用的正则匹配规则及其含义：

普通字符
a：匹配字符 "a"
5：匹配数字 5
.：匹配除换行符以外的任意字符

字符类
[abc]：匹配字符 "a"、"b" 或 "c"
[^abc]：匹配除了 "a"、"b" 或 "c" 之外的任意字符
[a-z]：匹配任意小写字母
[A-Z]：匹配任意大写字母
[0-9]：匹配任意数字

预定义字符类
\d：匹配任意数字，相当于 [0-9]
\D：匹配任意非数字字符，相当于 [^0-9]
\w：匹配任意字母、数字或下划线字符，相当于 [a-zA-Z0-9_]
\W：匹配任意非字母、数字或下划线字符，相当于 [^a-zA-Z0-9_]
\s：匹配任意空白字符，包括空格、制表符、换行符等
\S：匹配任意非空白字符

重复
*：匹配前面的模式零次或多次
+：匹配前面的模式一次或多次
?：匹配前面的模式零次或一次
{n}：匹配前面的模式恰好n次
{n,}：匹配前面的模式至少n次
{n,m}：匹配前面的模式至少n次，至多m次

边界
^：匹配字符串的开头
$：匹配字符串的结尾
\b：匹配单词边界

分组与引用
(pattern)：匹配 pattern 并捕获匹配的文本
(?:pattern)：匹配 pattern 但不捕获匹配的文本
(?P<name>pattern)：给分组命名
\1, \2：引用分组匹配的文本
"""

# python中使用re模块处理正则表达式
# 可以使用分组() 然后结合match\search\findall方法获取匹配结果
import json
import re

str1 = "0453-6935992"
pattern = "\d{4}-\d{7}"
res = re.match(pattern, str1)
print(res)  # <re.Match object; span=(0, 12), match='0453-6935992'>
res2 = re.search(pattern, str1)  # search和match方法类似
print(res2)  # <re.Match object; span=(0, 12), match='0453-6935992'>
# 结果.group方法可以获取具体结果,当前正则表达式没有()分组操作，直接返回实际匹配结果
print(res.group())  # 0453-6935992
print(type(res.group()))  # <class 'str'>

# 添加分组的方式
pattern2 = "(\d{4})-(\d{7})"
res3 = re.match(pattern2, str1)
print(res3.groups())  # ('0453', '6935992')
print(res3.group(0))  # 0453-6935992
print(res3.group(1))  # 0453
# 利用findall方法
res4 = re.findall(pattern2, str1)
print(res4)  # [('0453', '6935992')]

# findall在实际场景中的使用
dict_test = {"name": "${name_value}", "age": 15, "address": "${address_value}"}
dict_str = json.dumps(dict_test)
pattern3 = "\${(.*?)}"
res5 = re.findall(pattern3, dict_str)
print(res5)  # ['name_value', 'address_value']