《零基础学Python》模块与函数【五】

最新推荐文章于 2022-05-29 17:23:34 发布
最新推荐文章于 2022-05-29 17:23:34 发布
阅读量283 收藏 1
点赞数
分类专栏： 《零基础学Python》 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44414444/article/details/117791245
版权

整体文章目录

整体目录

一、 当前章节目录

在这里插入图片描述

二、Python程序的结构

  • Python的程序由包、模块和函数组成。
  • 模块是处理某一类问题的集合，模块由函数和类组成。
  • 包是由一系列模块组成的集合。

三、模块

3.1 模块的创建

# myModule.py
# 自定义模块
def func():
    print("MyModule.func()")                # 定义func函数

class MyClass:                              # 定义MyClass类
    def myFunc(self):                       # 定义myFunc方法
        print("MyModule.MyClass.myFunc()")  # 调用myFunc()方法

# call_myModule.py
# 调用自定义模块的类和函数
import myModule         # 导入moudle

myModule.func()
myClass = myModule.MyClass()
myClass.myFunc()

运行结果：

MyModule.func()
MyModule.MyClass.myFunc()

3.2 模块的导入

# myModule.py
count = 1                   # 定义全局变量count并赋值

def func():                 # 定义func函数
    global count
    count = count + 1
    return count

# call_myModule.py
import myModule
print("count = ", myModule.func())
myModule.count = 10
print("count = ", myModule.count)

import myModule
print("count = ", myModule.func())

# import置于条件语句中
if myModule.count > 1:
    myModule.count = 1
else:
    import myModule
print("count = ", myModule.count)

运行结果：

count = 2
count = 10
count = 11
count = 1

3.3 模块的属性

# myModule.py
if __name__ == '__main__':
    print('myModule作为主程序运行')
else:
    print('myModule被另一个模块调用')

运行结果：

myModule作为主程序运行

# call_myModule.py
import myModule
print(__doc__)

运行结果：

myModule被另一个模块调用
None

3.4 模块的内置函数

def func(x):                                    # 定义func函数
    if x > 0:                                   # if判断
        return x                                # 返回x的值

print(filter(func, range(-9, 10)))              # 调用filter函数，返回的是filter对象
print(list(filter(func, range(-9, 10))))        # 将filter对象转换为列表

运行结果：

<filter object at 0x000001EA4B86D1C0>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

def sum(x, y):                                  # 定义sum函数
    return x + y                                # 返回x + y的值
from functools import reduce                    # 引入reduce
print(reduce(sum, range(0, 10)))
print(reduce(sum,range(0, 10), 10))
print(reduce(sum, range(0, 0), 10))

运行结果：

45
55
10

def power(x): return x ** x                             # 定义power函数
print(map(power, range(1, 5)))                          # 打印map对象
print(list(map(power, range(1, 5))))                    # 转换为列表输出
def power2(x, y): return x ** y
print(map(power2, range(1, 5), range(5, 1, -1)))        # 打印map对象
print(list(map(power2, range(1, 5), range(5, 1, -1))))  # 转换为列表输出

运行结果：

<map object at 0x000001EA4B86D1C0>
[1, 4, 27, 256]
<map object at 0x000001EA4B86D310>
[1, 16, 27, 16]
在这里插入图片描述

3.5 自定义包

# pack\__init__.py
__all__ = ["myModule"]
if __name__ == '__main__':      # 判断本模块是否作为主程序运行
    print('作为主程序运行')
else:
    print('pack初始化')

运行结果：

作为主程序运行

# parent\pack\myModule.py
def func():                             # 定义func函数
    print("pack.myModule.func()")

if __name__ == '__main__':              # 判断本模块是否作为主程序运行
    print('myModule作为主程序运行')
else:
    print('myModule被另一个模块调用')

运行结果：

myModule作为主程序运行

# parent\pack2\__init__.py
__all__ = ["myModule2"]
if __name__ == '__main__':      # 判断本模块是否作为主程序运行
    print('作为主程序运行')
else:
    print('pack2初始化')

运行结果：

作为主程序运行

# parent\pack2\myModule2.py
def func():                             # 定义func函数
    print("pack.myModule2.func()")

if __name__ == '__main__':              # 判断本模块是否作为主程序运行
    print('myModule2作为主程序运行')
