第一二章：练习题汇总

小节练习

练习1：猜年龄游戏 

要求：

1. 允许用户最多尝试3次，3次都没猜对的话，就直接退出，如果猜对了，打印恭喜信息并退出

guess_age=24
count = 0

while count < 3:
    age = int(input("请输入年龄"))
    if guess_age > age:
        print ("你猜小了")
    elif guess_age < age:
        print ("你猜大了")
    else:
        print("恭喜你回答正确")
    count += 1
else:
    print("游戏结束")

练习2：猜年龄游戏升级版 

要求：

1. 允许用户最多尝试3次
2. 每尝试3次后，如果还没猜对，就问用户是否还想继续玩，如果回答Y或y, 就继续让其猜3次，以此往复，如果回答N或n，就退出程序
3. 如何猜对了，就直接退出

count = 0
age = 24
while True:
    guess_age = input('请输入您猜测的年龄： ')
    if guess_age == age:
        print('恭喜你，猜对啦！')
        break
    else:
        print('猜错啦，请重新输入')
        count += 1
        if count == 3:
            print('您是否想重新玩，回答Y/y或者N/n')
            ans = input('请输入您内心的想法： ')
            if ans == 'Y' or ans == 'y':
                print('请继续您的游戏吧!')
            elif ans == 'N' or ans == 'n':
                print('谢谢您参与游戏！')
                break

第一章练习题

1. 简述编译型与解释型语言的区别，且分别列出你知道的哪些语言属于编译型，哪些属于解释型                                                                                                                                                                                答：编译类：先翻译成二进制，产生两个文件，运行的时候是二进制文件。程序执行效率高，编译后程序运行时不需要重新翻译，直接使用编译的结果就可以了，但是跨平台性能差。如CC++、Delphi等。

   解释型：“同声翻译”，一边翻译成目标代码即机器语言一边执行，运行效率比较低且不能生成可独立执行的可执行文件，应用程序不能脱离解释器，这种方式比较灵活，可以动态调整、修改应用程序。可以跨平台，开发效率高。如：java、python等

2. 执行 Python 脚本的两种方式是什么                                                                                                                                                                                                                                                                              答：一进入解释器的交互式模式：调试方便，无法永久保存代码；二脚本文件的方式（使用nodpad++演示）：永久保存代码，但是不方便调试
3. Pyhton 单行注释和多行注释分别用什么?                                                                                                                                                                                                                                                                      答：单行注释用#，多行注释用 ‘’’  '''
4. 布尔值分别有什么?                                                                                                                                                                                                                                                                                                   答：布尔值有True 和False
5. 声明变量注意事项有那些?                                                                                                                                                                                                                                                                                           答：一数字、字母和下划线的组合；二是数字不能开头；三是以下关键字不能声明为变量名['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']。
6. 如何查看变量在内存中的地址?                                                                                                                                                                                                                                                                                  答：id（变量名）  #查看内存地址。                                                                                                                                                                                                 
7. 写代码
   1. 实现用户输入用户名和密码,当用户名为 seven 且 密码为 123 时,显示登陆成功,否则登陆失败!                                                                                                

      _username = "seven"
      _passworld = "123"
      username = input("username:")
      passworld = input("passworld:")
      if username == _username and passworld == _passworld:
          print("登录成功")

   2. 实现用户输入用户名和密码,当用户名为 seven 且 密码为 123 时,显示登陆成功,否则登陆失败,失败时允许重复输入三次                                                          

      _username = "seven"
      _passworld = "123"
      count = 0
      while count < 3:
          username = input("username:")
          passworld = input("passworld:")
          if username == _username and passworld == _passworld:
              print("登录成功")
              break
          else:
              print("登录失败，请重新输入")
              count += 1

   3. 实现用户输入用户名和密码,当用户名为 seven 或 alex 且 密码为 123 时,显示登陆成功,否则登陆失败,失败时允许重复输入三次                                             

      #_username = ["seven" , "alex"] #运用列表
      _username = "seven" or "alex"
      _passworld = "123"
      count = 0
      while count < 3:
          username = input("username:")
          passworld = input("passworld:")
          if username == "seven" or "alex"  and passworld == _passworld:
          #if username in _username and passworld == _passworld: #判断
              print("登录成功")
              break
          else:
              print("登录失败，请重新输入")
              count += 1

