python 常用面试题目（编程）

#!usr/bin/python
# -*- coding: utf-8 -*-

# 字符串去重后排序
from functools import reduce

s = "sheckjffs"
str_list = list(set(s))
str_list.sort()
s = "".join(str_list)
print(s)

# 列表扩展
a = [2, 4, 7, 1]
b = [4, 6, 8, 3]
a.extend(b)


# 冒泡排序
def bubbleSort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):

            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr


bubbleSort(a)
# 列表获取偶数位元素
a = [1, 2, 3, 4]
b = [i for i in a if i % 2 == 1]
print(b)

# 字典删除元素合并字典
a = {"a": "b", "c": "d"}
a.pop("a")
b = {"e": "f"}
a.update(b)
print(a)


# 下列输出是啥
def test_1(x, y, z):
    if x > 0 and y == 0:
        z = z + x
        return z
    elif x == 2 or z > 1:
        return z + 1
    else:
        return z


def add(n, i):
    return n + i


def test():
    for i in range(4):
        yield i


g = test()

for n in [1, 10, 5]:
    g = (add(n, i) for i in g)
    print("===========")
print(list(g))

# 所有的结果都是生成器表达式，不调用它，不从里面取值就不会取值
# 当n=1时，g=(add(1, i) for i in g),其中g=test()即g =(add(1, i) for i in test()) 结果是1,2,3,4
# 当n=10时，括号里边的g是上一次循环结束时的g，即括号中的g g =(add(1, i) for i in test()),
# 括号外的g=(add(10, i) for i in (add(10, i) for i in test()))

n = 1
g = (add(n, i) for i in test())
print(next(g))
# print(list(g)) # [1, 2, 3, 4]

n = 10

g = (add(n, i) for i in (add(n, i) for i in test()))

# print(list(g)) # [20, 21, 22, 23]
n = 5

g = (add(n, i) for i in (add(n, i) for i in (add(n, i) for i in test())))

g = (add(n, i) for i in (add(n, i) for i in (5, 6, 7, 8)))

g = (add(n, i) for i in (10, 11, 12, 13))

g = (15, 16, 17, 18)
L = [1, 2, 3, 5, 6]
B = "".join([str(i) for i in L])
# ls cd pwd mv cp touch mkdir cat wc su rm -rf kill -9 ifconfig


# 给列表中的字典排序：假设有如下 list 对象
alist = [{"name": "a", "age": 20}, {"name": "b", "age": 30}, {"name": "c", "age": 25}]

# 将 alist 中的元素按照 age 从大到小排序。

# 答：利用list的内置函数sort来进行排序


alist = [{"name": "a", "age": 20}, {"name": "b", "age": 30}, {"name": "c", "age": 25}]
alist.sort(key=lambda x: x['age'], reverse=True)
print(alist)
# 将a,b he为字典
a = ['a', 'b', 'c', 'd', 'e']
b = [1, 2, 3, 4, 5]
c = dict(zip(a, b))
print(c)


# zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
# 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。


# selenium 中难点介绍：1.多级frame,2.元素等待，使用WebDriverWait和expected_conditions 进行循环等待查找元素，超时就退出。3.下载框不属于浏览器的需要用
# PyuserInput中的pykeyboard进行处理4.selenium 无法处理的一些操作使用execute_js执行js操作来进行滚动条等操作


def binary_search1(alist, target):
    low = 0
    hight = len(alist)
    while low < hight:
        mid = int((low + hight) / 2)
        guess = alist[mid]
        if guess == target:
            return mid
        elif guess > target:
            hight = mid
        elif guess < target:
            low = mid + 1
    return -1


# def binary_search(alist, target, low, high):
#     mid = int((low + high) / 2)
#     if alist[mid] == target:
#         return mid
#     elif alist[mid] < target:
#         return binary_search(alist, target, mid, high)
#     elif alist[mid] > target:
#         return binary_search(alist, target, low, mid)

# 二进制和十进制转换
def ten_to_bin(num):
    '''
    十进制转二进制，取余数，然后余数到过来
    :param num:
    :return:
    '''
    result = ''
    while num != 0:
        yu = num % 2
        num = num // 2
        print(num, yu)
        result = str(yu) + result
    return result