else:
    print('myModule2被另一个模块调用')

运行结果：

myModule2作为主程序运行

# parent\__init__.py
# from pack import myModule
# from pack2 import myModule2

from pack import *
from pack2 import *

myModule.func()
myModule2.func()

运行结果：

pack初始化
myModule被另一个模块调用
pack2初始化
myModule2被另一个模块调用
pack.myModule.func()
pack.myModule2.func()

四、函数

4.1 函数的定义

# 函数的定义
from __future__ import division             # 导入division模块
def arithmetic(x, y, operator):
    result = {
        "+": x + y,
        "-": x - y,
        "*": x * y,
        "/": x / y
    }
    return result.get(operator)             # 调用get方法返回计算结果

# 函数的调用
print(arithmetic(1, 2, "+"))

运行结果：

3

4.2 函数的参数

# 函数的默认参数
def arithmetic(x=1, y=1, operator="+"):           # 定义arithmetic函数
    result = {                                    # 定义result字典
        "+": x + y,
        "-": x - y,
        "*": x * y,
        "/": x / y
    }
    return result.get(operator)                   # 调用get方法返回计算结果

print(arithmetic(1, 2))
print(arithmetic(1, 2, "-"))
print(arithmetic(y=3, operator="-"))
print(arithmetic(x=4, operator="-"))
print(arithmetic(y=3, x=4, operator="-"))

运行结果：

3
-1
-2
3
1

# 列表作为参数传递
def arithmetic2(args=[],operator="+"):
    x = args[0]
    y = args[1]
    result = {
        "+": x + y,
        "-": x - y,
        "*": x * y,
        "/": x / y
    }
    return result.get(operator)

print(arithmetic2([1, 2]))

运行结果：

3

def app(args=[]):
    args.append(0)
    print(args)

app()
app([1])
app()

运行结果：

[0]
[1, 0]
[0, 0]

def app1(args=[]):
    if len(args) <= 0:
        args = []
    args.append(0)
    print(args)

app1()
app1([1])
app1()

运行结果：

[0]
[1, 0]
[0]

# 传递可变参数
def func1(*args):
    print(args)
func1(1, 2, 3)

运行结果：

(1, 2, 3)

# 传递可变参数
def search(*t, **d):                    # 定义search函数
    keys = d.keys()
    values = d.values()
    print(keys)
    print(values)
    for arg in t:
        for key in keys:
            if arg == key:
                print("find:", d[key])

search("one", "three", one="1", two="2", three="3")             # 调用search函数

运行结果：

dict_keys([‘one’, ‘two’, ‘three’])
dict_values([‘1’, ‘2’, ‘3’])
find: 1
find: 3

4.3 函数的返回值

from __future__ import division                 # 导入division模块
def arithmetic(x, y, operator):                 # 定义arithmetic函数
    result = {
        "+": x + y,
        "-": x - y,
        "*": x * y,
        "/": x / y
    }
    return result.get(operator)                 # 调用get返回计算结果

# 没有return语句的函数返回None
def func():
    pass

print(func())

运行结果：

None

def func2():
    return

print(func2())

运行结果：

None

# return返回多个值
def func3(x, y, z):
    l =[x, y, z]
    l.reverse()
    numbers = tuple(l)
    return numbers

x, y, z = func3(0, 1, 2)
print(x, y, z)

运行结果：

2 1 0

def func4(x, y, z):             # 定义func函数
    l = [x, y, z]               # 定义l列表
    l.reverse()                 # 调用reverse方法
    a, b, c = tuple(l)
    return a, b, c

x, y, z = func4(0, 1, 2)
print(x, y, z)

运行结果：

2 1 0

# 多个return语句
def func5(x):                   # 定义func5函数
    if x > 0:                   # if判断
        return "x > 0"
    elif x == 0:
        return "x == 0"
    else:
        return "x < 0"

print(func5(-2))

运行结果：

x < 0

# 多个return语句的重构
def func6(x):
    if x > 0:
        result = "x > 0"
    elif x == 0:
        result = "x == 0"
    else:
        result = "x < 0"
    return result

print(func6(-2))

运行结果：

x < 0

4.4 函数的嵌套

# 嵌套函数
def sum(a, b):
    return a + b
