python基础面试题

最新推荐文章于 2024-08-04 20:11:50 发布

Pwsifeng

最新推荐文章于 2024-08-04 20:11:50 发布

阅读量587

点赞数

文章标签： python 开发语言后端

本文链接：https://blog.csdn.net/Pwsifeng/article/details/121568401

版权

1.Python的特点

Python是一种解释性语言【开发过程中没有了编译这个环节，类似于PHP或者Perl语言】
Python是交互式语言【可以在一个Python提示符，直接互动执行程序】
Python是面向对象语言【Python支持面向对象的风格或代码封装在对象的编程技术】
Python是初学者的语言【Python对于初级程序员而言，是一种伟大的语言，他支持广泛的应用程序开发，从简单的文字处理到浏览器再到游戏】
Python是跨平台的【它可以运行在Windows、Mac os或者Linux系统上，也就是说，在Windows上书写的Python程序，在Linux上也是可以运行的，类似于Java】

2.Python优缺点

优点：

易于学习【Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单】

易于阅读【Python代码定义的更清晰】

易于维护【Python的成功在于它的源代码是相当容易维护的】

一个广泛的标准库【Python的最大优势之一是丰富的库，跨平台的，在nuix、weindows和mac os上的兼容性很好】

互动模式【互动模式的支持，可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片段】

可移植性【基于其开发源代码的特性，Python已经被移植到许多平台】

可扩展性【如果需要一段运行很快的关键代码，或者想要编写一些不愿开发的算法，可以使用C或者C++完成那部分程序，然后从你的Python程序中调用】

数据库【Python提供所有主要的商业数据库的接口】

GUI编程（图形化界面）【Python支持GUI可以创建和移植到许多系统调用】

可嵌入性【可以将Python嵌入到C或者C++程序，让你程序的用户获得“脚本化”的能力】

点：

运行速度慢【和C程序相比非常慢，因为Python是解释型语言，代码在执行时会一行一行的翻译成CPU能理解的机器码，这个翻译过程非常耗时，所以很慢，而C程序是运行前直接编译成CPU能执行的机器码，所以非常快】

代码不能加密【如果要发布Python程序，实际上就是发布源代码，这一点跟C语言不通，C语言不用发布源代码，只需要把编译后的机器码（就是windows上常见的xxx.exe）发布出去，要从机器码反推出C代码是不可能的，所以，凡是编译型的语言，都没有这个问题，而解释型的语言，则必须把源码发布出去】

3.Python应用场景【面试题】

Web开发【通过mod_wsgi模块，Apache可以运行用Python编写的Web程序。Python定义了WSGI标准应用接口来协调Http服务器与基于Python的Web程序之间的通信。一些Web框架，如Django,TurboGears,web2py,Zope等，可以让程序员轻松地开发和管理复杂的Web程序】

操作系统管理、服务器运维的自动化脚本【在很多操作系统里，Python是标准的系统组件。大多数Linux发行版以及NetBSD、OpenBSD和Mac OS X都集成了Python，可以在终端下直接运行Python。Python编写的系统管理脚本在可读性、性能、代码重用度、扩展性几方面都优于普通的shell脚本】

网络爬虫【Python有大量的HTTP请求处理库和HTML解析库，并且有成熟高效的爬虫框架Scrapy和分布式解决方案scrapy-redis，在爬虫的应用方面非常广泛】

科学计算（数据分析）【NumPy、SciPy、Pandas、Matplotlib可以让Python程序员编写科学计算程序】

桌面软件【PyQt、PySide、wxPython、PyGTK是Python快速开发桌面应用程序的利器】

服务器软件（网络软件）【Python对于各种网络协议的支持很完善，因此经常被用于编写服务器软件、网络爬虫。第三方库Twisted支持异步网络编程和多数标准的网络协议(包含客户端和服务器)，并且提供了多种工具，被广泛用于编写高性能的服务器软件】

游戏【很多游戏使用C++编写图形显示等高性能模块，而使用Python或者Lua编写游戏的逻辑、服务器。相较于Python，Lua的功能更简单、体积更小；而Python则支持更多的特性和数据类型】