def bin_to_ten(num):
    '''
    二进制转十进制，对应位置数字乘以2的(n-i-1）次方，n为数字长度
    :param num:
    :return:
    '''
    n = len(str(num))
    result = 0
    for i in range(n):
        result = result + int(2 ** (n - i - 1)) * int(str(num)[i])
    return result


print("============5252=======")
print(ten_to_bin(21))
print(bin_to_ten(10101))
# 字典按照键或值排序
my_dict = {'lilee': 25, 'age': 24, 'phone': 12}
print(dict(sorted(my_dict.items(), key=lambda x: x[0])))
print(dict(sorted(my_dict.items(), key=lambda x: x[1])))
# 计算两个日志之间相隔天数
import time
import sys


def dateinput():
    date = input('please input the first date: ')
    return date


def datetrans(tdate):
    spdate = tdate.replace("/", "-")
    try:
        datesec = time.strptime(spdate, '%Y-%m-%d')
    except ValueError:
        print
        "%s is not a rightful date!!" % tdate
        sys.exit(1)
    return time.mktime(datesec)


def daysdiff(d1, d2):
    daysec = 24 * 60 * 60
    return int((d1 - d2) / daysec)


# date1 = dateinput()
# date2 = dateinput()
# date1sec = datetrans(date1)
# date2sec = datetrans(date2)
# print("The number of days between two dates is: ", daysdiff(date1sec, date2sec))

"""
 设计一个函数，对传入的字符串（假设字符串中只包含小写字母和空格）进行加密操作，
加密的规则是a变d，b变e，c变f，……，x变a，y变b，z变c，空格不变，返回加密后的字符串

"""


def caesar_encrypt(string):
    base = ord('a')
    encrypted_string = ''
    for ch in string:
        if ch != ' ':
            curr = ord(ch)
            diff = (curr - base + 3) % 26
            ch = chr(base + diff)
        encrypted_string += ch
    return encrypted_string


def main():
    print(caesar_encrypt('attack at dawn'))  # dwwdfn dw gdzq
    print(caesar_encrypt('dinner is on me'))  # glqqhu lv rq ph


main()
"""

设计一个函数，生成指定长度的验证码（由数字和大小写英文字母构成的随机字符串）

"""

from random import randrange


def generate_code(length=4):
    all_chars = 'abcdefghijklmnopqrstuvwxyzABDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
    all_chars_len = len(all_chars)
    code = ''
    for _ in range(length):
        index = randrange(all_chars_len)
        code += all_chars[index]
    return code


# 剑指offer）输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
# #
# # 思路：选定第一个数字，然后遍历后面的数字求和并与S比较，需要n-1次，不行的话再选定第2,3，，，n个数字，需要n^2次，时间复杂度比较高。
# # 更简单的方法可以是定义两个指针，第一个指向第一个元素，第二个指向最后一个元素，两个元素相加，如果等于S则输出这两个元素，如果大于，
# # 则将第二个指针向前移一位，再求和进行比较；如果小于，则将第一个指针向前移一位，再进行求和比较。
def get_num(data, sum_num):
    if not data or not sum_num:
        return []
    i = 0
    j = len(data) - 1
    result = []
    while i < len(data) and j > 0:
        if data[i] + data[j] == sum_num:
            result.append((data[i], data[j]))
        elif data[i] + data[j] > sum_num:
            j = j - 1
        elif data[i] + data[j] < sum_num:
            i = i + 1
    return result


# 查询同名学生信息
# select * from student where name in (select name from student group by name having count(name)>1);

# 实现栈结构
class Stack(object):
    # 初始化栈为空列表
    def __init__(self):
        self.items = []

    # 判断栈是否为空，返回布尔值
    def is_empty(self):
        return self.items == []

    # 返回栈顶元素
    def peek(self):
        return self.items[len(self.items) - 1]

    # 返回栈的大小
    def size(self):
        return len(self.items)

    # 入栈
    def push(self, item):
        self.items.append(item)

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


# 选择排序，选择一个数作为最小数的下标，然后拿这个数依次跟其他数进行对比，如果有比它小的数，就记录下那个值的下标，然后进行元素互换
def select_sort(alist):
    n = len(alist)
    for i in range(n):
        min = i
        for j in range(i + 1, n):
            if alist[j] < alist[i]:
                min = j
                alist[min], alist[i] = alist[i], alist[min]
    return alist


