第2章 Python基础-字符编码&数据类型 综合 练习题

1、转换

• 将字符串s = "alex"转换成列表

s = "alex"
s_list = list(s)
print(s_list)

• 将字符串s = "alex"转换成元祖

s = "alex"
s_tuple = tuple(s)
print(s_tuple)

• 将列表li = ["alex", "seven"]转换成元组

li = ["alex", "seven"]
li_tuple = tuple(li)
print(li_tuple)

• 将元祖tu = ('Alex', "seven")转换成列表

tu = ('Alex', "seven")
tu_list = list(tu)
print(tu_list)

• 将列表li = ["alex", "seven"]转换成字典且字典的key按照10开始向后递增

li = ["alex", "seven"]
li_dic = {}
for k,v in enumerate(li,10):
    li_dic[k] = v
print(li_dic)

2、元素分类

有如下值集合[11,22,33,44,55,66,77,88,99,90]，将所有大于66的值保存至字典的第一个key中，将小于66的值保存至第二个key的值中。

即：{'k1':大于66的所有值, 'k2':小于66的所有值}

li = [11,22,33,44,55,66,77,88,99,90]
li1 = []
li2 = []
for i in li :
    if i < 66:
        li1.append(i)
    elif i > 66:
        li2.append(i)
    else:
        pass
dic = {"k1": li1,"k2": li2}
print(dic)

3、输出商品列表，用户输入序号，显示用户选中的商品

商品 li = ["手机", "电脑", '鼠标垫', '游艇']

• 允许用户添加商品

• 用户输入序号显示内容

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

li = ["手机", "电脑", '鼠标垫', '游艇']

while True:
    print("商品信息".center(28, "-"))
    for index,goods in enumerate(li,1):
        print("%s. %s" % (index, goods))
    add_choice = input("\n是否添加商品(yes/no)：")
    if add_choice == "yes" or add_choice == "y":
        add_goods = input("\n请输入需要添加的商品：")
        li.append(add_goods)
    elif add_choice == "no" or add_choice == "n":
        break
    else:
        print("\n输入错误，请重新输入\n")
        continue
while True:
    goods_choice = input("\n请输入需要查看的商品序号,输入非数字退出本程序：")
    if goods_choice.isdigit():
        goods_choice = int(goods_choice)
        if goods_choice >= 1 and goods_choice <= len(li):
            print("\n",li[goods_choice-1])
        else:
            print("\n商品序号错误，请重新输入\n")
    else:
        break

4、用户交互显示类似省市县N级联动的选择

• 允许用户增加内容

• 允许用户选择查看某一个级别内容

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 输入省份、城市、县序号

China = {
    '河南省': {
        '焦作市': ['武陟', '温县', '博爱'],
        '郑州市': ['新郑', '荥阳', '中牟'],
        '开封市': ['兰考', '尉氏', '杞县'],
    },
    '广东省': {
        '广州市': ['越秀', '荔湾', '番禺'],
        '深圳市': ['福田', '罗湖', '龙岗'],
        '东莞市': ['莞城', '南城', '东城'],
    },
}

