3.7练习题

Posted bimg1999

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了3.7练习题相关的知识,希望对你有一定的参考价值。

#!/usr/bin/env python 
# -*- coding:utf-8 -*-
# date: 2019/6/30 9:55
# Author: 炳畅



# 请说明python2 与python3中的默认编码是什么?
‘‘‘
PYTHON2是A1SC码,python是utf-8
‘‘‘


# 为什么会出现中文乱码?你能列举出现乱码的情况有哪几种?
‘‘‘
解码和编码的格式不一样,一共有四种情况,中国windows是GBK的,linux和苹果都是utf-8
标准答案
.py文件是什么编码就需要告诉python用什么编码去读取这个.py文件。
sys.stdout(标准输出).encoding(编码),默认就是locale的编码,print会用sys.stdout.encoding去encode(编码)成字节流,
交给terminal(终端)显示。所以locale(开始)需要与terminal(结束)一致,才能正确print打印出中文。
sys.setdefault encoding(‘utf8’),用于指定str.encode(编码) str.decode(解码)的默认编码,默认是ascii。
以下几种(local 为软件运行时的语言环境):
终端为UTF-8,locale为zh_CN.GBK
终端为UTF-8,locale为zh_CN.UTF-8
终端为GBK,locale为zh_CN.GBK
终端为GBK,locale为zh_CN.UTF-8
‘‘‘


# 如何进行编码转换?
‘‘‘
字符串在python3内部中是采用unicode的编码方式,
所以其他语言先decode(解码)转换成unicode编码,
再encode(编码)转换成utf8编码。
‘‘‘

# -*-coding:utf-8-*- 的作用是什么?
‘‘‘
开头指明白这个是用utf-8编码的
‘‘‘


# 解释py2 bytes vs py3 bytes的区别
‘‘‘
pythn2是先把字符串转换成bytes(二进制类型)类型
Python3中所有的字符类型都是unicode(万国码)
string(字符串) -> encode(解码) -> bytes(二进制)
bytes(二进制) -> decode(编码) -> string(字符串)

‘‘‘


# r和rb的区别是什么
‘‘‘
r 只读
rb 二进制的方式读文件
‘‘‘


# 解释一下以下三个参数的分别作用
open(f_name,r,encoding="utf-8")
‘‘‘
open打开或者创建
f_name 文件名,自定义
r 只读
encoding = 自定编码方式

‘‘‘


# 函数基础:
# 写函数,计算传入数字参数的和。(动态传参)

def ji(a,x):
    return a + x
print(ji(2,1))


# 写函数,用户传入修改的文件名,与要修改的内容,执行函数,完成整个文件的批量修改操作
def han(s):  # 传入要修改的数值
    a = []
    for i in s:
        b = i.capitalize()  # 把大写的转换成小写
        a.append(b)
    print(a)


s = ["2019-06-20 09:51:36,787 - meanwhile - ERROR - account[1234] too 中文"]

han(s)

 


# 写函数,检查用户传入的对象(字符串、列表、元组)的每一个元素是否含有空内容。
def file(x):
    a = 0
    for i in x:
        if i == " ":
            a += 1
    print(a)

s = "2019-06-20 09:51:36,787 - meanwhile - ERROR - account[1234] too 中文"
file(s)

# 写函数,检查传入字典的每一个value(值)的长度,如果大于2,
# 那么仅保留前两个长度的内容,并将新内容返回给调用者。
dic = "k1": "v1v1", "k2": [11, 22, 33, 44]
# PS:字典中的value只能是字符串或列表
def file(x):
    for i, o in x.items():
        if len(o) > 2 :
            dic[i] = o[:2]
        else:
            continue
    return x
print(file(dic))

 


# 解释闭包的概念
‘‘‘
由于上一层的作用域没有释放,返回的函数对象包含了一个作用域,导致该函数,不管在哪里调用,都优先使用包含的作用域
官方答案
闭包(closure)是函数式编程的重要的语法结构。
函数式编程是一种编程范式 (而面向过程编程和面向对象编程也都是编程范式)。
在面向过程编程中,我们见到过函数(function);
在面向对象编程中,我们见过对象(object)。
函数和对象的根本目的是以某种逻辑方式组织代码,
并提高代码的可重复使用性(reusability)。
闭包也是一种组织代码的结构,它同样提高了代码的可重复使用性。
‘‘‘


