1.Python3扩展知识之笔试操作总结(一)

全栈工程师修炼指南

发布于 2022-09-28 14:11:03

1.1K0

文章被收录于专栏：全栈工程师修炼之路全栈工程师修炼之路

[TOC]

1)Python笔试基础知识

Python 是什么类型的语言？ Python是脚本语言(Scripting language)
IDLE 是什么？ IDLE是一个Python Shell，shell的意思就是“外壳”，基本上来说，就是一个通过键入文本与程序交互的途径！像我们Windows那个cmd窗口，像Linux那个黑乎乎的命令窗口，他们都是shell，利用他们，我们就可以给操作系统下达命令。同样的，我们可以利用IDLE这个shell与Python进行互动。
print() 的作用是什么？ print() 会在输出窗口中显示一些文本
Python 中表示乘法的符号是什么？ Python中的乘号是*（星号）。
为什么 >>>print(‘I love fishc.com ‘ * 5) 可以正常执行，但 >>>print(‘I love fishc.com ‘ + 5) 却报错？在 Python 中 不能把两个完全不同的东西加在一起，比如说数字和文本，正是这个原因，>>>print(‘I love fishc.com ‘ + 5) 才会报错，前边的例子就是将 “I love fishc.com” 这个字符串打印五次。
如果我需要在一个字符串中嵌入一个双引号，正确的做法是？你有两个选择：可以利用反斜杠（\）对双引号转义：\”，或者用单引号引起这个字符串。例如：’ I l”o”ve fishc.com ‘。
为什么我们要使用 Python3？Python2到底有什么问题？看起来很多程序员依然都在使用Python2？确实还有相当多的程序员在使用 Python2，不过 Python3 才是 Python 发展的未来，就像 XP 和 WIN7 一样。觉Python3 中有很多新特性确实很妙，很值得进行深入学习！你也不用担心,如果你了解了 Python3，Python2 的代码阅读对于你来说根本不成问题！
什么是BIF？ BIF 就是 Built-in Functions，内置函数,是为了方便程序员快速编写脚本程序;
Python3 提供了多少个 BIF？在 Python 或 IDLE 中，输入 dir(__builtins__) 可以看到 Python 提供的内置方法列表一共73个，当前版本 Python 3.7.2 (tags/v3.7.2:9a3ffc0492, Dec 23 2018, 23:09:28)
在 Python 看来：’FishC’ 和 ‘fishc’ 一样吗？对 Python 来说，fishc 和 FishC 是完全不同的两个名字，所以编程的时候一定要当心。
Python 中什么是最重要的？缩进是 Python 的灵魂，缩进的严格要求使得 Python 的代码显得非常精简并且有层次; 如果在正确的位置输入冒号“:”，IDLE 会自动将下一行缩进！
这节课的例子中出现了“=”和“==”，他们表示不同的含义，你在编程的过程中会不小心把“==”误写成“=”吗？ C语言的话，如果 if( c == 1 ) 写成 if( c = 1 )，程序就完全不按程序员原本的目的去执行，但在 Python 这里，不好意思，行不通，语法错误！ Python 不允许 if 条件中赋值，所以 if c = 1: 会报错！
你听说过“拼接”这个词吗？可以将两个字符串“相加”在一起，如：’I’ + ‘Love’ + ‘FishC’ 会得到 ‘ILoveFishC’，在 Python 里，这种做法叫做拼接字符串。
以下哪个变量的命名不正确？为什么？ (A) MM_520 (B) _MM520_ (C) 520_MM (D) _520_MM (C)选项不正确，因为 Python 中的变量名不能以数字开头。

除了使用饭斜杠（\）进行字符转义，还有什么方法可以打印：Let’s go! 这个字符串？

>>> myteacher = '小甲鱼'
>>> yourteacher = myteacher
>>> yourteacher = '黑夜'
>>> print(myteacher)     # 小甲鱼  , 变量是独立的

>>> myteacher = '小甲鱼'
>>> yourteacher = myteacher
>>> myteacher = '黑夜'
>>> print(yourteacher)  # 小甲鱼  , 变量是独立的(非关联)

