python—函数基础练习题

1，写函数，计算传入数字参数的和。（动态传参）

#写函数，计算传入数字参数的和。（动态传参）
x = int(input("输入要计算的值x: "))  #定义动态输入的x值
y = int(input("输入要计算的值y: "))  #定义动态输入的y值
 
def calc(x,y):
    result = x+y
    return ("结果是：",result)
a = calc(x,y)
print(a)
# 输入要计算的值x: 123
# 输入要计算的值y: 456
# ('结果是：', 579)

2.写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作

# 2、写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作
import os
 
file_name = "print_tofile.txt"
file_new_name = '%s.new' %file_name
 
old_str = '最近学习不太好'
new_str = '最近学习真不好'
 
f_old = open(file_name,'r',encoding='utf-8')
f_new = open(file_new_name,'w',encoding='utf-8')
 
for line in f_old:
    if old_str in line:
        line = line.replace(old_str,new_str)
        f_new.write(line)
        print(line)
f_old.close()
f_new.close()
os.replace(file_new_name,file_name)

　　

import os
def update_func(a: object, old_str: object, new_str: object) -> object:  #定义三个接受值的形参，a是要修改的文件名，b是要修改的内容，c是修改后的内容
    #打开文件，文件名为接受的形参a
    file_old = 'a.txt'
    file_new = 'aa.txt'
    f_old = open(file_old,'r',encoding='utf-8')
    #打开修改后写入的文件
    f_new = open(file_new,'w',encoding='utf-8')
 
    # old_str = '你是我唯一的爱'
    # new_str = 'you are my everything'
 
    #循环每一行的文件的数据
    for line in f_old:
        new_content = line.replace(old_str,new_str)      #将要修改的内容字符串用replace替换
        f_new.write(new_content)             #将替换后的内容写入修改后写入的文件中
    f_new.close()
    f_old.close()
    os.replace(file_new,file_old)
 
update_func('a.txt','你是我唯一的爱','you are my everything')

　　

修改前的文件内容：

你是我唯一的爱，you are my everything

修改后的文件内容：

you are my everything，you are my everything

　　

3，写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。

def check_str(a):  #a为传过来的参数
    calc = False  #空格统计默认False没有
    for line in a:
        if line.isspace():
            calc = True
    return calc
 
a = '123 132 456 7489 456'
res = check_str(a)
print(res)

　　

def func(strr,listt,tuplee):
    if strr.isspace():
        print("字符串有空内容")
    else:
        print("字符串里面没有空内容")
 
    if len(listt) ==0:
        print("列表有空内容")
    else:
        print("列表里面没有空内容")
 
    if len(tuplee) == 0:
        print("元祖有空内容")
    else:
        print("元组里面没有空内容")
 
res = func('123456',[],())
# 字符串里面没有空内容
# 列表有空内容
# 元祖有空内容

　　

4，写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者

dic = {"k1": "v1v1", "k2": [11,22,33,44]}
PS:字典中的value只能是字符串或列表

　　

# 4，写函数，检查传入字典的每一个value的长度,如果大于2，
        # 那么仅保留前两个长度的内容，并将新内容返回给调用者。
 
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
def check_func(a):  #a为传过来的参数
    li = []
    for item in a.values():
        length = len(item)
        if length >2:
            li.append(item[0:2])
        else:
            continue
    return li
 
a = check_func(dic)
print(a)
# ['v1', [11, 22]]

　　

5，解释闭包的概念

关于闭包，即函数定义和函数表达式位于另一个函数的函数体内（嵌套函数）。
而且这些内部函数可以访问他们所在的外部函数中声明的所有局部变量，参数。
当其中一个这样的内部函数在包含他们的外部函数之外被调用时候，就形成了闭包。
也就是说，内部函数会在外部函数返回后被执行。而当这个内部函数执行的时候，
它仍然必需访问其外部函数的局部变量，参数以及其他内部函数，这些局部变量，
参数声明（最初时）的值是外部函数返回时候的值，但也会受到内部函数的影响。
    闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，
这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

　　

简单的说，闭包就是一个内部函数+外部环境 

6，写函数，计算传入字符串中的【数字】、【字母】、【空格】和【其他】的个数

# 6，写函数，计算传入字符串中的【数字】、【字母】、【空格】和【其他】的个数
def func(strr):
    digit_number = 0
    space_number = 0
    alpha_number = 0
    else_number = 0
    for i in strr:
        if i.isdigit():
            digit_number +=1
        elif i.isspace():
            space_number +=1
        elif i.isalpha():
            alpha_number +=1
        else:
            else_number +=1
    return ("数字，空格，字母，其他内容分别有：",(digit_number,space_number,alpha_number,else_number))
res = func('sda!@#$%^&1234567dfghj da da ')
print(res)
# ('数字，空格，字母，其他内容分别有：', (7, 3, 12, 7))