8. 写代码

   a. 使用while循环实现输出2-3+4-5+6...+100 的和                                                                                                                                                                                 

   i = 2
   total_1 = 0
   total_2 = 0
   while i <=100:
       if i%2 == 0:
           total_1 += i
       else:
           total_2 += -i
       i += 1
   total = total_1 + total_2
   print(total)

   b. 使用 while 循环实现输出 1,2,3,4,5, 7,8,9, 11,12

   count = 1
   while count <= 12:
       if count == 10 or count==6:
           pass
       else:
           print("loop",count)
       count +=1

    c. 使用while 循环输出100-50，从大到小，如100，99，98...，到50时再从0循环输出到50，然后结束  

   i = 101
   while i >= 51:
       i -=1
       print(i)
   i = 0
   while i <= 50:
       print(i)
       i +=1

   d. 使用 while 循环实现输出 1-100 内的所有奇数                                          

   i = 1
   while i <= 100:
       if i %2==1:
           print(i)
       i+=1

   e. 使用 while 循环实现输出 1-100 内的所有偶数

   i = 0
   while i <= 100:
       if i %2==0:
           print(i)
       i+=1

9. 现有如下两个变量,请简述 n1 和 n2 是什么关系?

   n1 = 123456
   n2 = n1        关系是给数据123456起了另外一个别名n2，相当于n1和n2都指向该数据的内存地址
   

10. 制作趣味模板程序（编程题）
    需求：等待用户输入名字、地点、爱好，根据用户的名字和爱好进行任意显示
    如：敬爱可爱的xxx，最喜欢在xxx地方干xxx

    username = input("name:")
    place = input("place:")
    love = input("love:")
    info = '''
    敬爱的%s最喜欢在 %s干 %s
    '''% (username,place,love)
    print(info)

11. 输入一年份，判断该年份是否是闰年并输出结果。（编程题）
    注：凡符合下面两个条件之一的年份是闰年。 （1） 能被4整除但不能被100整除。 （2） 能被400整除。

    year = int(input("please input a year:"))
    if (year %2==0 and year %100!=0) or (year %400==0):
        print(year,"是闰年")
    else:
        print(year,"不是闰年")

12. 假设一年期定期利率为3.25%，计算一下需要过多少年，一万元的一年定期存款连本带息能翻番？（编程题）

    money = 10000
    year = 0
    while money <= 20000:
        year +=1
        money = money * (1+0.0325)
        print(year,money)
    print(year,"年以后，一万元的一年定期存款连本带息能翻番")

第二章练习题

列表练习题： 

 打印索引值：

#10 打印每个索引值和元素
names = ['alex','jack','rain','mack','racheal','shanshan']
count = 0
for i in names:
    print(count,i)
    count += 1

for i in enumerate(names):#枚举
    print(i)
for index,i in enumerate(names):#枚举
    print(index,i)

#输出

0 alex
1 jack
2 rain
3 mack
4 racheal
5 shanshan
(0, 'alex')
(1, 'jack')
(2, 'rain')
(3, 'mack')
(4, 'racheal')
(5, 'shanshan')
0 alex
1 jack
2 rain
3 mack
4 racheal
5 shanshan

#11题
names = ['alex','jack','rain','mack','racheal','shanshan']
for index,i in enumerate(names):#枚举
    if index%2 ==0: #偶数
        names[index] = -1
        print(index,i)
print(names)