除了使用反斜杠（\）进行字符转义，还有什么方法可以打印：Let’s go! 这个字符串？如果非要在原始字符串结尾输入反斜杠，可以如何灵活处理？

>>> "let's go!"
"let's go!"

>>> r'C:\Program Files\FishC\Good''\\'
'C:\\Program Files\\FishC\\Good\\'

内置函数也是可以修改但需要注意？ Python 貌似不介意我们对内置函数进行赋值操作，所以这点我们以后就要注意啦,否则可能会出现以下的 BUG：

>>> print = 1
>>> print("I love FishC")   #内置函数被修改后便不能实现原有的功能
Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    print("I love FishC")
TypeError: 'int' object is not callable

字符串最后提到的长字符串（三重引号字符串）其实在 Python3 还可以这么写？

#所见即所得
string = """
WeiyiGeek,
Python,
脚本语言.
"""
print(string)

#需要进行转义才行
string = (
"我爱C,\n"
"正如我爱Weiyigeek,\n"
"他那呱唧呱唧的声音,\n")
print(string)

while 循环为假的关键点造成死循环的原因是 while 后边的条件永远为真(True), 在 Python 看来,只有以下内容会被看作假(注意冒号括号里边啥都没有，连空格都不要有!) ：False None 0 “” ‘’ () [] {}

while '':
    print('进入循环')
print('退出循环')

while False:
    print('进入循环')
print('退出循环')

Python3 中，一行可以书写多个语句吗？一个语句可以分成多行书写吗？

#可以语句之间用分号隔开即可，不妨试试：
>>> print('I love fishc');print('very much!')

#可以一行过长的语句可以使用反斜杠或者括号分解成几行，不妨试试：
>>> 3 > 4 and \
    1 < 2

>>> ( 3 > 4 and
    1 < 2 )

请问Python的 and 操作符和C语言的 && 操作符有何不同？

# C
int main()
{
    print("%d , %d\n", 1 && 3, 0 && 1);  #[为真1,为假0]
}
# Python 返回整型数值
1 and 3 ==> 3
0 and 1 ==> 0

听说过”短路逻辑(short-circuit logic)”吗？逻辑操作符有个有趣的特性：在不需要求值的时候不进行操作。这么说可能比较“高深”，举个例子，表达式 x and y，需要 x 和 y 两个变量同时为真(True)的时候，结果才为真。因此如果当 x 变量得知是假(False)的时候，表达式就会立刻返回 False，而不用去管 y 变量的值。这种行为被称为短路逻辑(short-circuit logic)或者惰性求值(lazy evaluation),这种行为 同样也应用与 or 操作符 实际上，Python 的做法是如果 x 为假，表达式会返回 x 的值(0)，否则它就会返回 y 的值.

你知道为什么布尔类型(bool)的 True 和 False 分别用 1 和 0 来代替吗？

计算机是很“笨”的，究其根本是因为它只认识二进制数，所以所有的编程语言最终都会转换成简单的二进制序列给 CPU 按照一定的规则解析。
由于二进制只有两个数：0 和 1，因此用 0 和 1 来表示 False 和 True 再适合不过了，因为不用浪费资源在转换的过程上！

使用 int() 将小数转换为整数，结果是向上取整还是向下取整呢？你有什么办法使得 int() 按照“四舍五入”的方式取整吗? 小数取整会采用比较暴力的截断方式如下：

正数即向下取整。(注：5.5 向上取整为 6，向下取整为 5)

负数则刚好相反是向上取整。

>>> int(1.5)
1
>>> int(-1.5)
-1

#按照四舍五入的方法：
5.4 “四舍五入”结果为：5，int(5.4+0.5) == 5
5.6 “四舍五入”结果为：6，int(5.6+0.5) == 6

取得一个变量的类型使用 type() 和 isinstance()，你更倾向于使用哪个？建议使用 isinstance()，因为它的返回结果比较直接，另外 type() 其实并没有你想象的那么简单。

