Python技巧----函数作为参数以及dict代替if

最新推荐文章于 2022-12-20 17:59:21 发布
最新推荐文章于 2022-12-20 17:59:21 发布
阅读量341 收藏 1
点赞数
分类专栏： Python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzgdavid/article/details/84623319
版权

这是tkinter的代码，command参数表示按钮对应的动作，这个参数是个函数

# 操作符按钮
self.btn_add = tk.Button(self.tkwindow, text='+', command=self.command_add)
self.btn_add.pack(padx=1, side='left')

self.btn_minus = tk.Button(self.tkwindow, text='-', command=self.command_minus)
self.btn_minus.pack(padx=1, side='left')
        
self.btn_multiply = tk.Button(self.tkwindow, text='*', command=self.command_multipy)
self.btn_multiply.pack(padx=1, side='left')

self.btn_divide = tk.Button(self.tkwindow, text='/', command=self.command_divide)
self.btn_divide.pack(padx=1, side='left')

'''
省略
'''

    def command_add(self):
        if self.op_can_use:
            self.op_now = '+'
            self.op_pressed = True

    def command_minus(self):
        if self.op_can_use:
            self.op_now = '-'
            self.op_pressed = True

    def command_multipy(self):
        if self.op_can_use:
            self.op_now = '*'
            self.op_pressed = True

    def command_divide(self):
        if self.op_can_use:
            self.op_now = '/'
            self.op_pressed = True

 

但这4个command的函数几乎长得一模一样啊，有四个还好，如果有十几个怎么办，能不能精简点

    def command_op(self, op):
        if self.op_can_use:
            self.op_now = op
            self.op_pressed = True

    def command_add(self):
        return self.command_op('+')
    def command_minus(self):
        return self.command_op('-')
    def command_multipy(self):
        return self.command_op('*')
    def command_divide(self):
        return self.command_op('/')

 

 

和dict配合使用

self.opdict = {'+': add, '-': minus, '*': multiply, '/': divide}


#这是调用，根据op_now选择对应的函数，代替if判断
self.opnum = self.opdict[self.op_now](self.opnum, self.num_temp)[0]

 

 

 

全部代码，计算24点，用tkinter做了界面，两个文件一个界面，一个计算24点的函数

# enconding:utf-8
# file point24/gui

import tkinter as tk
import random
from point24.bk import cal_24point, add, minus, multiply, divide

