Python函数及参数

最新推荐文章于 2021-03-01 01:22:55 发布

YEGE学AI算法

最新推荐文章于 2021-03-01 01:22:55 发布

阅读量134

点赞数

分类专栏： Python

本文链接：https://blog.csdn.net/yegeli/article/details/100611102

版权

Python 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

函数

一个函数一般完成一项特定的功能
函数的使用
- 函数需要先定义
- 使用函数

#函数定义
def func():
    print("我爱王晓静")
    print("我在抖音，头条，微信号等都有作品")

func()

我爱王晓静
我在抖音，头条，微信号等都有作品

函数的参数和返回值

参数：负责给函数传递一些必要的数据或者信息
- 形参（形式参数）：再函数定义的时候用到的参数，没有具体的值，只是一个占位符
- 实参（实际参数）：在调用函数的时候输入的值
返回值：调用函数的时候的一个执行结果
- 使用return返回结果
- 如果没有值需要返回，我们推荐使用return None表示函数结束
- 函数一旦执行return，则函数立即结束
- 如果函数没有return关键字，则函数默认返回None

# 形参和实参的案例
# 参数person只是一个符号
# 调用的时候用另一个
def hello(person):
    print("{0},你好吗?".format(person))
    print("{},你看见我家晓静了吗？".format(person))
    return None
p = "小明"
# 调用函数，需要把p作为实参传入
hello(p)

小明,你好吗?
小明,你看见我家晓静了吗？

p = "小五"
hello(p)

小五,你好吗?
小五,你看见我家晓静了吗？

# 将运行hello函数，将函数的返回值赋值给pp
pp = hello("yege")
print(pp)

yege,你好吗?
yege,你看见我家晓静了吗？
None

# help 负责随时为你提供帮助
help(print)# help(None)等价与help(print()),因为print()函数没有返回值

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.



打印（…）
打印（值，…，sep=''，end='\\n'，file=sys.stdout，flush=false）
默认情况下，将值打印到流或sys.stdout。
可选关键字参数：
文件：类似于文件的对象（流）；默认为当前sys.stdout。
sep：在值之间插入的字符串，默认为空格。
结束：在最后一个值后附加的字符串，默认为换行符。
冲洗：是否强制冲洗水流。

## 九九乘法表
# version 1.0
for o in range(1,10): #控制外循环，从1到9
    for i in range(1,o+1):   #内循环，每次从第一个数字开始，打印到跟行数相同的数量,
                             # o+1是因为range函数左包括右不包括
        print(o*i,end="  ")
    print()

1  
2  4  
3  6  9  
4  8  12  16  
5  10  15  20  25  
6  12  18  24  30  36  
7  14  21  28  35  42  49  
8  16  24  32  40  48  56  64  
9  18  27  36  45  54  63  72  81

# 尝试用函数来打印九九乘法表

def jiujiu():
    for hang in range(1,10):
        for lie in range(1,hang+1):
            print(hang*lie,end=" ")
        print()
    
    return None  # 函数结束，注意函数对齐方式
                  #编译型语言，看是否能执行下去。解释型语言是指每一行进行执行。


jiujiu()
jiujiu()

1 
2 4 
3 6 9 
4 8 12 16 
5 10 15 20 25 
6 12 18 24 30 36 
7 14 21 28 35 42 49 
8 16 24 32 40 48 56 64 
9 18 27 36 45 54 63 72 81 
1 
2 4 
3 6 9 
4 8 12 16 
5 10 15 20 25 
6 12 18 24 30 36 
7 14 21 28 35 42 49 
8 16 24 32 40 48 56 64 
9 18 27 36 45 54 63 72 81

# 改造上面函数
def printLine(line_num):
    '''
    line_num: 代表行号
    打印一行九九乘法表
    '''
    for i in range(1,line_num+1):
        print(line_num*i,end="  ")
    print()
def jiujiu():
    for hang in range(1,10):
        printLine(hang)
    return None

jiujiu()

1  
2  4  
3  6  9  
4  8  12  16  
5  10  15  20  25  
6  12  18  24  30  36  
7  14  21  28  35  42  49  
8  16  24  32  40  48  56  64  
9  18  27  36  45  54  63  72  81

参数详解

参数分类
- 普通参数/位置参数
- 默认参数
- 关键字参数
  语法：
  def func(p1 = v1, p2 = v2…)
  func_body
```
  调用函数
  func(p1 = valu31, p2 = value2....)  
```
  比较麻烦，但也有好处：
  -不容易混淆，一般实参和形参只是按照位置一一对应即可
  - 使用关键字参数，可以不考虑参数设置
- 收集参数
  -把没有位置，不能和定义的参数位置相对应的参数，放入一个特定的数据结构中
  - 语法：
    
    def fuc(*args):
    func_body
    按照list使用方式访问args得到传入的参数
    调用：
    func(p1,p2,p3,…)
  - 参数名args不是必须这么写，但是，我们推荐直接用args，约定俗称
  - 参数名args前需要由星号
  - 收集参数可以和其他参数共存

# 普通参数案例
# 只是按照位置传递，容易出错
def norma_para(one, two, three):#每个参数后面用头号隔开，用空格隔开好看
    print(one + two)
    return None

norma_para(1,2,3)

# 默认参数案例