自动化测试

搜狐、豆瓣、腾讯、网易、百度、阿里、淘宝、土豆、新浪等都在内部大量的使用Python

4.标识符【面试题】

概念：计算机编程语言中，标识符是用户编程时使用的名字，用于给变量、常量、函数、语句块等命名，以建立起名称与使用之间的关系

合法标识符的命名规则：

只能由数字，字母和下划线组成
不可以是除了下划线之外的其他特殊字符
开头不能是数字或者空格
不能是Python的关键字
严格区分大小写 age Age

标识符的命名规范：

尽量做到见名知意【具有描述性】：尽量使用简单的英文单词表示
遵守一定的命名规范
Python官方推荐的命名方式：变量名，函数名和文件名全小写，使用下划线连接，如：stu_name check_qq
驼峰命名法：不同的单词之间使用首字母大写的方式进行分隔，又分为大驼峰和小驼峰，比如：stuName就是小驼峰，StuName就是大驼峰，小驼峰常用于变量或者函数的命名，大驼峰常用于类的命名

5.列出Python中常用的数据类型，至少5种【面试题】

方式一：数字类型，布尔类型，字符串类型，列表类型，元组类型，字典类型，集合类型，字节类型，空值
方式二：int/float,bool,str,list,tuple,dict,set,bytes,NoneType

6.【面试题】下面那些标识符是合法【规则】的,如果不合法，说明原因

    name
    name1
    name_1
    1name     不合法，数字不能开头
    @java     不合法，只能使用下划线
    abc$123    不合法，只能使用下划线
    xiaoming

7.【面试题】：打包pack和拆包unpack

##### *:所有

m1,m2,*m3 = 34,56,2,56,56,67,68,8,89
print(m1,m2,m3)
m1,*m2,m3 = 34,56,2,56,56,67,68,8,89
print(m1,m2,m3)
*m1,m2,m3 = 34,56,2,56,56,67,68,8,89
print(m1,m2,m3)

m1,m2,*m3 = 34,56,2,56,56,67,68,8,89
print(m1,m2,*m3)

m1,*m2 = [34,5,6,7,8]
print(m1,m2)

8.【面试题】：交换两个变量的值

##### 方式一：定义第三方变量

a = 10
b = 20
temp = a
a = b
b = temp
print(a,b)

# 方式二           ******

a = 10
b = 20
a,b = b,a
print(a,b)

# 方式三：加减法

a = 10
b = 20
a = a + b  # a = 30
b = a - b  # b = 10
a = a - b  # a = 20
print(a,b)

9.【面试题】：重点：短路原则

a.A and B,如果A为False，不需要计算B的值，整个表达式的结果为False

b.A or B,如果A为True，不需要计算B的值，整个表达式的结果为True

c.and和or混合使用

```
1>表达式从左往右运算，如果or的左侧为True，则会短路or后面所有的表达式【不管是and还是or连接】，整个表达式的结果为True

2>表达式从左往右运算,如果and的左侧为False,则短路后面所有的and，直到or出现，接着计算

3>如果or的左侧为False，或者and的左侧为True，则不能使用短路逻辑判断
```

注意：所有被短路的表达式均不会被输出
【面试题】
A and B
    如果A为真，则A and B的结果是B
    如果A为假，则A and B的结果是A

10.【面试题】：身份运算符用于比较两个对象的存储单元

is:判断两个标识符是不是引用自一个对象
	is not:判断两个标识符是不是引用自不同对象
"""

"""
【面试题】可变数据类型和不可变数据类型
    可变数据类型：list  dict   set
    不可变数据类型:int  float bool str tuple

【面试题】说明is和==的区别和联系
    a.==比较的是内容
    b.is比较的是地址
    c.如果两个变量的内容相同，他们的地址不一定相同,如果两个变量的地址相同，则他们的内容一定相同