def sub(a, b):
    return a - b
def func():
    x = 1
    y = 2
    m = 3
    n = 4
    return sum(x, y) * sub(m, n)

print(func())

运行结果：

-3

# 嵌套函数
def func2():
    x = 1
    y = 2
    m = 3
    n = 4
    def sum2(a, b):
        return a + b
    def sub2(a, b):
        return a - b
    return sum2(x, y) * sub2(m, n)

print(func2())

运行结果：

-3

# 嵌套函数，直接使用外层函数的变量
def func3():
    x = 1
    y = 2
    m = 3
    n = 4
    def sum3():                 # 内部函数
        return x + y
    def sub3():
        return m - n
    return sum3() * sub3()

print(func3())

运行结果：

-3

4.5 递归函数

# 计算阶乘
def refunc(n):                      # 定义refunc函数
    i = 1
    if n > 1:                       # 递归的结束判断
        i = n
        n = n * refunc(n - 1)       # 递推
    print("%d! = " %i, n)
    return n                       # 回归

refunc(5)

运行结果：

1! = 1
2! = 2
3! = 6
4! = 24
5! = 120

# 使用reduce计算阶乘
from functools import reduce                #Python3中reduce不再全局中，必须手动引入
print("5! = ", reduce(lambda x, y:x * y, range(1, 6)))

运行结果：

5! = 120

4.6 lambda函数

# lambda
def func():
    x = 1
    y = 2
    m = 3
    n = 4
    sum = lambda x, y : x + y
    print(sum)
    sub = lambda m, n : m - n
    print(sub)
    return sum(x, y) * sub(m, n)

print(func())

运行结果：

<function func.. at 0x000001CD9F42EF70>
<function func.. at 0x000001CD9F44D040>
-3

# lambda的函数用法
print((lambda x: -x)(-2))

运行结果：

2

4.7 Generator函数

# 定义Generator函数
def func(n):
    for i in range(n):
        yield i
# 在for循环中输出
for i in func(3):
    print(i)

# 使用next()输出
r = func(3)
print(r.__next__())
print(r.__next__())
print(r.__next__())
# print(r.__next__())

运行结果：

0
1
2
0
1
2

# yield与return区别
def func2(n):
    for i in range(n):
        return i
def func3(n):
    for i in range(n):
        yield i

print(func2(3))
f = func3(3)
print(f)
print(f.__next__())
print(f.__next__())

运行结果：

0
<generator object func3 at 0x000001C447C28900>
0
1

五、习题

习题：

  1. import和from都可以用来引入模块，在什么情况下没法使用from？
  2. 使用from比使用import有哪些优点？又有哪些缺点？
  3. 下面的代码片段的输出结果是什么？
    s = lambda x, y : x + y
    print(s(‘aa’,’bb’))
  4. 写一个根据日期计算是星期几的模块，在程序中引入并使用这个模块。

答案：

  1. 在函数中无法使用from
  2. （1）优点：我们只在两种场合下建议使用这样的方法, 一个场合是：目标模块中的属性非常多, 反复键入模块名很不方便 , 例如 Tkinter (Python/Tk) 和 NumPy (Numeric Python) 模块 , 可能还有 socket 模块。另一个场合是在交互解释器下, 因为这样可以减少输入次数。
    （2）缺点：当我们使用from导入的时候，就会出现变量名的重复问题，因为我们把另外一个模块中所有的变量名都导入了进来，在命名的时候会出现命名冲突的情况。
  3. aabb
  4. 代码如下。
year = int(input("请输入年份："))
month = int(input("请输入月份："))
day = int(input("请输入日："))

def yearsum(year):
    if year < 2001:
        return 0
    year = year - 1
    return yearday(year) + yearsum(year)

def yearday(year):
    if (year % 4 == 0 and year % 100 != 0) or (year % 100 == 0 and year % 400 == 0):
        return 366
    else:
        return 365

def monthsum(year, month):
    if month < 2:
        return 0
    month = month - 1
    if month == 1 or month == 3 or month == 5 or month == 7 or month == 8 or month == 10 or month == 12:
        months = 31
    elif month == 2:
        months = 28 + yearday(year) - 365
    else:
        months = 30
    return months + monthsum(year, month)


