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)