"""

11.【面试题】简述break和continue的区别

break是一个关键字，可以单独作为一条语句使用
break的作用:主要应用在循环中，作用是结束循环
2.continue是一个关键字，可以单独作为一条语句使用
continue表示结束本次循环，继续下一次循环

12.【面试题】切片

切片：根据指定的区间，通过某种规律在列表，元组或者字符串中进行截取，形成一个新的列表，元组或字符串
语法：列表[start:end:step]
    start:开始索引，可以省略，默认为0，不省略的情况下包含在内
    end:结束索引，可以省略，默认为最后一个【正数或负数】，不省略的情况下不包含在内
    step:步长，可以省略，默认为1

0   1   2   3   4   5   6   7   8
-9 -8  -7  -6  -5  -4  -3  -2   -1

注意：
    a.只要切片的语法正确，哪怕获取不到元素，都不会报错
    b.切片之后会得到一个新的列表，对原列表没有任何影响
    # 5.start和end都为正数
"""
结论1：
    如果start和end同符号，遵循下面的规律
    a.计算start + step
    b.判断上述结果是否在start和end区间内
    c.如果不在，则结果直接为[],如果在，则依次获取
   # 7.start和end一个为正数，一个为负数
"""
结论：
    如果start和end一个为正数，一个为负数，则以start的正负作为参考
    如果start为正，end为负数，则使用正数索引
    如果start为负，end为正数，则使用负数索引
"""
print(numlist[-6:1:1])    # []
print(numlist[-6:-8:1])   # []

print(numlist[-6:1:-1])   # [44,33]
print(numlist[-6:-8:-1])  # [44,33]
# 6.
"""
列表[start::step]
    step为正数：则从左往右获取
    step为负数：则从右往左获取
"""
print(numlist[6::1])
print(numlist[6::-1])

12.【面试题】append和extend都作为向列表中添加元素的功能，有什么区别和联系

相同点：
a.元素都会出现在列表的末尾
b.都可以添加单个或多个元素
c.都是在原列表的基础直接操作的
不同点：
a.append可以追加任意类型的数据，而extend只能添加可迭代对象
b.如果向列表中添加一个可迭代对象，append会将可迭代对象整体添加，而extend只会添加可迭代对象中的元素

# 补充：append()和pop()