print(select_sort([1, 5, 7, 2, 3, 6, 9, 77]))


# 文件中有三个字段，时间2020-08-12，userid,访问次数，求每个用户每个月访问的次数的和
def get_visit_time_by_month(month):
    dict_visit = {}
    with open("a.txt", "r")as f:
        for line in f.readlines():
            time, user_id, count = line.split(" ")
            month1 = time[4:6]
            if month1 == month:
                if user_id in dict_visit.keys():
                    dict_visit[user_id] = dict_visit[user_id] + count
                else:
                    dict_visit[user_id] = count
    return dict_visit


alist = [1, 2, 5, 9, 11, 15, 52]


# target = binary_search(alist, 52, 0, len(alist) - 1)
# print(target)


# 可变类型做默认参数，可变类型值一直增加
def f(x, l=[]):
    print("===============%s" % id(l))
    print(l)
    for i in range(x):
        l.append(i * i)
    print("结束后%s" % l)


f(2)
f(3, [3, 2, 1])
f(3)
f(3)
# ===============12139056
# []
# 结束后[0, 1]
# ===============51299512
# [3, 2, 1]
# 结束后[3, 2, 1, 0, 1, 4]
# ===============12139056
# [0, 1]
# 结束后[0, 1, 0, 1, 4]
# ===============12139056
# [0, 1, 0, 1, 4]
# 结束后[0, 1, 0, 1, 4, 0, 1, 4]
# Python 是强类型的动态脚本语言
# 打印结果说出理由
l = []
for i in range(10):
    l.append({'num': i})
print(l)

l = []
a = {'num': 0}
for i in range(10):
    a['num'] = i
    l.append(a)
print(l)


# 一句话解决阶乘函数
def get_jiecheng(n):
    reduce(lambda x, y: x * y, range(1, n + 1))


print("++++++++++++++")

# fibnaci数列
def fib(n):
    alist = [0, 1]
    for i in range(1, n):
        alist.append(alist[i] + alist[i - 1])
    return alist


def fib2(n):
    alist = [1, 1]
    if n < 1:
        return -1
    if n == 1 or n == 2:
        return 1
    if n > 2:
        return fib2(n - 1) + fib2(n - 2)


print(fib(10))
print([fib2(i) for i in range(1, 11)])

# 单例模式
class single:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            cls._instance = object.__new__(cls)
        return cls._instance

# 二分查找
def twofind(n, l):
    min = 0
    max = len(l)
    if n in l:
        while True:
            mid = int((max + min) / 2)
            if n > l[mid]:
                min = mid
            elif n < l[mid]:
                max = mid
            else:
                if n == l[mid - 1]:
                    return (mid - 1)
                else:
                    return (mid)
    else:
        return -1


'''
求两个字符串的最长公共子串
思想：建立一个二维数组，判断对应位置是否相等，相等记为1，最后数这个数组对角线上为1的最大长度
'''


def getNumofCommonSubstr(str1, str2):
    lstr1 = len(str1)
    lstr2 = len(str2)
    record = [[0 for i in range(lstr2 + 1)] for j in range(lstr1 + 1)]  # 多一位
    maxNum = 0  # 最长匹配长度
    p = 0  # 匹配的起始位

    for i in range(lstr1):
        for j in range(lstr2):
            if str1[i] == str2[j]:
                # 相同则累加
                record[i + 1][j + 1] = record[i][j] + 1
                if record[i + 1][j + 1] > maxNum:
                    # 获取最大匹配长度
                    maxNum = record[i + 1][j + 1]
                    # 记录最大匹配长度的终止位置
                    p = i + 1
                    # print(record)
    return str1[p - maxNum:p], maxNum


str1 = 'abcdef'
str2 = 'mcdea'

res = getNumofCommonSubstr(str1, str2)
print(res)

# 求质因数
def get_zhi(num):
    alist = []
    while num > 1:
        for i in range(2, num + 1):
            if num % i == 0:
                alist.append(i)
                num = int(num / i)
            if num == 1:
                break
    return alist


print(get_zhi(20))

# 打印函数执行时间装饰器
def get_exec_time(fun):
    def wapper(*args,**kwargs):
        start_time= time.time()
        fun(*args,**kwargs)
        end_time = time.time()
        print(end_time-start_time)
    return wapper