# 函数进阶:
# 写函数,返回一个扑克牌列表,里面有52项,每一项是一个元组
# 例如:[(‘红心’,2),(‘草花’,2), …(‘黑桃A’)]
def file():
    num = []
    for i in range(2, 12):
        num.append(i)
    num.extend([J, Q, K, A])
    type = [红心, 草花, 方块, 黑桃]
    t = []
    for i in num:
        for e in type:
            t.append((e,i))
    return t
print(file())

 


# 写函数,传入n个数,返回字典‘max’:最大值,’min’:最小值
# 例如:min_max(2,5,7,8,4)
# 返回:‘max’:8,’min’:2
def han(*ages):
    max_1 = ages[0]
    min_1 = ages[0]
    for i in ages :
        if i > max_1:
            max_1 = i
        elif i < min_1:
            min_1 = i
    return "max":max_1,"min":min_1
print(han(2,5,7,8,4))

 


# 写函数,专门计算图形的面积
#
# 其中嵌套函数,计算圆的面积,正方形的面积和长方形的面积
#
# 调用函数area(‘圆形’,圆半径) 返回圆的面积
# 调用函数area(‘正方形’,边长) 返回正方形的面积
# 调用函数area(‘长方形’,长,宽) 返回长方形的面积
# def area():
# def 计算长方形面积():
# pass
#
# def 计算正方形面积():
# pass
#
# def 计算圆形面积():
# pass
import math
print(
        请按照如下格式输出:
      调用函数area(‘圆形’,圆半径) 返回圆的面积
      调用函数area(‘正方形’,边长) 返回正方形的面积
      调用函数area(‘长方形’,长,宽) 返回长方形的面积
    )
def area(name,*ages):
    def areas(x,y):
        return ("该长方形的面积为",x*y)
    def aread(z):
        return ("该正方形的面积为:",z**2)
    def areaf(r):
        return ("该圆的面积:",math.pi*r*r)
    if name == 长方形:
        return areas(*ages)
    elif name == 正方形:
        return aread(*ages)
    elif name == 圆形:
        return areaf(*ages)
    else:
        return ("格式不正确,请重新输入")
print(area(长方形, 34, 34))
print(area(圆形, 3423))
print(area(正方形, 1243))
print(area(正z形, 12313))

 



# 写函数,传入一个参数n,返回n的阶乘
# 例如:cal(7)
# 计算7*6*5*4*3*2*1
def cal(n):
    a = []
    c = 1
    while int(n)>0:
        a.append(n)
        n -= 1
    if int(n) == 0:
        for i in a:
            c = c *i
            print(c)
cal(45)

# 答案2
def cal(n):
   res= 1
   for i in range(n,0,-1):
       # print(i)
       res = res*i
       print(res)
   return res

print(cal(7))


# 编写装饰器,为多个函数加上认证的功能(用户的账号密码来源于文件),
# 要求登录成功一次,后续的函数都无需再输入用户名和密码
# 答案
import json
def login(func):
    def file():
        name = input("name>>>:").strip()
        password = input("password>>>:").strip()
        a = True
        if a:
            with open(userinfo.txt, r, encoding=utf-8)as f:
                userinfo = json.load(f)
                if name == userinfo[name] and password == userinfo[password]:
                    print("success")
                    a = False
                    func()
                else:
                    print("输入错误!!")
        else:
            func()

    return file


@login
def name():
    print("hello")

name()

 




# 生成器和迭代器的区别?

‘‘‘
迭代器里面包含生成器
官方答案:
对于list(列表)、string(字符串)、tuple(元祖)、dict(字典)等这些容器对象,使用for循环遍历是很方便的。
在后台for语句对容器对象调用iter()函数。iter()是python内置函数。
iter()函数会返回一个定义了 next()方法的迭代器对象,它在容器中逐个访问容器内的
元素。next()也是python内置函数。在没有后续元素时,next()会抛出
一个StopIteration异常,通知for语句循环结束。
迭代器是用来帮助我们记录每次迭代访问到的位置,当我们对迭代器使用next()函数的
时候,迭代器会向我们返回它所记录位置的下一个位置的数据。实际上,在使用next()函数
的时候,调用的就是迭代器对象的_next_方法(Python3中是对象的_next_方法,
Python2中是对象的next()方法)。所以,我们要想构造一个迭代器,
就要实现它的_next_方法。但这还不够,python要求迭代器本身也是可迭代的,
所以我们还要为迭代器实现_iter_方法,而_iter_方法要返回一个迭代器,
迭代器自身正是一个迭代器,所以迭代器的_iter_方法返回自身self即可
‘‘‘


