django面试

1.青蛙跳台阶

一只青蛙一次可以跳上1阶，也可以跳上2阶。求该青蛙跳上一个n级的台阶总共有多少种跳法。

fib = lambda n: n if n < 2 else 2 * fib(n - 1)

0: 1

1: 1

2: 2(1,1 2)

3: 3(1,1,1 1,2 2,1)

4: 5(1,1,1,1 1,1,2 1,2,1 2,1,1 2,2) ( 3,1 2,2)

5: 8(…)( 4 的跳发 乘 1阶的) (4,1 3,2)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oE0Zblj2-1607152240681)(40题.assets/wpsGorffa.jpg)]

2.MySQL事物

事务是数据库区别于文件系统的重要特性之一，事务会把数据库从一种一致性状 态转换为另一种一致性状态

数据库提交时，可以确保要么所有修改都保存，要么都不保存

如果一个业务需要操作多个数据, 那么需要保证所有数据同时操作成功, 如果不成功, 就回滚所有操作

3.redis事物(批量操作, 中间不能插入其他的操作)

Pipline

1. redis pipline是可以一次执行多个命令，本质是一组命令的集合。

2. 一个事务中的所有命令都会序列化，按顺序串行化的执行而不会被其他命令插入

作用：一个队列中，一次性、顺序性、排他性的执行一系列命令

如果执行错误了: 继续执行, 不会回滚

4.MySQL优化

1. 字段设计优化 适应遵循数据库三范式

2. 引擎的选择 适应选择MyIsam & InnoDB

3. 索引 索引也会消耗内存空间，并不是越多越好。而且索引的种类都有各自的优点

4. 查询缓存 将 select查询结果缓存起来，key 为SQL语句，value 为查询结果

5. 分区

6. 水平分割和垂直分割

7. 集群

8. SQL语句

9. 服务器的选择 选择配置较高的服务器

5.迭代器

1. 迭代器是访问集合内元素的方式，迭代器对象从集合的第一个元素开始访问，直到所有的元素都被访问一遍后结束

2. 迭代器仅是一容器对象，它有两个基本方法

   1. next方法：返回容器的下一个元素

   2. _ _ iter _ _方法：返回迭代器自身

有Next() 方法的, 就可以被迭代

有 iter 方法的 返回一个 可迭代对象 可以被 for 语句迭代, in 迭代

Class Obj():
   def __next__():
   	Pass

   def __iter__():
   	Return self

obj = Obj()

While True:

   next(obj)  依赖 __next__()


for o in obj:  依赖 __iter__()
   print o

6.四大高阶函数

Sorted函数(排序)

filter()函数(过滤, 结果中存在 满足条件的数据, , 不存在不满足的数据)(原始数据5, 结果和原始数据的数量不一定一样, )

Map方法(加工, 按照方法, 加工每一个元素, 结果中, 含有所有的元素的加工结果, 结果和原始数据的数量是一样的 )

reduce函数(逐个两两处理, 第一次, 使用2个数据, 生成1结果, 再和下一个数据, 处理, 最后只有一个结果)

7.静态方法、类方法、实例方法

静态方法：

1. 作用：静态方法可以更好的组织代码，防止代码变大后变得比较混乱。

2. 特性: 静态方法只是名义上归类管理，实际上在静态方法里访问不了类或者实例中的任何属性

类方法：

1. 作用：无需实例化直接被类调用

2. 特性: 类方法只能访问类变量，不能访问实例变量

属性方法：

作用：属性方法把一个方法变成一个属性，隐藏了实现细节,调用时不必加括号直接d.eat即可调用self.eat()方法

魔法方法：

__new__ : 先于__init__方法，每生成一个实例执行一次，创建实例对象 (在内存中给对象分配空间)

__init__: 每生成一个实例就会执行一次，初始化实例对象 (给对象的空间中, 保存数据)

__call__: 有这个方法,  对象就可以被调用

__del__: delete  obj   就会调用这个方法

class A():
   class_name = 'A'
   
   def __init__(self, num):
       self.num = num

   @staticmethod  # 静态方法
   def func1():
       # 方法要操作的数据, 不是这个类里的
       print('func1')
       pass

   @classmethod  # 类方法
   def func2(cls):
       # 类方法, 这个方法, 要操作的数据是类中保存的
       print(cls.class_name)
       pass

   def func3(self):
       # 实例方法, 这个方法, 要操作的数据, 是实例中的数据
       print(self.num)
       pass

A.func1()
A.func2()
a = A(123)
a.func3()

属性方法

class A():
    name = 'aaa'
    birthday = '2010-01-01'

    @property  # 属性方法
    def age(self):
        return 10


a = A()

print(a.name)
print(a.age)  # age函数被当做属性使用

魔法方法

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

    def __call__(self, *args, **kwargs):
        print('被调用了')

    def __add__(self, other):
        return self.age + other.age

    def __ge__(self, value):
        return self.age >= value

    def __del__(self):

        print('被删除了')

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


p1 = Person('lisi', 18)
p2 = Person('zs', 19)  # 就算你不主动删除,  在脚本执行完成时,  解释器也会把p2 删除

# d1 = Dog('xiaohua', 3)

# print(p1 + d1)
# print(d1 + p1)
# print(p1 >= 20)
# l1 = [1, 2, 3]
# l2 = [4, 5, 6]
# print(l1 + l2)  # __add__()
# p1()

del p1
del p2

8.冒泡法排序

def bubble_sort(li):
	for i in range(len(li)-1):
		for j in range(len(li)-i-1):
			if li[j] > li[j+1]: # 后一个数比前一个数大，两个数换位置
				li[j],li[j+1]=li[j+1],li[j] # 交换位置
li = [1,5,2,6,3,7,4,8,9,0]
bubble_sort(li)
print(li)

第一轮:从第一个元素开始, 比较相邻的两个元素, 如果 a>b 就交互位置, 第一轮可以比较出一个最大的数, 放在最后面.

第二轮:从剩下的数据中, 再次比较出一个最大的.

以此类推, 比较n-1轮, 使列表大的数据靠后, 小的数据靠前.

9.快排

def quick(list):
	if len(list) < 2:
		return list
	tmp = list[0]  # 临时变量 可以取随机值
	left = [x for x in list[1:] if x <= tmp]  # 左列表
	right = [x for x in list[1:] if x > tmp]  # 右列表
	return quick(left) + [tmp] + quick(right)
li = [4,3,7,5,8,2]
print quick(li)

快速排序, 它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

10.二分查找

def func(list1,item):
	first=0
	end=len(list1)-1
	while first<=end:
		mid=(first+end)//2
		if item==list1[mid]:
			return True
		elif item>list1[mid]:
			first=mid+1
		else:
			end=mid-1
	return  False

print(func([i for i in range(1,101)],1))

提供一个有序的数组, 数组必须有序

2,3,4,5,7,8,9 => 找1

每次都排除一半数据