Day 18 函数之一

函数参数：

1.形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

2.实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

3.位置参数和关键字（标准调用：实参与形参位置一一对应；关键字调用：位置无需固定）

4.默认参数

5.参数组

局部变量和全局变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：

在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

#函数的使用必须遵循：先定义后使用的原则

#函数的定义，与变量的定义是相似的,如果没有事先定义函数而直接引用,就相当于在引用一个不存在变量名

#函数分为：定义阶段（只检测语法不执行代码）和调用阶段

# print(x) #NameError
# x=1

# def func():
#     print(‘hello world‘)
#
# print(func)
# func()

# def bar():
#     print(‘from bar‘)
#
# def foo():
#     print(‘from foo‘)
#     bar()
#
# foo()

# #定义阶段
# def foo():
#     print(‘from foo‘)
#     bar()
#
# def bar():
#     print(‘from bar‘)

# #调用阶段
# foo()

#定义阶段:只检测语法，不执行代码
# def func():
#    if 1>2
#        print(‘hahahahahahah‘)

# def func(): #语法没问题，逻辑有问题，引用一个不存在的变量名
#    asdfasdfasdfasdfasdf

一、函数的使用原则

‘‘‘
返回值：可以返回任意类型
没有return：None
return value: value
return val1,val2,val3 :(val1,val2,val3)

return的效果：只能返回一次值，终止函数的执行
‘‘‘

def foo():
    return 1
    print(‘=====>‘)
    return 2
    return 3
    return 4

print(foo())

二、函数的返回值

#形参与实参：

# def foo(x,y): #x=1,y=2
#     return x+y
#
# foo(1,2)

#===================================part1
#位置参数：按照从左到右的顺序依次定义的参数

# def foo(x,y):
#     print(x)
#     print(y)

#按位置定义的形参,必须被传值，多一个不行，少一个也不行
# foo(1,2,3)

#按位置定义的实参,与形参一一对应
# foo(2,10)

#===================================part2
#关键字参数：实参在定义时，按照key=value形式定义
# def foo(x,y):
#     print(x)
#     print(y)

# foo(y=10,x=1) #关键字参数可以不用像位置实参一样与形参一一对应，指名道姓地传值

def foo(x,y):
    print(x)
    print(y)

# foo(1,10)
# foo(x=1,y=10)
# foo(1,y=10)
# foo(y=10,1)     #所有是有误的！！！
# foo(x=10,1)         #无所谓位置，原则：关键字参数必须在位置参数之后

# foo(1,x=10,y=20)

# def foo(x,y,z):
#     print(x)
#     print(y)
#     print(z)
# # foo(1,z=20,10)
# foo(1,y=2,z=10)
#注意的问题一：位置实参必须在关键字实参的前面
#注意的问题二：实参的形式既可以用位置实参又可以是关键字实参，但是一个形参不能重复传值

#===================================part3
#默认参数：在定义函数阶段，就已经为形参赋值,定义阶段有值，调用阶段可以不用传值
# def func(x,y=10):
#     print(x)
#     print(y)

# func(1,20)
# func(1)

# def func(y=10,x):
#     print(x)
#     print(y)

#位置实参
#关键字实参

#位置形参
#默认参数（形参）

#形参的应用：值经常变化的需要定义成位置形参，
# 值大多数情况下都一样，需要定义成默认参数
# def register(name,age,sex=‘male‘):
#     print(name,age,sex)
#
# register(‘alex‘,1000)
# register(‘wupeiqi‘,9000)
# register(‘yuanhao‘,10000)
# register(‘王铁蛋‘,10000,‘female‘)

#默认参数需要注意的问题一：必须放在位置形参后面
#默认参数需要注意的问题二：默认参数通常要定义成不可变类型
#默认参数需要注意的问题三：默认参数只在定义阶段被赋值一次
# x=10
# def func(name,age=x):
#     print(name)
#     print(age)
# x=20
#
# func(‘egon‘)

# def func(name,age=10,sex=‘male‘,hobby=[‘play1‘,‘play2‘]):
#     print(name)
#     print(age)
#     print(hobby)
#
# func(‘egon‘)

#===================================part4
#可变长参数：可变长指的是实参的个数不固定
#按位置定义的可变长度的实参：*
#按关键字定义的可变长度的实参：**