class Window:
    def __init__(self, title='24点', width=650, height=400):

        self.w = width
        self.h = height
        self.tkwindow = tk.Tk(className=title)
        self.opdict = {'+': add, '-': minus, '*': multiply, '/': divide}
        self.init_status()
        self.add_compnent()

    def init_status(self):


        self.op_pressed = False
        self.op_now = ''
        self.opnum = 0
        self.num_temp = 0
        self.num_count = 0
        self.op_can_use = False
        self.btn_num_temp_used = False

    def fournumber(self):
        TEN_OR_K = 10
        self.num1 = random.randint(1, TEN_OR_K)
        self.num2 = random.randint(1, TEN_OR_K)
        self.num3 = random.randint(1, TEN_OR_K)
        self.num4 = random.randint(1, TEN_OR_K)

    def add_compnent(self):
        B_WIDTH = 6
        B_HEIGHT = 5

        self.label_ans = tk.Label(text="answer", fg="black", bg="white")
        self.label_ans.pack()

        # 数字按钮
        self.fournumber()
        self.btn_num1 = tk.Button(self.tkwindow, text=self.num1, 
                                  command=self.command_num1,
                                  width=B_WIDTH, height=B_HEIGHT,relief='groove')
        self.btn_num1.pack(side='left')

        self.btn_num2 = tk.Button(self.tkwindow, text=self.num2,
                                  command=self.command_num2,
                                  width=B_WIDTH, height=B_HEIGHT,relief='groove')
        self.btn_num2.pack(side='left')

        self.btn_num3 = tk.Button(self.tkwindow, text=self.num3,
                                  command=self.command_num3,
                                  width=B_WIDTH, height=B_HEIGHT,relief='groove')
        self.btn_num3.pack(side='left')
        
        self.btn_num4 = tk.Button(self.tkwindow, text=self.num4, 
                                  command=self.command_num4,
                                  width=B_WIDTH, height=B_HEIGHT,relief='groove')
        self.btn_num4.pack(side='left')

        self.btn_num_temp = tk.Button(self.tkwindow, text=self.num_temp, 
                                      command=self.command_num_temp,
                                  width=B_WIDTH, height=B_HEIGHT,relief='groove')
        self.btn_num_temp.pack(side='bottom')

        # 操作符按钮
        self.btn_add = tk.Button(self.tkwindow, text='+', 
                                 command=self.command_add,
                                 width=B_WIDTH, height=B_HEIGHT,relief='groove')
        self.btn_add.pack(padx=1, side='left')

        self.btn_minus = tk.Button(self.tkwindow, text='-', 
                                   command=self.command_minus,
                                   width=B_WIDTH, height=B_HEIGHT,relief='groove')
        self.btn_minus.pack(padx=1, side='left')
        
        self.btn_multiply = tk.Button(self.tkwindow, text='*', 
                                      command=self.command_multipy,
                                      width=B_WIDTH, height=B_HEIGHT,relief='groove')
        self.btn_multiply.pack(padx=1, side='left')

        self.btn_divide = tk.Button(self.tkwindow, text='/', 
                                    command=self.command_divide,
                                    width=B_WIDTH, height=B_HEIGHT,relief='groove')
        self.btn_divide.pack(padx=1, side='left')

        # 功能按钮
        self.btn_change = tk.Button(self.tkwindow, text='换一组', 
                                    command=self.command_change,
                                    width=B_WIDTH, height=B_HEIGHT,relief='groove')
        self.btn_change.pack(padx=1, side='right')

        self.btn_answer = tk.Button(self.tkwindow, text='显示答案', 
                                    command=self.command_answer,
                                 width=B_WIDTH, height=B_HEIGHT,relief='groove')
        self.btn_answer.pack(padx=1, side='right')

        self.btn_clear = tk.Button(self.tkwindow, text='清除', 
                                   command=self.command_clear,
                                 width=B_WIDTH, height=B_HEIGHT,relief='groove')
        self.btn_clear.pack(padx=1, side='right')

    # 一个数字只能按一次，按错了用clear重来
    def command_clear(self):
        self.btn_num1['state'] = 'active'
        self.btn_num2['state'] = 'active'
        self.btn_num3['state'] = 'active'
        self.btn_num4['state'] = 'active'
        self.btn_num_temp['state'] = 'active'
        self.btn_num_temp['text'] = '0'
        self.label_ans['text'] = 'answer'
        self.init_status()

    def command_answer(self):
        ans = cal_24point(self.num1, self.num2, self.num3, self.num4)
        self.label_ans['text'] = str(ans)

    def command_change(self):
        self.fournumber()
        self.btn_num1['text'] = self.num1
        self.btn_num2['text'] = self.num2
        self.btn_num3['text'] = self.num3
        self.btn_num4['text'] = self.num4
        self.command_clear()

    def command_op(self, op):
        if self.op_can_use:
            self.op_now = op
            self.op_pressed = True

    def command_add(self):
        return self.command_op('+')

    def command_minus(self):
        return self.command_op('-')

    def command_multipy(self):
        return self.command_op('*')

    def command_divide(self):
        return self.command_op('/')    

    def command_num_temp(self):
        if self.op_pressed:
            self.opnum = self.opdict[self.op_now](self.opnum, self.num_temp)[0]
            self.btn_num_temp['text'] = self.opnum
            self.num_temp = self.opnum
        else:
            self.opnum = self.num_temp
        print(self.opnum)
        self.op_pressed = False
        self.btn_num_temp['state'] = 'disabled'

        if self.opnum == 24:
            self.label_ans['text'] = 'right'

    def command_numwhich(self, num, btn_num):
        if self.op_pressed:
            self.opnum = self.opdict[self.op_now](self.opnum, num)[0]
            if not self.btn_num_temp_used:
                self.btn_num_temp['text'] = self.opnum
                self.num_temp = self.opnum
                self.btn_num_temp_used = True
        else:
            self.opnum = num
        print(self.opnum)
        self.op_pressed = False
        btn_num['state'] = 'disabled'
        self.op_can_use = True
        self.num_count += 1
        if self.opnum == 24 and self.num_count ==4:
            self.label_ans['text'] = 'right' 

    def command_num1(self):
        return self.command_numwhich(self.num1, self.btn_num1)

    def command_num2(self):
        return self.command_numwhich(self.num2, self.btn_num2)

    def command_num3(self):
        return self.command_numwhich(self.num3, self.btn_num3)

    def command_num4(self):
        return self.command_numwhich(self.num4, self.btn_num4)

    def center(self):
        ws = self.tkwindow.winfo_screenwidth()
        hs = self.tkwindow.winfo_screenheight()
        x = int((ws/2)-(self.w/2))
        y = int((hs/2)-(self.h/2))
        self.tkwindow.geometry('{}x{}+{}+{}'.format(self.w, self.h, x, y))

    def loop(self):
        self.tkwindow.resizable(False, False)
        self.center()
        self.tkwindow.mainloop()

