zoukankan      html  css  js  c++  java
  • 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)
    
  • 相关阅读:
    C++ 遍历文件
    C++ struct
    C++动态数组
    C++ 常量指针和矩阵
    imfilter与fspecial
    空间域图像增强:卷积和空间域滤波
    数字图像处理-图像的几何变换(一)
    多线程中的生产者消费者问题
    使用Netty进行Android与Server端通信实现文字发送接收与图片上传
    C# FileSystemWatcher 监视磁盘文件变更
  • 原文地址:https://www.cnblogs.com/petrolero/p/9794901.html
Copyright © 2011-2022 走看看