python常见面试题基础部分

基础

编程题

1.优化一下下面的程序
	result = []
	for x in range(10):
		result.append(x ** 2)
	print(result)
答案:
result = [ (x ** 2) for x in range(10)]
print(result)
用列表推导式的方式优化了上面的程序
2.写出下面a,b,c,d四个变量的值
	import copy 
	a = [1,2,3,4,['a','b']]  # 原始对象
	b = a
	c = copy.copy(a)
	d = copy.deepcopy(a)
	a.append(5)
	a[4].append('c')
	print('a的值是',a)
	print('b的值是',b)
	print('c的值是',c)
	print('d的值是',d)
答案: 
a的值是 [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b的值是 [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c的值是 [1, 2, 3, 4, ['a', 'b', 'c']]
d的值是 [1, 2, 3, 4, ['a', 'b']]
3.给定两个list A/ B, 请用python找到A、B中相同的元素,A、B中不同的元素
答案:
	def handleValue(list1, list2):
		# 判断数据格式
		if isinstance(list1, list) and isinstance(list2, list):
			sameElementList = [ value1 for value1 in list1 if value1 in list2]
			differentElementList = [ value2 for value2 in set(list1+list2) if value2 not in sameElementList]
			print("the list of same element is %s" % sameElementList)
			print("the list of different element is %s" % differentElementList)
		else:
			print("Error value")
答案二:
    A = [1,2,3]
    B = [2,3,4,5,6]
    set1 = set(A)    # 去重
    set2 = set(B)    # 去重
    # 
    print(set1&set2)
    # 非重复值
    print(set1^set2)
4. 写出以下程序的输出
    4.1------------
        a = 'abc'
        print(a[1])
        a[1]='a'
        print(a[1])

        答案:
            'b'
            'a'

    4.2------------
        class Parent(object):
            x = 1

        class Child1(Parent):
            pass

        class Child2(Parent):
            pass

        print(Parent.x,Child1.x, Child2.x)
        Child1.x = 3
        print(Parent.x,Child1.x, Child2.x)
        Parent.x = 'a'
        print(Parent.x,Child1.x, Child2.x)

        答案:  1 1 1
                1 3 1
                a 3 a

    4.3 ------------
        def count():
            fs = []
            for i in range(1, 4):
                def f():
                    return i * i

                fs.append(f)
            return fs

        for f in count():
            print(f())

        答案:
            9
            9
            9
        闭包函数,外函数 count() 再调用结束时会将在内部函数 f() 使用到的临时变量的最终结果值,也传给内部函数。所以此处的 i 都是 3for f in count(): 遍历是因为 count() 函数的返回值是 内部函数本身 。
5. 字典a = {1: 1},是否正确?
答案:
	正确,但是不建议这样定义字典类型变量, 键名使用字符串类型
6.请合并列表a = [1,2,3,4] 和列表b = [5,6,7,8]
答案:   
	print(a+b)
7.列表a,请写出实现正序排列,倒序排列,逆序排列的内置方法
	答案:
	正序:
		a.sort()
	倒序:
		a.sort(reserver=True)
8.字典d = {'k':1,'v':2},请写出d.items()的结果

	答案:
		[('k', 1), ('v', 2)]
9.复杂列表[{"k":1,"v":2},{"k":12,"v":22},{"k":13,"v"}],请用内置方法写出按K的倒序排列的代码 
答案:	
li = [{"k":1,"v":2},{"k":12,"v":22},{"k":13,"v":32}]
li.sort(key=lambda dict:dict["k"],reverse=True)
print(li)
10.集合s=set([1,2,3,4]),d= set([2,4,9,0,3]) 请用内置方法写出他们的并集,交集,对称公差。。
	答案:
		交集 : res = s.intersection(d)
		并集 : res = s.union(d)
		对称差集:res = s.symmertric_difference(d)
11.下面的代码会输入什么?
	def f(x,l=[]):
		for i in range(x):
			l.append(i*i)
		print(l)

	f(2)
	f(3,[3,2,1])
	f(3)
    答案:
    [0, 1]
    [3, 2, 1, 0, 1, 4]
    [0, 1, 0, 1, 4]
12.补充缺失的代码
def print_direchory_contents(sPath):

		"""

		合格函数接受文件夹的名称作为输入参数,

		返回该文件夹中文件的路径,

		以及其包含文件夹中文件的路径。

		(注意区分不同平台)

		"""

补充代码:
import os
def print_directory_contents(sPath):
    """
        这个函数接受文件夹的名称作为输入参数,
        返回该文件夹中文件的路径,
        以及其包含文件夹中文件的路径。
    """
    # 遍历获取当前文件路径下的文件路径
    for sChild in os.listdir(sPath):
        sChildPath = os.path.join(sPath,sChild)
        # 判断文件下是否含有其他文件,如果有调用原函数继续执行
        if os.path.isdir(sChildPath):
            print_directory_contents(sChildPath)
    	else:
			print(sChildPath)
13.请用自己的散发,按升序合并如下两个list,并去除重复的元素:
    list1 = [2,3,8,4,9,5,6]
    list2 = [5,6,10,17,11,2]

    # 遍历list2中的元素
    for i in list2:
        # 判断是否在list1中,如果没有添加到list1中
        if not i in list1:
            list1.append(i)
    # 列表升序
    list1.sort()
    print(list1)
14.输出结果是什么?
    lists = ['a','b','c','d','e']
    print(lists[10:])

    输出结果:
    []
15.A0-A6的值是什么?
    A0=dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))
    A1=range(10)
    A2=sorted([i for i in Al if i in A0])
    A3=sorted([A0[s] for s in A0 ])
    A4=[i for i in A l if i in A3]
    A5={i:i*i for i in A1}
    A6=[[i,i*i] for i in A1]

    A0:{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
    A1:range(0,10)
    A2:[]
    A3:[1,2,3,4,5]
    A4:[1,2,3,4,5]
    A5:{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
    A6:[[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81]]
16.以下三个输出结果分别是什么?
    def f(x, l=[]):
        for i in range(x):
            l.append(i * i)
        print(l)

    f(2)
    f(3, [3, 2, 1])
    f(3)

    输出结果:
    [0,1]
    [3,2,1,0,1,4]
    [0,1,0,1,4]
17.写一个简单的案例(装饰器的案例)

答案示例:
# 声明一个函数
def decor(func):
    # 声明内部函数来制作完整的装饰器函数
    def inner():
		Print(‘今天早餐吃什么?’)
		Func()
		Print(‘今天晚餐吃什么?’)
    return inner
# decor1 = decor(decor1)
@decor  
def decor1():
		Print(‘今天午餐吃什么?’)
# 调用函数
decor1()
18.请翻转字符串aStr;
    交换变量a,b值;
    指出下面程序存在的问题?
	def Lastllndextem(src,index)
	'''
	请返回传入src使用空格或者"\"切分后的倒数第index个子串
	'''
	    return src.split('\')[-index]

    答案示例:
        Astr = 'ab'
        print(Astr[-1:-3:-1])

        a,b = b,a

        函数名后没有冒号
        函数没有内容
        split()反斜杠没有转义
19.写入以下程序的输出
    1.  a = 'abc'
        print(a[1])
        a[1] = 'y'
        print(a[1])

    2.  class Parent(object):
            x=1
        class Child1(Parent):
            pass
        class Child2(Parent):
            pass

        print(Parent.x,Child1.x,Child2.x)
        Child1.x=3
        print(Parent.x,Child1.x,Child2.x)
        Parent.x='a'
        print(Parent.x,Child1.x,Child2.x)

    3.  
        def count():
            fs=[]
            for i in range(1,4):
                def f():
                    return i*i
                fs.append(f)
            return fs
        for f in count():
            print(f())
    4.  def f(x,l=[])

            for i in range(x):
                l.append(i+i)
            print(l)
        f(3)
        f(3,[3,2,1])
        f(2)


    答案示例:
    1.第一个print(a[1])输出结果为b
      第二个print(a[1])报错,TypeError,字符串是不可变对象,不能用下标赋值的方式去改变字符串。
    2.  1 1 1
        1 3 1
        a 3 a
    3.  9
        9
        9
    4.  [0,2,4]
        [3,2,1,0,2,4]
        [0,2,4,0,2]
20.给定一个 int list a,满足 a[i+1] >=a[i],给定int key,找出list a中第一个大于等于key的元素的index,无满足要求的元素则返回-1。
函数定义:
    def findindex(int_list,int_key)

答案示例:
    #定义函数
    def findIndex(int_list, int_key):
        '''
        给定一个int list a,满足a[i+1]>=a[i],给定int key,找出list a中第一个大于等于key的元素的index,无满足要求的元素则返回-1.
        :param int_list:
        :param int_key:
        :return:
        '''
        for i in int_list:
            if i >= int_key:
                return int_list.index(i)
                break
        if int_key not in int_list:
            return -1

    if __name__ == "__main__":
        #定义一个 int list,并初始化
        list1 = [1,1,2,2,3,3,4,4,5,5,6,6]
        #调用函数,并传入参数,注:传入的int_key值是一个不存在int_list的值.返回-1;
        index1 = findIndex(list1, 8)
        print (index1)

        # 调用函数,并传入参数,注:传入的int_key的值在int_list的值.返回其首次出现时对应的下标;
        index2 = findIndex(list1, 3)
        print(index2)
21.写一段代码,运行读入一个中文档案(编码为utf-8).输出在荧幕上并合并(去掉换行)输出另外一个档案。

答案示例:
    # 打开文件名为filename的文件
    f = open('filename')
    # 循环filename文件的内容
    while True:
        # 读取一行的内容
        line = f.readline()  
        # 判断文章结束则退出循环
        if not line: break
        # 去掉单行内容中的换行符
        newline = line.strip('\n')
        # 打印出行内容元素,去掉print自带换行符
        print(newline,end='')
        # 判断是否有newFile.txt的文件,如果没有创建,选择追加模式
        saveFile = open('newFile.txt', 'a')
        # 写入去掉换行符的单行内容
        saveFile.write(newline)
        # 操作完文件后一定要记得关闭,释放内存资源
        saveFile.close()
    # 操作完文件后一定要记得关闭,释放内存资源 
    f.close()
22.请用random打乱一个排好序的list对象a_list.

答案:
    #random模块中的shuffle(洗牌函数)
    import random
    alist = [1, 2, 3, 4]
    random.shuffle(alist)   
    print alist
23.编写一个程序,能在当前目录以及当前目录的所有子目录下查找文件名包含指定字符串的文件,并打印出绝对路径。

答案:
    import os
    class  SearchFile(object):

        def __init__(self,path='.'):
            self._path=path
            self.abspath=os.path.abspath(self._path) # 默认当前目录

        def findfile(self,keyword,root):
            filelist=[]
            for root,dirs,files in os.walk(root):
                for name in files:                
                    fitfile=filelist.append(os.path.join(root, name))
                    #print(fitfile)
                    print(os.path.join(root, name))
            #print(filelist)
            print('...........................................')
            for i in filelist:            
                if os.path.isfile(i):
                    #print(i)
                    if keyword in os.path.split(i)[1]:
                         print('yes!',i)    # 绝对路径
                    #else:
                        #print('......no keyword!')

        def __call__(self):
            while True:
                workpath=input('Do you want to work under the current folder? Y/N:')
                if(workpath == ''):
                    break
                if workpath=='y' or workpath=='Y':
                    root=self.abspath   # 把当前工作目录作为工作目录
                    print('当前工作目录:',root)
                    dirlist=os.listdir()  # 列出工作目录下的文件和目录
                    print(dirlist)
                else:
                    root=input('please enter the working directory:')
                    print('当前工作目录:',root)
                keyword=input('the keyword you want to find:')
                if(keyword==''):  
                    break
                self.findfile(keyword,root)  # 查找带指定字符的文件


    if __name__ == '__main__':
        search = SearchFile()
        search()
24.实现一个字符串反转的函数:(例如,输出:'hello python' 输出:'nohtyp olleh')

答案:
    1.使用字符串切片
    def reverse1():
        s = input("please input a string: ")
        return s[::-1]

    print(reverse1())

    2.使用递归
    def reverse2(s):
        if s == "":
            return s
        else:
            return reverse2(s[1:]) + s[0]

    str = 'hello python'
    print(reverse2(str))


    3.使用列表的reverse
    def reverse3(s):
        l = list(s)
        l.reverse()
        print("".join(l))
    reverse3('hello python')
25.字典dict_ori = {'A':1, 'B':2, 'C':3},请用代码完成key和value的交换

答案:	
    方法一: 
    使用dict.items()方式
    dict_ori = {'A':1, 'B':2, 'C':3}
    dict_new = {value:key for key,value in dict_ori.items()}
    print(dict_new)

    方法二: 
    使用zip方法
    dict_ori = {'A':1, 'B':2, 'C':3}
    dict_new2= dict(zip(dict_ori.values(), dict_ori.keys()))
    print(dict_new2)
26.Python获取对象属性的4种方法

    class Person(object):
        def __init__(self, name, age):
            self.name = name
            self.age = age

        def __str__(self):
            return 'name=%s, age=%s' % (self.name, self.age)
    xmr = Person('lisi',12)

    方法一:使用属性运算符
    print(xmr.name)
    方法二:通过属性字典__dict__
    print(xmr.__dict__['name'])
    方法三:通过getattr函数
    print(getattr(xmr, 'name'))
    方法四:operator.attrgetter
    import operator
    op = operator.attrgetter('name')
    print(op(xmr))

    扩展:通过年龄age来排序对象
    方法四可以用于对象的排序,比如需要根据年龄age来排序Person对象:
    import operator
    p_list = [Person('xiemanR', 18), Person('zhangshan', 17), Person('lisi', 20), Person('wangwu', 25)]

    r = sorted(p_list, key=operator.attrgetter('age'))
    for i in r:
        print(i)
27.有一个列表,[1,2,3,4,5,6,5,6,7,7,8],请写出列表去重的三种方式

    #利用集合,直接将列表转化为集合,自动去重后转回列表。有一个问题,转换为集合的同时,数据无序了。
    li = [11,22,22,33,44,44]
    set = set(li)
    li = list(set)
    print(li) #[33, 11, 44, 22]

    # 第二种运用新建字典的方式,去除重复的键
    list = [11,22,33,22,44,33]
    dic = {}
    list = dic.fromkeys(list).keys()#字典在创建新的字典时,有重复key则覆盖
    print(list) #dict_keys([11, 22, 33, 44])

    #第三种是用列表的推导
    list = [11,22,33,22,44,33]
    lis = [] #创建一个新列表
    for i in list: #循环list里的每一个元素
        if i not in lis: #判断元素是否存在新列表中,不存在则添加,存在则跳过,以此去重
            lis.append(i)
    print(lis) #[11, 22, 33, 44]
28.实现一个字符串反转的函数:
(例如:输入:'12345678' 输出:'87654321')
    答案:
    str1='1231234'
    str1=list(str1)
    str1.reverse()
    print(''.join(str1),type(''.join(str1)))
29.定义A=("a","b","c","d"),执行del A[2]后的结果为:
	A:("a","b","d")
	B: ("a","b","c")
	C: ("a","c","d")
	D:异常
    答案:D
    解析:元组对象不支持项删除。
30.string = "{1},{0}";string = string.format('hello','python'),请问将string打印结果为:
	A:hello,python			
	B:{1}{0}
	C:python,hello
	D: hello,hello
    答案:C
31.定义A = [1,2,3,4] 使用列表生成式[i*i for i in A]生成列表为:
	A: [1,2,3,4]
	B: [1,4,9,16]
	C: [1,4,6,8]
	D: [1,4,9,12]
	答案:B
32.请对python数据结果Tuple,List,Dict进行操作:
    (1)如何让元组内部可变(叙述或简单定义)
    答案:先变成列表 做改变 再转换成元组
    (2)如何将L1 = [1,2,3,4,5],L2 = [6,7,8,9];使用列表内置函数编程L1=[1,2,3,4,5,6,7,8,9]
    答案:L1+L2
    (3)如何将字典D={'Adam':95,'Lisa':85,'Bart':59}中的值'Adam'删除
    答案:
        D={'Adam':95,'Lisa':85,'Bart':59}
        del D['Adam']
        print(D)
    (4)请按照如下合适k : v 打印出字典D
    答案:
        D={'Adam':95,'Lisa':85,'Bart':59}
        for a,b in D.items():
            print(a,':',b)
33.请用yield写出一个生成器。
答案:
    def fab(max):
        n, a, b = 0, 0, 1 
        while n < max: 
            yield b 
            # print b 
            a, b = b, a + b 
            n = n + 1 
    for n in fab(5):
        print(n)
34.python里面如何实现tuplelist的转换?
答案:
	list()
	tuple()
35.请写出一段python代码实现删除一个list里面的重复元素:
答案:
    list1=[1,1,2,2,3,3]
    list1=list(set(list1))
    print(list1)
36.如何把列表a = ['a','b']里的各项,转为字符串并用逗号‘,’连接。
答案:
      target = ','.join(a)
      # 解析:列表的基本操作
37.请随机输出大于0小于1的数,请随机输出一个100以内的整型
答案:
    import random
    def randomTuple(a):
        times = int(random.random()*len(a))+1
        # print(times)
        tmp = []
        for i in range(times):
            res = random.choice(a)
            if res not in tmp:
                tmp.append(res)
            else:
                continue
        return tmp
    rt = randomTuple((1,3,4,5,6) )
    print(rt)
    # 解析:主要使用random模块相关用法
38.代码a = [{i:j} for i,j in enumerate(xrange(5))],请写出a的最终结果
答案:
    [{0: 0}, {1: 1}, {2: 2}, {3: 3}, {4: 4}]
    # 解析:xrange()是python2.7中的方法,同python3中的range(),列表推导式的方式获取一个字典,i=j
39.以下代码输出的结果是什么?
var1 = 100
var2 = 100
list1 = [101,102,103]
list2 = [101,102,103]
print(var1 is var2)
print(list1 is list2)

    答案:
    True
    False
    # 解析:字符串,数值型数据的变量内存地址一致,列表元组等不一致
40.请使用python内置函数处理如下问题:
1请判断一个字符串是否以er结尾;
2请将‘#teacher#’两侧的#去除;
答案:
    1.res = str1.endswith('er')
    2.res = str1.strip('#')
    # 解析:字符串操作
41.现从一个需要登录的简单网站获取信息,请使用python简要的写出登录函数 的具体实现(登录信息只包含username,password)
    def login(username, password):
        url = "https:xxxxxx"
        data = {"uname":username, "pwd":password}
        response = requests.post(url,data=data)
        return response.content.decode()
42.用正则表达式实现匹配手机号(包含手机号码前带86或者+86的情况)
	答案:
		import re

		resPat = re.compile('^(86|\+86|)1[3578][0-9]{9}$')
		data = '13044444444'
		res = resPat.search(data)
		if res is not None:
			print(res.group())
		else:
			print("Error Value")
43.请匹配出变量 a= 'json_393939({'Adam':95,'Lisa':85,'Bart':59});'中json字符串{'Adam':95,'Lisa':85,'Bart':59};
	答案:
		import re

		a= "json_393939({'Adam':95,'Lisa':85,'Bart':59});"
		aPat = re.compile('{.*?}')
		res = aPat.search(a)
		if res is not None:
			print(res.group())
		else:
			print("Error Value")
44.请用自己的算法,按升序合并如下两个list,并去除重复的元素:
	list1 = [2,3,8,4,9,5,6]
	list2 = [5,6,10,17,11,2]
	答案:
		tmp = list(set(list1 + list2))
		tmp.sort()
		# sort()函数的返回值为None,会直接改变原列表
45.输出结果是什么?
	list1 = ['a','b','c','d','e']
	print(list1[10:])
	答案:
		[]
46.A0-A6的值是什么
	A0 = dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))
	A1 = range(10)
	A2 = sorted([i for i in A1 if i in A0])
	A3 = sorted([A0[s] for s in A0])
	A4 = [i for i in A1 if i in A3]
	A5 = {i:i*i for i in A1}
	A6 = [[i,i*i] for i in A1]
	
	答案:
	A0 = {'d': 4, 'a': 1, 'c': 3, 'b': 2, 'e': 5}
	A1 = 生成器,只有在遍历的时候才出值 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
	A2 = []
	A3 = [1, 2, 3, 4, 5]
	A4 = [1, 2, 3, 4, 5]
	A5 = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
	A6 = [[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81]]
47.对比
	*args     **kwargs   的区别
	__new__   __init__   的区别
	  is      ==         的区别
	range 	  xrange     的区别
	
	答案:
        (1*args 表示非关键字收集参数,收集的实参会组成一个元组,接收没有任何形参接收的非关键字实参。可以与普通形参共存。
             **kwargs 表示关键字收集参数,收集的实参会组成一个字典,形参名作为键,值为值,仅接收没有任何形参接收的关键字参数。可以与普通形参共存。
        (2)__new__:在实例化对象是触发,参数至少一个cls,接收当前类。必须返回一个对象是实例,触发顺序:先触发__new__才会触发__init__。
            __init__: 初始化对象是触发,参数至少一个self,接收对象。使用该方式初始化的成员都是直接写入对象当中,类中无法具有。

        (3in: 表示成员检测 表示判断一个数据是否在指定的容器(复合数据)当中
            ==: 表示判断两个值的数据类型,数据值,是否一致。

        (4rangerange会直接生成一个list对象
            xrange:并不会直接生成一个list对象,会在每一个调用时返回其中的一个值。
            在 python3 中,去除了 range 函数,将 xrange 函数更名为 range 函数
47.常用的版本控制工具及其常用命令

答案:
	git: 
		git add .
		git status 
		git commit 提交至本地仓库
		git origin
		git push
48.装饰器用途:@staticmethod 和@classmethod,@property用途   

答案:  
		@classmethod:类方法,类方法是给类用的,类在使用时会将类本身当做参数传给类方法的第一个参数,python为我们内置了函数classmethod来把类中的函数定          义成类方法。  
		@staticmethod:静态方法
		@property:将一个实例方法提升为属性,便于访问
49.写一个简单的单例    /  请写出一段代码实现单例模式    
	
	class Singleton():
		__obj = None
		def __new__(cls):
			if cls.__obj is None:
				cls.__obj = object.__new__(cls)
			return cls.__obj

	obj1 = Singleton()
	obj2 = Singleton()
	print(obj1 is obj2)

50.	如何用python生成一个指定长度的斐波那契数列?
    def fib(n):
        a,b = 0,1
        for i in range(n):
            a,b =b,a+b
        print(a)
    f = fib(10)
    print(f)
51.python里如何反序的迭代一个序列?	 

	def fun(alist):
	    return alist[::-1]
	res=fun(f)
	print(res)
52.如何用python删除一个文件,删除一个非空目录?	

	import os  # 引入文件操作库

	def CEF(path):
	    """
	    CLean empty files, 清理空文件夹和空文件
	    :param path: 文件路径,检查此文件路径下的子文件
	    :return: None
	    """
	    files = os.listdir(path)  # 获取路径下的子文件(夹)列表
	    for file in files:
	        print('Traversal at', file)
	        if os.path.isdir(file):  # 如果是文件夹
	            if not os.listdir(file):  # 如果子文件为空
	                os.rmdir(file)  # 删除这个空文件夹
	        elif os.path.isfile(file):  # 如果是文件
	            if os.path.getsize(file) == 0:  # 文件大小为0
	                os.remove(file)  # 删除这个文件
	    print(path, 'Dispose over!')

	if __name__ == "__main__":  # 执行本文件则执行下述代码

	    CEF(path)
53.描述下decorator的用法和它的应用场景,如果可以的话,写一个decorator	

	所谓装饰器就是把函数包装一下,为函数添加一些附加功能,装饰器就是一个函数,参数为被包装的函数,返回包装后的函数
	def d(fp):
	    def _d(*arg, **karg):
	        print("do sth before fp..")
	        r= fp(*arg, **karg)
	        print("do sth after fp..")
	        return r
	    return _d
	@d
	def f():
	    print( "call f")
	#上面使用@d来表示装饰器和下面是一个意思
	#f = d(f)

	f()#调用f
54.如果让你用python设计一些有意思的小案例,你想做一些什么样的案例,列举案例中涉及到的主要知识点,至少需要设计三个案例。	
	案例一:根据用户输入的值判断相应的范围打印身高的值(多项分支)
	if 1<= height <=1.5:
		print("小强 你在哪里?")
	elif 1.5<height<=1.7:
		print("没有安全感~")
	elif 1.7<height<=1.8:
		print("帅哥 留个电话")
	elif 1.8<height<=2:
		print("帅哥 你建议多一个女朋友吗")
    案例二:百钱百鸡: 公鸡 = 1  母鸡 = 3  小鸡 = 0.5  100块钱 买 100只鸡 可以有多少种买法(while循环和判断)
	# x代表公鸡
	x = 0
	while x<=100:
		#y 代表母鸡
		y = 0
		while y<=33:
			# z代表小鸡
			z = 0
			while z<=100:
				if (x+3*y+0.5*z == 100) and (x+y+z == 100):
					print(x,y,z)
				z+=1
				
				
			y+=1
		x+=1
    案例三:汉诺塔递归(递归函数)
	def move(n, a, buffer, c):
	        if(n == 1):
	        print(a,"->",c)
	        return
	    move(n-1, a, c, buffer)
	    move(1, a, buffer, c)
	    move(n-1, buffer, a, c)
	move(3, "a", "b", "c")
55.请问下面代码输出什么?
	ss = 'sdfkjal;fj;lasd;asdlkf;las'
	print(len([s for s in ss if s ==';']) == ss.count(';'))
	答案:True
56.请问以下代码输出什么?
	ss = 'sdfkjal;fj;lasd;asdlkf;las'
	s1 = []
	[s1.append(s) for s in ss if s not in s1]
	print(set(s1) == set(ss))
	答案:True
57.
var1 = "8"
var2 = "3"
var1 += var2,var1等于几?
	答:var1="83"
58.
var = [1,{2,3},(88,99,[4,5,6,[7,8,9]])]
定位四级容器中的6:var[2][2][2]
59.怎么样的二级容器不能强转成字典
答:
	不等长的二级容器不能转化证字典
60.
dictvar = {"fhzm":"张铂金","fltt":"吴玉波","jxka":"袁文娟"}
res = "张铂金" not in dictvar
print(res)
#True
61.
res = True and False
print(res)
结果为?
	答:False

res = True or False
print(res)
结果为?
	答:True
62.
女生找对象(height)
	男生在1~1.5米之间 小强 你在哪里?
	男生在1.5~1.7米之间 没有安全感~
	男生 1.7~ 1.8米之间 帅哥 留个电话
	男生 1.8~2米之间 帅哥 你建议多一个女朋友吗
用if判断写出上面的条件语句
	答:
		if 1<= height <=1.5:
			print("小强 你在哪里?")
		elif 1.5<height<=1.7:
			print("没有安全感~")
		elif 1.7<height<=1.8:
			print("帅哥 留个电话")
		elif 1.8<height<=2:
			print("帅哥 你建议多一个女朋友吗")
63.求吉利数字:100~999 : 111 222 333 444... 666..888  123 321 456 ,654  789 987...:
	i = 100
	while i<=999:
		# 个位数
		gewei = i % 10 
		# 十位数
		shiwei = i // 10 % 10
		# 百位数
		baiwei = i // 100
		
		if gewei == shiwei  and  shiwei == baiwei :
			print(i)
		
		if shiwei == gewei -1 and  shiwei == baiwei + 1:
			print(i)
			
		if shiwei == gewei +1 and shiwei == baiwei -1:
			print(i)
		
		i+=1
64.如何用python删除一个文件,删除一个非空目录
    (1)删除一个文件
    import os
    my_file = '文件路径'
    if os.path.exists(my_file): # 如果文件存在
        #删除文件,可使用以下两种方法。
        os.remove(my_file) # 则删除
        #os.unlink(my_file)
    else:
        print('no such file:%s'%my_file)2) 删除一个非空目录
    import shutil
    path = '所删除文件夹路径'
    shutil.rmtree(path)
65.描述下decorator的用法和它的应用场景,如果可以的话,写一个decorator
    所谓装饰器就是把函数包装一下,为函数添加一些附加功能,装饰器就是一个函数,参数为被包
    装的函数,返回包装后的函数
    #为类添加装饰器(单例模式)
    #声明一个容器用于存放对象
    obj = {}#假设存入的对象键名only  值为对象本身 {'only':对象}
    def decor(cls):
        #装饰器的操作
        def _decor():
            if 'only' in obj:
                #对象已经创建
                return obj['only']
            else:
                #对象没有创建,创建对象并返回
                obj['only'] = cls()
                return obj['only']
        #返回装饰的操作
        return _decor
    #当前类只能实例化一个对象
    @decor
    class LiXue:
        name = '小雪'
        sex = '女'
        age = '21岁'
        def stuPy():
            print('好好学习天天向上!')
    #实例化第一个对象
    one = LiXue()
    print(one)
    two = LiXue()
    print(two)
    three = LiXue()
    print(three)
66.如下代码输出的是什么?
	def extendList(val,list=[]):
		list.append(val)
		return list
	list1 = extendList(10)
	list2 = extendList(123,[])
	list3 = extendList('a')
	print("list1 = %s" % list1)
	print("list2 = %s" % list2)
	print("list3 = %s" % list3)
答案:
    list1 = [10, 'a']
    list2 = [123]
    list3 = [10, 'a']
67.如下代码输出的是什么?
	def multipliers():
		return [lambda x : i * x for i in range(4)]
	res = multipliers()
	print(res)
答案:4个对象组成得列表
    [<function multipliers.<locals>.<listcomp>.<lambda> at 0x00000000021FE7B8>,
     <function multipliers.<locals>.<listcomp>.<lambda> at 0x00000000021FE840>, 
     <function multipliers.<locals>.<listcomp>.<lambda> at 0x00000000021FE8C8>, 
     <function multipliers.<locals>.<listcomp>.<lambda> at 0x00000000021FE950>]
68.如果判断一个python对象的类型?
    1):
        >>>a = 2
        >>> isinstance (a,int)
        True
        >>> isinstance (a,str)
        False
        >>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
        True
    2):
        >>>a = 2
        >>>print(type(a))
69.写尽可能多的str对象的方法?
    1、全部大写:str.upper()
    str1 = 'nostalgia'
    str2 = str1.upper()
    print(str2)
    2、全部小写:str.lower()
    str1 = 'NOSTALGIA'
    str2 = str1.lower()
    print(str2)
    3、大小写互换:str.swapcase
    str1 = 'No Smouking'
    str2 = str1.swapcase()
    print(str2)
    4、首字母大写,其余小写:str.capitalize()
    str1 = 'nostalgia fly'
    str2 = str1.capitalize()
    print(str2)
    5、首字母大写:str.title()
    str1 = 'nostalgia fly'
    str2 = str1.title()
    print(str2)
    6、应对所有字母的小写:str.casefold()
    str.lower() 只能转换ASCII字母。
    str1 = 'NOSTALGIA'
    str2 = str1.casefold()
    print(str2) 
70.请写出一段python代码实现删除一个list里面的重复元素.l = [1,1,2,3,4,5,4]
    # 用到集合自动去重的特点来实现
    l = [1,1,2,3,4,5,4]
    l = set(l)
    print(l)
71.写出如下list的交集和差集代码,b1=[1,2,3] b2=[2,3,4]
  交集:
      # 两个列表共同的部分
      b1=[1,2,3]
      b2=[2,3,4]
      b3 = [val for val in b1 if val in b2]
      print b3
  差集:
      # 两个列表的差集
      b1=[1,2,3]
      b2=[2,3,4]
      b3 = [val for val in b1 if val not in b2]
      print b3
72.D = [x * x for x in range(1,10)],请写出D的输出结果
  #生成数  x = 1,2,3,4,5,6,7,8,9
  # 所以结果是如下:
  [1, 4, 9, 16, 25, 36, 49, 64, 81]
73.如何用户python输出一个Fibonacci数列(100以内)?
    a,b = 0, 1
    while b<100:
        print (b),
        a, b = b, a+b
74.什么是lamada函数?下面这段代码输出的是什么?
    nums = range(2,20)
    for i in nums:
        nums = filter(lambda x:x==i or x % i,nums)
    nums
    答案:
        lambda表达式,通常是在需要一个函数,但是又不想费神去命名一个函数的场合下使用,也就是
        指匿名函数。
        Python允许你定义一种单行的小函数。定义lambda函数的形式如下(lambda参数:表达式
        )lambda函数默认返回表达式的值。你也可以将其赋值给一个变量。lambda函数可以接受任意
        个参数,包括可选参数,但是表达式只有一个。
        简单来说,编程中提到的 lambda 表达式,通常是在需要一个函数,但是又不想费神去命名一
        个函数的场合下使用,也就是指匿名函数。这一用法跟所谓 λ 演算的关系,有点像原子弹和质
        能方程的关系,差别其实还是挺大的。
        输出结果:
        <filter object at 0x00000000021ECBE0>
75.如下代码输出的是什么?
  list=['a','b','c','d','e']
      print list[10:]
  #输出的结果为[]
76.如下代码输出的是什么?
def extendList(val,list=[]):
		list.append(val)
		return list
	list1=extendList(10)
	list2=extendList(123,[])
	list3=extendList('a')
	print "list1=%s"%list1
	print "list2=%s"%list2
	print "list3=%s"%list3
    #输出的结果
    list1=[10, 'a'] 
    list2=[123] 
    list3=[10, 'a']
77.如下代码输出的是什么?
    var1=100
    var2=100

    list1=[101,102,103]
    list2=[101,102,103]

    print(var1 is var2)
    print(list1 is list2)
    #输出的结果True False
78.如下代码的输出是什么?
class Parent(object):
    x=1
class Childl(Parent):
    pass
class Child2(Parent):
    pass
print(Parent.x,Childl.x,Child2.x)
Childl.x =2
print(Parent.x,Childl.x,Child2.x)
Childl.x=3
print(Parent.x,Childl.x,Child2.x)
    #输出结果为1 1 1
    #输出结果为1 2 1
    #输出结果为1 3 1
79.编程用sort进行排序,然后从最后一个元素开始判断
    a=[1,2,4,2,4,5,7,10,5,5,7,8,9,0,3]
    a.sort()
    last=a[-1]
    for i in range(len(a)-2,-1,-1):
        if last==a[i]:
            del a[i]
        else:last=a[i]
    print(a)
80.python里面如何拷贝一个对象?(赋值、浅拷贝、深拷贝的区别)
答:
    赋值(=),就是创建了对象的一个新的引用,修改其中任意一个变量都会影响到另一个。
    浅拷贝:创建一个新的对象,但它包含的是对原始对象中包含项的引用(如果用引用的方式修改其中一个对象,另外一个也会修改改变){1,完全切片方法;2,工厂函		数,如list();3,copy模块的copy()函数}
    深拷贝:创建一个新的对象,并且递归的复制它所包含的对象(修改其中一个,另外一个不会改变){copy模块的deep.deepcopy()函数}
81.介绍一下except的用法和作用?
    Python的except用来捕获所有异常, 因为Python里面的每次错误都会抛出 一个异常,所以每个程序的错误都被当作一个运行时错误。
    一、下面是使用except的一个例子:
    try:
    foo = opne(̶file”) #open被错写为opne
    except:
    sys.exit(̶could not open file!”)
    因为这个错误是由于open被拼写成opne而造成的,然后被except捕获,所以debug程序的时候很容易不知道出了什么问题
    二、下面这个例子更好点:
    try:
    foo = opne(̶file”) # 这时候except只捕获IOError
    except IOError:
    sys.exit(̶could not open file”)
82.python中pass语句的作用是什么?
    pass语句什么也不做,一般作为占位符或者创建占位程序,pass语句不会执行任何操作,比如:
    while False:
    pass
    pass通常用来创建一个最简单的类:
    class MyEmptyClass:
    pass
83.介绍一下python下range()函数的用法?
    range(1,5)#代表从1到5(不包含5)
    range(1,5,2)#代表从1到5,间隔2(不包含5)
    range(5)#代表从0到5(不包含5)
84.如何用python来进行查询和替换一个文本字符串?
    可以使用sub()方法来进行查询和替换,sub方法的格式为:sub(replacement, string[, count=0])
    replacement是被替换成的文本
    string是需要被替换的文本
    count是一个可选参数,指最大被替换的数量
    例子:
    import re
    p = re.compile(‘(blue|white|red)’)
    print(p.sub(‘colour’,'blue socks and red shoes’))
    print(p.sub(‘colour’,'blue socks and red shoes’, count=1))
    输出:
    colour socks and colour shoes
    colour socks and red shoes
85.python里面如何生成随机数
    在 Python 中用于生成随机数的模块是 random,在使用前需要 import. 如下例子可以酌情列举:
    random.random():生成一个 0-1 之间的随机浮点数;
    random.uniform(a, b):生成[a,b]之间的浮点数;
    random.randint(a, b):生成[a,b]之间的整数;
    random.randrange(a, b, step):在指定的集合[a,b)中,以 step 为基数随机取一个数;
    random.choice(sequence):从特定序列中随机取一个元素,这里的序列可以是字符串,列表,元组等。
86.有没有一个工具可以帮助查找python的bug和进行静态的代码分析
    PyChecker是Python代码的静态分析工具,它能够帮助查找Python代码的bug,而且能够对代码的复杂度和格式等提出警告。
    PyChecker可以工作在多种方式之下。首先,PyChecker会导入所检查文件中包含的模块,检查导入是否正确,同时检查文件中的函数、类和方法等。
    PyChecker可以检查出来的问题有如下几种:
    全局量没有找到,比如没有导入模块
    传递给函数、方法、构造器的参数数目错误
    传递给内建函数和方法的参数数目错误
    字符串格式化信息不匹配
    使用不存在的类方法和属性
    覆盖函数时改变了签名
    在同一作用域中重定义了函数、类、方法
    使用未初始化的变量
    方法的第一个参数不是self
    未使用的全局量和本地量(模块或变量)
    未使用的函数/方法的参数(不包括self)
    模块、类、函数和方法中没有docstring
    Pylint是另外一个工具可以进行codingstandard检查
87.如何在一个function里面设置一个全局的变量
    # 加global程序就ok了
    def my_global():
        global x
        x=8;
    my_global()
    print(x)

    #打印结果8
88.已知字符串x = "hello world",那么执行语句x.replace('hello','hi'),x的值为(C)
	A:'hello world'	B:'hillo world'
	C: 'hi world'		D:'word'
89.表达式[1]*2的值为(C)
	A:[2]	B:[1]	C:[1,1]	D:[1,2]
90.已知列表x = [1,2,3],那么执行语句x.insert(1,4),x的值为(B)
	A:[1,2,3,4]	B:[1,4,2,3]		C:[4,3,2,1]	D:[4,2,3]
91.有17个人围成一圈(编号0-16)从第0号的人开始从1报数,反报到3的倍数的人离开圈子,然后再数下去,知道最后只剩下一个人位置,问此人原来的位置是多少号?
    def test(ren,count=0):
        a = len(ren)
        b = count
        for i in ren:
            b += 1
            if len(ren) == 1:
                return ren
            if b % 3 == 0:
                b += 1
                ren.remove(i)
        print(ren)
        count += a
        return test(ren,count)
    ren = list(range(17))
    test(ren)
    输出结果:
    [0, 1, 3, 4, 6, 7, 9, 10, 12, 13, 15, 16]
    [1, 3, 6, 7, 10, 12, 15, 16]
    [3, 6, 10, 12, 16]
    [3, 10, 12]
    [3, 10]
    [3, 10]
    [10]
92.随机生成100个数,然后写入文件
思路:
1.打开一个新文件,准备去写
2.然后随机生成一个数(整数或者小数),并将该数写入文件中
3.循环第二部,知道完成100个随机数的生成
    import random
    with open("1.txt",'w') as f:
        for i in range(1,101):
            n = random.randint(1,100)
            f.write(str(n)+"\n")
93.有1、2、3、4个数字,能组成多少个互不相同且无重复数字的三位数?都是多少? 

    1.程序分析:可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 
          掉不满足条件的排列。 
    for i in range(1,5):
        for j in range(1,5):
            for k in range(1,5):
                if( i != k ) and (i != j) and (j != k):
                    print (i,j,k)
94.下面代码分别会输出什么:
def f(x,l=[]):
	for i in range(x):
		l.append(i*i)
	print(l)

f(2)
f(3,[3,2,1])
f(3)

    答案:
    [0, 1]
    [3, 2, 1, 0, 1, 4]
    [0, 1, 0, 1, 4]

理论简答题

1.python中的关键字yield有什么作用?
答案:
    保存当前运行状态(断点),然后暂停执行,即将函数挂起
    将yeild关键字后面表达式的值作为返回值返回,此时可以理解为起到了return的作用,当使用next()、send()函数让函数从断点处继续执行,即唤醒函数。
2. 这两个参数是什么意思:*arg,**kwargs? 我们为什么要使用他们?
答案: 
    *args和**kwargs通常使用在函数定义里,*args允许函数传入不定量个数的非关键字参数,**kwargs允许函数传入不定量个数的关键字参数
3.python主要的内置数据类型都有哪些?print(dir('a'))的输出?
答案:
    数值型:整型,浮点型,布尔型,复数
    字符串型
    列表
    元组
    字典
    集合
    print(dir('a'))的输出是关键字参数
4.对比:
    1.*args **kwargs 区别
    2.__new__和__init__的区别
    3.is==区别

答案示例:
    1.*args 表示任何多个无名参数,它是一个tuple**kwargs 表示关键字参数,它是一个dict。并且同时使用*args和**kwargs时,必须*args参数列要在**kwargs     前。
    2.·__init__是当实例对象创建完成后被调用的,然后设置对象属性的一些初始值。
      ·__new__是在实例创建之前被调用的,因为它的任务就是创建实例然后返回该实例,是个静态方法。
      也就是,__new__在__init__之前被调用,__new__的返回值(实例)将传递给__init__方法的第一个参数,然后__init__给这个实例设置一些参数。
    3.is==都是对对象进行比较判断作用的,但对对象比较判断的内容并不相同。
    ==是python标准操作符中的比较操作符,用来比较判断两个对象的value()是否相等。
    is也被叫做同一性运算符,这个运算符比较判断的是对象间的唯一身份标识,也就是id是否相同。
5.装饰器用途:@staticmethod 和 @classmethod,@property用途?

答案示例:
    @classmethod
    类静态方法:与实例方法的区别是没有self参数,并且可以在类不进行实例化的情况下调用。
    @staticmethod
    类方法:与实例方法的区别是接收的第一个参数不是self(类实例的指针),而是cls(当前类的具体类型)。
    @property
    属性方法:将一个类方法转变成一个类属性,只读属性。
6.说说dict的items()方法与iteritems()方法的不同。

答案示例:
    字典的items方法作用:是可以将字典中的所有项,以列表方式返回。因为字典是无序的,所以用items方法返回字典的所有项,也是没有顺序的。
    字典的iteritems方法作用:与items方法相比作用大致相同,只是它的返回值不是列表,而是一个迭代器。
7.python中的变量作用域(变量查找顺序)。

答案:
函数作用域的LEGB顺序
    1.什么是LEGB? 
    L:local 函数内部作用域 
    E:enclosing 函数内部与内嵌函数之间 
    G:global 全局作用域 
    B:build-in 内置作用域

    2.它们是作什么用的 
    为什么非要介绍这个呢?或者说它们的作用是什么? 
    原因是因为我们的在学习Python函数的时候,经常会遇到很多定义域的问题,全部变量,内部变量,内部嵌入的函数,等等,Python是如何查找的呢?以及Python又是按照什么顺序来查找的呢?这里做一个顺序的说明

    3.顺序是什么 
    跟名字一样,Python在函数里面的查找分为4种,称之为LEGB,也正是按照这种顺序来查找的。

    首先,是local,先查找函数内部 
    然后,是enclosing,再查找函数内部与嵌入函数之间(是指在函数内部再次定义一个函数) 
    其次,是global,查找全局 
    最后,是build-in,内置作用域
8.描述python的进程、线程及协程的功能,以及它们的不同地方和适用场景。
答案:
    进程是操作系统资源分配的最小单位
    线程是CPU调度的单位
    进程切换需要的资源最大,效率很低
    线程切换需要的资源一般,效率一般(当然在不考虑GIL的情况下)
    协程切换任务资源很小,效率高
    多进程、多线程根据cpu核数不一样可能是并行的,但是协程是在一个线程中 所以是并发
9.简单比较一下python,java,javascript,如果您对后两者不熟悉,请和您熟悉的另一种语言比较。(不超过三句话)
答案:
	python  既有强类属性又有弱类    js   弱类 
10.说明os,sys模块的不同,并列举常用的模块方法:
答案:
    os: This module provides a portable way of using operating system dependent functionality. 
    翻译:提供一种方便的使用操作系统函数的方法。 
    sys:This module provides access to some variables used or maintained by the interpreter and to functions that interact strongly with       the interpreter. 
    翻译:提供访问由解释器使用或维护的变量和在与解释器交互使用到的函数。
    常用模块方法:os.path  os.mkdir  
11.python里面的search()和match()的区别:
答案:
    match()函数只检测RE是不是在string的开始位置匹配, search()会扫描整个string查找匹配, 也就是说match()只有在0位置匹配成功的话才有返回,如果不是开始位置匹配成功的话,match()就返回none
    例如:
    print(re.match(super, ‘superstition’).span())会返回(0, 5)print(re.match(super, ‘insuperable’))则返回None

    search()会扫描整个字符串并返回第一个成功的匹配
    例如:
    print(re.search(super, ‘superstition’).span())返回(0, 5)
    print(re.search(super, ‘insuperable’).span())返回(2, 7)
    match()比较挑剔
12.python匹配HTML tag的时候,<.*><.*?>有什么区别?
答案:
    贪婪和非贪婪
    贪婪模式在整个表达式匹配成功的前提下,尽可能多的匹配,而非贪婪模式在整个表达式匹配成功的前提下,尽可能少的匹配。
13.python是如何进行内存管理的?
答案:
    python内部使用引用计数,来保持追踪内存中的对象,Python内部记录了对象有多少个引用,即引用计数,当对象被创建时就创建了一个引用计数,当对象不再需要时,这个对象的引用计数为0时,它被垃圾回收。
14.什么是lambda函数,它有什么好处?
答案:
    lambda表达式是一种简洁格式的函数。该表达式不是正常的函数结构,而是属于表达式的类型。 
    基本格式:
        lambda 参数,参数...:    函数功能代码
    如:lambda x,y:x + y     获取2个值的和的lambda函数
15.分别说说函数cmp,map,filter的作用?
答案:
    #cmp:compare比较
    cmp(a,b) # a<b 返回-1 a>b 返回1 a=b返回0

    # map:映射
    map(function, iterable) # 将function作用于iterable,每个元素,将对应输出结果保存为一个list
    # 例:
    def plus_one(x):
    return x+1
    map(plus_one,[1,2,3,4]) ===>[2,3,4,5]

    # filter:过滤器
    filter(function, iterable) # 将 function依次作用于iterable的每个元素,如果返回值为true, 保留元素,否则从iterable里面删除
    # 例:
    def bigger_than_three(x):
    return (x>3)
    filter(bigger_than_three,[1,2,3,4,5]) ===>[4,5]
16.请阐述__new__和__init__的区别
答案:
    __new__: 在实例化对象时自动触发,接收的参数值至少有一个cls
    __init__:在初始化对象时自动触发,接收的参数值至少有一个self 

    在实例化对象时先触发__new__魔术方法,再触发__init__魔术方法

    __new__:创建对象时调用,会返回当前对象的一个实例
    __init__:创建完对象后调用,对当前对象的一些实例初始化,无返回值
    调用顺序:先调用__new__生成一个实例再调用__init__方法对实例进行初始化,比如添加属性。
17.分别简述一下列表,元组,字典,集合的特点
答案:
    列表:有序,可修改,元素可重复
    元组:有序,不可修改,元素可重复
    字典:键值对,无序,可修改,键不可重复,值可以重复
    集合:无序,不可修改,唯一性
18.这段代码的输出结果是什么?简述一下装饰器(decorator)
def singleton(cls, *arg, **kw):
    instances = {}
    def _singleton(*arg, **kw):
        if cls not in instances:
            instances[cls] = cls(*arg, **kw)
        return instances[cls]
    return _singleton
@singleton
class Fruits:
    def __init__(self, name):
        self.name = name
apple = Fruits('苹果')
orange = Fruits('橘子')
print(apple.name)
print(orange.name)
    答案:
    输出结果:
    苹果
    苹果
    理解:
    装饰器本质上是一个Python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象。
    功能:1.引入日志;2.函数执行时间统计;3.执行函数前预备处理;4.执行函数后清理功能;5.权限校验;6.缓存
19. 简述你对迭代器的理解;列表,字典,字符串是可迭代对象还是迭代器?
 答案:
  1、可迭代对象和迭代器
  可迭代的对象有个 __iter__ 方法,每次都实例化一个新的迭代器;而迭代器要实现 __next__ 方法,返回单个元素,此外还要实现 __iter__ 方法,返回迭代器本身
  可迭代的对象一定不能是自身的迭代器。也就是说,可迭代的对象必须实现
  __iter__ 方法,但不能实现 __next__ 方法
  2、迭代器:
  迭代器是这样的对象:实现了无参数的 __next__ 方法,返回序列中的下一个元素;如果没有元素了,那么抛出 StopIteration 异常。 Python 中的迭代器还实现了__iter__ 方法,因此迭代器可以迭代。
  列表,字典,字符串是可迭代对象
20.有一朵28个花瓣的花朵,你和小明轮流摘,每人每次必须任意摘14个花瓣,能找摘下最后一个花瓣的人获胜如果你先摘并且想要获胜,你会选择第一次摘掉几个花瓣,原因是什么?
    答案:
    3+5×5=28
    谁先手谁先赢,假设甲先手,乙后手
    甲先手拿3个,
    乙后手无论拿1-4其中一个,甲只要拿加起来等于5就行(乙14,乙23,乙32,乙41),每次两个人加起来刚好是5的倍数,甲一定赢了(甲一定会拿了第813182328个)
21.用你掌握的python知识,针对小朋友设计一些有趣的教学小案例,讲一下设计的理由,包括这个案例应用的知识点。
答案:
    九九乘法表,九九乘法表是从小学开始学习的口诀,贴近日常学习的数学知识,便于孩子理解。
    应用到了for...in...循环及格式化字符串等知识点
    for i in range(1,10):
        for j in range(i,10):
            print("%d*%d=%2d" % (i,j,i*j),end=" ")
        print("")
22.一个编码为GBK的字符串S,要将其专程utf-8编码的字符串,应该如何操作?
答案:
	S.encode('utf-8')
23.什么是代码块
	答:以冒号作为开始,用缩进划分相同作用域,这样的结构称之为代码块,是一个整体
24.变量是什么
	答:可以改变的量,实际具体指的是内存中的一块存储空间
25.全局变量与局部变量的区别,如何在function里面给一个全局变量赋值?
    全局变量与局部变量两者的本质区别就是在于作用域
    用通俗的话来理解的话,
    全局变量是在整个py文件中声明,全局范围内都可以访问
    局部变量是在某个函数中声明的,只能在该函数中调用它,如果试图在超出范围的地方调用,程
    序就爆掉了
    如果在函数内部定义与某个全局变量一样名称的局部变量,就可能会导致意外的效果,可能不是
    你期望的。因此不建议这样使用,这样会使得程序很不健全
    如果真的想要在函数体内修改全局变量的值,就要使用global关键字:
    num1 = 1
    def fun():  
        global num1  
        num1=2  
        print("函数内修改后num1=",num1)  
    num1=1  
    print("初始num1=",num1)  
    fun()  
    print("运行完函数后num1=",num1) 
26.python2和python3的区别
    #1.Python3 使用 print 必须要以小括号包裹打印内容,比如 print('hi')
    #2.python2 range(1,10)返回列表,python3中返回迭代器,节约内存
    #3.python2中使用ascii编码,python中使用utf-8编码
    #4.python2中unicode表示字符串序列,str表示字节序列,python3中str表示字符串序列,byte表示字节序列
    #5.python2中为正常显示中文,引入coding声明,python3中不需要
    #6.python2中是raw_input()函数,python3中是input()函数
27.单引号,双引号,三引号的区别
    python字符串通常有单引号('...')、双引号("...")、三引号("""...""")或('''...''')包围,三引号包含的字符串可由多行组成,一般可表示大段的叙述性字符串。在使用时基本没有差别,但双引号和三引号("""...""")中可以包含单引号,三引号('''...''')可以包含双引号,而不需要转义
28.判断题:
	1 Python3.x完全兼容Python2.x                                    F     
	2 在windows平台上编写的python程序无法在unix平台运行           T
	3 不可以在同一台计算机上安装多个Python版本                      F 
	4 3+4j不是合法的python表达式	                                F	
	5 python集合可以包含相同的元素	                                T
	6 在UTF-8编码中一个汉字需要占用3个字节		                    T
	7 python 3.x支持中文作为变量名                                  T
	8 函数中必须包含return语句                                      F
	9 栈和队列的都具有先入后出的特点                                 F
	10 定义类时实现了__eq__()方法,该类对象即可支持运算符==          T
29.字符串格式化:%.format的区别
    字符串的format函数非常灵活,很强大,可以接受的参数不限个数,并且位置可以不按顺序,而且有较为强大的格式限定符(比如:填充,对齐,精度等)
30.解释什么是匿名函数,它有什么好处
    匿名函数与函数有共同的作用域,但是匿名函数意味着引用计数为0除非让他有名字
    好处:一次性使用,随时随地的定义更容易阅读,做了什么更是一目了然
31.简述with方法打开处理文件帮我我们做了什么?
    打开文件在进行读写的时候可能会出现一些异常状况,如果按照常规的f.open
    写法,我们需要try,except,finally,做异常判断,并且文件最终不管遇到什么情况,都要执行finally f.close()关闭文件,with方法帮我们实现了finally中	     f.close
32.正则re.complie作用
  re.compile是将正则表达式编译成一个对象,加快速度,并重复使用
33.简单解释python的GIL锁,装饰器,生成器,以及使用场景
	GIL的问题其实是每个线程在执行的过程都需要先获取GIL,保证同一时刻只有一个线程可以执行代码
线程释放GIL锁的情况: 在IO操作等可能会引起阻塞的system call之前,可以暂时释放GIL,但在执行完毕后,
必须重新获取GIL Python 3.x使用计时器(执行时间达到阈值后,当前线程释放GIL)或Python 2.x,tickets计数
达到100
解决方案:
	1:更换解释器 比如使用jpython(java实现的python解释器)
	2:将线程内的代码换成其他语言来执行比如c
    3:使用多进程完成多任务的处理
结论:
    1. 在 处理像科学计算 这类需要持续使用cpu的任务的时候 单线程会比多线程快
    2. 在 处理像IO操作等可能引起阻塞的这类任务的时候 多线程会比单线程 
装饰器:
	1.什么是装饰器
	python装饰器就是用于拓展原来函数功能的一种函数,这个函数的特殊之处在于它的返回值也是一个函数,使用python装饰器的好处就是在不用更改原函数的代码前提下给函数增加新的功能。
    2.使用场景:
		权限验证
		增加log日志
        计算函数执行时间
        
    3.计算函数时间的装饰器
    import time
    def timeit(func):
        def wrapper():
            start = time.time()
            func()
            end =time.time()
        	print('used:', end - start)
    	return wrapper
    @timeit
    def foo():
    	for i in range(10000):
    		pass
    foo()
    
    生成器
    1.什么是生成器
    	在一个一般函数中使用yield关键字,可以实现一个最简单的生成器,此时这个函数变成一个生成器函数。yieldreturn返回相同的值,区别在于return返回后,函数状态终止,而yield会保存当前函数的执行状态,在返回后,函数又回到之前保存的状态继续执行。
     2.使用生成器逆序yield出对象的元素
def rev_str(my_str):
    length=len(my_str)
    for i in range(length-1,-1,-1):
        yield my_str[i]

for char in rev_str("hello"):
    print(char) 
34.如下代码执行后l,m的内容分别是什么
    def func1(m):
        for k,v in m.items():
            m[k+2] = v+2

    m = {1:2,3:4}
    l = m
    l[9] = 10
    func(l)
    m[7] = 8
    4.如下代码输出的是什么
    def multipliers():
        return [lambda x:i * x for i in range(4)]
    print [m(2) for m in multipliers()]
    考察闭包的延迟绑定
    结果 [6, 6, 6, 6]
35.utf-8unicode的区别是什么?
	Unicode 是「字符集」
    UTF-8 是「编码规则」
    字符集:为每一个「字符」分配一个唯一的 ID(学名为码位 / 码点 / Code Point)
    编码规则:将「码位」转换为字节序列的规则(编码/解码 可以理解为 加密/解密 的过程)
    广义的 Unicode 是一个标准,定义了一个字符集以及一系列的编码规则,即 Unicode 字符集和 UTF-8、UTF-		16、UTF-32 等等编码……
	Unicode 字符集为每一个字符分配一个码位,例如「知」的码位是 30693,记作 U+77E530693 的十六进制为 	   0x77E5)。
	UTF-8 顾名思义,是一套以 8 位为一个编码单位的可变长编码。会将一个码位编码为 14 个字节:
36. 1 * 2 . . . * 2014 的结果末尾有多少个0?请写出解题思路或者计算过程
    因数5的个数决定末尾0的个数
    2013÷5=402(取整)
    2013÷25=80(取整)
    2013÷125=16(取整)
    2013÷625=3(取整)
    402+80+16+3=501
    所以1*2*3*……*2012*2013的计算结果的末尾有501个连续的0
37.说说dict的items()方法与iteritems()方法的不同

dict.items()返回的是一个完整的列表,而dict.iteritems()返回的是一个生成器(迭代器)dict.items()返回列表list的所有列表项,形如这样的二元组list:[(key,value),(key,value),...dict.iteritems()是generator, yield 2-tuple。相对来说,前者需要花费更多内存空间和时间,但访问某一项的时间较快(KEY)。后者花费很少的空间,通过next()不断取下一个值,但是将花费稍微多的时间来生成下一item。
38.写一段代码,逐行读入一个中文档案(编码为utf-8),输出在荧幕上并合并(去掉换行)输出另外一个档案
f = open('文件名.txt', 'r', encoding='utf8')
ret = f.readlines()
f.close()
for i in ret:
    print(i, end='')
    with open('新文件名.txt', 'a', encoding='utf8') as f:
        f.write(i)
39.分别简述一下列表,元祖,字典,集合的特点?
    列表:
    1.可以用list()函数或者方括号[]创建,元素之间用逗号’,‘’分隔。 
    2.列表的元素不需要具有相同的类型 
    3.使用索引来访问元素 
    4.可切片
    元组:
    1.可以用tuple()函数或者方括号()创建,元素之间用逗号’,‘’分隔。 
    2.元组的元素不需要具有相同的类型 
    3.使用索引来访问元素 
    4.可切片 
    5.元素的值一旦创建就不可修改!!!!!(这是区别与列表的一个特征)
    字典:
    1.元素由键(key)和值(value)组成 
    2.可以用dict()函数或者方括号()创建,元素之间用逗号’,‘’分隔,键与值之间用冒号”:”隔开 
    3.键必须是唯一的,但值则不必。值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组 
    4.使用键(key)来访问元素
    集合:
    1.可以用set()函数或者方括号{}创建,元素之间用逗号”,”分隔。 
    2.与字典相比少了键 
    3.不可索引,不可切片 
    4.不可以有重复元素
40.python中如何动态获取和设置对象的属性?
    #dir():
    #调用这个方法将返回包含obj大多数属性名的列表(会有一些特殊的属性不包含在内),obj的默认值是当前的模块对象。
    #hasattr(obj, attr): 
    #这个方法用于检查obj是否有一个名为attr的值的属性,返回一个布尔值。
    #getattr(obj, attr): 
    #调用这个方法将返回obj中名为attr值的属性的值,例如如果attr为'bar',则返回obj.bar。
    #setattr(obj, attr, val):
    #调用这个方法将给obj的名为attr的值的属性赋值为val,例如如果attr为'bar',则相当于obj.bar = val。
41.请使用python内置函数处理如下问题:
	1.请判断一个字符串是否以er结尾;
	2.请将“#teacher#”两侧的“#”去除;
	3.请使用map函数将[1,2,3,4]处理成[1,0,1,0];
	4.请使用filter函数将[1,2,3,4]处理成[2,4];
	5.请使用reduce函数计算100的阶乘;
      #1.var1.endswith('er')	返回的是true

      #2.str.replace("#","")	返回的是teacher

      #3. #def square(x) :
          #if x%2 == 0:
              #print(0)
          #else:
              #print(1)
      #map(square, [1,2,3,4])

      #4.def is_odd(n):
          #return n % 2 == 0
      #tmplist = filter(is_odd, [1,2,3,4])
      #newlist = list(tmplist)
      #print(newlist)

      #5. #from functools import reduce
          #def prod(L):
              #def myCheng(x,y):
                  #return x*y
              #return reduce(myCheng,L)

          #varlist = []
          #for i in range(1,101):
              #varlist.append(i)
          #print(prod(varlist))
42.简述你对迭代器的理解?列表,字典,字符串是可迭代对象还是迭代器?
    1.可以被next() 函数调用并不断返回下一个值得对象称为迭代器。
    2.列表,字典,字符串是可迭代对象
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页