week = (yearsum(year) + monthsum(year, month) + day + 5) % 7
if week == 0:
    week = 7
print(year, '年', month, '月', day, '日为：星期', week)

运行结果：

请输入年份：2021
请输入月份：6
请输入日：1
2021 年 6 月 1 日为：星期 2

qq_44414444
关注
专栏目录
〖Python零基础入门篇㉜〗- 面向对象编程 - 模块化程序设计之函数的小实战
易编橙 · 终身成长社群，相遇已是上上签！
03-07 5万+
什么是模块化程序设计？程序设计的模块化指的是在进行程序设计时，把一个大的程序功能划分为若干个小的程序模块。每一个小程序模块实现一个确定的功能，并且在这些小程序模块实现的功能之间建立必要的联系，通过各个小模块之间的互相协作完成整个大功能实现的方法。
〖Python零基础入门篇㉛〗- 函数的定义与使用
热门推荐
易编橙 · 终身成长社群，相遇已是上上签！
03-07 4万+
什么是函数？ --- > 函数是具有某种特定功能的代码块，可以重复使用(在前面数据类型相关章节，其实已经出现了很多 Python 内置函数了）。它使得我们的程序更加模块化，不需要编写大量重复的代码。 函数可以提前保存起来，并给它起一个独一无二的名字，只要知道它的名字就能使用这段代码。函数还可以接收数据，并根据数据的不同做出不同的操作，最后再把处理结果反馈给我们。
python的division函数_python division如何取整
weixin_33140809的博客
02-21 2307
1、在python2 中导入division(精确除法)，即from __future__ import division ，当我们在程序中没有导入该特征时，"/"操作符执行的只能是整除，也就是取整数，只有当我们导入division(精确算法)以后，"/"执行的才是精确算法。如：#python2.7.6Python2.7.6(default,Nov102013,19:24:18)[...
python的division函数_python:__feature__模块
weixin_39801879的博客
12-23 1403
1.__feature__模块的作用:Python 提供了 __future__ 模块，把下一个新版本的特性导入到当前版本，这样,我们就可以在当前版本中测试一些新版本的特性。Python 为了确保你能顺利过渡到新版本，特别提供了 __future__ 模块，让你在旧的版本中试验新版本的一些特性。一般有:from __future__ import division, print_function,...
Python作用域问题详解
weixin_45144837的博客
01-30 1170
Python作用域问题 定义：在Python程序中创建、改变、查找变量名时，都是在一个保存变量名的空间中进行，我们称之为命名空间，也被称之为作用域。Python的作用域是静态的，在源代码中变量名被赋值的位置决定了该变量能被访问的范围。即Python变量的作用域由变量所在源代码中的位置决定。 作用域的产生： 只有当变量在Module(模块)、Class(类)、def(函数)中定义的时候，才会有作用...
python re function
qq_37228811的博客
07-23 407
1.【compile】:  先用此函数把正则表达式的字符串形式编译为pattern实例。 # pattern = re.compile('\daaa') # print(type(pattern)) 运行结果如下： 这是一个pattern对象，可多次使用。 2.【match】:只匹配开头，成功匹配就返回一个match对象，没有就返回None pattern=re.compile...
有关Python中的division问题
Jack Lee
06-13 1869
笔者在学习Natural Language Processing with PythonChapter2的过程中，在运行如下代码的时候生成结果和书中示例不同：import nltkdef content_fraction(text): stopwords = nltk.corpus.stopwords.words('english') content = [w for w in te
[『编程语言』] 小甲鱼零基础入门学习Python+全套源码课件
03-26
绝对零基础Python3.x 入门，掌握Python语言常数据类型与操作、语句语法、流程控制、函数定义、模块管理，类与面向对象编程，错误与异常处理，文件读写，数据库编程，Python Web编程初步等知识；为以后Python各方向...
《零基础学Python》PPT
10-12
《零基础学Python》PPT是一份针对初学者设计的教育材料，旨在帮助无编程背景的人逐步掌握Python语言。这份教程覆盖了Python的基础到进阶主题，通过一系列的PPT课件来阐述关键概念。 首先，"1.python简介"部分会介绍...
小甲鱼零基础学python全套课后题及答案
10-18
"小甲鱼零基础学Python"是一门针对初学者的课程，旨在帮助没有编程背景的人快速掌握Python基础知识。课程涵盖了从变量、数据类型、控制结构到函数、模块、面向对象编程等全面的内容。 在Python的学习过程中，课后题...
python面向对象编程高级篇__slots__ @property 多重继承
li4692625的博客
11-05 155
python语言中我们可以随时给实例增加新的属性和方法 class Student(object): pass >>> s = Student() >>> s.name = 'Michael' # 动态给实例绑定一个属性 >>> print(s.name) Michael >>> def set_age(self, age): # 定义一个函数作为实例方法 ... self.age = age ... >&g
第十六节课：函数(3)
weixin_53517861的博客
05-29 208
记录我的学习之旅——第十六课
【保姆级入门系列】阿ken教你学 Python(五) ——函数
06-08 7906
5.1 函数概述 函数是组织好的、可重复使用的、用来实现单一或相关联功能的代码段,通过函 数的名称表示和调用。函数也可以看作是一段有名字的子程序,可以在需要的地方使 用函数名调用执行。在学习本章内容之前,其实我们已经接触过一些函数,比如输出 信息到命令行窗口的prin(函数、接收键盘输人信息的iput()函数等。 函数是一种功能抽象,它可以完成特定的功能,与黑箱模型的原理一样。黑箱模 型是指所建立的模型只考虑输人与输出,而与过程机理无关。现实生活中,应用黑箱 原理的实物有很多,比如洗衣机,对于使用者来说,大
from __future__ import division 报错，不存在该模块。原因是。。。。
LOVEYSUXIN的专栏
06-20 2755
应该是from __future__ import division future前后都是双下划线 导入python未来支持的语言特征division(精确除法)，当我们没有在程序中导入该特征时，"/"操作符执行的是截断除法(Truncating Division),当我们导入精确除法之后，"/"执行的是精确除法。 >>> 3/40>>> from __future__ impo
C++ —— 理解引用及其原理
ifwecande的博客
09-19 1416
概念 引用的简单概念： 引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。 引用一般被使用做参数/返回值这样可以提高效率， 减少拷贝。 底层实现 在语言层面引用是一个对象的别名不占据空间， 但是实际上在底层的实现上引用是类似于指针实现的。 我们借助代码进行探索 int i=5; int &ri=i; ri=8; 通过：调试->窗口->反汇编 int i=5; 00A013DE mov dword
函数
陈洋的博客
03-15 198
函数的概念 带名字的代码块，用于完成具体工作 可以反复执行 函数命名 1.使用英文字母，不要使用中文 2.使用数字，但不能以数字开头 3.不使用特殊符号，_除外 4.函数名大小写敏感 5.避免使用python的关键字 6.函数名尽量有意义 函数的定义 使用def定义 注意冒号 形参：定义函数时，定义的函数参数 函数的调用 先定义后调用，调用后函数才会执行 实参...
第5章 模块与函数
weixin_33817333的博客
12-24 96
本章知识点： 1、模块的创建与使用；2、内置模块；3、常用模块；4、函数的创建和使用；5、lambda 函数；6、Generator 函数；7、函数化程序设计； 5.1 Python 程序的结构5.2 模块 5.2.1 模块的创建 1 ## 自定义模块 2 def func(): 3 print ("MyModule.func()") 4 5 class ...
递归
zhenge6的博客
07-24 414
def refunc(n):     i=1     if n>1:               #递归的结束判断         i=n         n=n*refunc(n-1)    #递推     print"%d!=" %i,n     return n               #回归 refunc(5) print print'使用reduce计算阶乘
python_9(获取字典值、函数参数、函数返回值、lambda的函数用法)
@风之谷
10-17 3457
如果我们需要获取字典值的话，我们有两种方法，一个是通过dict[‘key’],另外一个就是dict.get()方法#获取字典值 info = {'1':'first','2':'second','3':'third'} number = raw_input('input type you number:') print info.get(number,'error')#实例1 #!/usr/bin/
Python函数与模块实战解析
**函数与模块的结合** 在实际开发中，函数和模块经常一起使用。函数作为模块的一部分，负责执行特定的任务，而模块则作为一个容器，将这些功能组织在一起。例如，我们可以在`math_utils`模块中添加更多的数学相关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值