>>> type(int)  #<class 'type'>
>>> type(1)   #<class 'int'>
>>> isinstance(1,int)  #True

Python3 可以给变量命名中文名，知道为什么吗？ Pyhton3 源码文件默认使用utf-8编码（支持中文），这就使得以下代码是合法的：

>>小鱼 = ‘我爱你’;print(小鱼) #我爱你

除法现在使用 “//” 实现，那 3.0 // 2.0 与 3.0 / 2.0 您目测会显示什么内容呢？ Python 这里会义无反顾地执行 floor 除法原则:

>>> 3 / 2       #1.5  (floor)
>>> 3.0 // 2.0  #1.0  (默认是int，但是由于除数或被除数一个是浮点类型所以结果也是浮点，向下取值)
>>> 3.0 // 2  #1.0
>>> 3 // 2     #1

最快速度说出答案：not 1 or 0 and 1 or 3 and 4 or 5 and 6 or 7 and 8 and 9 逻辑运算符优先级是不同的：not > and > or

我们按照优先级给它们加上括号：(not 1) or (0 and 1) or (3 and 4) or (5 and 6) or (7 and 8 and 9)
== 0 or 0 or 4 or 6 or 9
== 4  #由于“短路逻辑” 3 and 4 == 4，而 3 or 4 == 3。

如果还没有学到“求余”操作，还记得用什么方法可以“委曲求全”代替“%”的功能呢？

使用了“if year/400 == int(year/400)”这样的方式来“委曲求全”

assert 的作用是什么？什么情况下我们会需要这样的代码呢？ (1)assert这个关键字我们称之为“断言”，当这个关键字后边的条件为假的时候，程序自动崩溃并抛出AssertionError的异常。 (2)当我们在测试程序的时候就很好用，因为与其让错误的条件导致程序今后莫名其妙地崩溃，不如在错误条件出现的那一瞬间我们实现“自爆”。 (3)一般来说我们可以用Ta再程序中置入检查点，当需要确保程序中的某个条件一定为真才能让程序正常工作的话，assert关键字就非常有用了。

假设有 x = 1，y = 2，z = 3，请问如何快速将三个变量的值互相交换？

>>> x=1;y=2;z=3;
>>> x,y,z = z,x,y
>>> print(x,y,z)  #3 1 2

猜猜 (x < y and [x] or [y]) [0] 实现什么样的功能？这其实是 Python 的作者还没有为 Python 加入三元操作符之前，Python 社区的小伙伴们灵活的使用 and 和 or 搭配来实现三元操作符的功能，这里边有涉及到列表和切片的知识，这部分知识很快就会讲解,迫不及待的朋友可以先稍微预习下。

什么情况下我们要使循环永远为真？同样用于游戏实现,因为游戏只要运行着，就需要时刻接收用户输入，因此使用永远为真确保游戏“在线”。操作系统也是同样的道理,时刻待命,操作系统永远为真的这个循环叫做消息循环。另外，许多通讯服务器的客户端/服务器系统也是通过这样的原理来工作的。

member.append([‘竹林小溪’, ‘Crazy迷恋’]) 和 member.extend([‘竹林小溪’, ‘Crazy迷恋’]) 实现的效果一样吗？

>>> name = ['F', 'i', 's', 'h']
>>> name.append('C')
>>> name  #['F', 'i', 's', 'h', 'C']
>>> name.extend(['.', 'c'])
>>> name  #['F', 'i', 's', 'h', 'C', '.', 'c']  直接扩展列表
>>> name.append(['o', 'm'])
>>> name   #增加元素到列表中。['F', 'i', 's', 'h', 'C', '.', 'c', ['o', 'm']]

请问 list1[0] 和 list1[0:1] 一样吗？list1[-3:-1] 会不会报错？但其实还有另外一个隐藏的设置：步长? 不一样，list1[0] 返回第0个元素的值，list1[0:1] 返回一个只含有第0个元素的列表。

#自己需要注意不同采用切片是列表
>>> list = [1,2,3,4,5]
>>> list[0]  #1
>>> list[0:1] #[1]