#12题
names = ['alex','jack','peiqi',2,'rain','mack',2,'racheal','shanshan',2,'longting']
first_index = names.index(2)
new_list = names[first_index+1:]
second_index = new_list.index(2)
second_val = names[first_index + second_index +1]
print(new_list,first_index,second_index)
print('second values:',second_val)

#13
products = [['iphone8',6888],['MacPro',14800],['小米6',2499],['Coffee',31],['Book',80],['Nike Shoes',799]]
print('-------------商品列表--------------')
for index,i in enumerate(products):#枚举
     print("%s.%s %s" %(index,i[0],i[1]) )

#14
products = [['iphone8',6888],['MacPro',14800],['小米6',2499],['Coffee',31],['Book',80],['Nike Shoes',799]]
shopping_cart = []
run_flag = True  #标志位
while run_flag:
#exit_flag = False
#while not exit_flag:
#while True:
    print('-------------商品列表--------------')
    for index,i in enumerate(products):#枚举
         print("%s.%s %s" %(index,i[0],i[1]) )
    choice = (input("输入你想买的商品编号或者输入q退出:"))
    if choice.isdigit():
        choice = int(choice)
        if choice >=0 and choice <= len(products):
            shopping_cart.append(products[choice])
            print("Added product %s into shopping cart."%(products[choice]))
        else:
            print("此商品不存在")
    elif choice == 'q':
        if len(shopping_cart) > 0:
            print("----------您已购买以下商品-------")
            for index,i in enumerate (shopping_cart):
                print("%s.%s  %s" % (index,i[0],i[1]))
        run_flag =False
        #exit_flag = True
        #break

字典练习题

写代码，有如下字典，按照要求实现每一个功能。dic = {'k1':'v1','k2':'v2','k3':'v3'}

1.请循环遍历出所有的key

for k in dic:
print(k)

2请循环遍历出所有的value

for k in dic:
print(dic[k])

3请循环遍历初所有的KEY和VALUE

for k in dic:
print(k,dic[k])

4请在字典中添加一个键值对，'k4':'v4',输出添加后的字典

dic['k4'] = 'v4'
print(dic)

5请删除字典中键值对'k1','v1',并输出删除后的字典

dic.pop('k1')
print(dic)

6请删除字典中键'k5'对应的键值对，如果字典中不存在键'k5'，则不报错，并且让其返回none

if 'k5' in dic:
dic.pop('k5')
else:
print(dic.get('k5'))

7请获取字典中'k2'对应的值

print(dic.get('k2'))

8请获取字典中'k6'对应的值，如果'k6'不存在，则不报错，并且让其返回Nnoe

print(dic.get('k6'))

9现有dic2 = {'k1':'v111','a':'b'}请通过一行操作使dic2 = {'k1':'v1','k2':'v2','k3':'v3','a':'b'}

dic = {'k1':'v1','k2':'v2','k3':'v3'}
dic2 = {'k1':'v111','a':'b'}
dic2.update(dic)
print(dic2)

10.组合嵌套题，写代码，有如下列表，按照要求实现每一个功能 lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]

10.1.将列表lis 中的'tt'变成大写（用两种方式）

#方法1
print(lis[0][1][2].get('k1')[0].upper())

#方法2
print(lis[0][1][2].get('k1')[0].swapcase())

