Python学习笔记-函数，模块，包-CSDN博客

本文链接：https://blog.csdn.net/weixin_44067856/article/details/140815141

一、函数

1. 定义

封装一段代码，在需要时调用

2. 格式

1）函数定义

def 函数名([形参]):

函数体

2）函数调用

函数名([实参])

函数体

无返回值，返回None

def func1():
    print(1)
res=func1()         #调用了func1，即执行一次func1，打印出1，res变量用于接收函数的返回值 
print(res)     #无返回值，返回None
print(func1)   #没有括号，返回的是对象本身<function func1 at 0x00000200BA883430>

有返回值，通过return关键字返回

def func1():
    return 1
res=func1()     #无输出
print(res)   #1 打印函数的返回值

return语句

1）函数中可以有多个return

不同的分支语句中都可以有return

def judge_score(score):
    if score >= 90:
        return '优秀'
    elif score>= 75 and score < 90:
        return '良好'
    elif score >= 60 and score < 75:
        return '及格'
    else:
        return '不及格'
res=judge_score(61)
print(res)          #及格

return之后可以再写return，不过后面的return语句是不执行的，称为不可达语句

def func1():
    return 1
    return 2
res=func1()
print(res)    #1

2）return语句中可以有多个返回值，以元组的形式返回

def func1(a,b):
    return a+b,a-b,a*b
res=func1(1,2)
print(res)        #(3, -1, 2)

3）return可以返回任何类型的值，包括列表和字典等较复杂的数据结构

def fruit(a,b):  
    fruit={'a':a,'b':b}
    return fruit
res=fruit('apple','banana')
print(res)         #{'a': 'apple', 'b': 'banana'}

形参和实参

形参：形式参数，定义函数时使用

实参：实际参数，调用函数时使用

def sum(a,b):      #a,b为形参
    return a+b
res=sum(1,2)       #1,2为实参
print(res)     #3

形参缺省值

形参可以有缺省值，即默认值

1）没有缺省值的时候省略实参会报错

def sum(a,b):      
    return a+b
res=sum(1)      #TypeError: sum() missing 1 required positional argument: 'b'

2）有缺省值的时候省略参数不会报错

def sum(a,b=1):      
    return a+b
res=sum(1)  
print(res)     #2

3）使用缺省值时，必须先列出没有默认值的形参，再列出有默认值的形参

def sum(a=1,b):     #SyntaxError: non-default argument follows default argument
    return a+b

4）有缺省值的时候，以用户自己的实参为准，用户没有输入参数时，才使用缺省值

def sum(a,b=1):      
    return a+b
res=sum(1,2)  
print(res)    #3

复杂形参

def func1(fruit):  
    for one in fruit:
        print(one)
fruit=['apple','banana']
func1(fruit)

'''
apple
banana
'''

在函数中修改参数

def make(fruit,dried_fruit):  
    while fruit:
        sliced_fruit=fruit.pop()
        dried_fruit.append(sliced_fruit)
         
fruit=['apple','banana']
dried_fruit=[]
make(fruit,dried_fruit)
print(fruit)         #[]
print(dried_fruit)   #['banana', 'apple']

如果希望不改变参数，可以传入参数的副本，如切片

def make(fruit,dried_fruit):  
    while fruit:
        sliced_fruit=fruit.pop()
        dried_fruit.append(sliced_fruit)
         
fruit=['apple','banana']
dried_fruit=[]
make(fruit[:],dried_fruit)
print(fruit)         #['apple', 'banana']
print(dried_fruit)   #['banana', 'apple']

可变长参数

格式：*参数名，用户可以传入0~无限个实参

def func1(a,*args):
    return a,*args
res1=func1(1,2,3,4,5)
res2=func1(1)
print(res1)        #(1, 2, 3, 4, 5)
print(res2)        #(1,)

关键字参数

格式：**参数名, 用户可以传入0~无限个实参，但实参必须是x=y的形式，返回值是字典

def func1(x,**kwargs):
    return x,kwargs
res1=func1(1,a='apple',b='banana')
res2=func1(1)
print(res1)        #(1, {'a': 'apple', 'b': 'banana'})
print(res2)        #(1, {})