# def func(x,y,*args): #x=1,y=2,args=(3,4,5,6)
#     print(x,y)
#     print(args)
#
# func(1,2,3,4,5,6)

# def func(x,y,*a):  #args=(3,4,5,6)
#     print(x,y)
#     print(a)
#
# func(1,2,*(3,4,5,6)) #foo(1,2,3,4,5,6)

# def func(x,y,z):
#     print(x,y,z)
#
# # func(1,*(2,3)) #func(1,2,3)
# func(*(2,3)) #func(2,3)

# def func(x,y=2,z=1):
#     print(x,y,z)
#
# func(*(‘a‘,‘b‘,‘c‘)) #func(‘a‘,‘b‘,‘c‘)

# def func(x,y,**kwargs): #x=1,y=2,kwargs={‘a‘:1,‘b‘:3,‘z‘:3}
#     print(x,y)
#     print(kwargs)
#
# func(1,y=2,z=3,a=1,b=3)
# def func(x,y,**kwargs): #x=1,y=2,**kwargs=**{‘a‘:1,‘b‘:3,‘z‘:3}
#     print(x,y)
#     print(kwargs)
#
# func(1,y=2,**{‘a‘:1,‘b‘:3,‘z‘:3}) #func(1,y=2,z=3,b=3,a=1)

# def func(x,y=1,z=1):
#     print(x,y,z)
#
# func(**{‘y‘:2,‘x‘:1,‘z‘:3}) #

# def wrapper(*args,**kwargs): #可以接受任意形式，任意长度的参数
#     print(args)
#     print(kwargs)
#
#
# wrapper(1,2,3,3,3,3,3,x=1,y=2,z=3)

# def index(name,group):
#     print(‘welcome %s to index page，group is: %s‘ %(name,group))
#
# def wrapper(*args,**kwargs): #可以接受任意形式，任意长度的参数
#     # print(args) #args=(1,2,3)
#     # print(kwargs) #kwargs={‘x‘:1,‘y‘:2,‘z‘:3}
#     index(*args,**kwargs) #index(*(1,2,3),**{‘x‘:1,‘y‘:2,‘z‘:3}) #index(1,2,3,z=3,y=2,x=1)
#
# wrapper(name=‘egon‘,group=‘group1‘)

#命名关键字参数:定义在*后的形参，这类形参，必须被传值，而且要求实参必须是以关键字的形式来传值

# def register(**kwargs):
#     print(kwargs)
#     if ‘name‘ in kwargs:
#         print(kwargs[‘name‘])
#     if ‘age‘ in kwargs:
#         print(kwargs[‘age‘])
#

# # register(name=‘egon‘,age=18)
# register()

# def register(*args,name=‘egon‘,age):
#     print(args)
#     print(name)
#     print(age)
#
# # register(name=‘egon‘,age=18)
# register(1,2,2,3,age=10)

# def register(name,age,*,group,**kwargs):
#     print(name)
#     print(age)
#     print(kwargs)
#
# # register(‘egon‘,18)
# register(‘egon1‘,18,hobby=‘paly1‘,group=‘group1‘)

# def func(x,y=1,*args,z,**kwargs):
#     print(x)
#     print(y)
#     print(args)
#     print(z)
#     print(kwargs)
#
# func(1,2,3,4,5,z=10,a=1,b=2)

# def func(x,*args,z=1,**kwargs):
#     print(x)
#     print(args)
#     print(z)
#     print(kwargs)
#
# func(1,2,3,4,5,a=1,b=2,c=3)

#形参：位置形参，默认参数，*args，命名关键字参数，**kwargs

三、函数参数的使用

#函数的嵌套调用
#
# def max2(x,y):
#     if x > y:
#         return x
#     else:
#         return y
#
# def max4(a,b,c,d):
#     res1=max2(a,b) #23
#     res2=max2(res1,c) #23
#     res3=max2(res2,d) #31
#     return res3
#
#
# print(max4(11,23,-7,31))

#函数的嵌套定义
def f1():
    def f2():
        def f3():
            print(‘from f3‘)
        print(‘from f2‘)
        f3()
    print(‘from f1‘)
    f2()
# print(f1)
f1()

‘‘‘
from f1
from f2
from f3

‘‘‘

四、函数的嵌套

#名字空间：存放名字与值的绑定关系

