python经典练习题及面试题

1. 有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？

1.程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去
      掉不满足条件的排列。
2.程序源代码：

count = 0
for i in range(1,5):
    for j in range(1,5):
        for k in range(1,5):
            if( i != k ) and (i != j) and (j != k):
                count+=1
                print("序号",count,i,j,k)

2. aXb的列表变成bXa的列表

代码如下：

# aXb的列表变成bXa的列表
matrix = [
     [1, 2, 3, 4],
     [5, 6, 7, 8],
    [9, 10, 11, 12]
 ]
transposed = []
for i in range(len(matrix[1])):
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
    transposed.append(transposed_row)
print(transposed)

结果：

3. 一元二次方程求解

代码如下：

# 二次方程式 ax**2 + bx + c = 0
# a、b、c 用户提供，为实数，a ≠ 0

# 导入 cmath(复杂数学运算) 模块
import cmath

a = float(input('输入 a: '))
b = float(input('输入 b: '))
c = float(input('输入 c: '))

# 计算
d = (b ** 2) - (4 * a * c)

# 两种求解方式
sol1 = (-b - cmath.sqrt(d)) / (2 * a)
sol2 = (-b + cmath.sqrt(d)) / (2 * a)

print('结果为 {0} 和 {1}'.format(sol1, sol2))

结果如下;

4. 九九乘法表

for i in range(1, 10):
    for j in range(1, i+1):
        print('%dx%d=%d\t'%(j, i, i*j), end='')
    print()

结果：

5.二分查找目标数据

二分查找，有弊端，查找的数必须在列表中， 不然查找一直继续出不来了

def BinarySearch(list1, num):
    min = 0  # 最小的下标
    max = len(list1) - 1  # 最大的下标
    i = 0
    while True:
        i += 1
        mid = (max + min) // 2  # 中间的下标每次向下取整
        if num > list1[mid]:
            min = mid + 1  # 小于需要的猜的数，则将最小下标变为中间的，又因为中间的已经猜过，所以要加1
        elif num == list1[mid]:
            print("找到数据")
            print("一共查找%d次" % i)
            break
        else:
            max = mid - 1  # 大于需要的猜的数，则将最大下标变为中间的，又因为中间的已经猜过，所以要减1


if __name__ == "__main__":
    list1 = [i for i in range(0, 100)]
    num = 98
    BinarySearch(list1, num)

6.冒泡排序

#冒泡排序
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]

arr=[1,2,4,3,55,22,88,11,44,12]
bubblesort(arr)
print("排序后的列表")
# for i in range(len(arr)):
#     print(arr[i])
print(arr)

# 简单的排序用sorted
arr1=[1,2,4,3,55,22,88,11,44,12]
a = sorted(arr1)
print(a)

   

7.类和方法，分配家具

class Home():
    def __init__(self,area,info,addr):
        self.area=area
        self.info=info
        self.addr=addr
        self.left_area=area
        self.jiaju_list=[]
    def __str__(self):
        return "房子的总面积{}，户型{}，地址{},添加的家具为{}，房间剩余面积为{}" \
               "".format(self.area,self.info,self.addr,str(self.jiaju_list),self.left_area)
    def add_jiaju(self,items):
        self.jiaju_list.append(items.name)
        self.left_area-=items.area
class Jiaju():
    def __init__(self,name,area):
        self.name=name
        self.area=area
    def __str__(self):
        return "新的家具{}，面积为{}".format(self.name,self.area)

fangzi=Home(129,"三室两厅","深圳南山区")
bed=Jiaju("席梦思床",3)
yigui=Jiaju("衣柜",1.4)
canzhuo=Jiaju("餐桌",2)
print(canzhuo)

fangzi.add_jiaju(bed)
fangzi.add_jiaju(yigui)
fangzi.add_jiaju(canzhuo)
print(fangzi)

8.判断奇数偶数