"""
append()是在列表的末尾添加元素
pop()将列表末尾的元素删除

列表的工作原理：列表的底层维护了一个栈的数据结构，而栈的工作特点：先进后出，后进先出，理解：一个开口向上的容器

队列：先进先出，后进后出，理解：一个水平放置的水管

13.【面试题】列表拷贝

浅拷贝结论：
一维列表：会将拷贝的列表开辟一份新的内存空间，所以其中一个列表中的元素修改，对另一个列表没有影响
多维列表：本质是一个浅拷贝，只会拷贝最外层的地址，所以如果一个列表修改内层列表的元素，另一个列表会随着修改。
深拷贝结论：两个列表指向不同的内存空间，不管是几维列表，所有的内容都会被重新拷贝，其中一个列表中的元素发生修改，则访问另一个列表，没有任何影响。

# 面试题一
# a.
a = [1,2,3]
b = [4,5]
c = [a,b]
d = c
e = c.copy()
a.append(6)
print(c,d,e)
"""
c:[[1,2,3,6],[4,5]]
d:[[1,2,3,6],[4,5]]
e:[[1,2,3,6],[4,5]]
"""

a = [1,2,3]
b = [4,5]
c = [a,b]
d = c
e = c.copy()
c.append(6)
print(c,d,e)
"""
c:[[1,2,3],[4,5],6]
d:[[1,2,3],[4,5],6]
e:[[1,2,3],[4,5]]
"""

# 面试题二
a = [1,2,['a','b']]
b = a
c = copy.deepcopy(a)
a[-1].append(3)
print(a,b,c)
"""
a:[1,2,['a','b',3]]
b:[1,2,['a','b',3]]
c::[1,2,['a','b']]
"""

# 面试题三
a = [1,2,['a','b']]
b = a
c = copy.copy(a)
a.append(3)
print(a,b,c)
"""
a:[1,2,['a','b'],3]
b:[1,2,['a','b'],3]
c:[1,2,['a','b']]
"""

14.【面试题】简单算法

# 冒泡排序
# 以升序为例
list1 = [45,6,8,9,2,56,68,98,100,56,4,19]
# 外层循环：控制比较的轮数
for i in range(len(list1) - 1):
    # 内层循环：控制的是每一轮比较的次数，兼顾参与比较的下标
    for j in range(len(list1) - 1 - i):
        # 相邻两个元素比较大小
        # 如果下标小的元素  > 下标大的元素，则交换位置
        if list1[j] > list1[j + 1]:
            list1[j],list1[j + 1] = list1[j + 1],list1[j]
print(list1)

# 选择排序
# 以升序为例
list1 = [45,6,8,9,2,56,68,98,100,56,4,19]
# 外层循环：控制比较的轮数
for i in range(len(list1) - 1):
    # 内层循环：控制的是每一轮比较的次数，兼顾参与比较的下标
    for j in range(i + 1,len(list1)):
        # 相邻两个元素比较大小
        # 如果下标小的元素  > 下标大的元素，则交换位置
        if list1[i] > list1[j]:
            list1[i],list1[j] = list1[j],list1[i]
print(list1)

二分法查找：
# 以升序为例
list1 = [34,6,7,8,9,40,26,7,73,48,737]
list1.sort()
key = 7

left = 0
right = len(list1) - 1

while left <= right:
    # 计算中间下标
    middle = (left + right) // 2
    # 比较
    if key  > list1[middle]:
        # 后半部分：重置left的值
        left = middle + 1
    elif key < list1[middle]:
        # 前半部分：重置right的值
        right = middle - 1
    else:
        print(f"待查找元素{key}在列表中的下标为{middle}")
        # 查找到元素，则提前结束循环
        break
else:
    print(f"待查找元素{key}在列表中不存在")

15.【面试题】元组

# a
t1 = (34,5,6,6,2,7,[1,2,3])
print(id(t1[-1]))
t1[-1][0] = 100
print(t1)    # (34, 5, 6, 6, 2, 7, [100, 2, 3])
print(id(t1[-1]))

# b.
# l1 = [3,5,6,7,7,(4,6,7)]
# l1[-1][0] = 100
# print(l1)  # 报错

16.【面试题】列表和字典的区别

格式：列表:[] 字典:{}
存储的数据：列表中可以存储任意类型的数据，
字典中存储的是键值对，其中键只能是不可变的数据类型，值可以是任意的类型
是否可变：列表是可变的，字典是可变的
是否有序：列表是有序的，字典Python3.7之前是无序的，3.7之后是有序的
是否可以存储重复数据：列表中可以存储重复数据，字典中的键是唯一的，值可以重复
使用的场景不同：列表常用与可以存储同类型的数据，字典常用于可以存储同一个对象的不同信息或者需要精确定位到某个数据。

17.【面试题】使用不同的方式定义字典，至少两种

# 方式一               ******
info_dict = {"name":"张三","age":18,"hobby":"吹牛逼"}
print(info_dict)

# 方式二                  ******
dict1 = {}
dict1['aaa'] = 10
dict1['bbb'] = 20
print(dict1)

# 方式三：
# dict(key1=value1,key2=value2.....)
dict2 = dict(x=10,y=20,z=30)
print(dict2)  # {'x': 10, 'y': 20, 'z': 30}
# 问题：采用dict(key1=value1,key2=value2.....)方式，字典的key只能是字符串
# d1 = {10:1,20:2}
# d2 = dict(10=1,20=2)

# 方式四
# dict([(key1,value1),(key2,value2).....])
dict3 = dict([('a',11),('b',22),('c',33)])
print(dict3)
dict3 = dict([(10,11),('b',22),('c',33)])
print(dict3)

# 方式五：                  *******
# 映射
# dict(zip([key1,key2....],[value1,value2...]))
dict4 = dict(zip(['name','age','score'],['jack',17,100]))
print(dict4)
dict4 = dict(zip(('name','age','score'),['jack',17,100]))
print(dict4)
dict4 = dict(zip(('name','age','score'),('jack',17,100)))
print(dict4)
dict4 = dict(zip(['name','age','score','height'],['jack',17,100]))
print(dict4)
dict4 = dict(zip(['name','age','score'],['jack',17,100,456,67,8]))
print(dict4)

# 注意：不管通过哪种方式定义字典，字典的key都不能是列表，字典，集合等可变的数据类型

18.【面试题】需求：已知一个字典dict1 = {‘a’:10,“b”:20},交换键值，生成一个新的字典

dict1 = {'a':10,"b":20}
# 方式一
dict2 = {}
for key in dict1:
    dict2[dict1[key]] = key
print(dict2)
# 方式二
dict2 = {}
for key,value in dict1.items():
    dict2[value] = key
print(dict2)
# 方式三
dict2 = dict(zip(dict1.values(),dict1.keys()))
print(dict2)
# 方式四
dict2 = {value:key for key,value in dict1.items()}
print(dict2)
# 方式五：
dict2 = {dict1[key]:key  for key in dict1}
print(dict2)

# 练习：生成一个字典{0:0,1:1,2:4,3:9,4:16,5:25}
dict3 = {i:i ** 2 for i in range(6)}
print(dict3)

19.【面试题】同列表推导式，可以同时使用多个for循环或者多个if语句

list1 = [a + b for a in "xyz" for b in '123']
print(list1) # ['x1', 'x2', 'x3', 'y1', 'y2', 'y3', 'z1', 'z2', 'z3']
dict4 = {a:b for a in "xyz" for b in '123'}
print(dict4)  # {'x': '3', 'y': '3', 'z': '3'}

20.【面试题】：简述列表，元组，字典，集合和字符串的区别

列表的本质：list,是一种有序的，可变的，可以存储重复元素的，可以存储不同类型的集合

元组的本质：tuple,是一种有序的，不可变的，可以存储重复元素的，可以存储不同类型的集合

字典的本质：dict,是一种有序的【Python3.7之后】，可变的，key不可以重复，

但是value可以重复，key只能是不可变的数据类型，vlue可以是任意的类型的集合

集合的本质：set,是一种无序的，可变的，不可以存储重复元素的，可以存储不同类型的集合

字符串的本质：str,是一种有序的，不可变的，可以存储重复字符的集合

21.【面试题】字符串替换

# name = "gouguoQ "
# name.replace("o","p")
# print(name)
# 注意1：默认将原字符串中的old全部替换
name = "gouguoQo3635o54ooo "
d1 = name.replace("o","p")
print(d1)
# 注意2：未省略count，则表示从左往右替换count个字符
d1 = name.replace("o","p",3)
print(d1)

# 注意3：可以采用映射替换设置替换的规则
# 注意4:在映射替换中，创建映射表使用的字符串的长度必须相等
name = "41564518"
table = str.maketrans("123456","abcdef")
print(table)  # {49: 97, 50: 98, 51: 99, 52: 100, 53: 101, 54: 102}
d2 = name.translate(table)
print(d2)

22.【面试题】编码和解码

编码：将字符串类型转换为字节类型，bytes()或encode()
解码：将字节类型转换为字符串类型,str()或decode()

字符串：''   ""
字节：b''   b""

编码格式：
    utf-8
    gbk
"""

