学而用之_函数篇

目录

1. 判断给定年份是否为闰年
2. 设计一个验证用户密码程序
3. for循环嵌套运用
4. 一个密码安全性检查的脚本代码
5. 一个简陋的通讯录程序（字典的运用）
6. 一个简陋的用户登录程序(函数基本运用)
7. 三个小递归
8. 函数不定长参数的运用

---

1. 判断给定年份是否为闰年

# 判断给定年份是否为闰年
print(' 请输入一个年份，我可以判断它是否为闰年：',end = " ")
temp = input()
while not temp.isdigit():
    temp = input(" 抱歉，您的输入有误，请输入一个整数： ") 
year = int(temp)
if year%400 == 0:
    print(temp+' 是闰年。')
elif year%4 == 0 and year%100 != 0:
    print(temp+' 是闰年。')
else:
    print(temp+' 不是闰年。')
# 请输入一个年份，我可以判断它是否为闰年： 2020
# 2020 是闰年。

2. 设计一个验证用户密码程序

# 设计一个验证用户密码程序，用户只有三次机会输入错误，
# 不过如果用户输入的内容中包含 "*" 则不计算在内
password = '2a'
print('请输入密码：',end = ' ')
count = 3
while count:
    temp = input()
    if temp == password:
        print('验证通过.')
        break
    elif '*' in temp:
        print('请不要输入包含''*''的内容，您还有',count,'次机会，请重新输入：',end = ' ')
        continue
    else:
        print('输入错误，您还有',count-1,'次机会,请重新输入：',end = ' ')
    count -=1

3. for循环嵌套运用

# 有红、黄、蓝三种颜色的球，其中红球 3 个，黄球 3 个，蓝球 6 个。
# 先将这12 个球混合放在一个盒子中，从中任意摸出 8 个球，编程计算摸出球的各种颜色搭配
print('red','\t','yellow','','blue')
for red in range(0,4):
    for yellow in range(0,4):
        for blue in range(2,7):
            if red+yellow+blue == 8:
                print(red,'\t',yellow,'\t',blue)

4. 一个密码安全性检查的脚本代码

#请写一个密码安全性检查的脚本代码：
symbols = r'''`!@#$%^&*()_+-=/*{}[]\|'";:/?,.<>''' 
chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' 
nums = '0123456789' 

passwd = input(' 请输入需要检查的密码组合： ') 

# 判断长度
length = len(passwd) 

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

if length <= 8: 
    flag_len = 1 
elif 8 < length < 16: 
    flag_len = 2 
else: 
    flag_len = 3 

flag_con = 0 

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

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

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

# 打印结果
while 1 : 
    print(" 您的密码安全级别评定为： ", end='') 
    if flag_len == 1 or flag_con == 1 : 
        print(" 低") 
    elif flag_len == 2 or flag_con == 2 : 
        print(" 中") 
    else : 
        print(" 高") 
        print(" 请继续保持 ") 
        break 

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

5. 一个简陋的通讯录程序（字典的运用）

#一个简陋的通讯录程序
print('''欢迎进入通讯录程序
1 :查询联系人资料
2 :插入新的联系人
3 :删除已有联系人
4 :退出通讯录程序''')
dict1 = {'华': 2247829280，'夏天': 877169862}

while 1:
    temp = int(input('请输入相关的指令代码：'))
    
    if temp == 1:
        name = input('请输入联系人姓名：')
        if name not in dict1:
            print('抱歉，您输入的联系人不存在。',end = '')
            yn_2 = input('请问您是否要将其添加到通信录?(YES/NO)')
            if yn_2 == 'YES':
                temp = 2
            else:
                continue
        else:
            print(name ,'：',dict1[name])
    if temp == 2:
        name = input('请输入联系人姓名：')
        if name in dict1:
            print('您输入的姓名已在通讯录中-->>',name ,'：',dict1[name])
            yn = input('是否修改用户资料？(YES/NO)')
            if yn == 'YES':
#                 向字典中添加键值对的一种方法
                dict1[name] = input('请输入联系人新的电话：')
            else:
                continue
            dict1[name] = input('请输入联系人电话：')
    if temp == 3:
        name = input('请输入需要删除的联系人姓名：')
        if name not in dict1.keys():
            print('您输入的姓名不在通讯录中')
            continue
        dict1.pop(name)
    if temp == 4:
        print('感谢使用通讯录程序!')
        break