while True:
    try:
        num=int(input('输入一个整数：')) #判断输入是否为整数
    except ValueError: #不是纯数字需要重新输入
        print("输入的不是整数！")
        continue
    if num%2==0:
        print('偶数')
    else:
        print('奇数')
    break

9. 判断闰年

year = int(input("输入一个年份: "))
if (year % 4) == 0:
   if (year % 100) == 0:
       if (year % 400) == 0:
           print("{0} 是闰年".format(year))   # 整百年能被400整除的是闰年,2000,2400
       else:
           print("{0} 不是闰年".format(year))  #2100,2200
   else:
       print("{0} 是闰年".format(year))       # 非整百年能被4整除的为闰年,2004,2008
else:
   print("{0} 不是闰年".format(year))        #2003,2013

10. 十进制转二进制八进制十六进制

# 获取用户输入十进制数
dec = int(input("输入数字："))

print("十进制数为：", dec)
print("转换为二进制为：", bin(dec))
print("转换为八进制为：", oct(dec))
print("转换为十六进制为：", hex(dec))

10. 字典相加

#合并字典
#字典不能相加

def merge(dict1,dict2):
    return dict2.update(dict1)
dict1={1:"a",3:"nn"}
dict2={2:"df",4:"sdf"}
merge(dict1,dict2)
print(dict2)


# 方法2建议使用
def megre1(dic1,dic2):
    res = {**dic1,**dic2}
    return res
dic1={1:"a",3:"nn"}
dic2={2:"df",4:"sdf"}
dic3=megre1(dic1,dic2)
print(dic3)

11. 同时遍历两个或多个序列，可以使用zip组合

questions = ['name', 'quest', 'favorite color']
answers = ['guiyin', 'handsome beautiful gril', 'green']
for q, a in zip(questions, answers):
    print('What is your {0}?  It is {1}.'.format(q, a))

12. 图书管理系统

class Book(object):
    def __init__(self,name,author,status,BookIndex):
        self.name = name
        self.author = author
        self.status=status
        self.BookIndex = BookIndex

    def __str__(self):
        if self.status == 1:
            status = '未借出'
        elif self.status == 0:
            status = '已借出'
        else:
            status = '状态异常'
        return '书名:《%s》 作者:<%s> 状态:<%s> 位置:<%s> ' %(self.name,self.author,status,self.BookIndex)

class BookManage(object):
    books = []

    def start(self):
        self.books.append(Book('python','guido',1,'ISO9001'))
        self.books.append(Book('C','潭浩强',1,'NFS8102'))

    def Menu(self):
        print('''
        图书管理系统
        1.查询图书
        2.增加图书
        3.借阅图书
        4.归还图书
        5.退出系统  
        ''')
        while True:
            choice = input('请选择:')
            if choice=='1':
                self.showAllBook()
            elif choice =='2':
                self.addBook()
            elif choice =='3':
                self.borrowBook()
            elif choice=='4':
                self.returnBook()
            elif choice =='5':
                print('欢迎下次使用...')
                exit()
            else:
                print('请输入正确选择')
                continue

    def showAllBook(self):
        for book in self.books:
            print(book)


    def checkBook(self,name):
        for book in self.books:
            if book.name == name:
                return book
        else:
            return None

    def addBook(self):
        name = input('Name:')
        author = input('Author:')
        status = int(input('Status'))
        BookIndex = input('BookIndex')
        self.books.append(Book(name,author,status,BookIndex))
        print('增加成功')

    def borrowBook(self):
        name = input('Name:')
        ret = self.checkBook(name)

        if ret != None:
            if ret.status == 0:
                print('书籍《%s》已经借出'%name)
            elif ret.status == 1:
                ret.status = 0
                print('借阅成功')
        else:
            print('书籍《%s》不存在'%name)

    def returnBook(self):
        name = input('Name:')
        ret = self.checkBook(name)
        ret.status = 1
        print('书籍《%s》归还成功'%name)