'''''
功能：找出来一个字符串中最长不重复子串
'''
def find_longest_no_repeat_substr(one_str):
  '''''
  找出来一个字符串中最长不重复子串
  '''
  # 思路：从第一个元素开始遍历，构造一个新字符串，如果新字符不在新字符串中，就加入，存在就跳出循环
  # 用一个列表记录每个新字符串，然后按照长度排序
  res_list=[]
  length=len(one_str)
  for i in range(length):
    tmp=one_str[i]
    for j in range(i+1, length):
      if one_str[j] not in tmp:
        tmp+=one_str[j]
      else:
        break
    res_list.append(tmp)
  res_list.sort(key=lambda x:len(x))
  return res_list[-1]

one_str_list=['120135435','abdfkjkgdok','123456780423349']
for one_str in one_str_list:
    res=find_longest_no_repeat_substr(one_str)
    print('{0}最长非重复子串为：{1}'.format(one_str, res))

# 约瑟夫斯问题（Josephus Problem）是应用队列（确切地说，是循环队列）的典型案例。在 约瑟夫斯问题 中，参与者围成一个圆圈，从某个
# 人（队首）开始报数，报数到n+1的人退出圆圈，然后从退出人的下一位重新开始报数；重复以上动作，直到只剩下一个人为止。
# 思路：使用队列先进先出特性，将报的n个数的人从队列中删除，然后添加到对尾，此时第一个人就是第一次计数后将要退出的人，将它退出，第一轮结束
# 此后每轮都依次进行即可
class Queue:
    def __init__(self):
        self.items = []

    def enqueue(self, item):
        self.items.append(item)

    def dequeue(self):
        return self.items.pop(0)

    def empty(self):
        return self.size() == 0

    def size(self):
        return len(self.items)


def printquene(queue):
    for i in queue.items:
        print(i, end=",")


def josephus(namelist, num):
    simqueue = Queue()

    for name in namelist:
        simqueue.enqueue(name)

    while simqueue.size() > 1:
        for i in range(num):
            simqueue.enqueue(simqueue.dequeue())
        printquene(simqueue)
        print()
        simqueue.dequeue()

    return simqueue.dequeue()


if __name__ == '__main__':
    print(josephus(["Bill", "David", "Kent", "Jane", "Susan", "Brad"], 3))


# Jane,Susan,Brad,Bill,David,Kent,
# David,Kent,Susan,Brad,Bill,
# Bill,Kent,Susan,Brad,
# Kent,Susan,Brad,
# Brad,Susan,
# Susan

# n接台阶问题
def fib8(n):
    if n == 1:
        return 1
    if n == 2:
        return 2
    while n > 2:
        return fib8(n - 1) + fib8(n - 2)


print("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
print(fib8(9), "============")
import random
# 抢红包算法，金额和几个人
# 思路：
# 红包的思路了，在你发红包的时候要填写两个重要参数就是红包的金额我命名为cash，人数person,在就要思考重要的一点就是红包的最大值和
# 最小值，不会有点红包领到0吧，一般0.01为最小值，为什么会来说还有最大值，你想假如一个10块的红包6个人抢第一个能抢了9.99，那么第二
# 个人只有剩下0.01，后面的人没得强，这不就有问题了。所以最大值应该就是红包总金额减去最小值乘以人数(10-0.01x6)这样才保证大家都有
# 得抢当然最贪婪的写法是10-0.01x5有人会问为什么是5，已经把第一个人排除剩下五个最惨的结局都是0.01
dic = {}
lis = ['KeLan', 'Monkey', 'Dexter', 'Superman', 'Iron Man', 'Robin']
def redpacket(cash, person, index):
    if cash > 0 and person != 1:

        n = round(random.uniform(0.01, cash - (0.01 * person)), 2)
        dic[lis[index]] = n

        print(str(n).ljust(4, "0"))
        person -= 1
        cash -= n
        index += 1
        redpacket(cash, person, index)
    else:
        dic[lis[index]] = round(cash, 2)

        print(str(cash).ljust(4, "0"))
redpacket(10, len(lis), 0)
print(dic)
print("手气最佳:", max(dic.items(), key=lambda x: x[1]))