# ##############################run##################################
w = Window()
w.loop()

 

 

 

# encoding:utf-8
# file point24/bk

import itertools
import random

def add(a, b):
    return a+b, str(a)+'+'+str(b)+'='+str(a+b)

def minus(a, b):
    # 打印答案时不要有负数
    if a<b:
        return 9999, 'no'
    return a-b, str(a)+'-'+str(b)+'='+str(a-b)

def multiply(a, b):
    return a*b, str(a)+'*'+str(b)+'='+str(a*b)

def divide(a, b):
    if b == 0:
        return 9999, 'no'
    return a/b, str(a)+'/'+str(b)+'='+str(a/b)


def cal_24point(a, b, c, d):
    # a, b, c, d的排列组合
    permutation_list = list(itertools.permutations([a, b, c, d], 4))  
    # 加减乘除 排列组合
    op_list = list(itertools.permutations([add, minus, multiply, divide], 4))  
    
    # pro1 到 pro5包装函数
    # ((a, b), c), d
    def pro1(op1, op2, op3):
        m = op1(pmt[0], pmt[1])
        n = op2(m[0], pmt[2])
        result = op3(n[0], pmt[3])
        if result[0] == 24:
            #print(m[1], n[1], result[1])
            return (m[1], n[1], result[1])
    
    # (c, (a, b)), d    
    def pro2(op1, op2, op3):
        m = op1(pmt[0], pmt[1])
        n = op2(pmt[2] , m[0])
        result = op3(n[0], pmt[3])
        if result[0] == 24:
            #print(m[1], n[1], result[1])
            return (m[1], n[1], result[1])

    # d, ((a, b), c)
    def pro3(op1, op2, op3):
        m = op1(pmt[0], pmt[1])
        n = op2(m[0], pmt[2])
        result = op3(pmt[3], n[0])
        if result[0] == 24:
            #print(m[1], n[1], result[1])
            return (m[1], n[1], result[1])

    # d, (c, (a, b))
    def pro4(op1, op2, op3):
        m = op1(pmt[0], pmt[1])
        n = op2(pmt[2], m[0])
        result = op3(pmt[3], n[0])
        if result[0] == 24:
            #print(m[1], n[1], result[1])
            return (m[1], n[1], result[1]) 

    # (a b)(c d)
    def pro5(op1, op2, op3):
        m = op1(pmt[0], pmt[1])
        n = op2(pmt[2], pmt[3])
        result = op3(n[0], m[0])
        if result[0] == 24:
            #print(m[1], n[1], result[1])
            return (m[1], n[1], result[1])

    for pmt in permutation_list:
        for op in op_list:
            # 相同运算符
            if pro1(op[0], op[0], op[0]):
                return pro1(op[0], op[0], op[0])
            if pro2(op[0], op[0], op[0]):
                return pro2(op[0], op[0], op[0])
            if pro3(op[0], op[0], op[0]):
                return pro3(op[0], op[0], op[0])
            if pro4(op[0], op[0], op[0]):
                return pro4(op[0], op[0], op[0])
            if pro5(op[0], op[0], op[0]):
                return pro5(op[0], op[0], op[0])

            # ((a, b), c), d
            if pro1(op[0], op[1], op[2]):
                return pro1(op[0], op[1], op[2])
            if pro1(op[0], op[1], op[1]):
                return pro1(op[0], op[1], op[1])
            if pro1(op[0], op[0], op[1]):
                return pro1(op[0], op[0], op[1])
            if pro1(op[0], op[1], op[0]):
                return pro1(op[0], op[1], op[0])

            # (c, (a, b)), d
            if pro2(op[0], op[1], op[2]):
                return pro2(op[0], op[1], op[2])
            if pro2(op[0], op[1], op[1]):
                return pro2(op[0], op[1], op[1])
            if pro2(op[0], op[0], op[1]):
                return pro2(op[0], op[0], op[1])
            if pro2(op[0], op[1], op[0]):
                return pro2(op[0], op[1], op[0])

            # d, ((a, b), c)
            if pro3(op[0], op[1], op[2]):
                return pro3(op[0], op[1], op[2])
            if pro3(op[0], op[1], op[1]):
                return pro3(op[0], op[1], op[1])
            if pro3(op[0], op[0], op[1]):
                return pro3(op[0], op[0], op[1])
            if pro3(op[0], op[1], op[0]):
                return pro3(op[0], op[1], op[0])

            # d, (c, (a, b))
            if pro4(op[0], op[1], op[2]):
                return pro4(op[0], op[1], op[2])
            if pro4(op[0], op[1], op[1]):
                return pro4(op[0], op[1], op[1])
            if pro4(op[0], op[0], op[1]):
                return pro4(op[0], op[0], op[1])
            if pro4(op[0], op[1], op[0]):
                return pro4(op[0], op[1], op[0])

            # (a b)(c d)
            if pro5(op[0], op[1], op[2]):
                return pro5(op[0], op[1], op[2])
            if pro5(op[0], op[1], op[1]):
                return pro5(op[0], op[1], op[1])
            if pro5(op[0], op[0], op[1]):
                return pro5(op[0], op[0], op[1])
            if pro5(op[0], op[1], op[0]):
                return pro5(op[0], op[1], op[0])
    print('no result')
    return None


