3.7练习题

小咪咪 2021-10-25 13:32 281阅读 0赞

#!/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 '100003'in 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)
    '''

谢谢欣赏,有问题或者建议请联系我邮箱861257034@qq.com，有道云有代码注释，

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

转载于:https://www.cnblogs.com/bimg1999/p/11144305.html