03_函数编程-上篇

目录

1.函数编程_上_概述

 2.函数的定义

3.函数的参数

3.1 概述

 3.2 实参和形参

3.3 参数的分类

3.3.1 实参的分类

3.3.2 形参的分类

3.4 动态传参

4.返回值

5.python的内置函数（一部分）

---

1.函数编程_上_概述

"""
函数的概念
函数的参数
函数的返回值
python内置函数

"""

 2.函数的定义

函数: 对某一个特定的功能或者代码块进行封装. 在需要使用该功能的时候直接调用即可

好处: 让程序更加简洁. 代码更加合理

定义:
def 函数的名字():
    被封装的功能或者代码块->函数体

调用:
函数的名字()

def buy_cai():  # 定义函数
    print("1. 打车")
    print("2. 去菜市场")
    print("3. 讨价还价")
    print("4. 回家")


buy_cai()

#结果：
1. 打车
2. 去菜市场
3. 讨价还价
4. 回家

3.函数的参数

3.1 概述

参数: 可以在函数调用的时候. 给函数传递一些信息

"""
参数: 可以在函数调用的时候. 给函数传递一些信息

分类:
    1. 形参, 在函数定义的时候. 需要准备一些变量来接收信息
        1. 位置参数, 按照位置一个一个的去声明变量
        2. 默认值参数,  在函数声明的时候给变量一个默认值, 如果实参不传递信息. 此时默认值生效, 否则就不生效
        3. 动态传参.
             1. *args,  表示接收所有的位置参数的动态传参
             2. **kwargs, 表示接收所有的关键字的动态传参

        顺序*: 位置 > *args > 默认值 > **kwargs

        上述参数可以随意搭配使用

    2. 实参, 实际在调用的时候传递的信息
        1. 位置参数. 按照位置进行传递参数
        2. 关键字参数. 按照参数的名字进行传递参数
        3. 混合参数.
            顺序: 位置参数放前面, 关键字参数放后面 -> 否则报错! 官方不让这么干
        实参在执行的时候. 必须要保障形参有数据



"""

 3.2 实参和形参

# 1.骂谁?  2.骂道什么程度?
def maren(ren, lvl):  # 形参
    print("1. 怒目而视", ren)
    print("2. 验证交涉", ren)
    if lvl > 99:
        print("3. 死不要脸")
    else:
        print("3. 你愁啥")
    print("4. 骂完手工")


maren("破键盘", 188)  # 在调用函数的时候. 才能知道到底骂谁, 骂道什么程度  -> 实参
maren("破鼠标", 10)

#结果：
1. 怒目而视 破键盘
2. 验证交涉 破键盘
3. 死不要脸
4. 骂完手工
1. 怒目而视 破鼠标
2. 验证交涉 破鼠标
3. 你愁啥
4. 骂完手工

Process finished with exit code 0

3.3 参数的分类

3.3.1 实参的分类

def chi(zhu, fu, tang, tian):
    print(zhu, fu, tang, tian)

#位置参数. 按照位置进行传递参数
chi("大米饭", "西红柿炒鸡蛋", "紫菜蛋花汤", "哈根达斯")

#关键字参数. 按照参数的名字进行传递参数
chi(zhu="小米饭", tang="胡辣汤", fu="韭菜炒大腰子", tian="老中街冰棍")

#位置参数放前面, 关键字参数放后面
chi("小米饭", "胡辣汤", tang="韭菜炒大腰子", tian="老中街冰棍")


#结果：
大米饭 西红柿炒鸡蛋 紫菜蛋花汤 哈根达斯
小米饭 韭菜炒大腰子 胡辣汤 老中街冰棍
小米饭 胡辣汤 韭菜炒大腰子 老中街冰棍

3.3.2 形参的分类

#位置参数, 按照位置一个一个的去声明变量
#默认值参数,  在函数声明的时候给变量一个默认值, 如果实参不传递信息. 此时默认值生效, 否则就不生效

def luru(name, age, gender="男"):
    print(name, age, gender)


luru("张三", 18)
luru("李四", 28)
luru("王二麻子", 38)
luru("吴老二", 14)
luru("赵敏", 12, "女")
luru("周芷若", 11, "女")

#结果：
张三 18 男
李四 28 男
王二麻子 38 男
吴老二 14 男
赵敏 12 女
周芷若 11 女

Process finished with exit code 0

3.4 动态传参

# * 表示位置参数的动态传参, *接收到的值会被统一放在一个元组里面

def chi(*food):  # * 表示位置参数的动态传参, *接收到的值会被统一放在一个元组里面
    print(food)


