python算法面试题总结

标签：作用域   方法   param   yield   tar   ISE   epc   _id   str   

各种类型的算法

import copy
# def num():
#     return [lambda x, i=i: x*i for i in range(4)]
# print([m(2) for m in num()])
# M(2)是取值得2倍   这个问题涉及到了Python的闭包及延时绑定的知识（Python作用域）。
# 在Python核心编程里，闭包的定义如下：
# 如果在一个内部函数里，对外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认定是闭包。
# 总结为三点：
# 1、是一个内嵌函数
# 2、对外部函数变量引用
# 3、外部函数返回内嵌函数
# 简单的闭包例子：
# def counter(start_at=0):
#     count = [start_at]
#     def incr():
#         count[0] += 1
#         return count[0]
#     return incr
# 上面的那道题，可以写成这样：
# def func():
#     fun_list = []
#     for i in range(4):
#         def foo(x):
#             return x*i
#         fun_list.append(foo)
#     return fun_list
# for m in func():
# 　　print m(2)
# func()是一个包含四个函数的列表：
# [, , , ]
# 当我们执行 m(2) 时，运行到foo()内部函数，发现变量 i 并不是foo()中的变量，于是就到外部函数func中寻找变量 i ，但此时外部的 for 已经循环完毕，最后的 i =3 。所以，每次
# 执行m(2)，i 的值都是 3 ，因此，最终结果会是 [6, 6, 6, 6] 。
# 当在foo()中添加 i=i 后，即：
# def func():
#     fun_list = []
#     for i in range(4):
#         def foo(x, i=i):
#             return x*i
#         fun_list.append(foo)
#     return fun_list
# for m in func():
# 　　print m(2)
# 这样的话，for循环执行时，就已经把 i（0, 1, 2, 3） 的值传给了foo()函数，此时的 i 已经是foo()函数的内部变量，运行到foo()函数时，就不会到外部函数寻找变量 i ，直接运行



# def num():
#     return [lambda x: i * x for i in range(4)]
# print([m(1) for m in num()])
#
#
#
# def num():
#     return (lambda x: i * x for i in range(4))
# print([m(2) for m in num()])




# 给定
# nums = [2, 7, 11, 15], target = 9
# # 因为
# nums[0] + nums[1] = 2 + 7 = 9
# # 所以返回
# [0, 1]




# todo   任务
# todo   也可以理解为to do   to do 是将要做的事情，还没做的事情


# def get_list_values(nums, values):
#     """
#         :param nums传过来的list
#         :param values 和为9
#         :returns 索引
#     """
#
#     for i in nums:
#         a = (values - i)  # 算出差值减少一次for循环
#         j = nums.index(i)
#         try:
#             k = nums.index(a)
#             if j #                 print(j, k)
#         except:
#             if a == 0:
#                 print(j)
#
#
# if __name__ == ‘__main__‘:
#     get_list_values([7, 2, 6, 9, 11, 15], 11)
#
# def get_list_values(nums,values):
#     """
#         :param nums传过来的list
#         :param values 和为9
#         :returns 索引
#     """
#     for i in nums:
#         a=(values-i)#算出差值减少一次for循环
#         j=nums.index(i)
#         if a!=0: #值为不为9
#             if a in nums: #in的时间复杂度为1
#                 k=nums.index(a)
#                 if j#                     print(j,k)
#         else:
#             print(j)
#
# if __name__ == ‘__main__‘:
#     get_list_values([7,2,6,9,11,15],11)



# def get_index(nums, target):
#     """
#     :param nums:传的参数列表
#     :param target:目标值
#     :return:索引值列表
#     """
#     index_dict={
#
#     }
#     for index,num in enumerate(nums):
#         tem=target-num
#         tem_index=index_dict.get(tem,‘‘)
#         if tem_index:
#             print(tem_index,index)
#             # return [tem_index,index]
#         else:
#             index_dict[num]=index
#
# if __name__ == ‘__main__‘:
#     pp = get_index([2, 4, 5, 8, 1, 11, 4, 15, 7], 9)
    # print(pp)





# 判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
# 示例 1:
# 输入: 121   输出: true
# 示例 2:
# 输入: -121    输出: false     解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
#
# 示例 3:
# 输入: 10    输出: false   解释: 从右向左读, 为 01 。因此它不是一个回文数。



# def rev(num):
#     """
#     :param num:
#     :return:
#     """
#     n=str(num)
#     if num == int(n[::-1]):
#         return True
#     else:
#         return False
#
# if __name__ == ‘__main__‘:
#     a=rev(111)
#     print(a)

# k = [1,2,3,4,5]
# n=copy.copy(k)
# print(f‘{k}‘)
# print(f‘{n}‘)
# print(‘-----------‘)
# k[3].append(‘231‘)
# print(f‘{k}‘)
# print(f‘{n}‘)



# 正常逻辑的深拷贝浅拷贝
# k=[1,2,3,4,[‘a‘,‘b‘]]
# c=copy.copy(k)
# k[4].append(‘c‘)
# print(k,c)
# print(k)
# print(id(k[4]))

# f=copy.deepcopy(k)
# print(id(k[4]),id(c[4]),id(f[4]))




## 迭代器：
# class FeiBo():
#     def __init__(self,n):
#         self.a = 1
#         self.b = 1
#         self.c = 0
#         self.n = n
#
#     def __iter__(self):
#         return self
#
#     def __next__(self):
#         if self.c #             r = self.a
#             self.a,self.b = self.b, self.a+self.b
#             self.c+=1
#             return r
#         else:
#             raise StopIteration
#
# f=FeiBo(9)
# for i in f:
#     print(i)
#
# ## 生成器：
#
# def FeiBo(n):
#     a=1
#     b=1
#     for i in range(n):
#         yield a
#         a,b=b,a+b
# f=FeiBo(10)
# for i in f:
#     print(i)


# 在一个长度为n的数组nums里的所有数字都在0-n-1的范围内，请找出数组中任意一个重复的数字

# class Son:
#     def fint(self,nums: list[int]) -> int:
#         dict={}
#         for i in nums:
#             if dict.get(i,‘‘):
#                 return  i
#             else:
#                 dict[i]=1
#     if __name__ == ‘__main__‘:
#         fint[2,3,4,5,2,2,3]

def grt_nums(nums):
    """
    :param nums: 传的值
    :return:   返回重复的数
    """
    for i in nums:
        a= nums.count(i)
    if a >=2:
        print(a)
if __name__ == ‘__main__‘:
    grt_nums([2,3,4,5,2,2,3,3])

‘‘‘第一种：使用字符串切片‘‘‘
s = ‘Hello World‘
print(s[::-1])  # dlroW olleH

‘‘‘第二种：使用列表的reverse方法‘‘‘
l = list(s)
l.reverse()
print( "".join(l) )   # dlroW olleH

‘‘‘第三种：使用reduce‘‘‘
from functools import reduce
result = reduce(lambda x,y:y+x,s)
print( result )      # dlroW olleH

python算法面试题总结

标签：作用域   方法   param   yield   tar   ISE   epc   _id   str   

原文地址：https://www.cnblogs.com/zjldeboke/p/13254164.html