# 1.编码
str1 = "3454hajgaj发哈哈%￥#@"
# a.bytes()
r1 = bytes(str1,encoding="utf-8")
print(r1)
print(type(r1))

# b.字符串.encode()
r2 = str1.encode(encoding="gbk")
print(r2)
print(type(r2))

# 2.解码
# 注意：编解码采用的格式必须保持一致
# a.str()
r3 = str(r1,encoding="utf-8")
print(r3)
print(type(r3))

# b.字节.decode()
r4 = r2.decode(encoding="gbk")
print(r4)
print(type(r4))

# 扩展
# f = open(r"file1.txt","w",encoding="gbk")
# f.write("你好hello")
# f.close()

23.【面试题】简述函数传参过程中，值传递和引用传递的区别

 值传递：传参的时候，传递的是不可变的数据类型，如：int/float/bool/str/tuple等，当形参发生修改，实参没有影响
    引用传递：传参的时候，传递的是可变的数据类型，如：list/dict.set等，当形参发生元素的修改，则实参会随着修改
"""

# 1.值传递
def func1(num):
    print(f"修改之前，num的id:{id(num)}")
    num = 100
    print(f"修改之后，num的id:{id(num)}~~~~~")
temp = 45
func1(temp)
print(f"函数调用完毕，temp的id:{id(temp)}")

print("*" * 50)

# 2.引用传递
# a
def func1(num):
    print(f"修改之前，num的id:{id(num)}")
    num = 100
    print(f"修改之后，num的id:{id(num)}~~~~~")
temp = [10,20,30]
func1(temp)
print(f"函数调用完毕，temp的id:{id(temp)}")

# b
def func1(num):
    print(f"修改之前，num的id:{id(num)}")
    num[1] = 100
    print(f"修改之后，num的id:{id(num)}~~~~~")
    print(num)
temp = [10,20,30]
func1(temp)   # num = temp
print(f"函数调用完毕，temp的id:{id(temp)}")
print(temp)

24.【面试题】字符串

name = "fahJFGk"
name.upper()
print(name)   # fahJFGk

name = "fahJFGk"
name = name.upper()
print(name)  # FAHJFGk

25.【面试题】输出

def  func():
    a = []
    for i in range(5):
        # a列表中添加的是函数的定义
        a.append(lambda x:i * x)
    return a
r = func()
print(r)
print(r[0](2))  # 函数的调用，i的值是4,2传值给x，返回值永远都是2 * 4
print(r[1](2))
print(r[2](2))
print(r[3](2))
print(r[4](2))

"""
def x1(x):
    return x * i