# 正常索引是从左到右索引，负数索引是从右到左。
>>> list[-3:-1]  #[2, 3]   3 -1 = 2
>>> list[0:-1]  # [1, 2, 3, 4]

# 另外一个就是步长
>>> list[::2]  # [1, 3, 5]
>>> list[::-2]  # [5, 3, 1]

#为了解释下面的话：(注意这里有坑)
>>> old = [1, 2, 3, 4, 5]
>>> new = old
>>> old = [6]    #这里是 赋了一个列表值 给了old列表
>>> print(new)   #输出还是 [1, 2, 3, 4, 5],并没有变化。
>>> old.sort(reverse=True)      # (注意这里有坑),排序是会带动变化的
>>> print(new)    #这时候new是会变化的 [5,4,3,2,1]

在进行列表赋值给其他变量的时候需要注意,采用 list2 = list1 (会随着list1改变而改变,但不会随的值覆盖而改变) 而 list3 = list1[\:] (相当于是重新建立一个列表,并不会受到原列表的影响)

请用一句话描述什么是列表？再用一句话描述什么是元组？什么情况下你需要使用元组而不是列表？列表：一个大仓库，你可以随时往里边添加和删除任何东西，提高了编程的灵活性元组：封闭的列表，一旦定义就不可改变 （不能添加、删除或修改）,提高了编程的安全性。当我们希望内容不被轻易改写的时候，使用元组（把权力关进牢笼;当我们需要频繁修改数据，就使用列表。

创建一个元组，什么情况下逗号和小括号必须同时存在，缺一不可？由于元组是不能够被更改的,所有如果需要插入或者修改就需要采用切片的方式进行重新建立元组.

>>> tuple = ('Weiyi','GEEK')
>>> tuple1 = tuple[:1]   #('Weiyi',)  时刻注意切片返回与原始类型一致
>>> tuple1 = tuple[1]    #'GEEK'     但采用索引得到值仅仅是元素
>>> tuple1 = tuple[:1] + ('YES',) + tuple[1:]  #('Weiyi', 'YES', 'GEEK')   方法1
>>> tuple2 = (tuple1[1],'Weiyi',tuple1[2])     #('YES', 'Weiyi', 'GEEK')   方法2

x, y, z = 1, 2, 3 请问x, y, z是元组吗？答案：所有的多对象的、逗号分隔的、没有明确用符号定义的这些集合默认的类型都是元组 tuple ;

>>> x, y, z = 1, 2, 3
>>> type(x)   # <class 'int'>
>>> h = x, y, z
>>> type(h)  # <class 'tuple'>

那请问如果我把中括号改为小括号，会不会得到“元组推导式”呢？答案:不会,Python3 木有“元组推导式”,虽然修改建立后不会报错但是它的类型变成生成器(generator)类型。

>>> tuple1 = (x**2 for x in range(10))
>>> type(tuple1)  #<class 'generator'>
# 注意，Python3 开始 next() 方法改为 __next__() 哦~,您可以用这个方式访问生成器
>>> tuple1.__next__()  #0
>>> tuple1.__next__()  #1
>>> tuple1.__next__()  #4

如何定义一个跨越多行的字符串吗（请至少写出两种实现的方法）？

方法一：
>>> str1 = '''待我长发及腰，将军归来可好？
此身君子意逍遥，怎料山河萧萧。江南晚来客，红绳结发梢。'''
   
方法二：
>>> str2 = '待卿长发及腰，我必凯旋回朝。\
昔日纵马任逍遥，俱是少年英豪。'
   
方法三：
>>> str3 = ('待卿长发及腰，我必凯旋回朝。'
'昔日纵马任逍遥，俱是少年英豪。')

格式化字符串的常用方法有那些?如果想要显示Pi = 3.14，format前边的字符串应该怎么填写呢？

"{1}".format("不打印", "打印") #"打印"
"{a} love {b}.{c}".format(a="I", b="百度", c="com") #关键字参数
"{0} love {1}.{2}".format("I", "C", "com")  #位置参数
'{0}{1:.2f}'.format('Pi = ', 3.1415)