chi('大米饭', "烧茄子", '紫菜蛋花汤', "哈根达斯")
chi("大米饭")
chi("大米饭", "烧茄子")
chi("大米饭", "紫菜蛋花汤")
chi("大米饭", "紫菜蛋花汤", "紫菜蛋花汤")


#结果：
('大米饭', '烧茄子', '紫菜蛋花汤', '哈根达斯')
('大米饭',)
('大米饭', '烧茄子')
('大米饭', '紫菜蛋花汤')
('大米饭', '紫菜蛋花汤', '紫菜蛋花汤')

Process finished with exit code 0

# ** 表示接收关键字的动态传参, 接收到的所有参数都会被处理成字典

def chi(**food):  # ** 表示接收关键字的动态传参, 接收到的所有参数都会被处理成字典
    print(food)


chi(fu="木须柿子", zhu="小米饭")


#结果：
{'fu': '木须柿子', 'zhu': '小米饭'}

# 混合传参 顺序*: 位置 > *args > 默认值 > **kwargs

def func(a, b, *args, c="哈哈", **kwargs):
    print(a, b, c, args, kwargs)


func(1,2,3,4, c="呵呵", hello=456, hahalou =654)



#结果：1 2 呵呵 (3, 4) {'hello': 456, 'hahalou': 654}

def func(*args, **kwargs):  # 没有限制的接收任何参数
    print(args, kwargs)

func()  # (), {}
func(1) #  (1, ), {}
func(1,2,3,4,4, a=2)  # (1,2,3,4,4), {"a":2}
func(1,2,3,4, c=4, a=2)# (1,2,3,4), {"c":4, "a":2}

4.返回值

"""
    返回值: 函数执行之后. 会给调用方一个结果. 这个结果就是返回值

    关于return:
        函数只要执行到了return. 函数就会立即停止并返回内容. 函数内的return的后续的代码不会执行
        1. 如果函数内没有return , 此时外界收到的是None
        2. 如果写了return
            1. 只写了return, 后面不跟数据, 此时接收到的依然是None  -> 相当于break
            2. return 值 , 此时表示函数有一个返回值, 外界能够收到一个数据 -> 用的最多
            3. return 值1, 值2, 值3....., 此时函数有多个返回值, 外界收到的是元组, 并且, 该元组内存放所有的返回值
"""

def func(a, b):
    print(a + b)
    return a + b
#
#
ret = func(10, 20)
print(ret * 3)   

# 结果：30
       90

# 如果函数内没有return , 此时外界收到的是None

def func():
    pass
    # return None

ret = func()

print(ret)  #结果：None
   

return   # 会让程序停止.  后续代码不会继续执行. 有点儿像循环里面的break

def func():
    print(123)
    return   # 会让程序停止.  后续代码不会继续执行. 有点儿像循环里面的break
    print(456)

ret = func()
print(ret)

#结果：123
       None

return 值1, 值2, 值3....., 此时函数有多个返回值, 外界收到的是元组, 并且, 该元组内存放所有的返回值

def func():
    return 1, 2, 3, 4


ret = func()
print(ret)


#结果:(1, 2, 3, 4)

5.python的内置函数（一部分）

内置函数: 直接能拿来用的函数

# # bin, oct, hex（二进制，八进制，十六进制）

# # bin, oct, hex
a = 18  # 十进制
print(bin(a))  # 0b10010
print(oct(a))  # 0o22
print(hex(a))  # 0x12



# a = 0b10010
# print(int(a))  # 二进制转化成十进制 #18

# sum（总和）, min（最小值）, max（最大值）, pow（次方）

a = 10
b = 3
print(pow(a, b))
print(a ** b)  # 次幂

#结果：1000
       1000

lst = [12,456,32,18,64,57]
print(max(lst))
print(min(lst))
print(sum(lst))

#结果：
456
12
639

# list（列表） slice（切割）

s = {1,2,3,}
lst = list("呵呵哒")  # 内部一定会有一个循环(for)
print(lst)

s = slice(1, 4, 2)  # [1:4:2]
print("呵呵呵呵呵呵呵呵呵"[s])


#结果：['呵', '呵', '哒']
       呵呵

# enumerate, all, any

print(all([1, "123", '豆沙包']))   # 当成and来看  t and t and t
print(any([0, "", '']))  # 当成or来看

# 结果：True
        False

lst = ["张无忌", "张翠山", "张三丰", "张大大"]

for index, item in enumerate(lst):
    print(index, item)

#结果：
0 张无忌
1 张翠山
2 张三丰
3 张大大