def x2(x):
    return x * i
def x2(x):
    return x * i
def x3(x):
    return x * i
def x4(x):
    return x * i
r[0](2) --->x1
r[1](2) ---》x2
"""

26.【面试题】什么是匿名函数，优缺点

是一个lambda表达式，本质上还是一个函数，可以设置必需参数，默认参数，关键字参数和不定长参数
只不过表达式的执行结果就是函数的返回值
优点：
简化代码
减少内存空间的使用
缺点：
只能实现简单的逻辑，逻辑一旦复杂，如果使用，代码的可读性会降低，后期的维护性降低，则不建议使用

27.【面试题】局部变量和全局变量的作用

# a
n = 9
def check():
    n = 1
    print(n)  # 1
check()
print(n)  # 9

# b.
# n = 9
# def check():
#     n += 1   # n = n + 1
# check()
# print(n)

# UnboundLocalError: local variable 'n' referenced before assignment
 # global  n,声明n变量来自于全局变量，则在函数中出现的n将不再是重新定义的新变量
 # nonlocal x,声明x不是局部变量，而是来自于函数作用域的变量

28.【面试题】简述可迭代对象和迭代器之间的区别和联系

区别：
可迭代对象：Iterable,可以直接作用于for循环的对象【可以使用for循环遍历其中元素的对象】，
如：list,tuple,dict,set，str,range(),生成器等
迭代器:Iterator,可以直接作用于for循环,或者可以通过next()获取下一个元素的对象，
如：生成器
联系：
迭代器一定是可迭代对象，可迭代对象不一定是迭代器
但是，可以通过系统功能iter()将不是迭代器的可迭代对象转换为迭代器

29.【面试题】分别解释什么是列表推导式，字典推导式，集合推导式，生成器，可迭代对象，迭代器

30.【面试题】说明sort()和sorted()之间的区别和联系

相同点：
a.二者都是用来排序的
b.默认的情况下，二者都是升序,如果要降序，都是设置reverse=True
c.如果要自定义排序规则，二者都是设置key，key的值都得是一个函数
不同点：
a.调用方式不同：列表.sort() ， sorted(列表)
b.sort是在原列表内部排序的，sorted是生成了一个新的列表

31.【面试题】：书写一个装饰器,统计下面函数的执行时间

import time
# print(time.time())  # 时间戳：从1970.1.1 00:00:00到当前时间的秒数
# a.
def test():
    for i in range(100000):
        pass
def wrapper(func):
    def get_time():
        # 开始时间戳
        start = time.time()
        func()
        # 结束时间
        end = time.time()
        return  round(end - start,5)
    return get_time
f = wrapper(test)
print(f())

# b.
def wrapper(func):
    def get_time():
        # 开始时间戳
        start = time.time()
        func()
        # 结束时间
        end = time.time()
        return  round(end - start,5)
    return get_time
@wrapper
def test():
    for i in range(100000):
        pass
print(test())
【面试题】：书写一个装饰器,可以统计任意一个函数的执行时间
import  time
def wrapper(func):
    def get_time(*args,**kwargs):
        # 开始时间戳
        start = time.time()
        func(*args,**kwargs)
        # 结束时间
        end = time.time()
        return  round(end - start,5)
    return get_time

print("*" * 30)

32.【面试题】@xxx被称为无参装饰器，@xxxx(value)有参的装饰器

"""
def outter(a):
    def inner(b):
        pass
    return inner

