python面试100题（日更）_python 面试100题 闭包

1、赋值、深拷贝和浅拷贝的区别

1.1、赋值

默认浅拷贝传递对象的引用，
若原对象为不可变类型对象，原对象改变，被赋值的对象将不变
若原对象为可变类型对象，原对象改变，则被赋值的对象将改变
1
2
3

eg2:原对象为不可变类型对象

alist2 = "shenme"

b = alist2 
print(b)

alist2 = "斗鱼"
print(b)
1
2
3
4
5
6
7

运行结果：

eg2:原对象为可变类型对象

alist = [1,2,3,["a","b"]]

b = alist  #默认浅拷贝传递对象的引用，原始列改变，被复制的对象也将改变
print(b)

alist.append(90)
print(b)
1
2
3
4
5
6
7

运行结果：

1.2、浅拷贝

改变原始对象中为**元素为可变类型**的值，会同时影响拷贝对象；
改变原始对象中为**元素为不可变类型**的值，不会响拷贝对象。
1
2

import copy
alist = [1,2,3,["a","b"]]

b = copy.copy(alist)  
print(b)

alist.append(90)
print(alist)
print(b)

alist[3].append('aaa')
print(b)
1
2
3
4
5
6
7
8
9
10
11
12

输出结果：

1.3、深拷贝

原始对象的改变不会造成深拷贝里任何子元素的改变
1

import copy
alist = [1,2,3,["a","b"]]

b = copy.deepcopy(alist)  
print(b)

alist.append(90)
print(alist)
print(b)

alist[3].append('aaa')
print(b)
1
2
3
4
5
6
7
8
9
10
11
12

运行结果：

2、列表和元组有什么不同？

列表中元素可变，元组中元素不可变

列表是有序序列，通常是相同类型的对象
元组具有结构，每个索引可能存在不同的数据类型
1
2

3、三元表达式

[on true] if [expression] else [on false]
#为真执行左边的，为假执行右边的

4、如何在python中管理内存

5、python字典

键值对的数据结果
1

6、负索引

正索引从左往右(从0开始)，负索引从右往左(从-1开始)。
都可用于列表切片。
1
2

7、字符添加和字符切割函数

a.join(b)：字符添加函数,将指定的字符a添加到字符串中
a.split(b)：字符切割函数，用指定的字符b切割字符串a
1
2

8、python区分大小写

9、python的闭包

在一个内部函数里，对外部作用域的变量进行了引用，则内部函数称为闭包

10、传参数

argv：用来传递不定个数参数
	argv[0] 一般是“被调用的脚本文件名或全路径”，
	argv[1]和以后就是传入的系统命令参数。
1
2
3

11、字符串插值

#字符串插值
name = 'li'
#1. % string
print('hello %s %s'%(name,name))

#2. format string
print('hello {}'.format(name))
1
2
3
4
5
6
7

运行结果：

12、is和==的区别

is为id，==为值
1

#is==
a = [1,2,3]
b = a
c = [1,2,3]
print(a==b,a==c)
print(a is b,a is c)
1
2
3
4
5
6

运行结果；

13、range函数

range(stop)：生成0到stop-1的整数
range(start,stop)：生成start到stop-1的整数
range(start,stop,step)：以step为间隔生成从start到stop-1的整数
1
2
3

print(range(3))
print(range(1,3))
print(range(1,3,2))
1
2
3

运行结果：

14、创建类实例化后返回属性

#定义一个类
class Car:
    def __init__(self,color,speed):
        self.color = color
        self.speed = speed

#创建实例并返回属性
car = Car('red','100ph')
car.speed
1
2
3
4
5
6
7
8
9

运行结果：

15、func和func（）的区别

func：表示函数对象，可以将其分配给变量或传递给另一个函数
func()：调用该函数并返回其输出
1
2

16、Map功能的工作方式

将函数应用于序列中的每个元素，返回一个由返回值组成的列表
1

li = [1,2,3]
[i for i in map(add_one,li)]
1
2

运行结果：

17、reduce的工作原理

reduce接受一个函数和一个序列，然后对该序列进行迭代
前一次函数的输出和当前元素都活i传递给函数，最后返回一个值
1
2

from functools import reduce
def add_two(x,y):
    return x + y
reduce(add_two,li)
1
2
3
4

运行结果：6
***为1+2+3

18、filter函数运行原理

过滤器：按顺序过滤元素
	每个元素都会传递一个函数，如果函数返回True，则按输出顺序返回；否则返回False.
1
2

li = [1,2,3,4,5]
def add_tree(x):
    if x % 2 == 0:
        return x
    else:
        return False

[i for i in filter(add_tree,li)]
1
2
3
4
5
6
7
8

输出结果：

19、python的调用方式

不变的对象是按值调用的，比如字符串、数字、元组；
	在函数内部发生改变时，不会影响外部的对象。