10.2.将列表中的数字3 变成字符串'100'(用两种方式）

#方法1
print(lis)
lis[0][1][2].get('k1')[1] = '100'
print(lis)

#方法2
lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
dic3 = {'k1':['tt','100','1']}
print(lis)
lis[0][1][2].update(dic3)
print(lis)

10.3 将列表中的字符串'1'变成数字101（用两种方式）

#方法1
lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
print(lis)
lis[0][1][2].get('k1')[2] = 101
print(lis)

#方法2
lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
dic3 = {'k1':['tt',3,101]}
print(lis)
lis[0][1][2].update(dic3)
print(lis)

11 按照要求实现以下功能：

现有一个列表li = [1,2,3,'a','b',4,'c']，有一个字典（此字典是动态生成的，你并不知道他里卖弄有多少键值对，所以

用dic = {}模拟此字典）；现在需要完成这样的操作：如果该字典没有'k1'这个键，那就创建'k1'键和其对应的值(该键对应的值设置为空列表）

并将列表li 中的 索引为奇数的对应元素，添加到'k1'这个键对应的空列表中。如果该字典有'k1'这个键，且'k1'对应的value

是列表类型，那就将li中的索引为奇数的对应元素，添加到'k1'这个键对应的键中

dic = {'k2':2,'k3':3}#1. dic{}字典中 没有 'k1'
#dic = {'k1':['we','tt'],'k2':2}#2 dic{}字典中有'k1'
#dic = {'k1':1,'k2':33} # 有'k1'但'k1'value 非列表
li = [1,2,3,'a','b',4,'c']
if not 'k1' in dic:
dic.setdefault('k1',[])
for i in li :
if li.index(i) % 2 == 1:
dic['k1'].append(i)
else:
if type(dic['k1']) == type([]):
for i in li:
if li.index(i) % 2 == 1:
dic['k1'].append(i)
else:
print("字典K1,VALUE 不是列表，无法追加")
print(dic)

第二章总结-练习

1、请用代码实现：利用下划线将列表的每一个元素拼接成字符串，li＝['alex', 'eric', 'rain']

>>> li = ['alex','eric','rain']
>>> '_'.join(li)
'alex_eric_rain'

2、查找列表中元素，移除每个元素的空格，并查找以a或A开头并且以c结尾的所有元素。

li = ["alec", " aric", "Alex", "Tony", "rain"]

tu = ("alec", " aric", "Alex", "Tony", "rain")

dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}

li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
list1 = list(tu)
list2 = list(dic.values())
new_list = li + list1 + list2
for i in new_list:
    ret = i.strip()  # i.strip():删除字符串当前行首尾的的空格
    if (ret.startswith('a') or ret.startswith('A') or ret.endswith('c')): #startswith查看是否已什么开始，endswith查看是否已什么结尾
        print(ret)

3、写代码，有如下列表，按照要求实现每一个功能

li＝['alex', 'eric', 'rain']

• 计算列表长度并输出
• 列表中追加元素“seven”，并输出添加后的列表
• 请在列表的第1个位置插入元素“Tony”，并输出添加后的列表
• 请修改列表第2个位置的元素为“Kelly”，并输出修改后的列表
• 请删除列表中的元素“eric”，并输出修改后的列表
• 请删除列表中的第2个元素，并输出删除的元素的值和删除元素后的列表
• 请删除列表中的第3个元素，并输出删除元素后的列表
• 请删除列表中的第2至4个元素，并输出删除元素后的列表
• 请将列表所有的元素反转，并输出反转后的列表
• 请使用for、len、range输出列表的索引
• 请使用enumrate输出列表元素和序号（序号从100开始）
• 请使用for循环输出列表的所有元素

a 

>>> li = ['alex','eric','rain']
>>> v = len(li)
>>> v
3

b

>>> li.append('seven')
>>> li
['alex', 'eric', 'rain', 'seven']

c

>>> li.insert(0,'Tony')
>>> li
['Tony', 'alex', 'eric', 'rain', 'seven']

d

>>> li[1] = 'Kelly'
>>> li
['Tony', 'Kelly', 'eric', 'rain', 'seven']

e

>>> li.remove('eric')
>>> li
['Tony', 'Kelly', 'rain', 'seven']

f

>>> del li[1]
>   K = del.li[1]
>>> li
['Tony', 'rain', 'seven']

g

>>> del li[2]
>>> li
['Tony', 'rain']

h

>>> del li[1:3]
>>> li
['Tony']

i

>>> li = ['alex','eric','rain']
>>> li
['alex', 'eric', 'rain']
>>> li.reverse()
>>> li
['rain', 'eric', 'alex']

j

li = ['alex','eric','rain']
for i in range(len(li)):
    print(i)

k

li = ['alex','eric','rain']
for k ,v in enumerate(li,100):
    print(k,v)

l

li = ['alex','eric','rain']
for i in li :
    print(i)

4、写代码，有如下列表，请按照功能要求实现每一个功能

li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]