exit_flag = False
while not exit_flag:  # 第1层循环
    province_list = [] # 定义一个省份列表
    city_list = [] # 定义一个城市列表
    print("\33[31;1m---------------------------------\33[1m")
    print("         \33[31;1m欢迎您来到中国\33[1m      ")
    print("\33[31;1m---------------------------------\33[1m")
    for index,Province in enumerate(China,1):
        print("%s. %s" % (index,Province))
        province_list.append(Province) # 添加所有省份到省份列表中
    print()
    choice_province = input("一.请输入您要前往的省份序号 (输入q退出,输入b返回上级,输入i自定义):")
    print()
    if choice_province == "q" or choice_province == "Q":
        exit_flag = True
    elif choice_province == "b" or choice_province == "B":
        continue  # 跳出第1层循环的剩下语句，继续进行下一次循环（选择省份）
    elif choice_province == "i" or choice_province == "I":
        print("\33[32;1m自定义信息\33[1m".center(40, "-"))
        province = input("省份名称：")
        if China.get(province) == None:
            China[province] = {} # 增加的省份对应的键值是一个空字典
        city = input("城市名称：")
        if China[province].get(city) == None:
            China[province][city] = [] # 增加的城市对应的键值是一个空列表
        county = input("县名称：")
        China[province][city].append(county) # 增加的县是列表中的一个元素
        print()
        print("您的自定义信息已经存储成功，请重新进行选择")
        print()
    elif choice_province.isdigit():
        choice_province = int(choice_province)
        if choice_province >= 1 and choice_province <= len(province_list):
            while not exit_flag:  # 第2层循环
                for index,City in enumerate(China[province_list[choice_province-1]],1):
                    print("%s. %s" % (index,City))
                    city_list.append(City)  # 添加所有城市到城市列表中
                print()
                choice_city = input("二.请输入您要前往的城市序号 (输入q退出,输入b返回上级):")
                print()
                if choice_city == "q" or choice_city == "Q":
                    exit_flag = True
                elif choice_city == "b" or choice_city == "B":
                    break  # 跳出整个第2层循环，重新进行第1层循环（选择省份）
                elif choice_city.isdigit():
                    choice_city = int(choice_city)
                    if choice_city >=1 and choice_city <= len(city_list):
                        while not exit_flag:  # 第3层循环
                            for index,County in enumerate(China[province_list[choice_province-1]][city_list[choice_city-1]],1):
                                print("%s. %s" % (index, County))
                            print()
                            choice_county = input("三.请输入您要前往的县序号 (输入q退出,输入b返回上级):")
                            print()
                            if choice_county == "q" or choice_county == "Q":
                                exit_flag = True
                            elif choice_county == "b" or choice_county == "b":
                                break  # 跳出整个第3层循环，重新进行第2层循环（选择城市）
                            elif choice_county.isdigit():
                                choice_county = int(choice_county)
                                county_list = China[province_list[choice_province - 1]][city_list[choice_city - 1]] # 县列表
                                if choice_county >= 1 and choice_county <= len(county_list):
                                    print("---------------------------------")
                                    print("您现在的位置是：", province_list[choice_province-1],city_list[choice_city-1],county_list[choice_county-1])
                                    print("---------------------------------")
                                    exit_flag = True
                                else:
                                    print("您输入的县序号不存在")
                                    print()
                            else:
                                print("您输入的县序号不存在")
                                print()
                                continue
                    else:
                        print("您输入的城市序号不存在")
                        print()
                        continue
                else:
                    print("您输入的城市序号不存在")
                    print()
                    continue
        else:
            print("您输入的省份序号不存在")
            print()
    else:
        print("您输入的省份序号不存在")
        print()
        continue

5、列举布尔值是False的所有值

bool(0)   bool(None)  bool("") bool(())  bool([])  bool({})

6、有两个列表

　　l1 = [11,22,33]

　　l2 = [22,33,44]

• 获取内容相同的元素列表

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

l1 = [11,22,33]
l2 = [22,33,44]

s1 = set(l1)
s2 = set(l2)
s3 = s1 & s2

l3 = list(s3)

print(l3)

• 获取l1中有，l2中没有的元素列表

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

l1 = [11,22,33]
l2 = [22,33,44]

s1 = set(l1)
s2 = set(l2)
s3 = s1 - s2

l3 = list(s3)

print(l3)

• 获取l2中有，l3中没有的元素列表

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

l1 = [11,22,33]
l2 = [22,33,44]

s1 = set(l1)
s2 = set(l2)
s3 = s2 - s1

l3 = list(s3)

print(l3)

• 获取l1和l2中内容都不同的元素

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

l1 = [11,22,33]
l2 = [22,33,44]

s1 = set(l1)
s2 = set(l2)
s3 = s2 ^ s1

l3 = list(s3)

print(l3)

7、利用For循环和range输出

• For循环从小到大输出1 - 100

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

for i in range(1,101):
    print(i)