def default_para(one, two, three=100):#three默认参数值给100,参数需要与调用的一对一
    print(one + two)
    print(three)
    return None

default_para(1,2)
default_para(1, 2, 3)

# 关键字参数

def keys_para(one, two, three):
    print(one +two)
    print(three)
    return None

keys_para(one=1, two=2, three=30)

keys_para(three=30, two=2, one=1)

# 收集参数
# 函数模拟一个学生进行自我介绍，但具体内容不清楚
# args把他看做一个list

def stu(*args):
    print("Hello 大家好，我自我介绍一下：")
    #type函数作用是检测变量的类型
    print(type(args))
    for item in args:
        print(item)
        
stu("yege",18,"北京","wangxiaojing","single")

stu("周大神")

Hello 大家好，我自我介绍一下：
<class 'tuple'>
yege
18
北京
wangxiaojing
single
Hello 大家好，我自我介绍一下：
<class 'tuple'>
周大神

# 收集参数
# 说明收集参数可以不带任何参数调用，此时收集参数为空tuple
stu()

Hello 大家好，我自我介绍一下：
<class 'tuple'>

# 如果使用关键字参数格式调用，会出现问题
stu(name="yege")

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-3-f377cdefc5c6> in <module>()
      1 # 如果使用关键字参数格式调用，会出现问题
----> 2 stu(name="yege")


TypeError: stu() got an unexpected keyword argument 'name'

收集参数值关键字收集参数

把关键字参数按字典格式存入收集参数
语法：

def func( **kwargs):
func_body

调用：
func(p1=v1,p2=v2,p3=v3,…)
- kwargs一般约定俗成
- 调用的时候，把多余的关键字参数放入kwargs
- 访问kwargs需要按字典格式访问

# 收集参数
# 自我介绍
# 调用的时候需要使用关键字参数调用
def stu( **kwargs):
    print("hello 大家我，我先自我介绍一下：")
    print(type(kwargs))
    # 对于字典的访问，python2和python3有区别
    for k,v in kwargs.items():
        print(k, "----",v)
stu(name="yegeli",age=19,addr="北京",lover="wangxiaojing",work="IT")
print("*" * 50)
stu(name = "周大生")

hello 大家我，我先自我介绍一下：
<class 'dict'>
name ---- yegeli
age ---- 19
addr ---- 北京
lover ---- wangxiaojing
work ---- IT
**************************************************
hello 大家我，我先自我介绍一下：
<class 'dict'>
name ---- 周大生

# 收集参数为空
stu()

hello 大家我，我先自我介绍一下：
<class 'dict'>

# 收集参数混合调用案例
# stu模拟一个学生的自我介绍
def stu(name, age, *args, hobby="没有", **kwargs):
    print("Hello 大家好")
    print("我叫{0},我今年{1}大了。".format(name,age))
    if hobby == "没有":
        print("我没有爱我,so soory")
    else:
        print("我的爱好是{0}".format(hobby))
    
    print("#" * 20)
    
    for i in args:
        print(i)
    
    print("*" *30)
    
    for k,v in kwargs.items():
        print(k,"---",v)
        
# 开始调用函数
name = "yege"
age = 19
# 调用不同的格式
stu(name,age)

stu(name,age,hobby="游泳")

stu(name,age,"王晓静","野哥",hobby="游泳",hobby2="篮球",hobby3="打游戏")

Hello 大家好
我叫yege,我今年19大了。
我没有爱我,so soory
####################
******************************
Hello 大家好
我叫yege,我今年19大了。
我的爱好是游泳
####################
******************************
Hello 大家好
我叫yege,我今年19大了。
我的爱好是游泳
####################
王晓静
野哥
******************************
hobby2 --- 篮球
hobby3 --- 打游戏

收集参数的解包问题

把参数放入list或者字典中，直接把list/dict中的值放入收集参数中

# 收集参数的解包

def stu(*args):
    print("哈哈哈哈")
    # n用来表示循环次数
    # 主要用来调试
    n = 0
    for i in args:
        print(type(i))
        print(n)
        n += 1
        print(i)
        
#stu("yegeli","yegeligx",19,200)

l =["yegeli",19,20,"wangxiaojing"]
stu(l)
# 此时，args的表示形式是字典内一个list类型元素，即 arg = （["yegeli",19,20,"wangxiaojing"]）
# 很显然跟我们最初的想法违背了
# 此时的调用，我们就需要解包符号，即调用的时候前面加一个星号

stu(*l)

哈哈哈哈
<class 'list'>
0
['yegeli', 19, 20, 'wangxiaojing']
哈哈哈哈
<class 'str'>
0
yegeli
<class 'int'>
1
19
<class 'int'>
2
20
<class 'str'>
3
wangxiaojing

同理，dict类型收集参数一样可以解包，但是

对dict类型进行解包
需要用两个星号进行解包

YEGE学AI算法

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python函数及参数

函数一个函数一般完成一项特定的功能函数的使用函数需要先定义使用函数#函数定义def func(): print("我爱王晓静") print("我在抖音，头条，微信号等都有作品")func()我爱王晓静我在抖音，头条，微信号等都有作品函数的参数和返回值参数：负责给函数传递一些必要的数据或者信息形参（形式参数）：再函数定义的时候用到的参数，...
复制链接

扫一扫