# 生成器有几种方式获取value(值)?
‘‘‘
有next和for循环的方式
‘‘‘


# 通过生成器写一个日志调用方法, 支持以下功能
‘‘‘
根据指令向屏幕输出日志
根据指令向文件输出日志
根据指令同时向文件&屏幕输出日志
以上日志格式如下
2017-10-19 22:07:38 [1] test log db backup 3
2017-10-19 22:07:40 [2] user alex login success
#注意:其中[1],[2]是指自日志方法第几次调用,每调用一次输出一条日志
代码结构如下
def logger(filename,channel=‘file‘):
"""
日志方法
:param filename: log filename
:param channel: 输出的目的地,屏幕(terminal),文件(file),屏幕+文件(both)
:return:
"""
...your code...
#调用
log_obj = logger(filename="web.log",channel=‘both‘)
log_obj.__next__()
log_obj.send(‘user alex login success‘)
import logging

#
# def logger(filenamea, channel=‘file‘):
#     # logger = logging.getLogger()
#     # logger.setLevel(logging.DEBUG)
#     # fh = logging.FileHandler(filename)
#     # logger.addHandler(fh)
#     # file_formatter = logging.Formatter("%(asctime)s  - %(message)s")
#     # fh.setFormatter(file_formatter)
#     qw = 1
#     a2w = yield
#     if channel == ‘terminal‘:
#         logging.error(qw, a2w)
#     elif channel == ‘file‘:
#         logging.basicConfig(filename=filenamea, level=logging.DEBUG)
#         logging.error(qw, a2w)
#     elif channel == ‘both‘:
#         # logger.error(a,a2)
#         logging.error(qw, a2w)
#     else:
#         print("格式不正确")
#     qw += 1
#
#
# log_obj = logger(filenamea="web.log", channel=‘terminal‘)
# log_obj.__next__()
# log_obj.send(‘user alex login success‘)
def logger(filenamea, channel=‘file‘):
    qw = 1
    logger = logging.getLogger()
    logger.setLevel(logging.DEBUG)

    if channel == ‘terminal‘:
        while True:
            a2w = yield
            a3 = str([qw]) + a2w
            logging.log(logging.DEBUG, a3)
            qw += 1
    elif channel == ‘file‘:
        # logging.basicConfig(filename=filenamea, level=logging.DEBUG)
        fh = logging.FileHandler(filenamea)
        file_formatter = logging.Formatter("%(asctime)s - %(message)s")
        fh.setFormatter(file_formatter)
        logger.addHandler(fh)
        while True:
            a2w = yield
            a3 = str([qw]) + a2w
            logging.error(a3)
            qw += 1
    elif channel == ‘both‘:
        fh = logging.FileHandler(filenamea)
        ch = logging.StreamHandler()
        logger.addHandler(fh)
        logger.addHandler(ch)
        file_formatter = logging.Formatter("%(asctime)s  - %(message)s")
        com = logging.Formatter("%(asctime)s  - %(message)s")
        ch.setFormatter(com)
        fh.setFormatter(file_formatter)
        while True:
            a2w = yield
            a3 = str([qw]) + a2w
            logging.error(a3)
            qw += 1

    else:
        print("格式不正确")




log_obj = logger(filenamea="web.log", channel=‘both‘)
#log_obj = logger(filenamea="web.log", channel=‘file‘)
log_obj.__next__()
log_obj.send(‘user alex login success‘)
log_obj.send(‘user alex login success‘)
log_obj.send(‘user alex login success‘)
log_obj.send(‘user alex login success‘)
log_obj.send(‘user alex login success‘)

 




# 用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
name=[alex,wupeiqi,yuanhao,nezha]
a = map(lambda x :x+_sb , name )
for i in a:
    print(i)

# 官方答案
# map()函数
# map()是 Python 内置的高阶函数,它接收一个函数 f 和一个 list,并通过把
# 函数 f 依次作用在 list 的每个元素上,得到一个新的 list 并返回。
#
#   注意:map()函数在不改变原有的lisy,而是返回一个新的list
# 代码:
name=[alex,wupeiqi,yuanhao,nezha]
a = map(lambda x :x+_sb , name )
for i in a:
    print(i)


# 用filter函数处理数字列表,将列表中所有的偶数筛选出来
num = [1,3,5,6,7,8]
a = filter(lambda x : x%2 == 0,num)
for i in a:
    print(i)


# 标准答案
num = [1,3,5,6,7,8]
def func(x):
   if x%2 == 0:
       return True