实参的几种写法

def sum(a,b):      
    return a+b
res=sum(a=1,b=2)  #完整写法
res=sum(b=1,a=2)  #完整写法，顺序与定义不同
res=sum(a=1,2)    #先完整后省略，不可以这样写SyntaxError: positional argument follows keyword argument
res=sum(1,b=2)    #先省略后完整
res=sum(1,2)      #全省略

二、模块

1. 定义

一个.py文件就是一个模块，如example.py就是一个模块

2. 使用

通过将函数存储在独立的文件中，可以隐藏程序代码的细节，也可以在不同的程序中重用函数

将模块导入以使用模块中的函数，待导入的模块和使用模块的文件必须处于同一个目录下才能使用以下导入方式：

1）导入整个模块

格式：import 模块名

先定义一个名为mymath.py模块，里面内容为：

def sum(a,b):
    return a+b


def product(a,b):
    return a*b

在另一个main.py中导入mymath.py模块，使用mymath.py中的函数时，需要用模块名.函数名()的形式，直接用函数名()会报错

import mymath

res=mymath.sum(1,2)
print(res)    #3

2）导入特定的函数

此时使用导入模块中的函数时，直接用函数名()的形式，用模块名.函数名()会报错

导入一个函数

格式：from 模块名 import 函数名

from mymath import sum

res=sum(1,2)
print(res)    #3

导入多个函数

格式：from 模块名 import 函数名, 函数名, ... (函数名以逗号隔开)

from mymath import sum,product

res1=sum(1,2)
res2=product(1,2)
print(res1)    #3
print(res2)    #2

导入全部函数

格式：from 模块名 import *

from mymath import *

res1=sum(1,2)
res2=product(1,2)
print(res1)    #3
print(res2)    #2

3）使用as指定别名

给模块指定别名

格式：import 模块名 as 模块别名，此时就不能再在代码中使用模块本来的名字，只能使用别名

import mymath as mm

res1=mm.sum(1,2)
print(res1)     #3
res2=mymath.product(1,2)    #NameError: name 'mymath' is not defined

给函数指定别名

如果导入的函数与程序中现有函数名字一致，或者导入的多个模块中有同名函数，或者函数名太长，可以使用别名

格式：from 模块名 import 函数名 as 函数别名

from mymath import sum as s

def sum(a,b):
    return a+a+b+b
res1=s(1,2)
res2=sum(1,2)
print(res1)     #3
print(res2)     #6

如果没有起别名，导入模块与程序现有函数有冲突，执行的是程序现有的函数

from mymath import sum

def sum(a,b):
    return a+a+b+b
res1=sum(1,2)
print(res1)    #6

三、包

1. 定义

存放多个模块的文件夹，且文件夹中含有__init__.py，则这个文件夹被称为包，如果没有该文件，则是普通的文件夹，不能被导入使用

当加载包的时候会自动执行一次__init__.py里的内容

2. 使用

将包导入以使用包中的模块，待导入的包和使用包的文件（如果文件也包含在一个包内，则这两个包在同一目录）必须处于同一个目录下才能使用以下导入方式：

1）导入包中的模块

格式：from 包名 import 模块名，调用

新建一个文件夹english，在文件里包含两个文件__init__.py和myenglish.py

__init__.py:

print('执行了一次__init__.py文件')

myenglish.py:

def greeting():
    print('Lihua says "Hello, Han Meimei"')
    print('Han Meimei says "Hello, Lihua"')

在main.py导入myenglish.py，使用myenglish.py中的函数时，需要用模块名.函数名()的形式

from english import myenglish  #执行了一次__init__.py文件

myenglish.greeting()  

'''
Lihua says "Hello, Han Meimei"
Han Meimei says "Hello, Lihua"
'''

2）导入模块中的函数

from 包名.模块名 import 函数名，使用包中模块里的函数时，用函数名()的形式

from english.myenglish import greeting   ##执行了一次__init__.py文件

greeting()

'''
Lihua says "Hello, Han Meimei"
Han Meimei says "Hello, Lihua"
'''

3）使用as指定别名

与模块中使用as指定别名的形式类似