Python面试题（练习二）

1、用Python实现一个二分查找的函数。

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
 
def binary_search(dataset,find_num):
    if len(dataset) > 1:
        mid = int(len(dataset) / 2)
        if dataset[mid] == find_num:
            print('找到数字：',dataset[mid])
        elif dataset[mid] > find_num:
            print('你要找的数字在mid[%s]左边'%dataset[mid])
            return binary_search(dataset[0:mid],find_num)
        else:
            print('你要找的数字在mid[%s]右边'%dataset[mid])
            return  binary_search(dataset[mid+1:],find_num)
    else:
        if dataset[0] == find_num:
            print('找到数字了:%s'%dataset[0])
        else:
            print('没得找了，你找的%s不在列表中啊。。。'%find_num)
 
find_num = 17
binary_search(data,find_num)
 
结果:
你要找的数字在mid[18]左边
你要找的数字在mid[9]右边
你要找的数字在mid[16]右边　　　　　　　　　　　　　　
找到数字了:17

2、如何生成一个随机数？

import random
print(random.random())  # 0.2711376711558152 输出一个0~1的随机浮点数
print(random.randint(1,10)) # 7 输出一个1-10的随机整数
print(random.uniform(1,10)) # 3.235651225758224 输出一个1-10的随机浮点数
print(random.choice('aksdhkfae')) # 输出一个随机字符
print(random.sample('fahfewke',3)) # 输出一个含有3个随机字符的列表
items = [1,2,3,4,5,6,7,8]
random.shuffle(items)   # 洗牌
print(items)    # [7, 2, 3, 5, 8, 1, 6, 4]

 3、如何使用python删除一个文件？

import os
os.remove('path/filename')     # 删除文件
os.rmdir/removedirs('dirname') 删除目录/多层目录

 4、谈谈你对面向对象的理解？

对面向对象的理解
 
在我理解,面向对象是向现实世界模型的自然延伸，这是一种“万物皆对象”的编程思想。在现实生活中的任何物体都可以归为一类事物，而每一个个体都是一类事物的实例。面向对象的编程是以对象为中心，以消息为驱动，所以程序=对象+消息。
 
面向对象有三大特性，封装、继承和多态。
 
封装就是将一类事物的属性和行为抽象成一个类，使其属性私有化，行为公开化，提高了数据的隐秘性的同时，使代码模块化。这样做使得代码的复用性更高。
 
继承则是进一步将一类事物共有的属性和行为抽象成一个父类，而每一个子类是一个特殊的父类--有父类的行为和属性，也有自己特有的行为和属性。这样做扩展了已存在的代码块，进一步提高了代码的复用性。
 
如果说封装和继承是为了使代码重用，那么多态则是为了实现接口重用。多态的一大作用就是为了解耦--为了解除父子类继承的耦合度。如果说继承中父子类的关系式IS-A的关系，那么接口和实现类之之间的关系式HAS-A。简单来说，多态就是允许父类引用(或接口)指向子类(或实现类)对象。很多的设计模式都是基于面向对象的多态性设计的。
 
总结一下，如果说封装和继承是面向对象的基础，那么多态则是面向对象最精髓的理论。掌握多态必先了解接口，只有充分理解接口才能更好的应用多态。
---------------------
作者：samhan0616
来源：CSDN
原文：https://blog.csdn.net/weixin_40066829/article/details/78111476?utm_source=copy
版权声明：本文为博主原创文章，转载请附上博文链接！

# 多态的实现：
 