@outter(value)
def func():
    pass
    
工作原理：
    a.自动调用装饰器的内外部函数
    b.将装饰器的参数value传参给外部函数的参数a，将被修饰的函数传参给内部函数的参数b
    c.原函数的函数名指向内部函数的返回值
"""
base_dict = {}
def add(name):  # 111 222  333
    def inner(data):  # func1   func2  func3
        base_dict[name] = data
        data()
        return 23
    return inner
@add("111")
def func1():
    print("func~~~1111")
@add("222")
def func2():
    print("func~~~2222")
@add("333")
def func3():
    print("func~~~3333")
print(base_dict)

print(func1)  # 23
print(func2)  # 23
print(func3)  # 23

33.【面试题】自定义模块的优点：

提高代码的可维护性
提高了代码的复用度，当一个模块书写完毕，可以被多个地方引用
引用其他的模块
避免函数名和变量名的命名冲突

注意：其实一个.py文件就是一个模块

34.【面试题】splitext(path) 路径进行分割

# 结果为一个元组，格式：（父路径，扩展名），如果指定路径是一个文件夹，则扩展名为""
r2 = os.path.splitext(p1)
print(r2)  # ('C:\\Users\\zhangbingbing\\Desktop\\XA2102\\Day11', '')

p2 = r"C:\Users\zhangbingbing\Desktop\XA2102\Day1\notes\Day1笔记.md"
r2 = os.path.splitext(p2)
print(r2)  # ('C:\\Users\\zhangbingbing\\Desktop\\XA2102\\Day1\\notes\\Day1笔记', '.md')

35.【面试题】简述实例属性【对象属性】和类属性之间的区别

a.定义的位置不同：类属性直接定义在类中，实例属性可以通过动态绑定或者定义在构造函数中
b.访问的方式不同：类属性可以通过对象或类名访问，而实例属性只能通过对象访问
c.优先级不同：在类属性和实例属性重名的情况下，使用对象访问，优先访问的是实例属性
d.在内存中出现的时机不同：类属性优先于实例属性出现在内存中，类属性随着类的加载而出现，实例属性随着对象的出现而出现
e.使用场景不同：类属性适用于多个对象共享的数据，实例属性适用于每个对象特有的数据

36.【面试题】普通实例函数和init之间的区别和联系

不同点：
a.函数名不同：实例函数的函数名需要自定义，但是，__init__是固定的，是系统的函数
b.调用不同：实例函数需要手动调用，__init__是在创建对象的过程中自动调用的
c.调用的次数不同：对于同一个对象而言，实例函数可以被调用无数次，__init__只会被调用一次
相同点：
a.定义在类中，本质上都是实例函数，形参列表的第一个参数都是self
b.默认参数，关键字参数，不定长参数都可以使用
c.也可以设置返回值

37.【面试题】析构函数的调用时机

38.【面试题：面向对象语言的三大特征是什么？是什么？分别解释怎么使用？有什么作用】

39.【面试题】阅读下面的代码，写出执行结果

"""
class Person():
    @property
    def show(self):
        return 10