在Windows上打开文件路径需要进行转义\才能正常进行找出文件，我们约定“\t”和“\r”分别表示“横向制表符（TAB）”和“回车符”:如下面

open('C:\windows\temp\readme.txt', 'r')  #会报错
file1 = open(r'C:\windows\temp\readme.txt', 'r')  #方式1
file1 = open('C:\\windows\\temp\\readme.txt', 'r') #方式2

2)Python操作实验

1.编程输入程序并且进行验证选择.

#!/usr/bin/python3
#功能：课后作业1
import random
name = input("请输入您的姓名：")
num = input('请输入一个1~100的数中:')
num = int(num)
if num > random.randint(0,100):
    print("恭喜您：" + name,"您输入的数字"+ num +"大于随机数")
else:
    print("不能恭喜您了",name)


####### 结果输出 ##########
#请输入您的姓名：weiyigeek #
#请输入一个1~100的数中:50  #
#不能恭喜您了 weiyigeek    #

2.打印输出如下图所示的代码：

#!/usr/bin/python3
#功能：课后作业04

count = input("请输入显示*号的个数:")
count = int(count)
while count:
    print(' ' * (count - 1),'*' * count)
    count = count - 1
else:
    print("打印结束")

####### 结果输出 ##########
#请输入显示*号的个数:10
#          **********
#         *********
#         ********
#        *******
#       ******
#      *****
#     ****
#    ***
#   **
#  *

3.改进游戏增加数据类型输入错误判断。前面使用 type(temp) != type(1) 或者 not isinstance(temp, int) 输入类型判断的;以上方法的思路是正确的，不过似乎忽略了一点儿：就是 input() 的返回值始终是字符串，所以 type(temp) 永远是 < class ‘str’> .

我们解决方法将采用字符串内置模块的方法，如String.isdigit() while not temp.isdigit(): temp = input(“抱歉，您的输入有误，请输入一个整数：”)

#!/usr/bin/python3
#功能：课后作业05
import random
jihui = 3
secret = random.randint(1,10)
print('##############简单的数字游戏###############')
guess  = 0
print("请输入0~10之间的数字：",end='')

while (guess != secret) and (jihui > 0):
    temp = input()
    if temp.isdigit():
        guess = int(temp) 
        if (guess == secret):
            print("您刚好猜中数字：",secret) #猜中则会结束循环
        else:
            if (guess > secret):
                print("MAX 值大了，亲")
            else:
                print("Min 值小了，亲")
            if jihui > 1:
               print("请再尝试一次：",end='')
            else:
                print("请机会用光了")
    else:
        print("对不起,输入有误,需要重新输入。")
    jihui = jihui - 1  # 用户每输入一次，可用机会就-1
else:
    print("游戏结束！")

####### 结果输出 ##########
# ------简单的数字游戏---------
# 请输入0~10之间的数字：5
# Min 值小了，亲
# 请再尝试一次：6
# Min 值小了，亲
# 请再尝试一次：8
# MAX  值大了，亲
# 请机会用光了
# 游戏结束！

4.现在的 Python 可以计算很大很大的数据，但是真正的大数据计算可是要靠刚刚的硬件滴,比如：

print(2 ** 2 ** 32)
# 一般很多机子都会在一会儿之后：Memory Overflow，内存不够用。
# 设计到幂操作，结果都是惊人滴。

你猜猜为何 print( (2 ** 2) ** 32) 就可以计算出结果呢？
结果：18446744073709551616
我猜想的是 print(2 ** 2 ** 32) 中由于 幂运算符 右边表达式的优先级大于左边表达式的优先级 ,计算的时候会这样：print(2 ** (2 ** 32))  #想想这个是一个多么恐怖的数字

5.爱因斯坦难题有一道有趣的数学题：有一个长阶梯，若每步上2阶，最后剩1阶；若每步上3阶，最后剩2阶；若每步上5阶，最后剩4阶；若每步上6阶，最后剩5阶；只有每步上7阶，最后刚好一阶也不剩。题目：请编程求解该阶梯至少有多少阶？