#名称空间分为三种

#一、内置名称空间：python解释器自带的名字，python解释器启动就会生成

#二、全局名称空间：文件级别定义的名字都会存放与全局名称空间，执行python文件时会产生

# x=1
# def func():
#     pass
#
# class Foo:
#     pass
#
# import os
#
# if 1 > 2 :
#     y=3

#三、局部名称空间:定义在函数内部的名字，局部名称空间只有在调用函数时才会生效，函数调用结束则失效
# def func(x,y): #x=1,y=2
#     z=3

# func(1,2)

#三者的加载顺序：内置名称空间->全局名称空间->局部名称空间

#取值：局部名称空间->全局名称空间->内置名称空间

# # max=10
# def func(): #x=1
#     # max=20
#     print(max)
#
#
# func()

# max=10
#
# def func(): #x=1
#     max=20
#     # print(max)
# func()
#
#
# print(max)

# # x=0
# def f1():
#     # x=1
#     def f2():
#         # x=2
#         def f3():
#             # x=3
#             print(x)
#         f3()
#     f2()
#
# f1()

#作用域：作用范围
#全局作用域：内置名称空间与全局名称空间的名字属于全局范围，
            # 在整个文件的任意位置都能被引用，全局有效
#局部作用域：局部名称空间的名字属于局部范围，
            #只在函数内部可以被引用，局部有效

# x=1
# def foo():
#     def f2():
#         print(x)
#     f2()
# def bar():
#     print(x)
#
# foo()
# bar()

# def f1():
#     x=1
#     def f2(): #f2=value
#         # x=2
#         print(x)
#     f2()
# f1()

x=1
def func():
    x=2
    def f1():pass
    # print(dir(globals()[‘__builtins__‘])) #全局作用域name
    # print(locals()) #局部作用域name

func()

print(globals() is locals())

#局部作用域----->全局作用域

五、名称空间与作用域

#函数是第一类对象： 指的是函数可以被当做数据传递

def func():
    print(‘from func‘)

#可被引用
# f=func

#可以当做函数的参数
# def func():
#     print(‘from func‘)
# def foo(x):
#     print(x)
#     x()
#
# foo(func)

#可以当做函数的返回值
# def foo():
#     print(‘from foo‘)
# def bar():
#     return foo
# f=bar()
# print(f)
# print(foo)

# x=0
# def f1():
#     x=1
#     def f2():
#         # x=2
#         print(x)
#     return f2
# f=f1()
# # print(f)
# f()

#可以当做容器类型的元素
# def select():
#     print(‘select function‘)
#
# func_dic={
#     ‘select‘:select,
# }
#
# # print(func_dic[‘select‘])
# func_dic[‘select‘]()

#
# def select():
#     print(‘select func‘)
#
# def delete():
#     print(‘delete func‘)
#
# def change():
#     print(‘change func‘)
#
# def add():
#     print(‘add func‘)
#
#
# while 1:
#     cmd=input(‘>>: ‘).strip()
#     if not cmd:continue
#     if cmd == ‘select‘:
#         select()
#     elif cmd == ‘delete‘:
#         delete()
#     elif cmd == ‘change‘:
#         change()
#     elif cmd == ‘add‘:
#         add()
#     else:
#         print(‘无效的命令‘)

def select(cmd_l):
    filename=cmd_l[-1]
    pattern=cmd_l[1]

    with open(filename,‘r‘,encoding=‘utf-8‘) as f:
        for line in f:
            if pattern in line:
                print(line)

def delete():
    print(‘delete func‘)

def change():
    print(‘change func‘)

def add():
    print(‘add func‘)

def check():
    print(‘check func‘)

func_dic={
    ‘select‘:select,
    ‘delete‘:delete,
    ‘change‘:change,
    ‘add‘:add,
    ‘check‘:check,
}

while 1:
    inp=input(‘>>: ‘).strip()
    if not inp:continue
    cmd_l=inp.split()
    # print(cmd_l)
    cmd=cmd_l[0]
    if cmd in func_dic:
        func_dic[cmd](cmd_l)
    else:
        print(‘无效的命令‘)

六、函数对象

时间： 2024-08-02 15:14:19

Day 18 函数之一的相关文章

6.18 函数查缺，补漏

