---

1、什么是解释性语言，什么是编译性语言？

编译型语言特点：编译成二进制文件；一次编译，多次执行；执行速度快（只需要翻译一次），跨平台型比较弱
解释型语言特点：翻译成C代码，再翻译成二进制，再执行；每次编译每次执行；执行速度慢（多次执行、多次编译），跨平台型比较强

2、说说中作用域是怎么划分的

内建作用域、全局作用域、闭包函数作用域、局部作用域
内建作用域：max、len，在任何地方都可以使用
全局作用域：全局变量，定义在.py文件中的变量
闭包函数作用域：定义在闭包函数中
局部作用域：定义在内部函数中

import os
from functools import reduce
from typing import Iterator, Iterable

c = 1  # 全局作用域


def fn():
    d = 2  # 函数作用域

    def fn1():
        e = 3  # 局部作用域


max(1, 2, 3)  # 内建作用域：在任何地方都可以用

3、type和isinstance方法的区别

目的不同：
type：用于获取对象的类型，其返回值是对象的类型
isinstance：用于测试对象是否是某种类型，返回True或者False
type不能判断子类对象是否属于父类，isinstance可以

a = 2
b = 2.4
print(isinstance(a, (int, float)))      #True
print(isinstance(b, (int, float)))      #True


class Father:
    pass


class Son(Father):
    pass


if __name__ == '__main__':
    son = Son()
    print(type(son))  # <class '__main__.Son'>
    print(isinstance(son, Son))  # True
    print(isinstance(son, Father))  # True
    print(isinstance(son, object))  # True

4、浅拷贝和深拷贝

总结：
1、浅拷贝只拷贝父对象，不会拷贝父对象中子对象
2、深拷贝不但拷贝父对象，父对象中的子对象也会拷贝
3、不可变对象，无论是深拷贝还是浅拷贝，都不会发生拷贝**

浅拷贝旨在减少内存的占用
深拷贝可以在做数据的清洗、修改或者入库的时候，对原数据进行复制一份，以防数据修改之后，找不到原数据
对于不可变对象类型，没有深浅拷贝的说法，无论是深拷贝还是浅拷贝结果一样的，如果对其重新赋值，
对于可变类型来说，浅拷贝只复制容器，不复制容器中元素;
深拷贝复制容器，元素如果是可变类型，也复制元素。

5、python中变量在内存中存储方式

1、什么是引用赋值？
定义了变量a，并且指向了内存中的一个地址，定义变量b时，将a变量的引用赋给b，两个变量指向了同一个内存地址。
2、引用赋值，如果使用的是可变类型：会被关联修改。

按值赋值：python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址付给新创建的变量。
符合字符串驻留条件的有：
1、数字在-5~256之间
2、符合标识符的字符串
3、字符串的长度为0或者为1时
4、字符串的由数字、字母、下划线组成时
5、字符串在编译前进行驻留，而不是编译后

1,当进行修改操作时，可变类型传递的是内存中的地址，也就是说，直接修改内存中的值，并没有开辟新的内存。
2,不可变类型被改变时，并没有改变原内存地址中的值，而是开辟一块新的内存，将原地址中的值复制过去，对这块新开辟的内存中的值进行操作。

6、python中的封装、继承、多态

https://blog.csdn.net/YZL40514131/article/details/121731536

7、python中内存管理机制是怎么样的？

https://blog.csdn.net/YZL40514131/article/details/125884570

8、简述类属性和对象属性的区别

类属性在__init__方法之外，
类属性可以让类和对象调用

实例属性定义在__init__中或者方法中
self.开头
只能通过实例对象调用
不能通过类去调用

调用类属性：
类调用：直接调用类属性
对象调用：先得到对象属性，如果有对象属性则获取类属性
类属性是共享的
同一个类创建的不同对象共享属性
对象属性
不同对象内存是独立的

9、类方法、实例方法、静态方法区别

https://blog.csdn.net/YZL40514131/article/details/119744665

10、类中property有什么用

https://blog.csdn.net/YZL40514131/article/details/120056165

11、with方法使用原理

用于上下文管理协议
__enter__:进入上下文
__exit__：退出上下文

class MyOpen:
    def __init__(self,filename,mode,encoding='utf-8'):
        self.f=open(filename,mode,encoding=encoding)

    def __enter__(self):
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()


with MyOpen('1.txt','r',encoding='utf-8') as f:
    res=f.readline()
    print("res",res)

12、while-else for-else语法的用法

换句话说，如果我们不是以正常方式退出循环，那么else分支将不被执行。
也就说在循环体内用break、return退出不会执行else语句。

13、编写程序实现：该函数的输入是一个仅包含数字的list，输出一个新的list，

其中每一个元素需要满足以下条件
1、该元素是偶数；
2、该元素在原list中是在偶数的位置

def num_list(num):
    return [i for i in num if i % 2 == 0 and num.index(i) % 2 == 0]


num = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(num_list(num))

14、read、readline、readlines

https://blog.csdn.net/YZL40514131/article/details/125609673

15、传递方式是值传递还是引用传递

不可变参数用值传递
可变参数是引用传递

16、正则表达式中贪婪模式和非贪婪模式的区别

贪婪模式：正则表达式去匹配时，会尽量多的匹配符合条件的内容
非贪婪模式：正则表达式去匹配时，会尽量少的匹配符合条件的内容，一旦匹配成功，不会继续往下匹配

17、python异步场景有哪些

1、多任务执行任务时不涉及共享资源，或者面对共享资源时只是读取数据，不会操作数据。
2、没有时序上的要求。
3、不能影响主线程的运行。
4、常用于IO操作等耗时操作，因为比较影响客户的体验和使用。
5、不需要原子操作，或可以通过其他方式控制原子性。

18、把字符串s中的每个空格替换成”%20”，

输入:s= “We are happy.", 输出: “We%20are%20happy.”

s = "We are happy."
s.replace("", "20%")

19、打乱一个排好序的对象

l = [2, 3, 4, 6]
import random

random.shuffle(l)
print(l)

20、将d按value进行排序

d = {'a': 24, 'g': 52, 'i': 12, 'k': 33}
d2 = sorted(d.items(), key=lambda d: d[1])
d3 = {key: value for key, value in d2}
print(d3)

21、将str1="k:1|k1:2|k2:3|k3:4"处理为字典

str1 = "k:1|k1:2|k2:3|k3:4"
d = {k.split(":")[0]: k.split(":")[1] for k in str1.split("|")}
print(d)

22、写一个列表生成式，产生一个公差为11的等差数列 0 11 22

l = [i for i in range(0, 100, 11)]
print(l)

l1 = [i * 11 for i in range(10)]
print(l1)

23、给定两个列表，怎么找出他们相同的元素和不同的元素

l1 = [1, 2, 3, 4]
l2 = [2, 3, 5, 6]

ll1 = set(l1)
ll2 = set(l2)

print(ll1 & ll2)  # 相同的元素
print(ll1 ^ ll2)  # 互不相同的元素
print(ll1 - ll2)  # l1不同l2的元素


{2, 3}
{1, 4, 5, 6}
{1, 4}

24、请写出一段python代码实现删除list里面的重复元素?

list1 = [1, 2, 2, 2, 3, 3, 4]


def func(list1):
    slow = 0
    fast = 0
    while fast < len(list1):
        if list1[fast] != list1[slow]:
            slow += 1
            list1[slow] = list1[fast]
        fast += 1
    return list1[:slow + 1]
print(func(list1))

---