ret = filter(func,num)
print(list(ret))



# 如下,每个小字典的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
]
# 计算购买每支股票的总价

for i in portfolio:
    a = int(i["shares"]) * int(i["price"])
    print(i[name], "的总价为", a)

# 用filter过滤出,单价大于100的股票有哪些
f = filter(lambda d: d[price] >= 100, portfolio)
print(list(f))


# 请分别介绍文件操作中不同的打开方式之间的区别:
‘‘‘
模式 含义
r 文本只读模式
rb 二进制模式 这种方法是用来传输或存储,不给人看的
r+ 读写模式,只要有r,那么文件必须存在
rb+ 二进制读写模式
w 只写模式,不能读,用w模式打开一个已经存在的文件,如果有内容会清空,重新写
wb 以二进制方式打开,只能写文件,如果不存在,则创建
w+ 读写模式,先读后写,只要有w,会清空原来的文件内容
wb+ 二进制写读模式
a 追加模式,也能写,在文件的末尾添加内容
ab 二进制追加模式
a+ 追加模式,如果文件不存在,则创建文件,如果存在,则在末尾追加
ab+ 追读写二进制模式,从文件顶部读取文件,从文件底部添加内容,不存在则创建



# 2、有列表 li = [‘alex‘, ‘egon‘, ‘smith‘, ‘pizza‘, ‘alen‘], 请将以字母“a”开头的元素的首字母改为大写字母;
li = [alex, egon, smith, pizza, alen]
li_w = []
for i in li:
    if i.startswith("a"):
        li_w.append(i.capitalize())
    else:
        li_w.append(i)
print(li_w)

for i in range(len(li)):
    if li[i][0] == "a":
        li[i] = li[i].capitalize()
    else:
        continue
print(li)



# 有如下程序, 请给出两次调用show_num函数的执行结果,并说明为什么:
num = 20
def show_num(x=num):
    print(x)
show_num()
num = 30

# 答
‘‘‘
是20,因为在函数的X是默认参数
如果函数收到的是一个不可变对象(比如数字、字符或者元组)的引用,
就不能直接修改原始对象,
相当于通过“传值’来传递对象,
此时如果想改变这些变量的值,
可以将这些变量申明为全局变量。


# 有列表 li = [‘alex‘, ‘egon‘, ‘smith‘, ‘pizza‘, ‘alen‘], 请以列表中每个元素的第二个字母倒序排序;

# 答案
li = [alex, egon, smith, pizza, alen]
print(sorted(li, key=lambda x: x[1], reverse=True))
sorted(iterable[, cmp[, key[, reverse]]]),排序语法
参数说明:

iterable -- 可迭代对象。
cmp -- 比较的函数,这个具有两个参数,参数的值都是从可迭代对象中取出,此函数必须遵守的规则为,大于则返回1,小于则返回-1,等于则返回0。
key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则,reverse = True 降序 , reverse = False 升序(默认)。
‘‘‘


# 有名为poetry.txt的文件,其内容如下,请删除第三行;
#
# 昔人已乘黄鹤去,此地空余黄鹤楼。
# 黄鹤一去不复返,白云千载空悠悠。
# 晴川历历汉阳树,芳草萋萋鹦鹉洲。
# 日暮乡关何处是?烟波江上使人愁。
import os

p = ‘poetry.txt‘
file = open(p,‘r‘,encoding=‘utf-8‘)
pnew = ‘%s.new‘%p
filenew = open(pnew,‘w‘,encoding=‘utf-8‘)
x = ‘晴川历历汉阳树,芳草萋萋鹦鹉洲。‘
for i in file:
    if x in i:
        i = ‘‘
        filenew.write(i)
    else:
        filenew.write(i)
file.close()
filenew.close()
os.replace(pnew,p)

# 逐行读取文件

f1 = open(‘poetry.txt‘, ‘r‘,encoding=‘utf-8‘)
str=‘晴川历历汉阳树,芳草萋萋鹦鹉洲。‘
with open(‘poetry1.txt‘, ‘w‘,encoding=‘utf-8‘)as f2:
    f3 = ‘poetry.txt‘
    f4 = ‘poetry1.txt‘
    for l in f1:
        if str in l:
            l = ‘‘
            f2.write(l)
        else:
            f2.write(l)

f1.close()
f2.close()
os.replace(f4,f3)


