精华内容
下载资源
问答
  • 2018-04-21 19:51:00
    # 函数封装成一个类
    # 将不同功能封装成不同函数
    
    '''
    0!+1!+2!+3!...+n!
    1+1+1+2+6+...+n*(n-1)*(n-2)...*1
    '''
    # 求一个数的阶乘
    class JieChengCount(object):
        def __init__(self,n):
            self.n = n
        # 阶乘求积
        def jc(self,n):
            result = 1
            if n == 0:
                return result
            else:
                for i in range(1, n + 1):  # 1到n的积
                    result *= i
                return result
    
        # 求和
        def count(self):
            count = 0
            for i in range(0, int(self.n) + 1):  # 0到num的和
                count += self.jc(i)  # 调用求阶乘
            print("1-{0}的阶乘求和 = {1}".format(self.n, count))
    
    def main():
        num = input("input a number:")
        jieChengCount = JieChengCount(int(num))  #初始化并传参
        jieChengCount.count()
    
    if __name__ == '__main__':
        main()

    转载于:https://my.oschina.net/u/3824134/blog/1799029

    更多相关内容
  • Python中的封装有什么作用?发现自己的错误,就是开悟;改正自己的错误,就是成就。日常生活中可以看到很多的汽车,...怎么将python代码封装成一个程序如何将python程序封装成exe可执行文件 将python程序直接转成...

    Python中的封装有什么作用?发现自己的错误,就是开悟;改正自己的错误,就是成就。

    日常生活中可以看到很多的汽车,汽车包括车轮、发动机、车架等零部件。可以在车架上安装车轮,然后安装发动机,最后安装其他零件,刷漆。就形成了汽车。这个过程,是把各种零件放到车架上的过程。但思考一下,对于开车的人。

    怎么将python代码封装成一个程序

    如何将python程序封装成exe可执行文件 将python程序直接转成exe程序的方法很多,主流的工具有PyInstaller、cx_freeze、py2exe等,论及优缺点,可谓各有千秋。然而,再好的工具在使用的时候也会遇到各种各样的问题。

    Python如何把一段代码封装起来重复使用

    小编在用Python语言做Abaqus分析,反复使用一段语句,不是function,没有p你可以用类或者函数将其封装一下,将需要后期变动的变量作为参数放在其中,可以使用默认值传参。 举个简单函数和类的栗子: # 函数封装def sum(a, b=3): return a + b# 类封装class S(object): def __init__(self, a=2, b=3) self.a = a self.b 当有人和你闲聊的时候会觉得不自在,而且很不想回复更多的沉浸于自己的世界希望别人别来打扰

    python中将函数和变量封装成类的好处爱恨是玻璃板上的两滴水,有时混在一起,分不出彼此,有时经过时间的蒸发,全不见了。

    比如说,小编有一个不断滚动的球,然后小编创建一个类,把这个球的图片,坐封装成类的好处,总结归纳有2个:一个是保护隐私。

    将下面Python代码封装成函数

    Python:常用函数封装: def is_chinese(uchar): """判断一个unicode是否是汉字""" if uchar >= u'\u4e00' and uchar= u'\u0030' and uchar= u'\u0041' and uchar= u'\u0061' and uchar年少的梦总是可以做的很长久,就像明明意中人在前,却还是满心满眼的江湖梦。总是想着少年侠气,想着仗剑天涯。想着踏遍千山万水,总会有她。想着等到成了英雄,再驾着七色云彩来接她。

    可以定义一个类,类里定义很多函数(主要用它做什么)或直接定义函数在一个py文件中 在另一个文件中导入这个那个py包。

    小编现在想把自己写的python模块源代码封装成dll,然小编主要是想实现模块代码的加密,请问能详细说明一下过程吗?有实例更好。

    可以的,只要把python模块转换成dll模块,利用Python自带的ctypes模块加载调用就行。 ctypes 是Python的外部函数库。它提供了与 C语言兼容的数据类型,并允许调用 DLL 或共享库中的函数。可使用该模块以纯 Python 形式对这些库进行封装。

    分享将下面的Python代码封装成函数,。。

    如何把Python脚本文件封装起来嫉妒是对别人最大的赞美,对自己最无能的体现。

    python类和函数的区别

    小编想请教下,在python中,是进来用函数,还是进来用类。还有,python中一、主体不同 满城的雨水,模糊的痕迹,呆呆伫立一步也不想往前。

    类:是面向对象程序设计实现信息封装的基矗 江山如画不如你眉眼清浅,山河千秋不及你泛笑风华。

    函数:是指一段在一起的、可以做某一件事儿的程序。也叫做子程序、(OOP中)方法。 二、特点不同 人生至少有一次,为了某个人丢掉矜持,放下自尊,毁掉自己的全部原则。

    以上就是四十五资源网为大家整理的python类封装 python中将函数和变量封装成类的好处内容,如果觉得本站更新的资源对您有帮助 不要忘记分享给您身边的朋友哦!

    展开全文
  • 将以上.py文件做成python模块,需要在相同目录下创建setup.py文件,setup.py中输入配置信息: from setuptools import setup setup(name='printtest', version='1.0', py_modules=['printtest'], ) 打开终端,...
  • 我就废话不多说了,直接看代码吧! import multiprocessing as mp from multiprocessing import Process class MyProcess(Process): """ 自定义多进程,继承自原生Process,目的是获取多进程结果到queue ...
  • 主要介绍了python函数声明和调用定义及原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Python必备封装基本代码~Python函数

    千次阅读 多人点赞 2022-04-02 15:37:13
    一遍看不懂就收起来慢慢看,我写的还是很详细的,一定是能轻松拿捏住Python函数

    大家好,我是辣条

    最近不少粉丝通过文末找到辣条让我分享一些代码封装这一块的内容,今天他来了~
    一遍看不懂就收起来慢慢看,我写的还是很详细的,一定是能轻松拿捏住Python函数的,不过还请记得多多支持辣条,码字不易~
    在这里插入图片描述

    1.如何用函数

    ​ 先定义后调用,定义阶段只检测语法,不执行代码
    调用阶段,开始执行代码
    函数都有返回值
    定义时无参,调用时也是无参
    定义时有参,调用时也必须有参

    2.默认参数陷阱

    2.1针对可变数据类型,不可变不受影响

    def c(a=[]):
        a.append(1)
        print(a)
    c()
    c()
    c()
    结果:
    [1]
    [1, 1]
    [1, 1, 1]
    
    def c(a=[]):
        a.append(1)
        print(a)
    c([])
    c([])
    c([])
    结果:
    [1]
    [1]
    [1]
    

    3.名称空间和作用域

    ​ 名称空间就是用来存放名字与值内存地址绑定关系的地方(内存空间)
    但凡查找值一定要通过名字,访问名字必须去查找名称空间
    名称空间分为三大类
    内置名称空间: 存放的是python解释器自带的名字
    生命周期: 在解释器启动时则生效,解释器关闭则失效
    全局名称空间: 存放的是文件级别的名字
    生命周期: 在解释器解释执行python文件时则生效,文件执行完毕后则失效
    局部名称空间: 在函数内定义的名字
    生命周期: 只在调用函数时临时产生该函数的局部名称空间,该函数调用完毕则失效
    加载顺序
    内置->全局->局部
    查找名字的顺序
    基于当前所在位置往上查找
    假设当前站在局部,查找顺序:局部->全局->内置
    假设当前站在全局,查找顺序:全局->内置
    名字的查找顺序,在函数定义阶段就已经固定死了(即在检测语法时就已经确定了名字的查找顺序),与函数的调用位置无关

    也就是说无论在任何地方调用函数,都必须回到当初定义函数的位置去确定名字的查找关系

    作用域: 作用域指的就是作用的范围
    全局作用域: 包含的是内置名称空间与全局名称空间中的名字
    特点: 全局有效,全局存活
    局部作用域: 包含的是局部名称空间中的名字
    特点: 局部有效,临时存活
    global: 在局部声明一个名字是来自于全局作用域的,可以用来在局部修改全局的不可变类型
    nonlocal: 声明一个名字是来自于当前层外一层作用域的,可以用来在局部修改外层函数的不可变类型

    4闭包函数:

    定义在函数内部且包含对外部函数的作用域名字的引用,需要结合函数对象的概念将闭包函数返回到全局作用域去使用,从而打破函数的层级限制
    闭包函数提供了一种为函数体传值的解决方案

    def func():
        name='egon'
        def inner():
            print(name)
        return inner
    inner = func()
    inner()
    

    5函数的参数

    5.1定义阶段

    ​ 位置形参
    在定义阶段从左往右的顺序依次定义的形参
    默认形参
    在定义阶段已经为其初始化赋值
    关键字参数
    自由主题
    可变长度的形参args
    溢出的位置参数,打包成元组,给接受,赋给args的变量名
    命名关键字参数
    放在*和之间的参数,必须按照key=value形式传值
    可变长度的位置形参kwargs
    溢出的关键字实参,打包成字典,给**接受,赋给变量kwargs
    形参和实参关系: 在调用函数时,会将实参的值绑定给形参的变量名,这种绑定关系临时生效,在调用结束后就失效了

    5.2调用阶段

    ​ 位置实参
    调用阶段按照从左往右依次传入的传入的值,会与形参一一对应
    关键字实参
    在调用阶段,按照key=value形式指名道姓的为形参传值
    实参中带*的,再传值前先将打散成位置实参,再进行赋值
    实参中带的**,在传值前先将其打散成关键字实参,再进行赋值

    6.装饰器:闭包函数的应用

    在这里插入图片描述
    装饰器就是用来为被装饰器对象添加新功能的工具
    **注意:**装饰器本身可以是任意可调用对象,被装饰器的对象也可以是任意可调用对象
    为何使用装饰器
    **开放封闭原则:**封闭指的是对修改封闭,对扩展开放

    6.1装饰器的实现必须遵循两大原则:

    ​ 1. 不修改被装饰对象的源代码`
    2. 不修改被装饰器对象的调用方式
    装饰器的目标:就是在遵循1和2原则的前提下为被装饰对象添加上新功能

    6.2装饰器语法糖

    在被装饰对象正上方单独一行写@装饰器的名字
    python解释器一旦运行到@装饰器的名字,就会调用装饰器,然后将被装饰函数的内存地址当作参数传给装饰器,最后将装饰器调用的结果赋值给原函数名 foo=auth(foo) 此时的foo是闭包函数wrapper

    6.3无参装饰器

    import time
    def timmer(func):
        def wrapper(*args,**kwargs):
            start_time=time.time()
            res=func(*args,**kwargs)
            stop_time=time.time()
            print('run time is %s' %(stop_time-start_time))
            return res
        return wrapper
    
    @timmer
    def foo():
        time.sleep(3)
        print('from foo')
    foo()
    

    6.4有参装饰器

    def auth(driver='file'):
        def auth2(func):
            def wrapper(*args,**kwargs):
                name=input("user: ")
                pwd=input("pwd: ")
    
            if driver == 'file':
                if name == 'egon' and pwd == '123':
                    print('login successful')
                    res=func(*args,**kwargs)
                    return res
            elif driver == 'ldap':
                print('ldap')
        return wrapper
    return auth2
    
    @auth(driver='file')
    def foo(name):
        print(name)
    
    foo('egon')
    

    7.题目

    #题目一:
    db='db.txt'
    login_status={'user':None,'status':False}
    def auth(auth_type='file'):
        def auth2(func):
            def wrapper(*args,**kwargs):
                if login_status['user'] and login_status['status']:
                    return func(*args,**kwargs)
                if auth_type == 'file':
                    with open(db,encoding='utf-8') as f:
                        dic=eval(f.read())
                    name=input('username: ').strip()
                    password=input('password: ').strip()
                    if name in dic and password == dic[name]:
                        login_status['user']=name
                        login_status['status']=True
                        res=func(*args,**kwargs)
                        return res
                    else:
                        print('username or password error')
                elif auth_type == 'sql':
                    pass
                else:
                    pass
            return wrapper
        return auth2
    
    @auth()
    def index():
        print('index')
    
    @auth(auth_type='file')
    def home(name):
        print('welcome %s to home' %name)
    
    
    # index()
    # home('egon')
    
    #题目二
    import time,random
    user={'user':None,'login_time':None,'timeout':0.000003,}
    
    def timmer(func):
        def wrapper(*args,**kwargs):
            s1=time.time()
            res=func(*args,**kwargs)
            s2=time.time()
            print('%s' %(s2-s1))
            return res
        return wrapper
    
    
    def auth(func):
        def wrapper(*args,**kwargs):
            if user['user']:
                timeout=time.time()-user['login_time']
                if timeout < user['timeout']:
                    return func(*args,**kwargs)
            name=input('name>>: ').strip()
            password=input('password>>: ').strip()
            if name == 'egon' and password == '123':
                user['user']=name
                user['login_time']=time.time()
                res=func(*args,**kwargs)
                return res
        return wrapper
    
    @auth
    def index():
        time.sleep(random.randrange(3))
        print('welcome to index')
    
    @auth
    def home(name):
        time.sleep(random.randrange(3))
        print('welcome %s to home ' %name)
    
    index()
    home('egon')
    
    #题目三:简单版本
    import requests
    import os
    cache_file='cache.txt'
    def make_cache(func):
        def wrapper(*args,**kwargs):
            if not os.path.exists(cache_file):
                with open(cache_file,'w'):pass
    
            if os.path.getsize(cache_file):
                with open(cache_file,'r',encoding='utf-8') as f:
                    res=f.read()
            else:
                res=func(*args,**kwargs)
                with open(cache_file,'w',encoding='utf-8') as f:
                    f.write(res)
            return res
        return wrapper
    
    @make_cache
    def get(url):
        return requests.get(url).text
    
    
    # res=get('https://www.python.org')
    
    # print(res)
    
    #题目四:扩展版本
    import requests,os,hashlib
    engine_settings={
        'file':{'dirname':'./db'},
        'mysql':{
            'host':'127.0.0.1',
            'port':3306,
            'user':'root',
            'password':'123'},
        'redis':{
            'host':'127.0.0.1',
            'port':6379,
            'user':'root',
            'password':'123'},
    }
    
    def make_cache(engine='file'):
        if engine not in engine_settings:
            raise TypeError('egine not valid')
        def deco(func):
            def wrapper(url):
                if engine == 'file':
                    m=hashlib.md5(url.encode('utf-8'))
                    cache_filename=m.hexdigest()
                    cache_filepath=r'%s/%s' %(engine_settings['file']['dirname'],cache_filename)
    
                    if os.path.exists(cache_filepath) and os.path.getsize(cache_filepath):
                        return open(cache_filepath,encoding='utf-8').read()
    
                    res=func(url)
                    with open(cache_filepath,'w',encoding='utf-8') as f:
                        f.write(res)
                    return res
                elif engine == 'mysql':
                    pass
                elif engine == 'redis':
                    pass
                else:
                    pass
    
            return wrapper
        return deco
    
    @make_cache(engine='file')
    def get(url):
        return requests.get(url).text
    
    # print(get('https://www.python.org'))
    print(get('https://www.baidu.com'))
    
    
    #题目五
    route_dic={}
    
    def make_route(name):
        def deco(func):
            route_dic[name]=func
        return deco
    @make_route('select')
    def func1():
        print('select')
    
    @make_route('insert')
    def func2():
        print('insert')
    
    @make_route('update')
    def func3():
        print('update')
    
    @make_route('delete')
    def func4():
        print('delete')
    
    print(route_dic)
    
    
    #题目六
    import time
    import os
    
    def logger(logfile):
        def deco(func):
            if not os.path.exists(logfile):
                with open(logfile,'w'):pass
    
            def wrapper(*args,**kwargs):
                res=func(*args,**kwargs)
                with open(logfile,'a',encoding='utf-8') as f:
                    f.write('%s %s run\n' %(time.strftime('%Y-%m-%d %X'),func.__name__))
                return res
            return wrapper
        return deco
    
    @logger(logfile='aaaaaaaaaaaaaaaaaaaaa.log')
    def index():
        print('index')
    
    index()
    
    展开全文
  • 展开全部Python:常用函数封装:def is_chinese(uchar):"""判断一个unicode是否62616964757a686964616fe58685e5aeb931333366306466是汉字"""if uchar >= u'\u4e00' and uchar= u'\u0030' and uchar= u'\u0041' and ...

    展开全部

    Python:常用函数封装:

    def is_chinese(uchar):

    """判断一个unicode是否62616964757a686964616fe58685e5aeb931333366306466是汉字"""

    if uchar >= u'\u4e00' and uchar<=u'\u9fa5':

    return True

    else:

    return False

    def is_number(uchar):

    """判断一个unicode是否是数字"""

    if uchar >= u'\u0030' and uchar<=u'\u0039':

    return True

    else:

    return False

    def is_alphabet(uchar):

    """判断一个unicode是否是英文字母"""

    if (uchar >= u'\u0041' and uchar<=u'\u005a') or (uchar >= u'\u0061' and uchar<=u'\u007a'):

    return True

    else:

    return False

    def is_other(uchar):

    """判断是否非汉字,数字和英文字符"""

    if not (is_chinese(uchar) or is_number(uchar) or is_alphabet(uchar)):

    return True

    else:

    return False

    def B2Q(uchar):

    """半角转全角"""

    inside_code=ord(uchar)

    if inside_code<0x0020 or inside_code>0x7e: #不是半角字符就返回原来的字符

    return uchar

    if inside_code==0x0020: #除了空格其他的全角半角的公式为:半角=全角-0xfee0

    inside_code=0x3000

    else:

    inside_code+=0xfee0

    return unichr(inside_code)

    def Q2B(uchar):

    """全角转半角"""

    inside_code=ord(uchar)

    if inside_code==0x3000:

    inside_code=0x0020

    else:

    inside_code-=0xfee0

    if inside_code<0x0020 or inside_code>0x7e: #转完之后不是半角字符返回原来的字符

    return uchar

    return unichr(inside_code)

    def stringQ2B(ustring):

    """把字符串全角转半角"""

    return "".join([Q2B(uchar) for uchar in ustring])

    def uniform(ustring):

    """格式化字符串,完成全角转半角,大写转小写的工作"""

    return stringQ2B(ustring).lower()

    def string2List(ustring):

    """将ustring按照中文,字母,数字分开"""

    retList=[]

    utmp=[]

    for uchar in ustring:

    if is_other(uchar):

    if len(utmp)==0:

    continue

    else:

    retList.append("".join(utmp))

    utmp=[]

    else:

    utmp.append(uchar)

    if len(utmp)!=0:

    retList.append("".join(utmp))

    return retList

    2Q==

    已赞过

    已踩过<

    你对这个回答的评价是?

    评论

    收起

    展开全文
  • python怎么封装函数

    千次阅读 2020-11-25 11:00:48
    要了解封装,离不开“私有化”,就是将或者是函数中的某些属性限制在某个区域之内,外部无法调用。python学习网,大量的免费python视频教程,欢迎在线学习!为什么要封装封装数据的主要原因是:保护隐私(把不想...
  • 本文实例讲述了Python3实现的Mysql数据库操作封装类。分享给大家供大家参考,具体如下: #encoding:utf-8 #name:mod_db.py ''''' 使用方法:1.在主程序中先实例化DB Mysql数据库操作。 2.使用方法:db=database()...
  • 本文实例讲述了Python面向对象之封装操作。分享给大家供大家参考,具体如下:承接上一节《Python面向对象之和实例》,学了Student的定义及实例化,每个实例都拥有各自的name和score。现在若需要打印一个学生...
  • 该楼层疑似违规已被系统折叠 隐藏此楼查看此楼下面的两段代码是经过简化后的,现在想封装成一个函数,传入一个list p,然后返回listA,因为p的长度是不定的,一时想不起来如何抽象,似乎应该用两个循环?import ...
  • 本文实例讲述了Python访问MySQL封装的常用。分享给大家供大家参考。具体如下: python访问mysql比较简单,下面整理的就是一个很简单的Python访问MySQL数据库。 自己平时也就用到两个mysql函数:查询和更新,下面...
  • 本文实例讲述了Python数据操作方法封装类。分享给大家供大家参考,具体如下: 工作中经常会用到数据的插叙、单条数据插入和批量数据插入,以下是本人封装的一个,推荐给各位: #!/usr/bin/env python # -*- ...
  • python 函数的定义封装函数调用, 局部变量,全局变量,内容中我举例写代码说明
  • 以__init__为例,是用来封装实例化对象的属性,只要是实例化对象就一定会执行__init方法,如果对象子类中没有则会寻找父类(超类),如果父类(超类)也没有,则直接继承object(python 3.x),执行中的__init__...
  • 本文实例讲述了Python操作Oracle数据库的简单方法和封装类。分享给大家供大家参考,具体如下: 最近工作有接触到Oracle,发现很多地方用Python脚本去做的话,应该会方便很多,所以就想先学习下Python操作Oracle的...
  • Python-封装对象

    千次阅读 2018-11-10 19:31:42
    正因为如此,在Python中创建一个和对象是很容易的,当然如果习惯面向过程或者函数的写法也是可以的,Python并不做硬性的限制。 接下来一步一步的和大家分享一下Python是怎么样封装类的。 版本一: 封装一个,最...
  • Python实战——函数封装和调用

    千次阅读 2021-03-04 18:20:50
    # 将抽奖函数封装成函数 def lottory(x,y,z): luckylist = [x, y, z] a = random.choice(luckylist) #随机在3位候选者中抽取一位 print('开奖倒计时',3) time.sleep(1) #调用time模块,控制打印内容出现的时间 ...
  • python封装函数

    2020-11-20 17:26:25
    python函数教程函数本身其实就相当于一个集装箱,她负责把我们之前写的那些代码装进去,她在打包的时候会在箱子的上下各开两个透气的口子,上面的口子叫参数,下面的口子叫返回值~~~~~(当然你也可以选择性的关闭这...
  • 将常用一些的函数封装成可以直接调用的模块方法1. 背景2. 具体步骤3. 扩展 1. 背景 在实际的操作过程中,经常会用到一个功能,如果每次编写代码的时候都进行重新编写或者打开已经编写好的函数进行复制粘贴,这样就...
  • 今天小编就为大家分享一篇对python中不同模块(函数、变量)的调用详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 使用flask封装,简单来讲就是将python文件引入flask。这样的结果就是在网页上输入一个url就能得到结果。下面就讲如何进行实现。 2. 任务1:求两数之和 2.1 代码讲解 新建一个server.py的文件,文件中代码如下所示: ...
  • python函数 - 14 函数的封装(模块)

    万次阅读 多人点赞 2018-05-17 19:40:08
    封装函数-模块定义: 一个.py文件就是一个模块(把一个函数写入py文件中存起来被其它py文件调用)1.模块管理函数定义: 模块管理函数就是将函数的定义放到一个.py文件中.可以在其他.py文件中通过import关键字导入模块....
  • 主要介绍了python读取ini配置的类封装代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • python(面向对象-类封装调用)

    千次阅读 2020-11-21 01:40:52
    一、面对对象思想(1)大家肯定听过 Python 中”一切皆对象“的说法,但可能并不了解它的具体含义,只是在学习的时候听说 Python 是面向对象的编程语言,本节将向大家详细介绍 Python 面向对象的含义。面向对象编程...
  • python函数实现模块化程序设计
  • 在本篇文章里小编给大家分享了关于python调用自己的函数的实例方法,有兴趣的朋友们可以学习参考下。
  • python 封装

    千次阅读 2020-11-08 15:53:24
    也就是的属性或者函数限制到限制在中使用,而外部无法调用。 二、为什么要用封装 1、封装数据:保护隐私 2、封装方法:隔离复杂度(只保留部分接口对外使用) 三、如何用封装 1 封装语法 已双下划线开头: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 174,505
精华内容 69,802
关键字:

python函数封装成类