manager=BookManage()
manager.start()
manager.Menu()

13. 士兵与枪

class Gun():
    def __init__(self,model):
        self.model=model
        self.bullet_count=0
    def add_bullet(self,count):
        self.bullet_count += count
    def shoot(self):
        if self.bullet_count <= 0:
            print("{}没有子弹了".format(self.model))

        self.bullet_count -= 1
        print("{}枪开火，剩余子弹为{}".format(self.model,self.bullet_count))

class Soldier():
    def __init__(self,name):
        self.name=name
        self.gun= None
    def fire(self):
        if self.gun == None:
            print("没有枪，请拿枪开火")
        self.gun.add_bullet(5)
        self.gun.shoot()

ak47 = Gun('ak47')
ak47.add_bullet(20)
ak47.shoot()
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()

14. 将列表中首尾两个元素对调

def swapList(newList):
    size = len(newList)

    temp = newList[0]
    newList[0] = newList[size - 1]
    newList[size - 1] = temp

    return newList


newList = [1, 2, 3]

print(swapList(newList))



# 方法2
def swapList(newList):
    newList[0], newList[-1] = newList[-1], newList[0]

    return newList


newList = [1, 2, 3]
print(swapList(newList))

15. 将字符串作为代码执行

def exec_code():
    LOC = """ 
def factorial(num): 
    fact=1 
    for i in range(1,num+1): 
        fact = fact*i 
    return fact 
print(factorial(5)) 
"""
    exec(LOC)


exec_code()

16. 字符串大小写转换

str = "www.guisine.com"
print(str.upper())          # 把所有字符中的小写字母转换成大写字母
print(str.lower())          # 把所有字符中的大写字母转换成小写字母
print(str.capitalize())     # 把第一个字母转化为大写字母，其余小写
print(str.title())          # 把每个单词的第一个字母转化为大写，其余小写

# 获取昨天日期
# 引入 datetime 模块
import datetime

def getYesterday():
    yesterday = datetime.date.today() + datetime.timedelta(-1)
    return yesterday
# 输出
print(getYesterday())

li = [1, 9, 8, 4]
# [elem*2 for elem in li]
# [2, 18, 16, 8]
# li
# [1, 9, 8, 4]
i = [elem*2 for elem in li]
print(i)
lim=[2, 18, 16, 8]

17. 将字符串的时间转换为时间戳

import time

a1 = "2019-5-10 23:40:00"
# 先转换为时间数组
timeArray = time.strptime(a1, "%Y-%m-%d %H:%M:%S")

# 转换为时间戳
timeStamp = int(time.mktime(timeArray))
print(timeStamp)

# 格式转换 - 转为 /
a2 = "2019/5/10 23:40:00"
# 先转换为时间数组,然后转换为其他格式
timeArray = time.strptime(a2, "%Y/%m/%d %H:%M:%S")
otherStyleTime = time.strftime("%Y/%m/%d %H/%M/%S", timeArray)
print(otherStyleTime)

18. 按键值key或值value对字典进行排序

def dictionairy():
    # 声明字典
    key_value = {}

    # 初始化
    key_value[2] = 56
    key_value[1] = 2
    key_value[5] = 12
    key_value[4] = 24
    key_value[6] = 18
    key_value[3] = 323

    print("按键(key)排序:")

    # sorted(key_value) 返回一个迭代器
    # 字典按键排序
    for i in sorted(key_value):
        print((i, key_value[i]), end=" ")


def main():
    # 调用函数
    dictionairy()


# 主函数
if __name__ == "__main__":
    main()


def returnSum(myDict):
    sum = 0
    for i in myDict.keys():
        sum = sum + myDict[i]

    return sum


dict = {'a': 100, 'b': 200, 'c': 300}
print("Sum :", returnSum(dict))

19. Python 斐波那契数列实现

斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13,特别指出：第0项是0， 第1项是第一个1。从第三项开始，每一项都等于前两项之和

# Python 斐波那契数列实现
# 斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13,特别指出：第0项是0，
# 第1项是第一个1。从第三项开始，每一项都等于前两项之和。
#
# Python 实现斐波那契数列代码如下：
# 获取用户输入数据
nterms = int(input("你需要几项？"))

# 第一和第二项
n1 = 0
n2 = 1
count = 2

# 判断输入的值是否合法
if nterms <= 0:
    print("请输入一个正整数。")
elif nterms == 1:
    print("斐波那契数列：")
    print(n1)
else:
    print("斐波那契数列：")
    print(n1, ",", n2, end=" , ")
    while count < nterms:
        nth = n1 + n2
        print(nth, end=" , ")
        # 更新值
        n1 = n2
        n2 = nth
        count += 1

20. 斗地主

# -*- coding: cp936 -*-
import random
class Doudizhu:#斗地主的一个类，下面使用的变量如果在两个实例方法里使用，要定义成实例属性。要不然会出现后面不能引用前面的变量。
    def __init__(self):
        self.a=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,
                19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,
                36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53]
    def xipai(self):#洗牌
        random.shuffle(self.a)
        n=random.randint(1,54)
        b=self.a[:n]
        c=self.a[n:]
        self.a=c+b
    def fapai(self):#发牌
        self.str1=self.a[:-3:3]
        self.str2=self.a[1:-3:3]
        self.str3=self.a[2:-3:3]
        self.str4=self.a[-3:]
    def qiangdizhu(self):#抢地主
        n=random.randint(1,3)
        self.dizhu=n#定义一个实例属性，赋给地主的序号
        if n==1:
            self.str1+=self.str4
        if n==2:
            self.str2+=self.str4
        if n==3:
            self.str3+=self.str4
    def mapai(self):#码牌
        self.str1.sort(reverse=True)
        self.str2.sort(reverse=True)
        self.str3.sort(reverse=True)
    def yingshe(self):#映射
        paizd=[(0,'方片3'),(1,'梅花3'),(2,'红桃3'),(3,'黑桃3'),
               (4,'方片4'),(5,'梅花4'),(6,'红桃4'),(7,'黑桃4'),
               (8,'方片5'),(9,'梅花5'),(10,'红桃5'),(11,'黑桃5'),
               (12,'方片6'),(13,'梅花6'),(14,'红桃6'),(15,'黑桃6'),
               (16,'方片7'),(17,'梅花7'),(18,'红桃7'),(19,'黑桃7'),
               (20,'方片8'),(21,'梅花8'),(22,'红桃8'),(23,'黑桃8'),
               (24,'方片9'),(25,'梅花9'),(26,'红桃9'),(27,'黑桃9'),
               (28,'方片10'),(29,'梅花10'),(30,'红桃10'),(31,'黑桃10'),
               (32,'方片J'),(33,'梅花J'),(34,'红桃J'),(35,'黑桃J'),
               (36,'方片Q'),(37,'梅花Q'),(38,'红桃Q'),(39,'黑桃Q'),
               (40,'方片K'),(41,'梅花K'),(42,'红桃K'),(43,'黑桃K'),
               (44,'方片A'),(45,'梅花A'),(46,'红桃A'),(47,'黑桃A'),
               (48,'方片2'),(49,'梅花2'),(50,'红桃2'),(51,'黑桃2'),
               (52,'BlackJoker'),(53,'RedJoker')]
        zdpai = dict(paizd)
        paistr1=''
        for i in range (len(self.str1)):
            paistr1+=zdpai[self.str1[i]]+' '
        paistr2=''
        for i in range (len(self.str2)):
            paistr2+=zdpai[self.str2[i]]+' '
        paistr3=''
        for i in range (len(self.str3)):
            paistr3+=zdpai[self.str3[i]]+' '
        self.user1=paistr1 #这里要把牌的序列赋给三个玩家的实例属性
        self.user2=paistr2
        self.user3=paistr3
