python基础语法-函数_tykcxac-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_44423372/article/details/98197360

函数

函数是代码的一种组织形式
函数应该能完成一项特定的工作，而且一般一个函数值完成一项工作
有些语言，分函数和过程两个概念，通俗解释是，有返回结构的叫函数，无返回结构的叫过程，python不加以区分

函数的使用
函数的使用需要先定义
使用函数，俗称调用

# 定义一个函数
# 只是定义的划不会执行
# 1.def关键字，后跟一个空格
# 2.函数名，自己定义，起名必需遵循便令命名规则，约定成俗，大驼峰命名只给类用
# 3.后面括号和冒号不能省，括号可以有参数
# 4.函数所有代码缩进

def func():
    print("我这辈子都不可能是函数，不可能！")
    print("真香！")
print("函数结束了")        # 函数结束了
#函数的调用
#直接写出函数名字，后面小括号不能省略，括号内内容根据情况
func()                     # 我这辈子都不可能是函数，不可能！
                           # 真香！

函数的参数
参数：负责和函数传递一些必要的数据或者信息
形参（形式参数）：在函数定义的时候用到的参数，没有具体值，只是一个占位符号
实参(实际参数）：在调用函数的时候输入的值

# 形参和实参的案例
# 参数person只是一个符号
# 调用的时候用另一个

def hello(person):
    print("{0},你好吗".format(person))
    print("{},你看见我加狗蛋了吗？".format(person))
    return None
p = "小明"
# 调用函数， 需要把p作为实参传入
hello(p)
#小明,你好吗
#小明,你看见我加狗蛋了吗？

pp = "小红"
hello(pp)
#小红,你好吗
#小红,你看见我加狗蛋了吗？

pp = hello("飒飒")
print(pp)
#飒飒,你好吗
#飒飒,你看见我加狗蛋了吗？
#None

返回值:
函数和过程的区别
有无返回值
需要用return显示返回内容
如果没有返回，则默认返回None

# 返回值案例
def func_1():
    print("有返回值")
    return 1
def func_2():
    print("没有返回值")
    return None
f1 = func_1()
print(f1)   
f2 = func_2()
print(f2)
###
有返回值
1
没有返回值
None
####

九九乘法表

# version 1.0
for row in range(1,10):
    for col in range(1,row+1):
        #print函数默认任务打印后换行
        print(row * col, end=" ")
    print("-------")   

# 然而这样不简洁

# # version 2.0
#  定义一个函数，打印一行九九乘法表
def printLine(row):
    for col in range(1,row+1):
        print(row * col, end=" ")
    print(" ")
for row in range(1,10):
    printLine(row)

**注释：**help负责随时为你提供帮助
在这里插入图片描述

参数详解
参数分类
普通参数/位置参数
默认参数
关键字参数
收集参数

普通参数
定义的时候直接定义变量名
调用的时候直接把变量或者值放入指定位置
语法：
def 函数名（参数1，参数2，…)：
函数体
调用
函数名（value1，value2，…)
调用的时候，具体值参考的是位置，按位置赋值

# # 普通参数案例
def normal_para(one,two,three):
    print(one + two)
    return None
normal_para(1,2,3)     # 3

**默认参数**
形参带有默认值
调用的时候，如果没有对相应形参赋值，则使用默认值
语法

                 def func_name(p1=v1, p2=v2,  .....):
                     func_block
                  #调用
                  func_name()
                  #调用2
                  value1 =100
                  value2 = 200
                  func_name(value1, value2)

# 默认参数案例
def reg(name, age, gender="male"):
    if gender == "male":
        print("{0} is {1}, and he is a good student".format(name,age))
    else:
        print("{0} is {1}, and she is a good student".format(name,age))
reg("hauhau",19)
reg("rongrong", 18, "female")
###
#hauhau is 19, and he is a good student
#rongrong is 18, and she is a good student

**关键字参数**
语法

     def func(pl=v1,p2=v2......):
           func_body

    #调用函数：
    func(p1=vlaue1,p2=value2......)

比较麻烦，但也有好处：不容易混淆，一般实参和形参只是按照位置一一对应即可，容易出错；使用关键字参数，可以不考虑参数位置

# 关键字参数案例
def stu_key(name="No name", age=0, addr="No addr"):
    print("I am a studet")
    print("我是{0},我今年{1}岁了，我住{2}".format(name,age,addr))
n = "zhizangzang"
a = 18
addr = "我家"
stu_key(age = a, name = n, addr = addr)
###I am a studet
###我是zhizangzang,我今年18岁了，我住我家



# 如果用 普通参数，只按照位置传递，则容易出错，看
def stu(name,age,addr):
    print("I am a student")
    print("我是{0},我今年{1}岁了，我住{2}".format(name,addr,age))
n = "zhizangzang"
a = 18
addr = "我家"
stu(n,a,addr)
####I am a student
####我是zhizangzang,我今年我家岁了，我住18

收集参数
把没有位置，不能定义的参数位置相对的参数，放入一个特定的数据结构中
语法

    def func(*args):
          func_body
          #按照list使用方式访问agrs得到传入的参数
    
    #调用：
    func(p1,p2,p3....)

参数名args不是必定写，但是，我们推荐直接使用args，约定成俗
参数名args前需要有星号
收集参数可以和其他参数共存

def func(*args):
    func_body
    #安装list使用方式访问args得到传入的参数
#调用
func(p1, p2, p3,....)

参数名args不是必然这么写，但是，推荐直接使用args，约定俗成
参数名agrs前必需要有 * 星号
收集参数可以和其他参数共存