7.用map来处理字符串列表啊,把列表中所有人都变成sb,比方alex_sb
name=['alex','wupeiqi','yuanhao']

name = ['alex', 'wupeiqi', 'yuanhao']
f = map(lambda name_f: name_f+"_sb", name)
print(list(f))

　　

8.用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾
>>> l=[{'name':'alex'},{'name':'y'}]

l = [{'name': 'alex'}, {'name': 'y'}]
f = map(lambda dic: dic["name"]+"_sb", l)
print(list(f))

　　

9.用filter来处理,得到股票价格大于20的股票名字

shares={
    "IBM":36.6,
    "Lenovo":23.2,
    "oldboy":21.2,
    "ocean":10.2,
}
 
g=filter(lambda k:shares[k]>20,shares)
for i in g:
    print(i)

　　

10.如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格
portfolio = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'HPQ', 'shares': 35, 'price': 31.75},
    {'name': 'YHOO', 'shares': 45, 'price': 16.35},
    {'name': 'ACME', 'shares': 75, 'price': 115.65}
]

portfolio = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'HPQ', 'shares': 35, 'price': 31.75},
    {'name': 'YHOO', 'shares': 45, 'price': 16.35},
    {'name': 'ACME', 'shares': 75, 'price': 115.65}
]
# 1.:map来得出一个包含数字的迭代器，数字指的是：购买每支股票的总价格
f=map(lambda dic:dic["price"]*dic["shares"],portfolio)
print(f)
# 2.基于1的结果，用reduce来计算，购买这些股票总共花了多少钱.
f=map(lambda dic:dic["price"]*dic["shares"],portfolio)
l=list(f)
from functools import reduce
sum_portfolio=reduce(lambda x,y:x+y,l)
print(sum_portfolio)
# 3：用filter过滤出，单价大于100的股票有哪些
portfolio_list=filter(lambda dic:dic["price"]>100,portfolio)
print(list(portfolio_list))

　　

　

11.修改个人信息程序：

在一个文件里存多个人的个人信息，如以下

1.输入用户名密码，正确后登录系统 ，打印

2.每个选项写一个方法

3.登录时输错3次退出程序

import json
user_info = [
                {'alex': {'name': 'alex', 'password': 'abc123', 'age': 21, 'position': 'Engineer', 'department': 'IT'},
                'rain': {'name': 'rain', 'password': 'df2@432', 'age': 25, 'position': 'Teacher', 'department': 'Teching'},
    'shanshan': {'name': 'shanshan', 'password': 'zzg521', 'age': 22, 'position': 'student', 'department': 'IT'}}
]
f = open('saa.json', 'w')
json.dump(user_info, f)
f.close()


def print_info():  # 自定义变量，打印需求
    print('%s . 打印个人信息' % 1)
    print('%s . 修改个人信息' % 2)
    print('提示 ： 按 q 退出, 输入序号满足要求 .')


def personal_info():  # 打印个人信息
    file = open('saa.json', 'r')
    data = json.load(file)
    for index, i in enumerate(data[0][user_name]):
        print('     %s . %s :  %s' % (index + 1, i, data[0][user_name][i]))
    print('     '.ljust(30, '-'))
    f.close()


def change_info():  # 修改个人信息
    file = open('saa.json', 'r')
    data = json.load(file)
    print('person_data : ', data[0][user_name])
    for index, i in enumerate(data[0][user_name]):
        print('%s . %s :  %s' % (index + 1, i, data[0][user_name][i]))
    select = input('[select column id to change]>> : ')
    if select in data[0][user_name]:
            print('current value>> : ', data[0][user_name][select])
            new_value = input('new value>> : ')
            data[0][user_name][select] = new_value
            f = open('saa.json', 'w')
            json.dump(data, f)
            print(data[0][user_name])
            f.close()
    else:
        print('你的选择不存在！')


count = 0
while count < 3:  # 进行用户登录，并循环3次
    user_name = input('用户名 : ').strip()
    key = input('密码 ： ').strip()
    if user_name in user_info[0]:
        if key == user_info[0][user_name]['password']:
            print(('欢迎，%s' % user_name). center(30, '-'))
            print_info()
            while True:
                num = input('>>>:').strip()
                if num.isdigit():
                    num = int(num)
                    if num == 1:
                        print('     '.ljust(30, '-'))
                        personal_info()
                        print_info()
                        continue
                    elif num == 2:
                        change_info()
                        print_info()
                        continue
                    else:
                        print('请重新选择！')
                elif num == '':
                    print('不能为空..')
                elif num == 'q':
                    exit()
                else:
                    print('请重新选择！')
                    break
        else:
            print('登陆失败，还可以登陆%s次' % (2-count))
        count += 1
    else:
        print('登陆失败，还可以登陆%s次' % (2 - count))
        count += 1
        print('用户名不存在！')
        pass
else:
    exit('对不起，退出登录')