##########算法方法1##########
#!/usr/bin/python3
jieti = 7
while 1:
    if ( jieti % 2 == 1) and ( jieti % 3 == 2) and ( jieti % 5 == 4) and ( jieti % 6 == 5) :
        print("至少有 %d 阶梯" %jieti)  #至少有 119 阶梯
        break
    else:
        jieti = jieti + 7 # 根据题意，x一定是7的整数倍，所以每次+ 7


##########算法方法2##########
x = 7
i = 1
flag = 0
while i <= 100:
    if (x%2 == 1) and (x%3 == 2) and (x%5 == 4) and (x%6==5):
        flag = 1
    else:
        x = 7 * (i+1) # 根据题意，x一定是7的整数倍，所以每次乘以7
    i += 1

if flag == 1:
    print('阶梯数是：', x)
else:
    print('在程序限定的范围内找不到答案！')

6.使用 if elif else 在大多数情况下效率要比全部使用 if 要高,替代了switch…case 的功能;

score = int(input('请输入一个分数：'))
if 80 > score >= 60:
    print('C')
elif 90 > score >= 80:
    print('B')
elif 60 > score >= 0:
    print('D')
elif 100 >= score >= 90:
    print('A')
else:
    print('输入错误！')

7.请将以下代码修改为三元操作符实现：

x, y, z = 6, 5, 4
if x < y:  
    small = x
    if z < small:     #先判断外部，再判断内部关系
        small = z
elif y < z:
    small = y
else:
    small = z

###########转换成三元运算符#############
small = x if (x < y and x < z) else (y if y < z else z)

7.设计一个验证用户密码程序，用户只有三次机会输入错误，不过如果用户输入的内容中包含”*”则不计算在内。

#!/usr/bin/python3
count = 3
password = '123456'

while count:
    temp = input("请输入密码：")
    if '*' in temp:
        continue
    elif temp == password:
        print("输入的密码正确")
        break;
    else:
        count = count - 1
        print("密码输入错误,您还有 %d 次机会" %count)

print("Login Successful")


####### 结果输出 ##########
# 请输入密码：123
# 密码输入错误,您还有 2 次机会
# 请输入密码：*asdsa
# 请输入密码：156454
# 密码输入错误,您还有 1 次机会
# 请输入密码：123456
# 输入的密码正确
# Login Successful

8.有红、黄、蓝三种颜色的求，其中红球 3 个，黄球 3 个，绿球 6 个。先将这 12 个球混合放在一个盒子中，从中任意摸出 8 个球，编程计算摸出球的各种颜色搭配。


#!/usr/bin/python3
print('red\tyellow\tgreen')
for red in range(0, 4):
    for yellow in range(0, 4):
        for green in range(2, 7):
            if red + yellow + green == 8:
                # 注意，下边不是字符串拼接，因此不用“+”哦~
                print(red, '\t', yellow, '\t', green)

####### 结果输出 ##########
# red     yellow  green
# 0        2       6
# 0        3       5
# 1        1       6
# 1        2       5
# 1        3       4
# 2        0       6
# 2        1       5
# 2        2       4
# 2        3       3
# 3        0       5
# 3        1       4
# 3        2       3
# 3        3       2

注释：range(2, 7) 是产生 [2, 3, 4, 5, 6] 这 5 个数，绿球不能是 1 个，因为如果绿球是 1 个的话，红球 + 黄球需要有 7 个才能符合题意，而红球和黄球每种只有 3 个，因此是 range(2, 7)

9.按照特定的格式进行输出列值;

#方法一：
member = ['小甲鱼', 88, '黑夜', 90, '迷途', 85, '怡静', 90, '秋舞斜阳', 88]
count = 0
length = len(member)
while count < length:
    print(member[count], member[count+1])
    count += 2

#方法二：
length = len(member)
for each in range(len(length)):
    if each%2 == 0:
        print(member[each], member[each+1])