user=Doudizhu()#使用这个类时，要挨个使用实例的方法
user.xipai()
user.fapai()
user.qiangdizhu()
user.mapai()
user.yingshe()
print ('dizhu:',user.dizhu)
print ('user1:',user.user1)
print ('user2:',user.user2)
print ('user3:',user.user3)

21. 最大公约数

# 定义一个函数
def hcf(x, y):
    """该函数返回两个数的最大公约数"""

    # 获取最小值
    if x > y:
        smaller = y
    else:
        smaller = x

    for i in range(1, smaller + 1):
        if ((x % i == 0) and (y % i == 0)):
            hcf = i

    return hcf


# 用户输入两个数字
num1 = int(input("输入第一个数字: "))
num2 = int(input("输入第二个数字: "))
a=hcf(num1, num2)

print(num1, "和", num2, "的最大公约数为", a)

22. 最小公倍数

# 定义函数
def lcm(x, y):
    #  获取最大的数
    if x > y:
        greater = x
    else:
        greater = y

    while (True):
        if ((greater % x == 0) and (greater % y == 0)):
            lcm = greater
            break
        # 如果上边不满足，一直加一，直到满足条件
        greater += 1

    return lcm


# 获取用户输入
num1 = int(input("输入第一个数字: "))
num2 = int(input("输入第二个数字: "))

print(num1, "和", num2, "的最小公倍数为", lcm(num1, num2))

23. 根据三边求三角形面积，弊端，当三边长不能组成三角形时，计算的面积值错误

a = float(input('输入三角形第一边长: '))
b = float(input('输入三角形第二边长: '))
c = float(input('输入三角形第三边长: '))

# 计算半周长
s = (a + b + c) / 2

# 计算面积
area = (s * (s - a) * (s - b) * (s - c)) ** 0.5
print('三角形面积为 %0.2f' % area)

24. 移除字符串中指定位置字符

# 移除字符串中的指定位置字符
test_str = "guiyinGaijiangshan"

# 输出原始字符串
print("原始字符串为 : " + test_str)

# 移除第三个字符 n
new_str = ""

for i in range(0, len(test_str)):
    if i != 2:
        new_str = new_str + test_str[i]

print("字符串移除后为 : " + new_str)

str="oidhfhqogfe"
def ff(str,num):
    return str[0:num] + str[num+1:]
print(ff(str,3))
print(ff(str,4))


string="hashhadhha.www.baidu"
str="www"
if str in string:
    print("存在")
else:
    print("不存在")

25.线性查找

def search(arr,n,x):
    for i in range (0,n):
        if (arr[i] == x):
            return i
    # for循环运行完之后才可以
    return -1
arr=['a','b','c','d','e']
n=len(arr)
x= 'c'
result=search(arr,n,x)
if (result == -1):
    print("元素不在")
else:
    print("元素的索引为%d"%result)

26. 翻转列表

def Reverse(lst):
    return [ele for ele in reversed(lst)]


lst = [10, 11, 88, 13, 14, 15]
print(Reverse(lst))


# 方法2
def Reverse(lst):
    lst.reverse()
    return lst


lst = [10, 11, 12, 13, 14, 15]
print(Reverse(lst))

# 方法3
def Reverse(lst):
    new_lst = lst[::-1]
    return new_lst


lst = [10, 11, 12, 13, 14, 15]
print(Reverse(lst))

27. 翻转字符串

def reverseWords(input):
    # 通过空格将字符串分隔符，把各个单词分隔为列表
    inputWords = input.split(" ")

    # 翻转字符串
    # 假设列表 list = [1,2,3,4],
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
    inputWords = inputWords[-1::-1]

    # 重新组合字符串
    output = ' '.join(inputWords)

    return output