6. 一个简陋的用户登录程序(函数基本运用)

#一个简陋的用户登录程序函数
def showmenu():
    # 界面
    print('''新建用户:N/n
登陆账号:E/e
退出程序Q/q''')
    # 初始值
    dict2 = {}

    # 循环初始化instr的值
    while True:
        # 不能为空
        instr = ' '
        # 使用户输入正确指令代码
        while instr not in 'NEQneq':
            instr = input('请输入指令代码:')

        # 三个功能
        if instr in 'Qq':
            break
        if instr in 'Nn':
            new_user(instr,dict2)
        if instr in 'Ee':
            old_user(instr,dict2)

# 新建            
def new_user(instr,dict2):
    name = input('请输入用户名：')

    # 输入是否为已有用户名            
    while name in dict2:
        name = input('抱歉，此用户名已经被使用，请重新输入：')

    dict2[name] = input('请输入密码：')
    print('注册成功，赶紧试试登录吧')
        
# 是否登录 
def old_user(instr,dict2):
    name = input('请输入用户名：')
                
    # 要登陆的用户的用户名是否存在
    while name  not in dict2:
        name = input('您输入的用户名不存在，请重新输入：')
                    
    # 输入的密码是否正确且只有三次机会
    count = 3
    while input('请输入密码(三次机会)：') != dict2.get(name):
        print('密码输入错误!')
        count -= 1
        if count == 0:
            print('抱歉，您的三次机会已用完。')                        
            # 跳出输入密码循环体
            break
    else:
        print('欢迎进入XO系统……')

7. 递归

7.1 求最大公约数

# 求最大公约数
def gcd0(a,b):
    '''递归'''
    t = a % b
    a = b
    b = t
    if b != 0:
        gcd1(a,b)
        return a

def gcd1(a,b):
    '''循环'''
    while b:
        t = a % b
        a = b
        b = t
        return a
print(gcd0(4,6))
print(gcd1(4,6))

7.2 编写一个将十进制转换为二进制的函数

• 编写一个将十进制转换为二进制的函数，要求采用“除 2 取余”的方式且以字符串的形式返回

# 编写一个将十进制转换为二进制的函数，要求采用“除 2 取余”的方式且以字符串的形式返回
def Dec2Bin0(dec): 
    temp = []
    result = ''

    while dec:
        quo = dec % 2
        dec = dec // 2
        temp.append(quo)

    while temp:
        result += str(temp.pop())

    return result
print(Dec2Bin0(7))
# 递归
def Dec2Bin1(dec):
    result = ''

    if dec:

        result = Dec2Bin1(dec//2)

        return result + str(dec%2)
    else:
        return result
print (Dec2Bin1(8))

7.3 回文联

• 判断传入的字符串参数是否为“回文联”

# 方法一，用循环
def huiwen(str1):
    l = len(str1)
    i = 0
    while l//2 != i:
        if str1[i] == str1[l-i-1]:
            i += 1     
        else:
            print('不是回文联!')
            break
    if i == l//2:
        print('是回文联！')
str2 = input('请输入一句话：')
# huiwen(str2)

# 方法二，用reversed
def huiwen2(string):
    list1 = reversed(string)
    if list(list1) == list(string):
        print('是回文联！')
    else:
        print('不是回文联!')
 # huiwen2('上海海上')

# 方法三，递归
def fn2(s):

    # 参数s就是要检查的字符串

    # 1.基线条件
    # 字符串的长度小于2 则字符串一定是个回文
    if len(s)<2:
        return True
    # # 第一个字符和最后一个字符不相同，则一定不是回文字符串
    # elif s[0] != s[-1]:
    #     return False
    # 2.递归条件
    return s[0] == s[-1] and fn2(s[1:-1])

8. 函数不定长参数的运用

# 编写一个函数,分别统计出传入字符串参数(可能不只-个参数)的英文字母、空格、数字和其它字符的个数。
def tongji(*string):
    chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' 
    nums = '0123456789'
    length = len(string)
    for a in range(length):
        i = 0
        j = 0
        k = 0
        l =0
        for each in string[a]:
            if each in nums:
                i += 1
            elif each in chars:
                j += 1
            elif each in ' ':
                k += 1
            else:
                l += 1
        print('第%d个字符串的英文字母，空格，数字，其他字符分别有%d%d%d%d个'%(a+1,j,k,i,l))
tongji('abc','   ','123','[)]')