# 6、有名为username.txt的文件,其内容格式如下,写一个程序,判断该文件中是否存在"alex",
# 如果没有,则将字符串"alex"添加到该文件末尾,否则提示用户该用户已存在;
# pizza
# alex
# egon
with open(username.txt,r+,encoding=utf-8) as f:
    str = alex
    i = f.read()
    if str in i:
        print("该用户已存在")
    else:
        f.write(\nalex)



# 7、有名为user_info.txt的文件,其内容格式如下,写一个程序,删除id为100003的行;
‘‘‘
# pizza, 100001
# alex, 100002
# egon, 100003
a = user_info.txt
b = user_info1.txt
with open(a, r, encoding=utf-8) as f:
    with open(b, w, encoding=utf-8) as f2:
        for i in f:
            if 100003in i:
                pass
            else:
                f2.write(i)

os.replace(b,a)

 




# 有名为user_info.txt的文件,其内容格式如下,写一个程序,
# 将id为100002的用户名修改为alex li
file = user_info.txt
old_str = 100002
new_str = alex li, 100002
file_data = ‘‘
with open(file, r, encoding=utf-8) as f1:
    for line in f1:
        if old_str in line:
            line = new_str
        file_data += line
        with open(file,w,encoding=utf-8)as f1:
            f1.write(file_data)


9、写一个计算每个程序执行时间的装饰器;
import time
def timer(func):
    def x(*ages):
        s_time = time.time()
        func(*ages)
        t_time = time.time
        print(s_time,t_time)
    return x

@timer
def a():
    print("执行结算!")

a()

 


# lambda是什么?请说说你曾在什么场景下使用lambda?
‘‘‘
# 答案
lambda函数就是可以接受任意多个参数(包括可选参数)并且返回单个表达式值得函数
好处:
1.lambda函数比较轻便,即用即扔,适合完成只在一处使用的简单功能
2.匿名函数,一般用来给filter,map这样的函数式编程服务
3.作为回调函数,传递给某些应用,比如消息处理
‘‘‘


# 11、题目:写一个摇骰子游戏,要求用户压大小,赔率一赔一。
#
# 要求:三个骰子,摇大小,每次打印摇骰子数。
import random

def roll_a(numbers=3, points=None):
    print("游戏开始")
    if points is None:
        points = []
    while numbers > 0:
        point = random.randrange(1, 7)
        points.append(point)
        numbers -= 1
    return points
def roll_r(total):
    is_b = 11 <= total <= 18
    is_s = 3 <= total <= 10

    if is_b:
        return "b"
    elif is_s:
        return "s"
def start_game():
    your_money = 1000
    while your_money > 0:
        print(----- 游戏开始 -----)
        choices = ["", ""]
        your_choice = input("请下注, 大 or 小")
        your_bet = input("下注金额:")
        if your_choice in choices:
            points = roll_a()
            total = sum(points)
            you_win = your_choice == roll_r(total)
            if you_win:
                your_money = your_money + int(your_bet)
                print("骰子点数", points)
                print("恭喜, 你赢了%s元, 你现在的本金%s 元" % (your_bet, your_money + int(your_bet)))
            else:
                your_money = your_money - int(your_bet)
                print("骰子点数", points)
                print("很遗憾, 你输了%s元, 你现在的本金%s 元" % (your_bet, your_money - int(your_bet)))
        else:
            print(格式有误,请重新输入)
    else:
        print("game over")

start_game()

 





‘‘‘
# 请使用列表生成式将列表li = [1, 2, 3, 4, 5, 6, 7, 8, 9]中的每一个元素乘以2
# li = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# def lb():
# while True:
# m = yield
# print(m + 2)
# a = lb()
# a.__next__()
# for i in li :
# a.send(i)

#
# li = [1, 2, 3, 4, 5, 6, 7, 8, 9]
#
#
# def lb():
# c = 0
# while True:
# m = yield c
# c = m + 2
#
#
# a = lb()
# a.__next__()
# for i in li:
# r = a.send(i)
# print(r)
‘‘‘

谢谢欣赏,有问题或者建议请联系我邮箱[email protected],有道云有代码注释,

有道云链接:http://note.youdao.com/noteshare?id=f05692f283b0e25557a3a9116c64b154&sub=54E2674777384F39AF941BDB91F800E4

以上是关于3.7练习题的主要内容,如果未能解决你的问题,请参考以下文章

挑战练习3.7 禁止一题多答

习题3.7三角形的知识5

MySQL 查询练习

MySQL 查询练习

练习3.73.83.93.11

2018-2019 20165227《信息安全系统设计基础》第三周学习总结