if __name__ == "__main__":
    input = 'qwe like qweds sunoob'
    rw = reverseWords(input)
    print(rw)

28.随机生成11位手机号

import random

# 生成一个手机号码
def generate_mobile():
    """随机生成一个手机号码。。    1[3,5,6,8,9] + 9"""
    phone = '1' + random.choice(["3", "5","6" ,"7", "8"])
    for i in range(9):
        num = random.randint(0, 9)
        phone += str(num)
    return phone

if __name__ == '__main__':
    print(generate_mobile())

29.获取某文件夹下所有文件

import os


def getAllFiles(path):
    flist = []
    for root,dirs,fs in os.walk(path):
        for f in fs:
            f_fullpath = os.path.join(root,f)
            f_relativepath = f_fullpath[len(path):]
            flist.append(f_relativepath)
    print(flist)
getAllFiles("E:\dir")

30. 两个变量值互换

m = 10
n = 20

#第一种方法
# m,n = n,m
# print("交换后的m，n值{}，{}".format(m,n))

#第二种方法
# temp = m
# m = n
# n = temp
# print("交换后的m，n值{}，{}".format(m,n))

#第三种方法

m = m + n
n = m - n
m = m -n
print("交换后的m，n值{}，{}".format(m,n))

31.输入三个整数x,y,z，请把这三个数由小到大输出

# 1.录入数据
x = int(input(">>>>>>>>:"))
y = int(input(">>>>>>>>:"))
z = int(input(">>>>>>>>:"))

# 2.使用列表存储数据并进行排序
num_list = [x, y, z]
num_list.sort()
print(num_list)

32.将一个列表的数据复制到另一个列表中

list1 = [23, 21, 32, 64, 85]
print(list1)

# 1.直接使用列表的copy方法
new_list1 = list1.copy()
print(new_list1)

# 2.使用列表的切片
new_list2 = list1[:]
print(new_list2)

33.打印水仙花数

"""题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方
程序分析:利用for循环控制100-999个数，每个数分解出个位，十位，百位
核心: 就是如何获取到每个位上的数字"""
# 例子: 54328
# 个位: 54328 % 10
# 十位: 54328 // 10 % 10
# 百位: 54328 // 100 % 10
# 千位: 54328 // 1000 % 10
# 万位: 54328 // 10000

# 1.三位数的范围为:100~999 所以需要使用循环
for i in range(100, 1000):
    # 2.根据水仙花数的概念去判断
    ge_wei = i % 10
    shi_wei = i // 10 % 10
    bai_wei = i // 100
    if i == (ge_wei ** 3 + shi_wei ** 3 + bai_wei ** 3):
        print(i)

sxh = []
for i in range(100, 1000):
 s = 0
 m = list(str(i))
 for j in m:
    s += int(j)**len(m)
 if i == s:
    print(i)
    sxh.append(i)
print("100-999 的水仙花数：%s" % sxh)

34.输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数

import re

s = input("请输入一个字符串:").strip()
letters = 0
space = 0
digit = 0
other = 0
# 1.方式1使用for循环 while循环也一样
for i in s:
    if i.isalpha():  # 判断是否是字母
        letters += 1
    elif i.isspace():  # 判断是否是空白字符
        space += 1
    elif i.isdigit():  # 判断是否是数字
        digit += 1
    else:
        other += 1

print(f'char = {letters},space = {space},digit = {digit},others = {other}')


# 2.使用正则表达式
letters = len("".join(re.findall(r"[a-zA-Z]", s)))  # 匹配字母
space = len("".join(re.findall(r"\s+", s)))  # 匹配空白字符
digit = len("".join(re.findall(r"\d+", s)))  # 匹配数字
# 匹配非字母 数字 下划线 此时空白字符也会被匹配到 所以先要将空白字符移除
other_list = re.findall(r"\W", s)
for i in other_list:
    if i.isspace:
        other_list.remove(i)
