为什么输出6，6，6，6

def num():
    return [lambda x: i*x for i in range(4)]   # 这里使用的是lambda函数 
print([m(2) for m in num()])     # 输出: [6, 6, 6, 6]

思路

这题涉及到了闭包延时绑定，当循环执行完了之后才会执行传参，循环四次，每一次循环完 i=3 然后再和x相乘 所以结果是6，6，6，6。 如果把 [ lambda x: ix for i in range(4) ] 改成 （ lambda x: ix for i in range(4) ）这样就变成了一个生成器 自动实现迭代器协议，一边循环一边计算的机制， 这样结果就是 0，2，4，6.

两数之和

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

思路：

这里可以使用字典来解题，通过enumerate方法遍历获取数据的下标包括对应值，然后以key，value形式把该数据的下标和对应值存入字典，然后再出通过enumerate方法遍历数据，每一次获取数据就从字典拿出一个值，用目标值减去从字典拿出的这个值得到一个结果值，如果结果值存在字典当中，那么返回两个数的下标，如果为None，说明字典中没有这个值。

def get_index_list(nums, target):

    # Todo 作为一个方法来实现，批量解决这个获取索引的问题
    """
    :params nums：传的参数的列表
    :params target: 目标值
    :return: 返回索引
    """

    dic = {}

    for a, b in enumerate(nums):  # a是下标 b是对应值

        dic[b] = a  # 对应值存入字典

    for i, b in enumerate(nums):

        j = dic.get(target-b)  # 从字典中拿出对应值 用目标值减去对应值

        if j is not None:  # 判断如果减去的对应值不为空，则返回下标

            return [i, j]
if __name__ == "__main__":
    print(get_index_list([2, 7, 11, 15],9))

数组中重复的数字

示例：

输入:
[2,3,1,0,2,5,3]
输出: 2 或 3

思路：

这道题想到的是，使用列表中的count方法，定义一个空列表，遍历数据然后进行判断，如果数据值出现个数大于或等于2，说明该数据是重复的，然后把重复的筛取出来之后存入空列表，再进行返回输出。

实现代码：

def get_number(nums):
    """
    :params nums：传的参数的数组
    :return: 返回重复数字
    """
    nub = []

    for i in nums:
        if nums.count(i) >= 2:
            if str(i) not in nub:
                nub.append(str(i))

    print('或'.join(nub))


if __name__ == "__main__":
    get_number([2, 3, 1, 0, 2, 5, 3])

队列实现一个栈

思路：

使用一个队列，实现栈的一些基本操作，栈（后进先出）的特性。

实现代码：

# 队列实现一个栈 （栈：后进先出）
class Stack(object):

    def __init__(self):
        # 定义一个队列
        self.lst = []

    def is_None(self):
        # 判断栈是否为空 返回 ture false
        return self.lst == []

    def push(self, i):
        # 加入元素
        self.lst.append(i)

    def pop(self):
        # 出栈
        return self.lst.pop()

    def stack_top(self):
        # 返回栈顶元素
        return self.lst[-1]

    def size(self):
        # 栈的大小
        return len(self.lst)


if __name__ == "__main__":

    stack = Stack()
    print(stack.is_None())
    stack.push(1)
    stack.push(2)
    stack.push(3)
    print(stack.lst)
    print(stack.pop())
    print(stack.stack_top())
    print(stack.size())

---

回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例1：

输入: 121
输出: true

示例2：

输入: -121
输出: false
解释: 从左向右，为 -121 。 从右向左读，为121- 。 因此它不是一个回文数

示例3：

输入: 10
输出: false
解释: 从右向左读，为 01 。 因此它不是一个回文数

思路：

这题可以使用字符串 双指针的方法 将数据转化为字符串 首先定义好第一个元素下标和最后一个元素下标，while循环 只要条件不满足 一直循环 循环判断第一个和最后一个元素是否相等 不相等返回false 相等继续循环，如果循环条件满足之后都相等，返回 false

实现代码：

def palindromic_number(x):

    """
    :params x：传的参数的列表
    :return: 返回Ture False
    """

    lst = list(str(x))
    print(lst)
    L, R = 0, len(lst)-1

    while L <= R:
        print(L, R)
        if lst[L] != lst[R]:
            return False

        L += 1
        R -= 1
    return True


if __name__ == "__main__":
    print(palindromic_number(1231))

---

分别用生成器和迭代器生成斐波那契数列

示例：

输出: 1 1 2 3 5 8 13

# 使用迭代器生成斐波那契数列
class Fibonacii(object):
    def __init__(self,all_num):
        self.all_num = all_num
        self.cur_idx = 0
        self.a = 0  
        self.b = 1
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.cur_idx >= self.all_num:
            raise StopIteration
        ret = self.a
        
        self.a, self.b = self.b, self.a + self.b
        self.cur_idx += 1
        return ret
 
fibo = Fibonacii(10)
for i in fibo:
    print(i)

# 使用生成器生成斐波那契数列
def fibnacii(count):
    num = 0
    a, b = 0, 1
    while num < count:
        yield a
        a, b = b, a+b
        num += 1


fi = fibnacii(10)
for i in fi:
    print(i)

反转字符数组

思路：

直接使用反转

实现代码：

# 反转字符串
def reverseString(s):
    s[0::] = s[::-1]
    print(s)


if __name__ == "__main__":
    reverseString(['b', '', 'a', 'r'])

字符串反转

a="Let's take LeetCode contest"
def b():
    return ' '.join(a.split(' ')[::-1])[::-1]
if __name__ == '__main__':
    print(b())

球

def a():
    slit=[]
    s=100
    for c in range(0,10):
        if c==0:
            slit.append(s)
        else:
            slit.append(s*2)
        s=s/2
    print(sum(slit))
    print(s)
if __name__ == '__main__':
    a()

冒泡排序

#定义一个函数传入个变量
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)

本文地址：https://blog.csdn.net/weixin_45499040/article/details/107153228