• 请根据索引输出“Kelly”
• 请使用索引找到'all'元素并将其修改为“ALL”，如：li[0][1][9]...

li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])

li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
li[2][2] = 'All'
print(li)

5、写代码，有如下元组，请按照功能要求实现每一个功能

tu＝('alex', 'eric', 'rain')

• 计算元组长度并输出
• 获取元组的第2个元素，并输出
• 获取元组的第1-2个元素，并输出
• 请使用for输出元组的元素
• 请使用for、len、range输出元组的索引
• 请使用enumrate输出元祖元素和序号（序号从10开始）

>>> tu = ('alex','eric','rain')
>>> len(tu)
3

>>> tu
('alex', 'eric', 'rain')
>>> tu[1]
'eric'

>>> tu
('alex', 'eric', 'rain')
>>> tu[0:2]
('alex', 'eric')

 tu = ('alex', 'eric', 'rain')
 for i in tu:
    print(i)

tu = ('alex','eric','rain')
for i in range(len(tu)):
    print(i)

tu = ('alex','eric','rain')
for k,v in enumerate(tu,10):
    print(k,v)

6、有如下变量，请实现要求的功能

tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])

• 讲述元祖的特性
• 请问tu变量中的第一个元素“alex”是否可被修改？
• 请问tu变量中的"k2"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素“Seven”
• 请问tu变量中的"k3"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素“Seven”

a 　特性：　1.可存放多个值；   2.不可变；  3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序
b　不可被修改。

c    k2对应的值是列表，可以被修改。

>>> tu
('alex', [11, 22, {'k1': 'v1', 'k2': ['age', 'name'], 'k3': (11, 22, 33)}, 44])
>>> tu[1][2]['k2'].append('seven')
>>> tu
('alex', [11, 22, {'k1': 'v1', 'k2': ['age', 'name', 'seven'], 'k3': (11, 22, 33)}, 44])

d   k3对应的是元组，不能被修改。

7、字典

dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}

• 请循环输出所有的key
• 请循环输出所有的value
• 请循环输出所有的key和value
• 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
• 请在修改字典中“k1”对应的值为“alex”，输出修改后的字典
• 请在k3对应的值中追加一个元素44，输出修改后的字典
• 请在k3对应的值的第1个位置插入个元素18，输出修改后的字典

a 

dic = {'k1':'v1','k2':'v2','k3':[11,22,33]}
for k in dic:
    print(k)

b

dic = {'k1':'v1','k2':'v2','k3':[11,22,33]}
for k in dic.values():
    print(k)
# for k in dic:
#     print(dic[k])

c

dic = {'k1':'v1','k2':'v2','k3':[11,22,33]}
for k,v in dic.items(): #items 是把字典转换成列表
    print(k,v)
# for k in dic:
#     print(k,dic[k])

e

>>> dic
{'k1': 'v1', 'k2': 'v2', 'k3': [11, 22, 33]}
>>> dic['k4'] = 'v4'
>>> dic
{'k1': 'v1', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}

f