1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using System.Threading.Tasks; 6 7 namespace 函数查缺补漏 8 { 9 10 class Program 11 { 12 //1. 没有返回值没有参数 13 public void aa() 14 { 15 Console.WriteLine("查缺补漏"

18.函数定义和参数

函数定义:函数是指一组语句的集合通过一个名字封装起来,要执行这个函数,只需调用函数名即可def function(x,y): """ 函数说明 :param x: 参数x,int类型 :param y: 参数y int类型 :return: 返回值 """ res=x*y print(res) return res # return 是函数返回值,不写默认返回的是none,如有多个返回值,以元组形式返回,return下面的代码不再执行functi

调用 get(fgetc) 和 putc(fputc) 函数进行输入、输出

当成功地打开文件后,接下来的事情就是对文件进行输入或输出操作,最简单的是调用 getc(或 fgetc) 和 putc(或 fputc) 函数进行字符的输入和输出. 1.调用 putc(或 fpuct) 函数输出一个字符 putc 函数的调用形式如下: putc(ch, fp); 这里 ch 是待输出的某个字符,它可以是一个字符常量,也可以是一个字符变量:fp 是文件指针.putc(ch, fp) 的功能是将字符 ch 写到文件指针 fp 所指的文件中去.如果输出成功,putc 函数返回所输出的

【Java学习笔记】函数的可变参数

1 package p2; 2 3 public class ParamterDemo { 4 5 public static void main(String[] args) { 6 7 int sum1 = add(4,5); 8 int sum2 = add(4,5,6); 9 int sum3 = add(4,5,6,7); 10 11 System.out.println(sum1); 12 System.out.println(sum2); 13 System.out.println

函数的参数与嵌套使用

函数的使用:先定义后使用 #与变量的定义相似x=1 变量名==函数名def func(): 值 == 函数值 print('hello world') 定义阶段: 只检测语法,不执行代码/ return返回值类型:效果:只能返回一次值,终止函数的执行无return 默认 None return返回值:如果只有一个则返回本身,多个值则为元组形式 形参<形式上存在,而实际不存在,变量名>与实参<实际存在,变量值>:def foo(x,y): return x+y foo(1,2) 位置

Delphi Math单元函数

这个单元包含高性能的算术.三角.对数.统计和金融方面的计算及FPU程序函数用于补充Delphi语言System.pas 单元中的数学常规程序函数注意1) 对于有些函数,这个单元中涉及的概念或常数由Earl F. Glynn (www.efg2.com) 和 Ray Lischner (www.tempest-sw.com)提供.2) 所有的角度参数三角函数的结果都用弧度表示3) 下列大部分的三角和对数程序直接的映射到Intel 80387 FPU4) 浮点机指令.输入域.输出范围和错误处理主要由

Python学习之路6?函数，递归，内置函数

一python中的函数 函数是逻辑结构化和过程化的一种编程方法. python中函数定义方法: def test(x): "The function definitions" x+=1 return x def:定义函数的关键字 test:函数名 ():内可定义形参 "":文档描述(非必要,但是强烈建议为你的函数添加描述信息) x+=1:泛指代码块或程序处理逻辑 return:定义返回值 调用运行:可以带参数也可以不带 函数名() 二 为何使用函数 背景提要 现在老

python3--函数(函数，全局变量和局部变量，递归函数)

1.1函数 1.1.1什么是函数 函数就是程序实现模块化的基本单元,一般实现某一功能的集合.函数名:就相当于是程序代码集合的名称参数:就是函数运算时需要参与运算的值被称作为参数函数体:程序的某个功能,进行一系列的逻辑运算return 返回值:函数的返回值能表示函数的运行结果或运行状态. 1.1.2函数的作用 函数是组织好的,可重复使用的,用来实现单一,或者相关功能的代码. 函数能够提高应用的模块性,和代码的重复利用率 我们已近知道python提供了许多内置函数,比如print(),我们自已创建的

python函数定义语法总结

见下面代码及注释: 1 def calc(value): 2 sum=0 3 for m in value: 4 sum=sum+m 5 return sum 6 7 data=[1,2,3,4,5,6,7,8,9,10] 8 print(str(calc(data))) 9 print(calc([1,2,3])) 10 print(calc((1,2,3))) 11 #print(calc(1,2,3)) 这句会报错,不过可以用可变参数改造函数calc 12 13 def calc1(*va