# ---------------------------test---------------------------------
'''

for n in range(30):
    a = random.randint(1,13)
    b = random.randint(1,13)
    c = random.randint(1,13)
    d = random.randint(1,13)
    print(a, b, c, d)
    print(cal_24point(a, b, c, d),'*'*10)
'''

 

 界面是难看了点 ，哈哈哈哈



 

wzgdavid
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
chatgpt赋能python：Python中如何不适用if语句
虚幻私塾
05-31 342
本文由chatgpt生成，文章没有在chatgpt生成的基础上进行任何的修改。以上只是chatgpt能力的冰山一角。作为通用的Aigc大模型，只是展现它原本的实力。对于颠覆工作方式的ChatGPT，应该选择拥抱而不是抗拒，未来属于“会用”AI的人。🧡AI职场汇报智能办公文案写作效率提升教程 🧡专注于AI+职场+办公方向。下图是课程的整体大纲下图是AI职场汇报智能办公文案写作效率提升教程中用到的ai工具。
python day4 关于字典
Peng_xxx的博客
03-09 1436
一、字典 1、字典里的每一个元素都是一个键值对 2、可以通过get()函数来索引，通过输入键来索引“值” 3、字典的创建 （1）：通过{}创建： a={“姓名”:“彭晓峰”,“年龄”:“18”} （2）：通过dict函数创建：b=dict(name=“pengxiaofeng”,age=22)或者 a=dict([(“name”,“pengxiaofeng”),(“age”,22)]) （3）：通...
Python:告别if...else...做真正面向对象的编程
【码农在新加坡】的专栏
05-15 8377
最近在给服务器做一套指令系统,大家都知道一个服务器的指令有很多，像(加金币，加道具，加经验...) 代码就像这样： cmd = REQUEST.get("cmd", "") if cmd == "add_gold": pass elif cmd == "add_item": pass elif cmd == "add_exp": pass ... ... else: s
Python通过字典来替代if..else
lylelo的博客
12-20 1989
在应对多策略的场景下，大量使用if...else...不仅提高了后期的维护成本，还降低了运行效率。通过字典做映射就可以更好的优化代码。
python 内存不足 dict 替代方案_Python笔记：配合docopt，用dict取代密集if-else实现命令行参数控制...
weixin_30476025的博客
02-19 268
过完春节回来之后，我开始学着用Python写点脚本来帮助自己快速批处理数据、批量作图。三个月的自学、实践、反复迭代自己的编程知识之后，我目前的脚本开头有段这样的东西：这就是我给自己的脚本写的一份“帮助文档”。而这有什么作用呢？ 结合docopt这个Python库，就可以解析在终端调用脚本时的参数，控制我这个脚本执行设定好的某段代码。比如我在终端输入这行命令来执行spin_main.py这个脚本：这...
Python函数关键字参数及用法
Python零基础入门学习
07-06 651
在定义 Python 函数时可定义形参（形式参数的意思），这些形参的值要等到调用时才能确定下来，由函数的调用者负责为形参传入参数值。简单来说，就是谁调用函数，谁负责传入参数值。 Python 函数的参数名不是无意义的，Python 允许在调用函数时通过名字来传入参数值。因此，Python 函数的参数名应该具有更好的语义，这样程序可以立刻明确传入函数的每个参数的含义。 按照形参位置传入的参...
Python函数参数与异常处理
L_Henry_Euler的博客
12-02 996
1. 一些常识 help(函数名)可以看到函数相关说明，和stata很像； func.doc 可以查看函数func的文档说明（需要事先用）
python-2.7.15编程软件.rar
09-15
1. **语法基础**：Python 以其简洁明了的语法闻名，如缩进代替大括号表示代码块，使用 `for` 和 `while` 循环，以及 `if-else` 语句等。在Python 2.7.15中，函数定义使用 `def` 关键字，类定义使用 `class`。 2. **...
python-basic
12-04
5. **控制结构**：Python的控制结构包括条件语句（if-else, if-elif-else）、循环（for, while）和异常处理（try-except）。这些结构用于控制程序流程，实现条件判断和重复执行。 6. **函数与模块**：Python中的...
python入门python-geodesy.rar
最新发布
05-31
4. **函数**：Python中的函数定义使用`def`关键字，可以有参数和返回值。函数可以提高代码的可重用性和模块化。 5. **模块与包**：Python有庞大的标准库和第三方库，如Numpy用于数值计算，Pandas用于数据处理，...
Python-junior-master.zip
07-27
1. **语法结构**：Python的语法简洁且易于理解，如缩进代替大括号表示代码块，使用`print()`函数进行输出，以及变量声明的灵活性等。初学者需要掌握如何编写有效的Python语句，包括赋值、条件判断、循环结构以及函数...
python第3天，python-Day03.rar
04-29
2. **控制结构**：包括条件语句（if-elif-else）和循环语句（for和while）。例如，你可以用这些结构来执行特定的代码块，当满足特定条件时，或者重复执行一段代码直到满足某个条件。 3. **函数**：Python中的函数是...
python中or语句的妙用，一行代替if/elif/else多行代码
SergioSilva的博客
01-28 804
import os args = {'search_engine':'baidu'} if args['search_engine']: search_engine = args['search_engine'] elif os.getenv('HOWDOI_SEARCH_ENGINE'): search_engine = os.getenv('HOWDOI_SEARCH_ENGINE') else: search_engine = 'bing' print(search_engine) imp
Python中枚举取代IF
baidu_32542573的博客
05-25 2846
策略模式+工厂模式（反射）+枚举代替 if..else if.. 邹祥慧2019-01-24 11:04:06509收藏1 实际项目中我们经常碰到需要使用if..else..if的分支判断这种情况。 这种写法带来一些弊端。 01一旦分支多太多，逻辑复杂，会导致代码十分冗长，增加阅读难度。 02如果需要增加或减少分支，需要改动if…elseif，增大因代码改动而出错的风险。这种粗鄙，丑陋的代码是我们不能接受的。 如： 注：实际项目中的订单状态远远...
JAVA-异常处理
LUOHANG22的博客
10-25 192
异常处理 1、try{} 语句块 试一试，里面放可能发生异常的语句块。当发生异常的时候，try语句块中发生异常后发生异常那行代码后面的代码是不会执行的直接跳转到catch语句块。 2、catch(){};语句块 捕捉异常 异常对象引用.printStackTrace()：打印出异常的类型、性质、栈层次已经出现在程序中的位置。 异常对象引用.getMessage()：错误的性质，发生了什么异常 3、finally{} 不管是否发生异常或者捕获异常成功与否都会执行finally语句块中的内容。 3、throw
Python第四课：if语句和字典
qq_50838422的博客
10-07 510
原码Gitee：https://gitee.com/xu-wen-jie/python.git 原码Github：https://github.com/miracleboys/Python.git 参考：《Python编程从入门到实践》 文章目录1.if语句1.1检查相等1.2比较数字1.3多条件1.4检查列表1.5elif2.字典2.1使用字典2.2遍历字典2.3字典嵌套 1.if语句 users = ['acc','Ghs','hJk','BBC'] for user in users: i
IF语句与字典
Ouy_Kai的博客
03-21 555
一、条件测试    Python提供 ==  !=操作判断是否相等二、if - elif - else语句三、使用if处理列表四、创建字典    item（）函数，它返回的是一个键值对列表，for循环一次将表格中的内容存储到指定的两个变量中。五、遍历列表与列表嵌套    set（）函数可以排除重复项，让列表元素都是独一无二的。    sorted（）函数可以对字典进行排序。...
Python小技巧--利用列表、字典表达式代替if 分支语句
百无一用生
12-01 3428
from datetime import datetime, timedelta class Date_today(object): def __init__(self): self.today = datetime.today() def next_day(self): self.tomorrow = self.today + ti...
Python 的import用法，调用自己写的类和函数
wzgdavid的博客
07-02 5732
同一个路径下a,b,c三个文件   a.py中定义一个函数   def foo(): print("here in foo") return  b.py中定义一个类     class Person(object): def __init__(self): print("new person ")  c.py中调用他们 impo...
代替if else的方法
11-24
以下是几种代替if else语句的方法： 1.使用字典映射： ```python def dispatch_if(operator, x, y): if operator == 'add': return x + y elif operator == 'sub': return x - y elif operator == 'mul': ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值