p = Person()
# p.show()
# 报错,被@property修饰的函数会被当做属性使用，则p.show的值为show函数的返回值
# 修改方式：p.show()--->r = p.show

40.【面试题】解释下面不同形式的变量出现在类中的意义

a:普通属性，在类的外面可以直接访问

_a：在类的外面可以直接访问，但是不建议使用，容易和私有化属性混淆

__a：私有属性，只能在类的内部被直接访问，类的外面可以通过暴露给外界的函数访问

a：在类的外面可以直接访问，但是不建议使用，因为系统的属性和魔术方法都是这种形式的命名，

如:slots,init.del,new,add,sub,mul,gt,lt,eq,ne，__str__等

41.【面试题】写出下面打印结果

class MyClass(object):
    x = 10
class SubClass1(MyClass):
    pass
class SubClass2(MyClass):
    pass
print(MyClass.x,SubClass1.x,SubClass2.x)   # 10  10 10
SubClass1.x = 20
print(MyClass.x,SubClass1.x,SubClass2.x)  # 10 20 10
MyClass.x = 30
print(MyClass.x,SubClass1.x,SubClass2.x)  # 30 20 30

42.【面试题】简述类中的实例函数，静态函数和类函数之间的区别

a.定义不同：被@classmethod修饰的函数表示类函数，被@staticmethod修饰的函数表示静态函数，实例函数没有装饰器

b.形参列表不同：实例函数的第一个参数是self，表示当前对象，类函数的第一个参数是cls，表示当前类，静态函数的参数没有要求

c.调用方式不同：类函数和静态函数都可以通过类名或者对象调用，但是，实例函数只能通过对象调用

d.使用场景不同：如果要封装一个工具类，则尽量使用类函数或静态函数，在实际项目开发中，常用实例函数

【面试题】编写程序，定义一个学生类，统计该类总共实例化了几个学生

# 方式一
class Person(object):
    __count = 0
    @classmethod
    def __init__(cls,name,age):
        cls.__count += 1
        cls.name = name  # 类属性
        cls.age = age
    @property
    def count(self):
        return self.__count

# 方式二
class Person1(object):
    __count = 0
    def __new__(cls, *args, **kwargs):
        cls.__count += 1
        return super().__new__(cls)
    def __init__(self,name,age):
        self.name = name  # 实例属性
        self.age = age

# p1 = Person('a',5)
# p2 = Person('b',67)
# p3 = Person('c',10)
# print(p2.count)
# print(p3.count)
# print(p1.count)

【面试题】下面哪些打开文件的方式，可以自动创建一个新的文件

a.open('f1.txt','w',encoding='utf-8')     b.open('f1.txt','wb',encoding='utf-8')
c.open('f1.txt','w+',encoding='utf-8')    d.open('f1.txt','a',encoding='utf-8')
e.open('f1.txt','r',encoding='utf-8')

【面试题】执行with上下文的时候，底层的工作原理

# 1.with读
# f表示打开的文件对象
# with  open(r"致橡树.txt",'r',encoding="gbk") as f:
#     r = f.read()
#     print(r)

# 2.with写
# with open(r"f1.txt","a",encoding="utf-8") as f1:
#     f1.write("ajgh")

# 3.with上下文的工作原理
"""
语法：
with  对象  as  变量名:
    处理事务
"""
class Person(object):
    # 进入
    def __enter__(self):
        print("进入with上下文管理~~~")
        return self
    # 退出
    def __exit__(self, exc_type, exc_val, exc_tb):
        # except异常
        print("退出with上下文管理~~~")
        return True

    def show(self):
        print("showing")

with Person() as p1:
    print("处理事务~~~~")
    p1.show()