class Animal(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
 
    def talk(self):
        raise NotImplementedError('Subclass must implement abstract method')
 
class Cat(Animal):
    def talk(self):
        print('%s:喵喵喵。。。'%self.name)
 
class Dog(Animal):
    def talk(self):
        print('%s:汪汪汪。。。'%self.name)
 
def fun(obj): # 一种接口，多种实现
    obj.talk()
 
cat = Cat('小七',3)
dog = Dog('小汪',5)
 
fun(cat)    # 小七:喵喵喵。。。
fun(dog)    # 小汪:汪汪汪。。。

 5、Python面向对象中的继承有什么特点？

继承的优点：

　　1、建造系统中的类，避免重复操作。

　　2、新类经常是基于已经存在的类，这样就可以提升代码的复用程度。

继承的特点：

　　1、在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。有别于C#

　　2、在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数

　　3、Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

6、面向对象中super的作用？

super() 函数是用于调用父类(超类)的一个方法。
　　super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
　　MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

7、是否使用过functools中的函数？其作用是什么？

Python的functools模块用以为可调用对象（callable objects）定义高阶函数或操作。简单地说，就是基于已有的函数定义新的函数。
所谓高阶函数，就是以函数作为输入参数，返回也是函数。

8、列举面向对象中带爽下划线的特殊方法，如：__new__、__init__

__str__ 、 __call__ 、__getattr__ 、__setattr__ 、__enter__
__exit__ 、__getitem__ 、__setitem__ 、__iter__ 、__doc__

9、如何判断是函数还是方法？

def fun():
    print('这是一个函数')
 
class Obj(object):
    def fun(self):
        print('这是一个方法')
 
obj = Obj()
print(type(fun))    # <class 'function'>
print(type(obj.fun))    # <class 'method'>

10、静态方法和类方法区别？

一、先是在语法上面的区别:
1、静态方法不需要传入self参数，类成员方法需要传入代表本类的cls参数；
2、静态方法是无妨访问实例变量和类变量的，类成员方法无法访问实例变量但是可以访问类变量
二、使用的区别：
由于静态方法无法访问类属性，实例属性，相当于一个相对独立的方法，跟类其实并没有什么关系。这样说来，静态方法就是在类的作用域里的函数而已。

11：1、2、3、4、5 能组成多少个互不相同且无重复的三位数？

count = 0
nums = []
for index1 in range(1,6):
    for index2 in range(1,6):
        for index3 in range(1,6):
            if index1 != index2 and index1 != index3 and index2 != index3:
                num = index1 * 100 + index2 * 10 + index3
                nums.append(num)
                count += 1
print(count)
print(nums)

12、metaclass作用？以及应用场景？

metaclass是类的产生类,而并非继承类
通过它来控制类的产生,以及类实例化的操作
wtform中实例化自定义form类时执行了其元类的__call__方法

13、异常处理写法以及如何主动跑出异常（应用场景）

try:
    执行语句
except 异常类型:
    触发异常后执行的语句
else:
    没有触发异常执行的语句
findlly:
    有没有异常都执行的语句
 
# 主动抛出异常
raise 异常类实例

14、什么是面向对象的mro

方法查找的顺序

15、isinstance作用以及应用场景？

isinstance作用：来判断一个对象是否是一个已知的类型；
 
其第一个参数（object）为对象，第二个参数为类型名(int...)或类型名的一个列表((int,list,float)是一个列表)。其返回值为布尔型（True or flase）。
 
若对象的类型与参数二的类型相同则返回True。若参数二为一个元组，则若对象类型与元组中类型名之一相同即返回True。

16、写代码并实现：

Given an array of integers, return indices of the two numbers such that they add up to a specific target.You may assume that each input would 
have exactly one solution, and you may not use the same element twice.
Example:

          Given nums = [2, 7, 11, 15], target = 9,
           
Because nums[0] + nums[1] = 2 + 7 = 9,

           return [0, 1]

nums = [1,2,3,4,5,]
target = 6
index = []
for i in range(len(nums)):
    for j in range(i,len(nums)):
        if nums[i]+nums[j] == target:
            li = []
            li.append(i)
            li.append(j)
            index.append(li)
print(index)
# [[0, 4], [1, 3], [2, 2]]

17、json序列化时，可以处理的数据类型有哪些？如何定制支持datetime类型？

字符串、列表、字典、数字、布尔值、None
自定义cls类
import json
import datetime
class MyEncoder(json.JSONEncoder):
    def default(self, o):
        if isinstance(o,datetime.datetime):
            return o.strftime('%Y-%m-%d %H:%M:%S')
        else:
            return super(MyEncoder,self).default(o)
 
d = {'name':'petrolero','data':datetime.datetime.now()}
print(json.dumps(d,cls=MyEncoder))　　
# {"name": "petrolero", "data": "2018-10-17 13:01:47"}

18、json序列化时，默认遇到中文会转换成unicode，如果想要保留中文怎么办？

import json
a = json.dumps({'nh':'你好'},ensure_ascii=False)
print(a)
# {"nh": "你好"}

 19、什么是断言？应用场景？

断言条件为真时代码继续执行,否则抛出异常,这个异常通常不会去捕获他.我们设置一个断言目的就是要求必须实现某个条件

 20、有用过 with statement吗？它的好处是什么？

with语句的作用是通过某种方式简化异常处理，它是所谓的上下文管理器的一种
 
用法举例如下：
 
 with open('output.txt', 'w') as f:
        f.write('Hi there!')
 
当你要成对执行两个相关的操作的时候，这样就很方便，以上便是经典例子，with语句会在嵌套的代码执行之后，自动关闭文件。这种做法的还有另一个优势就是，无论嵌套的代码是以何种方式结束的，它都关闭文件。如果在嵌套的代码中发生异常，它能够在外部exception handler catch异常前关闭文件。如果嵌套代码有return/continue/break语句，它同样能够关闭文件。
 
我们也能够自己构造自己的上下文管理器
 
我们可以用contextlib中的context manager修饰器来实现，比如可以通过以下代码暂时改变当前目录然后执行一定操作后返回。
 
from contextlib import contextmanager
import os
 
@contextmanager
def working_directory(path):
    current_dir = os.getcwd()
    os.chdir(path)
    try:
        yield
    finally:
        os.chdir(current_dir)
 
with working_directory("data/stuff"):
    # do something within data/stuff
# here I am back again in the original working directory
 
本段转载自：http://www.cnblogs.com/zhuifeng-mayi/p/9248581.html

 21、使用代码实现查看列举目录下的所有文件。

import os
# 使用os.listdir
dir_aim = input('请输入目标路径:')
for filename in os.listdir(dir_aim):
    print(filename)
 
# 使用os.walk递归遍历
for root,dirs,files in os.walk(dir_aim):
    print('root:',root)
    if files:
        print('files:')
        for file in files:
            print(file)
        print('')
    if dirs:
        for dir in dirs:
            print(dir)