Python函数基础知识

于 2019-01-08 21:43:17 发布
阅读量655 收藏 5
点赞数
CC 4.0 BY-SA版权
分类专栏： Python函数 Python介绍 Python基础 文章标签： Python基础 Python函数 小白学Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/g_optimistic/article/details/85679976

目录

 

一、函数的引出

二、函数的定义与调用

1.定义

（1）.格式

（2）.注意：

2.调用：

（1）格式：

（2）注意事项：

三、函数的注释

​

四、函数的参数

1.格式

2.参数的数据类型

（1）可变，不可变数据类型

（2）注意：

3.参数的类型

（1）位置参数，关键字参数，默认参数，可变参数（*args,     **kwargs）

（2）位置参数与关键字参数混用

（3）参数顺序

五、函数的返回值

1.格式

​

2.注意

​

3.函数返回多个值

（1）格式

（2）注意事项

六、函数的嵌套

一、函数的引出

程序中重复的内容太多了

'''

程序中重复的内容太多了

在程序开始的时候，打印哈哈，呵呵，嘻嘻
在程序的中间，打印三句哈哈，呵呵，嘻嘻
在程序结束的时候，打印哈哈，呵呵，嘻嘻
'''


# print('哈哈', '呵呵', '嘻嘻')
# print('哈哈', '呵呵', '嘻嘻')
# print('哈哈', '呵呵', '嘻嘻')
# 100行
#
# print('哈哈', '呵呵', '嘻嘻')
# print('哈哈', '呵呵', '嘻嘻')
# print('哈哈', '呵呵', '嘻嘻')
# 200行
#
# print('哈哈', '呵呵', '嘻嘻')
# print('哈哈', '呵呵', '嘻嘻')
# print('哈哈', '呵呵', '嘻嘻')


def laugh():
    print('哈哈', '嘻嘻', '呵呵')
    print('哈哈', '嘻嘻', '呵呵')
    print('哈哈', '嘻嘻', '呵呵')


laugh()
# 100行
laugh()
# 200行
laugh()

二、函数的定义与调用

1.定义

（1）.格式

def   函数名称():

    ....函数体....

（2）.注意：

    1）函数的名称要遵循标识符命名规则，多个单词使用下划线命名法

    2）函数体靠缩进来表示

    3）:     ()    都是英文来表示的

    4）函数只有在调用的时候才执行，只创建不调用是不会执行的

2.调用：

（1）格式：

函数名()

（2）注意事项：

    1）先创建后调用

    2）一般情况下，不要将调用函数放到函数体里面

         特殊情况下，在递归的时候，函数自己可以调用自己

# 一.创建一个say_hello函数：
def say_hello():
    print('hello world')
    print('hello python')
    print('hello 云计算')


# 调用函数
say_hello()
print('程序结束了....')

三、函数的注释

1.在函数的第一行使用多行注释对函数的功能进行解释说明

2.调用函数的时候，通过用快捷键   ctrl+Q 可以看出函数的解释说明，而了解函数的功能

'''
函数的注释：
1.在函数体的第一行使用多行注释对函数的功能进行解释说明
2.调用函数的时候，通过快捷键  ctrl+Q 可以查看函数的解释说明。而了解此函数的功能
'''


def say_hello():
    '''
    这是一个打招呼的方法
    你好世界  你好 python 你好 云计算
    '''
    print('hello world')
    print('hello python')
    print('hello 云计算')


say_hello()

四、函数的参数

1.格式

def  变量名称(参数1，参数2，参数3.........):

     ....函数体....

# 需求：定义一个求和函数
# 这个函数只能求出10+20的值，扩展性不高，
def sum_num():
    num1 = 10
    num2 = 20
    num3 = num1 + num2
    print(num3)


sum_num()
'''函数的参数：
格式
def 函数名称(参数1，参数2，参数3.......):
    ....函数体....
说明：
1，在小括号里写的变量名就是函数的参数，多个参数之间使用逗号","隔开
2.函数定义几个参数，调用的时候，就必须传递对应的参数的个数
定义函数的参数是形参   形式的参数
调用函数是的参数是实参    实际的参数

'''