####### 结果输出 ##########
# 小甲鱼 88
# 黑夜 90
# 迷途 85
# 怡静 90
# 秋舞斜阳 88

# 小甲鱼 88
# 黑夜 90
# 迷途 85
# 怡静 90
# 秋舞斜阳 88

10.编写密码强度验证

#!/usr/bin/python3
#密码验证：强度检查
# 密码安全性检查代码
#
# 低级密码要求：
#   1. 密码由单纯的数字或字母组成
#   2. 密码长度小于等于8位
#
# 中级密码要求：
#   1. 密码必须由数字、字母或特殊字符（仅限：~!@#$%^&*()_=-/,.?<>;:[]{}|\）任意两种组合
#   2. 密码长度不能低于8位
#
# 高级密码要求：
#   1. 密码必须由数字、字母及特殊字符（仅限：~!@#$%^&*()_=-/,.?<>;:[]{}|\）三种组合
#   2. 密码只能由字母开头
#   3. 密码长度不能低于16位

symbols = r'''`!@#$%^&*()_+-=/*{}[]\|'";:/?,.<>'''
chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
nums = '0123456789'

password = input("输入检查的密码:")
length = len(password)

while (password.isspace() or length == 0):
    password = input("您输入的密码为空（或空格），请重新输入：")
    length = len(length)

#判断字符串长度
if length <= 8:
    flag_len = 1
elif length <16:
    flag_len = 2
else:
    flag_len = 3

flag_con = 0
#判断是否包含特殊字符
for each in password:
    if each in symbols:
        flag_con += 1
        break;

#判断是否包含字母
for each in password:
    if each in chars:
        flag_con += 1
        break;

#判断是否包含数字
for each in password:
    if each in nums:
        flag_con += 1
        break;

#结果打印
while 1:
    print("您的密码评级：",end="")
    if flag_len == 1 or flag_con == 1: 
        print("低")
    elif flag_len == 3 and flag_con == 3 and password[0].isalpha():
        print("高")
        break   #这里的break用得精辟
    else:
        print("中")

    print("请按以下方式提升您的密码安全级别：\n\
    \t1. 密码必须由数字、字母及特殊字符三种组合\n\
    \t2. 密码只能由字母开头\n\
    \t3. 密码长度不能低于16位")
    break

########### 结果输出 ##########
# 输入检查的密码:Weiyi2000Geek16!
# 您的密码评级：高

# 输入检查的密码:wwq5678897ae@1
# 您的密码评级：中
# 请按以下方式提升您的密码安全级别：
#         1. 密码必须由数字、字母及特殊字符三种组合
#         2. 密码只能由字母开头
#         3. 密码长度不能低于16位

11.进制转换案例。

#!/usr/bin/python3
#方式1：进制转换
while 1:
    temp = input("请输入一个整数(输入Q退出程序)：")
    if temp == 'Q':
        break
    temp = int(temp)
    print("十进制 -> 十六进制 ： %d -> 0x%x" %(temp,temp))
    print("十进制 -> 八进制 ： %d -> 0o%o" %(temp,temp))
    print("十进制 -> 二进制 ： %d ->" %temp, bin(temp))

#方式2：递归方式 list
listbin = []
def binary(x):
    if x != 1:
        binary(x // 2)
        return listbin.append(x % 2)
    else:
        return listbin.append(1)

value = input("输入一个整形值:")
value = int(value)
binary(value)
for each in listbin:
    print(each,end="")
else:
    print("")

#方式3：更精简的方法 str
def Dec2Bin(dec):
    result = ''
    if dec:
        result = Dec2Bin(dec//2)   
        return result + str(dec%2)  #精辟之处
    else:
        return result   #先记录第一个值

print(Dec2Bin(62))



########### 结果输出 ##########
# 请输入一个整数(输入Q退出程序)：255
# 十进制 -> 十六进制 ： 255 -> 0xff
# 十进制 -> 八进制 ： 255 -> 0o377
# 十进制 -> 二进制 ： 255 -> 0b11111111

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2019-03-19，如有侵权请联系 cloudcommunity@tencent.com 删除

python