• For循环从大到小输出100 - 1

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

for i in range(100,0,-1):
    print(i)

• While循环从小到大输出1 - 100

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

n = 1
while n <= 100:
    print(n)
    n += 1

• While循环从大到小输出100 - 1

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

n = 100
while n >= 1:
    print(n)
    n -= 1

8、利用for循环和range输出9 * 9乘法表

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

for i in range(1,10):
    for j in range(1,i+1):
        print("%d*%d=%2d" % (j,i,i*j),end=" ") # 每次输出不换行(默认print会换行)，第二位数字是固定的，所以最外层循环的i代表第二位
    print (" ") # 当j(第一位数字)遍历一遍时换行

9、判断一个数是否为素数。（编程题）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 素数又称为质数，它指的是只能被1和它本身整除的整数。其中，1不是素数，任何时候都不用考虑1。

while True:
    flag = True # 设置一个标志位,flag = True代表是素数，flag = Flase代表非素数
    n = int(input("请输入一个数字:"))
    if n < 2: # 0、1以及负数都不是素数
        flag = False
    else:
        for i in range(2,n): # 除以比它小的所有数（不包括1和它本身）,看它是否还有其他因数
            # print(i)
            if n % i == 0:
                # print("%d能整除%d" %(n,i))
                flag = False # 出现一次余数为0就代表可以除尽，即代表这个数为素数，就可以设置flag = False
                break # 只要第一次出现flag = False，就不用继续往下循环，直接退出整个循环（第二层）
    if flag == True:
        print("%d，是素数" %(n))
    else:
        print("%d，非素数" %(n))

10.输出100以内的所有素数。（编程题）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 素数又称为质数，它指的是只能被1和它本身整除的整数。其中，1不是素数，任何时候都不用考虑1。

L = [] # 定义一个初始的素数列表
for n in range(2,101): # 循环100以内的素数n,从2开始,0、1不是素数
    flag = True # 设置一个标志位,flag = True代表是素数，flag = Flase代表不是素数
    for i in range(2,n): # 除以比它小的所有数（不包括1和它本身）,看它是否还有其他因数
        if n % i == 0:
            flag = False # 出现一次余数为0就代表可以除尽，即代表这个数为素数，就可以设置flag = False
            break # 只要第一次出现flag = False，就不用继续往下循环，直接退出整个循环（第二层）
    if flag == True:
        L.append(n) # 当flag = True时代表n为素数,追加到素数列表中
print("100以内的所有素数:",L)

11、求100以内的素数和。（编程题）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 素数又称为质数，它指的是只能被1和它本身整除的整数。其中，1不是素数，任何时候都不用考虑1。

s = 0 # 设置一个素数初始和为0
for n in range(2,101): # 循环100以内的素数n,从2开始,0、1不是素数
    flag = True # 设置一个标志位,flag = True代表是素数，flag = Flase代表不是素数
    for i in range(2,n): # 除以比它小的所有数（不包括1和它本身）,看它是否还有其他因数
        if n % i == 0:
            flag = False # 出现一次余数为0就代表可以除尽，即代表这个数为素数，就可以设置flag = False
            break # 只要第一次出现flag = False，就不用继续往下循环，直接退出整个循环（第二层）
    if flag == True:
        s += n # 当flag = True时代表n为素数，此时和之前的素数之和相加得到最新的素数之和
print("100以内的素数和为:",s)

12、将[1,3,2,7,6,23,41,24,33,85,56]从小到大排序（冒泡法）（编程）

li = [1,3,2,7,6,23,41,24,33,85,56]

for i in range(len(li)-1): # i的范围0-9
    if li[i] > li[i+1]: # 相邻的两个数比较
        li[i],li[i+1] = li[i+1],li[i]
print(li)

li = [1,3,2,7,6,23,41,24,33,85,56]

for i in range(len(li)-1): # i的范围0-9
    for j in range(i+1,len(li)): # j的范围1-10
        if li[i] > li[j]: # 相邻的两个数比较
            li[i],li[j] = li[j],li[i]
print(li)