def sum_num(aa, bb):
    print(aa, '----->', bb)
    num1 = aa
    num2 = bb
    num3 = num1 + num2
    print(num3)


sum_num(1, 2)

2.参数的数据类型

（1）可变，不可变数据类型

可变数据类型lsit   dict   set............
不可变数据类型str   tuple   int     float............

（2）注意：

  • 如果传递的是不可变数据类型，会重新开辟一块新的内存空间，函数体中不能修改传递的值的大小
  • 1）
  • a = 10000
print(id(a))  # 31178544
print(a)  # 10000


def func(b):
    print(id(b))  # 31178544
    print(b)  # 10000


func(a)

  • 2）
  • a = 10000
print(id(a))
print(a)


def func(b):
    print(id(b))
    print(b)
    b = 200
    print(id(b))
    print(b)


func(a)
print(id(a))
print(a)
# 34586416
# 10000
# 34586416
# 10000
# 1623426288
# 200
# 34586416
# 10000

  • 如果传递的是可变数据类型，用的是它的方法，不会开辟新的内存空间，可直接修改函数体中传递的内容
  • 1）
outter_list = [1, 2, 3]
print('----->', outter_list)  # -----> [1, 2, 3]


def func(inner_list):
    print('inner_list', inner_list)  # inner_list [1, 2, 3]


func(outter_list)

  • 2） 
    outter_list = [1, 2, 3]
print(outter_list)  # [1, 2, 3]
print(id(outter_list))  # 41952840


def func(inner_list):
    print(inner_list)  # [1,2,3]
    print(id(inner_list))  # 41952840
    inner_list.append(4)
    print(inner_list)  # [1,2,3,4]
    print(id(inner_list))  # 41952840


func(outter_list)
print(outter_list)  # [1,2,3,4]
print(id(outter_list))  # 41952840

  • 如果传递的是可变数据类型，重新给它赋值，会开辟新的内存空间
  • outter_list = [1, 2, 3]
print(outter_list)  # [1,2,3]
print(id(outter_list))  # 31663688


def func(inner_list):
    print(inner_list)  # [1,2,3]
    print(id(inner_list))  # 31663688
    inner_list = [3, 4, 5, 6]
    print(inner_list)  # [3,4,5,6]
    print(id(inner_list))  # 31664008


func(outter_list)
print(outter_list)  # [3,4,5,6]
print(id(outter_list))  # 31664008

3.参数的类型

（1）位置参数，关键字参数，默认参数，可变参数（*args,     **kwargs）

位置参数

实参与形参一一对应，按位置传递参数

第一个实参给第一个形参传值，第二个实参给第二个形参传值

 

 
关键字参数

我们在传参的时候，以形参等于实参的形式忽略形参定义的顺序进行传参的传参方式

形参是什么，实参就是什么

关键字只能是形参中声明过得才能使用

 
默认参数

在定义函数的形参的过程中，可以给形参赋一个初始值（默认值），这种参数叫做默认参数

当调用函数的时候，如果不给默认参数赋值，函数就会使用默认值，如果给默认参数赋值，

函数就会使用重赋的值

 
可变参数

（1）如果函数中参数过多，我们定义起来就比较麻烦，调用起来也非常麻烦，

因此Python给我们提供了可变参数类型，能处理比当初声明时更多的参数，

会将传入的参数可以接收多个位置参数

（2）格式：   * 变量名

（3）注意事项：

          多个位置参数组织成一个元组类型

          一般情况下，使用的变量类型名称叫做args(arguments)

用来接收多个位置参数

*args

 

*  具有打散元组的功能

可变参数

（1）关键字参数组织成一个字典类型的数据

（2）** 可以打散字典

用来接收多个关键字参数

**kwargs

 

** 具有打散字典的功能

  • 位置参数