{'k1': 'v1', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}
>>> dic['k1'] = 'alex'
>>> dic
{'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}

g

>>> dic['k3'].append(44)
>>> dic
{'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33, 44], 'k4': 'v4'}

k

>>> dic
{'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33, 44], 'k4': 'v4'}
>>> dic['k3'].insert(0,18)
>>> dic
{'k1': 'alex', 'k2': 'v2', 'k3': [18, 11, 22, 33, 44], 'k4': 'v4'}

8、转换

• 将字符串s = "alex"转换成列表
• 将字符串s = "alex"转换成元祖
• 将列表li = ["alex", "seven"]转换成元组
• 将元祖tu = ('Alex', "seven")转换成列表
• 将列表li = ["alex", "seven"]转换成字典且字典的key按照10开始向后递增

>>> s = "alex"                                                                                                                    
>>> list(s)
['a', 'l', 'e', 'x']

>>> tuple(s)
('a', 'l', 'e', 'x')

>>> li = ["alex","seven"]
>>> tuple(li)
('alex', 'seven')

>>> tu = ('Alex','seven')
>>> list(tu)
['Alex', 'seven']

li = ["alex","seven"]
dic ={}
for k ,v in enumerate (li,10):
    dic[k] = v   #列表转换成字典
    print(dic)

9、元素分类

有如下值集合[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]
li.sort() #排序
z = li.index(66)
l = len(li)
dict = {'k1':li[z+1:l],'k2':li[:z]}
print(dict)

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

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

• 允许用户添加商品
• 用户输入序号显示内容

li = ["手机", "电脑", '鼠标垫', '游艇']
for k,i in enumerate(li):
    print(k,i)
num = int(input("please input your number:"))
print(li[int(num)])
choice = input('是否添加商品(y|Y):')
if choice == 'y' or choice == 'Y':
    goods = input("请输入商品:")
    li.append(goods)  #添加商品
    for k,i in enumerate(li):
        print(k, i)
s = input("是否查找商品(y|Y):")
if s == 'y' or s == 'Y' :
    n = int(input('请输入要查询的序号:'))
    print(li[n])

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

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

city = {"北京":{"朝阳":["大望路","国贸"],
                "昌平":["沙河","昌平"]},
         "河北":{"张家口":["沙城","宣化"],
                 "石家庄":["某某路","某某街"]}
         }
 go = True
 while go:
     cc = []
     dq = []
     print("33[31;1m一级列表33[1m".center(40,"="))
     for i,v in enumerate(city,1):
         print(i,v)
         cc.append(v)
     print("33[35;1m插入数据 i 退出按Q33[1m")
     u_c1 = str(input(">>>"))
     if u_c1.isdigit():#进二级之前判断
         u_c1 = int(u_c1)
         if u_c1 >0 and u_c1 <=len(cc):
             while go:
                 print("33[32;1m二级列表33[1m".center(40, "="))
                 for i1,v1 in enumerate(city[cc[u_c1-1]],1):
                     print(i1,v1)
                     dq.append(v1)
                 print("33[35;1m退出按Q 返回 B33[1m")
                 u_c2 = input(">>>")
                 if u_c2.isdigit():#进三级之前判断
                     u_c2 = int(u_c2)
                     if u_c2 >0 and u_c2<=len(dq):
                         while go:
                             print("33[32;1m三级列表33[1m".center(40, "="))
                             for s in city[cc[u_c1-1]][dq[u_c2-1]]:
                                 print(s)
                             print("33[35;1m退出按Q 返回 B33[1m")
                             u_c3 = input(">>>")
                             if u_c3 == "q" or u_c3 == "Q":
                                 go = False
                                 break
                             if u_c3 == "b" or u_c3 =="B":
                                 del dq[:]
                                 break
                             else:
                                 print("33[31;1m输入不正确33[1m")
                     else:
                         print("33[31;1m输入超出范围！33[1m")
                 elif u_c2 == "q" or u_c2 == "Q":
                     go = False
                     break
                 elif u_c2 == "b" or u_c2 == "B":
                     del cc[:]
                     del dq[:]
                     break
                 else:
                     print("33[31;1m输入格式不对！33[1m")
     elif u_c1.isalpha():
         if u_c1 == "q" or u_c1 == "Q":
             break
         elif u_c1 == "i" or u_c1 == "I":
             print("33[32;1m添加信息33[1m".center(40,"="))
             ct_name = input("省：")
             if ct_name == "Q" or ct_name == "q":
                 break
             else:
                 if city.get(ct_name,0) == 0:
                     city[ct_name] = {}
             dq_name = input("市：")
             if dq_name == "Q" or dq_name == "q":
                 break
             else:
                 if city[ct_name].get(dq_name,0) == 0:
                     city[ct_name][dq_name]=[]
             while True:
                 print("33[31;1m循环添加，退出请按Q！33[1m")
                 s = input("县：")
                 if s == "q" or s == "Q":
                     break
                 else:
                     city[ct_name][dq_name].append(s)
         else:
             print("33[31;1m输入超出范围！33[1m")
     else:
         print("33[31;1m输入格式不对！33[1m")

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

1 None ""  () []  {} 0 

13、有两个列表

　　l1 = [11,22,33]

　　l2 = [22,33,44]

• 获取内容相同的元素列表
• 获取l1中有，l2中没有的元素列表
• 获取l2中有，l1中没有的元素列表
• 获取l1和l2中内容都不同的元素

l1 = [11,22,33]
l2 = [22,33,44]
print(list(set(l1) & set(l2)))
print(list(set(l1) - set(l2)))
print(list(set(l2) - set(l1)))
print(list(set(l2) ^ set(l1)))

14、利用For循环和range输出

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

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

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

while True:
    a = 100
    for i in  range(100):
        print(a - i)
    break

while True:
    for i in range(100):
        print(i+1)
    break

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

#方法一
for x in range(1,10):
      for y in range(1,x+1):
          print("{0} * {1} = {2}".format(x,y,x*y),end = " ")     #end = " " 作用就是：不换行
      print('
',end = " ")

#方法二：
for i in range(1,10):
     for j in range(1,i+1):
         print("%d*%d=%2d" % (i,j,i*j),end=" ")  #%d是数值整型对应的格式通配符
     print(" ")

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

 　　解题思路：

1. 求出100以内除了1的所有整数（1不是素数）。
2. 用每一个整数分别除以比他小的整数，判断是否可以整除。
3. 定义一个空列表，用以储存素数。
4. 设定一个判断条件。

#1
L=[]
    for i in range(2,101):
      flg=True
      for j in range(2,i):
        if (i%j==0):
          flg=False
          break
      if flg:
        L.append(i)
    print(L)
#2
for i in range(2,101): 
　　fg = 0 
　　for j in range(2,i-1): 
　　　　if i%j == 0: 
　　　　　　fg = 1 
　　　　　　break 
if fg == 0: 
　　print i

17、将[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)

18、分页显示内容

a.通过for循环创建301条数据，数据类型不限，如：
alex-­‐1alex1@live.compwd1
alex-­‐2alex2@live.compwd2
alex-­‐3alex3@live.compwd3
....

1 for i in range(301):
2     a = "alex- - %salex%s@live.com pwd%s"%(i+1,i+1,i+1)
3     print(a)

b.提示用户请输入要查看的页码，当用户输入指定页码，则显示指定数据

注意：
-­‐每页显示10条数据
-­‐用户输入页码是非十进制数字，则提示输入内容格式错误

while True:
     u = []
     for i in range(301):
         a = "alex{0} alex{0}@live.com pwd{0}".format(i+1)
         x = [a]
         u = u + x
     # print(u[0:10])
     s = input("请输入您想查看的页码：")
     v3 = s.isnumeric()    #检测字符串是否只由数字组成,如果字符串中只包含数字字符，则返回 True，否则返回 False
     if v3 == False :
         print("输入内容格式错误")
 
     elif int(s) < 1 or int(s) > 31:
         print("输入页码错误")
 
     else:
         s = int(s)
         a = (s-1)*10
         b = s*10
         j = (u[a:b])
         for g in j:
             print(g)
     A =input("是否继续查看（y or Y）")
     if A =="y" or A =="Y":
         continue
     else:
         break

19、有1、2、3、4、5、6、7、8、8个数字，能组成多少个互不相同且无重复数字的3位数？

count = 0
for i in range(1, 9):
     for x in range(1, 9):
         for y in range(1, 9):
             if i != x and x != y and i != y:
                 print(i, x, y)
                 count += 1
print(count)

20、有一下列表，
nums=[2,7,11,15,1,8,7]
请找到列表中任意两个元素相加能够等于9的元素集合，如：[(0,1),(4,5)]

nums = [2, 7, 11, 15, 1, 8, 7]
li = []
n1 = []
for i in nums:
     for x in nums:
         y = i + x
         if y == 9:
             v = [i, x]
             x =(i,x)
             if v not in li:
                 v.reverse()
                 if v not in li:
                     n1.append(x)
                     li.append(v)
print(n1)

21、用Python开发程序自动计算方案：

公鸡5文钱一只，母鸡3文钱一只，小鸡3只一文钱，用100文钱买100只鸡,其中公鸡，母鸡，小鸡都必须要有，问公鸡，母鸡，小鸡要买多少只刚好凑足100文钱？

for x in range(1, 100):
     for y in range(1, 100):
         for z in range(1, 100):
             if x + y + z == 100 and 5 * x + 3 * y + z / 3 == 100:  # 小鸡  1/3
                 print(x, y, z)

执行结果：

1 4 18 78
2 8 11 81
3 12 4 84

补加练习题：

分别用append、extend方法，给一个序列增加一个元素

>>> lst1 = [4,2,'rs','name']
>>> lst1.append(9)
>>> print(lst1)
[4, 2, 'rs', 'name', 9]
>>> lst1.extend([1,2,3])
>>> print(lst1)
[4, 2, 'rs', 'name', 9, 1, 2, 3]

x.append([1,2,3])和x.extend([1,2,3])的区别

 x.append('abc')和x.extend('abc')的区别

>>> lst1.append([1,2,3])
>>> print(lst1)
[4, 2, 'rs', 'name', 9, 1, 2, 3, [1, 2, 3]]
>>> lst1.extend([1,2,3])
>>> print(lst1)
[4, 2, 'rs', 'name', 9, 1, 2, 3, [1, 2, 3], 1, 2, 3]
>>> lst1.append('abc')
>>> print(lst1)
[4, 2, 'rs', 'name', 9, 1, 2, 3, [1, 2, 3], 1, 2, 3, 'abc']
>>> lst1.extend('abc')
>>> print(lst1)
[4, 2, 'rs', 'name', 9, 1, 2, 3, [1, 2, 3], 1, 2, 3, 'abc', 'a', 'b', 'c']
>>>

 sort()和sorted()什么区别

>>> lst1.sort()
>>> print(lst1)
[2, 4, 5, 8, 9]
>>> lst1.sort(reverse=True)
>>> print(lst1)
[9, 8, 5, 4, 2]
>>> lst2 = sorted(lst1)
>>> print(lst2)
[2, 4, 5, 8, 9]
>>>

 m=[4,5,6,73,4,4,4,4,2]，删除所有的4

#方法一 set（）方法
>>> m
[4, 5, 6, 73, 4, 4, 4, 4, 2]
>>> list(set(m))
[2, 4, 5, 6, 73]

#方法二 set() 方法会改变列表顺序，使用sort()使之与原来的相同；
>>> z = list(set(m))
>>> z.sort(key = m.index)
>>> z
[4, 5, 6, 73, 2]

#方法三
>>> m=[4,5,6,73,4,4,4,4,2]
>>> n={}.fromkeys(m).keys()  #fromkeys（）用于创建一个字典；dict.fromkeys(iterable[,value=None])
>>> n
dict_keys([4, 5, 6, 73, 2])

#方法四：
m=[4,5,6,73,4,4,4,4,2]
n=[]
for i in m:
    if i not in n:
        n.append(i)
print(n)
打印：
[4, 5, 6, 73, 2]