other = len("".join(other_list))
print(f'char = {letters},space = {space},digit = {digit},others = {other}')

35.自由落体每次反弹高度是原高度的一半

# 题目: 一球从100米高度自由落下，每次落地后反跳回原高度的一半
# 再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
tour = []
height = []
hei = 100  # 起始高度
tim = 10  # 次数
for i in range(1, tim + 1):
    # 从第二次开始，落地时的距离应该是反弹高度乘以2(弹到最高点再落下)
    if i == 1:
        tour.append(hei)
    else:
        tour.append(2 * hei)
    hei /= 2
    height.append(hei)

print(f"总高度: tour = {sum(tour)}")
print(f"第10次反弹高度: height = {height[-1]}")

36.三级菜单

# 初始化数据
menu = {
    '北京': {
        '海淀': {
            '东升': {
                'soho': {},
                '网易': {},
                'google': {}
            },
            '中关村': {
                '百度': {},
                '联想': {},
                '腾讯': {},
            },
            '上地': {
                '快手': {},
            },
        },
        '昌平': {
            '沙河': {
                '北邮': {},
                '北航': {},
            },
            '天通苑': {},
            '回龙观': {},
        },
        '朝阳': {},
        '西城': {},
    },
    '上海': {
        '闵行': {
            "人民广场": {
                '炸鸡店': {}
            }
        },
        '闸北': {
            '火车站': {
                '携程': {}
            }
        },
        '浦东': {},
    },
    '山东': {},
}

# 使用死循环保持程序可以不停地进行录入 然后根据指定的条件退出循环
current_level = menu  # 当前菜单层
layer_list = []  # 存储之前的菜单层 列表有序
while True:
    for city in current_level:
        print(city)
    choice = input(">>:").strip()  # 去除空白字符
    if choice in current_level:  # 判断选择城市是否在字典中
        layer_list.append(current_level)  # 使用列表存储上层菜单
        current_level = current_level[choice]  # 当前菜单更改为下层菜单
    elif choice == "b":  # 用户输入的为b的时候 表示回退上一层
        if current_level == menu:  # 判断是否是顶层
            print("reach top level")
            continue
        else:
            current_level = layer_list.pop()  # 回退
    elif choice == "q":
        exit("bye~")

37.统计在一个队列中的数字，有多少个正数，多少个负数，如[2, 31, 6, -7, 0, -1, -9, -4, -5, 8]

#统计在一个队列中的数字，有多少个正数，多少个负数，如[2, 31, 6, -7, 0, -1, -9, -4, -5, 8]
# 方法1
a = [2, 31, 6, -7, 0, -1, -9, -4, -5, 8]
m = 0
n = 0
for i in a :
    if i > 0:
        m += 1
    elif i < 0:
        n += 1
    else:
        pass
print("大于0的个数为%d"%(m))
print("大于0的个数为%d"%(n))

# 方法2

b = [ i for i in a if i > 0]
print("大于0的个数为%d"%(len(b)))
c = [ i for i in a if i < 0]
print("小于0的个数为%d"%(len(c)))

38.字符串 “axbyczdj”，如果得到结果“abcd”

#字符串 "axbyczdj"，如果得到结果“abcd”
#方法1
s = "axbyczdj"
print(s[::2])
#方法2
k = []
for i in range(len(s)):
    if i % 2 == 0:
        k.append(s[i])
print("".join(k))

39.已知一个字符串为“hello_world_guiyin”, 如何得到一个队列 [“hello”,“world”,“guiyin”]

#已知一个字符串为“hello_world_guiyin”, 如何得到一个队列 ["hello","world","guiyin"]

a = "hello_world_guiyin_python"
b = a.split("_")
print(b)

40.已知一个数字为 2，如何输出“0002”

#已知一个数字为 1，如何输出“0001”
a = 1
print("%04d" % a)