可变的对象是按引用调用的，比如列表。
	在函数内部发生改变时，会影响外部对象。
1
2
3
4

#定义对象
var1 = 'shenmewanyi'
var2 = [1,2,3,4,5]
#定义函数
def add_var1(x):
    x = 'is' + x
    return x
def add_list(y):
    y = y.append(10)
    print y

#输出相关结果、
x = add_var1(var1)
print(var1,x)
y = add_list(var2)
print(var2,y)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出结果：

20、字符串/列表乘法

字符串将自身连接n次
输出包含n次的目标列表的列表
1
2

var3 = 'lz'
print(var3*2)
list1 = [1,2,3,4]
print(list1*2)
1
2
3
4

输出结果：

21、类上的"self"含义

自我是指类本身的实例，赋予方法访问权限，并且能更新方法所属对象的能力
1

class c1:
    def __init__(self,color):
        self.color = color
s = c1('red')
s.color
1
2
3
4
5

运行结果：’red‘

22、列表连接方式

list1 = [1,2,3,4]
list2 = [1,2,43,54]
list3 = list1 + list2
print(list3)
1
2
3
4

运行结果：

23、如何分割列表

采用切片进行列表元素切割，list[start:stop:step]，前开后闭。
1

list1 = [1,2,3,4]
list2 = [1,2,43,54]
list3 = list1 + list2
print(list3[:3])
print(list3[2:5])
print(list3[1:5:2])
1
2
3
4
5
6

输出结果：

24、any和all区别

any接受一个序列，若序列中任何元素为true，则返回true
all接受一个序列，若序列中所有元素为true，则返回true
1
2

a = [True,False,True]
print(any(a))
print(all(a))
1
2
3

输出结果：

25、删除列表中重复元素

先转集合再转列表
1

list5 = [1,2,3,4,5,6,1,32,4]
list5 = list(set(list5))
print(list5)
1
2
3

运行结果：

26、检查列表中的值存在

list5 = [1,2,3,4,5,6,1,32,4]
list5 = list(set(list5))
print(4 in list5)
1
2
3

运行结果：

27、append和extend的区别

append将值添加进列表；
extnd将另一个列表添加进列表中。
1
2

list1 = [1,2,3,4]
list2 = [1,2,43,54]
list3 = list1.append(999)
list4 = list2.extend(list1)
print(list1)
print(list2)
print(list3)
print(list4)
1
2
3
4
5
6
7
8

输出结果：

28、多个列表合并为一个元组列表

使用zip函数
1

list1 = [1,2,3,4]
list2 = [1,2,43,54]
[(k,v) for k,v in zip(list1,list2)]
1
2
3

输出结果：

29、字典按键值排序

dic = {2:'a',1:'b',3:'c'}
sorted(dic.items())
1
2

输出结果：

30、for循环转换为列表推导

list5 = [1,2,3,4,5,6,1,32,4]
list5 = list(set(list5))
list6 = []
for i in list5:
    list6.append(i+1)
    print(list6)
1
2
3
4
5
6

输出结果：

list5 = [1,2,3,4,5,6,1,32,4]
list5 = list(set(list5))
list6 = []
for i in list5:
    list6.append(i+1)
print(list6)
1
2
3
4
5
6

输出结果：

31、从字典返回键列表

list(字典对象)
1

dic = {2:'a',1:'b',3:'c'}
list(dic)
1
2

运行结果：

32、异常处理

try:
	有可能发生异常的语句
except 异常名字:
	处理异常的代码
else:
	不发生异常才执行的代码
finally:
	不管异常是否发生，都要执行的代码
1
2
3
4
5
6
7
8

运行代码：

def test3():
    try:
        print("----test3-1----")
        test1()
        print("----test3-2----")
    except Exception as result:
        print("捕获到了异常，信息是:%s" % result)

    print("----test3-2----")


test3()
print("------华丽的分割线-----")
1
2
3
4
5
6
7
8
9
10
11
12
13

运行结果：

33、匿名函数用法

#lambda函数：匿名函数

a = lambda x,y:x+y 
print(a(1,9))
1
2
3
4

运算结果：10

34、元组和列表类型互转

list1 = [1,2,43,4]
tuple1 = (1,2.0,3,4)
list2 = tuple(list1)
tuple2 = list(tuple1)
print(type(list2))
print(type(tuple2))
1
2
3
4
5
6

运行结果：

35、单引号、双引号、三引号区别

单引号和双引号没有区别
1

s1 = 'shneme'
s2 = "shneme"
s3 = "i like 'python'"
s4 = 'i like "python"'
print(s1)
print(s2)
print(s3)
print(s4)
1
2
3
4
5
6
7
8

运行结果：

	三引号为注释符号
1

36、列表循环

info = [i for i in range(10)]
print(info)
1
2

运行结果：