def func(num1, num2):
    print(num1)  # 1
    print(num2)  # 2
    print(num1 + num2)  # 3


func(1, 2)
  • 关键字参数
def func(num1, num2):
    print(num1)  # 10   10
    print(num2)  # 20    30
    print(num1 + num2)  # 30   40


# func(num1=10, num2=20)
func(num2=30, num1=10)
  • 默认参数
def save_userinfo(name, age, gender='男'):
    print('姓名：{}，年龄：{}，性别：{}'.format(name, age, gender))


save_userinfo('wb', 20)  # 姓名：wb，年龄：20，性别：男
save_userinfo('hua', 20, gender='女')  # 姓名：hua，年龄：20，性别：女
  • 可变参数（* args）
# * 变量名   用来接收多个位置参数
def func(*aa):
    print(aa)  # (1, 2, 3, 4, 5)
    print(aa[0], aa[1])  # 1 2


func(1, 2, 3, 4, 5)
# *  有打散元组的功能
tup = (1, 2, 3)


def func(a, b, c):
    print(a, b, c)  # 1 2 3 


func(*tup)

#  * args
def func(*args):
    print(args)  # (1,2,3,4)
    print(args[0])  # 1
    print(args[1])  # 2


func(1, 2, 3, 4)
  • 可变参数（** kwargs）
def func(**kwargs):
    print(kwargs)  # {'name': 'zs', 'age': 20}
    print(kwargs['name'])  # zs
    print(kwargs['age'])  # 20


func(name='zs', age=20)


#
def func(name, age):
    print(name, age)  # ww 14


dic = {'name': 'ww', 'age': 14}
func(**dic)

（2）位置参数与关键字参数混用

必须位置参数在前，关键字参数在后

def func(num1, num2):
    print(num1)  # 10
    print(num2)  # 10
    print(num1 + num2)  # 20   


# func(num1=10, num2=20)
# func(num2=30, num1=10)
func(10, num2=10)
# func(num1=10, 20) 位置参数在关键字参数之后会报错

（3）参数顺序

位置参数>* args >默认参数> ** kwargs

位置参数     接收多个位置参数  默认参数   接收多个关键字参数

五、函数的返回值

1.格式

def  函数名(参数1，参数2，参数3..........)：

    ....函数体.....

    reutrn .......

def sum_num(aa, bb):
    num3 = aa + bb
    return num3


ret = sum_num(1, 3)
print(ret)  # 4

2.注意

（1）在函数体的最后一行使用一个关键字return要返回的值

（2）定义一个变量来接收函数的返回值

（3）如果没有在函数体中定义返回值，就返回一个None

def func():
    print('func...')


ret = func()
print(ret)  # None

（4）return有两个作用：

  •        结束函数：一般return后面不会写其他代码
  •       返回

3.函数返回多个值

（1）格式

def 函数名（参数1，参数2，参数3......）:

    .....函数体.....

    return 值1，值2.......

（2）注意事项

  •      多个值之间用逗号隔开
  •      多个值被组织成一个元组返回
  • def func():
    a = 10
    b = 20
    return a, b


ret = func()
print(ret)  # (10, 20)

     

  •      用多个变量接收返回的值
  • # 用多个变量来接收元组的值
tup = (1, 2, 3)
a, b, c = (1, 2, 3)
print(a, b, c)  # 1 2 3
# a, b, c, d = (1, 2, 3)
# print(a, b, c, d)#会报错   变两个数多于元组内元素的个数
# 用多个变量来接收函数的多个返回值
def func():
    a = 10
    b = 20
    return a, b


num1, num2 = func()
print(num1, num2)  # 10 20

     

六、函数的嵌套

def outter():
    print('aaa')

    def inner():
        print('bbb')

    inner()


outter()
# aaa
# bbb
def func1():
    print('func1...')


def func2():
    func1()
    print('func2...')


def func3():
    func2()
    print('func3...')


func3()
# func1...
# func2...
# func3...

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值