41.已知一个队列,如： [1, 3, 5, 7], 如何把第一个数字，放到第三个位置，得到：[3, 5, 1, 7]

#已知一个队列,如： [1, 3, 5, 7], 如何把第一个数字，放到第三个位置，得到：
#[3, 5, 1, 7]
a = [1, 3, 5, 7]
# insert 插入数据
a.insert(3, a[0])
print(a[1:])

42.如果一个数恰好等于它的因子之和，则称该数为“完全数”，又称完美数或完备数。 例如：第一个完全数是 6，它有约数 1、2、3、6，除去它本身 6 外，其余3 个数相加，1+2+3=6。第二个完全数是 28，它有约数 1、2、4、7、14、28，除去它本身 28外，其余 5 个数相加，1+2+4+7+14=28。那么问题来了，求 1000 以内的完全数有哪些？

a = []
for i in range(1, 1000):
    s = 0
    for j in range(1, i):
        if i % j == 0 and j < i:
            s += j
    if s == i:
        print(i)
        a.append(i)
print("1000 以内完全数：%s" % a)

43.sort排序

a = [1, 3, 6, 9, 7, 3, 4, 6]
# 1.sort 排序，正序
a.sort()
print(a)
# 2.sort 倒叙
a.sort(reverse=True)
print(a)
# 3.去重
b = list(set(a))
print(b)

44.递归 n的阶乘

#方法1
from functools  import reduce
a = 6
b = reduce(lambda x,y : x*y, range(1,a+1))
print(b)

#方法2
def chengfa(x,y):
    return x*y
c = reduce(chengfa,range(1,a+1))
print(c)

#方法3
def digui(n):
    if n == 1:
        return 1
    else:
        return n*digui(n-1)
d = 6
print(digui(6))

45.斐波那契数列

#已知一个数列：1、1、2、3、5、8、13、。。。。的规律为从 3 开始的每一项都
#等于其前两项的和，这是斐波那契数列。求满足规律的 100 以内的所以数据
a = 0
b = 1
while b < 100:
    print(b, end=",")
    a, b = b, a+b

46.控制台输入邮箱地址（格式username@companyname.com），程序识别用户名和公司名后，将用户名和公司名输出到控制台

import re
"""
1. 校验输入内容是否符合规范（xx@yy.com）, 如是进入下一步，如否则抛出提
示"incorrect email format"。注意必须以.com 结尾
2. 可以循环“输入--输出判断结果”这整个过程
3. 按字母 Q（不区分大小写）退出循环，结束程序
"""
# 判断邮箱.com 结尾
def is_mail_style(x):
     a = re.match(r'^[0-9a-zA-Z\_\-]*@[0-9a-zA-Z]+(\.com)$', x)
     if a:
        yhm = re.findall("^(.+?)@", x)
        print(yhm)
        print("用户名:%s " %yhm[0])
        gc = re.findall("@(.+?)\.com", x)
        print(gc)
        print("公司名:%s " %gc[0])
        return True
     else:
        print("incorrect email format")
        return False
a = input("请输入：")
while 1:
 if a == "q" or a == "Q":
    exit()
 else:
    if is_mail_style(a):
        break
    a = input("请输入：")
print("下一步！")

47.Python数据类型有哪些？ 区别？ —总结—列表 元祖 字典区别 ！！！

答：整型、浮点型、字符串、布尔型、列表、元组、字典。
（1）列表可以支持所有数据类型，可以重复，取值通过索引和切片，列表是可以改变的，对其进行“增删改”都可以。
（2）元组也可以支持任意数据类型，可以重复。但是元组不可以更改。
（3）字典，键值对，并且是没有顺序的，所以没有索引。Key值不可以重复，key不能是列表和字典，之外的数据格式是支持的，value可以是任意数据类型。“增删改”因为没有顺序，所以通常需要通过用key值去取value值、修改或删除value值，或新增一对键值对。