在这里插入代码片

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

   def func( **kwargs):
         func_body

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

# 函数模拟一个学生进行自我介绍，但具体内容不清楚
# args 可以看成一个list

def stu( *args):
    print("Hello,大家好，大家先自我介绍下，简要的说几句也都可以的")
    # type函数作用是检查变量的类型
    print(type(args))
    for item in args:
        print(item)
        
stu("须须", "29岁", "湖北武汉", "喜欢唱歌")

stu("壳哥", "年龄未知", "杀杀手的杀手")
###Hello,大家好，大家先自我介绍下，简要的说几句也都可以的
###<class 'tuple'>
###须须
###29岁
###湖北武汉
###喜欢唱歌
###Hello,大家好，大家先自我介绍下，简要的说几句也都可以的
###<class 'tuple'>
###壳哥
###年龄未知
###杀杀手的杀手

收集参数混合调用的顺序问题
收集参数，关键字参数，普通参数可以混合使用
使用规则就是，普通参数和关键字参数优先
定义的时候一般找普通参数，关键字参数，收集参数tuple，收集参数dict

# 收集函数混合调用案例
# stu 模拟一个学生自我介绍
def stu(name, age, hobby = '看电影', *args, **kwargs):
    print("Hello,大家好")
    print("我是{0}，我今年{1}岁了".format(name, age))
    if hobby == "我喜欢看电影":
        print("我喜欢看电影")
    else:
        print("我的爱好是{0}".format(hobby))
    print("*" * 30)
    for i in args:
        print(i)
    print("*" * 30)
    for k,v in kwargs:
        print(k,"---",v)
# 调用函数
name = "壳壳"
age = "x"

stu(name, age)
stu(name, age, hobby="杀杀手")

收集参数的解包问题
把参数放入list或者字典中，直接把list/dict中的值放入参数中
语法：看案例
同理，dict类型收集参数一样可以解包，但是
对dict类型解包，需要两个星号

# 收集函数的解包问题
def stu(*args):
    print("emmmmmm")
    n = 0
    # n = 0 表示循环次数
    #主要用来调用
    for i in args:
        print(type(i))
        print(n)
        n += 1
        print(i)
l = ["huahua", 29, 20, "rongrong"]
stu(l)
# 此时，args的表示形式是字典内一个list类型的元素，即arg = (["huahua", 29,23,"rongrong"])
# 很显然跟我们的想法违背
# 则此时的调用，我们就需要解包符号，即在调用的时候前面加一个星号
stu(*l)
###打印结果为
###emmmmmm
###<class 'list'>
###0
###['huahua', 29, 20, 'rongrong']
###emmmmmm
###<class 'str'>
###0
###huahua
###<class 'int'>
###1
###29
###<class 'int'>
###2
###20
###<class 'str'>
###3
###rongrong

**函数文档

**
函数的文档的作用是对当前函数提供使用相关的参考信息
文档的写法
在函数内部开始的第一行使用字符串定义符
一般具有特定格式
参看案例
文档查看
使用help函数，比如 help(func)
使用__doc__, (两杠）参看案例

# 文档案例
# 函数stu 是模拟一个学生的自我介绍的内容
def stu(name, age, *args):
    "这是文档"
    print("This is hanshu stu")
# 查看文档
help(stu)
stu.__doc__


def stu(name,age):
    """
    这是文档的文子内容
    :param name: 表示学生的姓名
    :param age: 表示学生的年龄
    """
    pass
print(help(stu))
print("*" * 30)
print(stu.__doc__)

变量作用域

变量由作用范围限制
分类：按照作用域分类
全局（global）：在函数外部定义
局部（local）：在函数内部定义
变量的作用范围
全局变量：在整个全局范围都i有效
全局变量在局部可以使用（即函数内部可以方位函数外部定义的变量）
局部变量在局部范围可以使用
局部变量在全局范围无法使用
LEGB原则
L（local）：局部作用域
E（Enclosing function locale）：外部嵌套函数作用域
G（Global module）：函数定义所在模块作用域
B（Buildin）：python内置模块的作用域

a1 = 100
def fun():
    print(a1)
    print("I am in fun")
    # a2 的作用范围是fun
    a2 = 99
    print(a2)
print(a1)
fun()

a1 = 100
def fun():
    print(a1)
    print("I am in fun")
    # a2 的作用范围是fun
    a2 = 99
    print(a2)
print(a1)
fun()
#100
#100
#I am in fun
#99

globals,locals函数
可以通过globals和locals显示局部变量和全局变量

# globals 和 locals
a = 1
b = 2
def fun(a, b):
    e = 123
    print("Locals={0}".format(locals()))
    print("Globals={0}".format(locals()))
fun(100,200)
#Locals={'a': 100, 'b': 200, 'e': 123}
#Globals={'a': 100, 'b': 200, 'e': 123}

**elval()**函数
把一个字符串当成一个表达式来执行，返回表达式执行后的结果
语法：
eval(string_code,globals=None,local=None)
cxac()函数
跟eval功能类似，但是，不返回结果
语法：exac(string…eode,globals=None,local=None)

#eval
x = 100
y = 200
#执行 x + y
# z = x + y
z1 = x + y
z2 = eval("x + y")
print(z1)
print(z2)

#exec
x = 100
y = 200
#执行 x + y
# z = x + y
z1 = x + y
# 1。注意字符串中引号的写法
# 2。比对exac执行结果和代码执行结果
z2 = exec("print('x + y :, x + y')")
print(z1)
print(z2)
#300
#300
#x+y:,x + y
#300
#None