python函数暗中认可参数成效域,Python入门笔记02

by admin on 2019年3月26日

当def函数参数暗中认可值为目的时,例如列表[],字典{}

二、函数

1.参数的牵线

(1)可变和不可变参数

(2)必选参数

(3)默许参数

(4)可变参数

(5)关键字参数


python 在调用时总计暗中同意值

大家都知道python的私下认可值是在函数定义时总括出来的,
也正是说暗中认可值只会猜度1次, 之后函数调用时, 借使参数没有交到,

同1个值会赋值给变量, 那会造成, 假诺大家想要一个list暗许值,
新手经常那样写:

 

def foo(a=[]):

 a.append(3)

 print a

实在是不对的,两回调用会那样的结果:

 

[3]

[3, 3]

实质上应当如此写

 

def baz(a=None):

   a = a or []

    a.append(3)

    print a

三遍调用输出以下结果:

 

[3]

[3]

 

 

 

 

诸如此类好挫啊, 搞的即便有私下认可值用法,可是大家却须要写的和js,lua一样,
我们无法像c++一样, 在函数运行时老是执行暗中认可值么.

用decorator能够里丑捧心下

 

复制代码

import functools

import copy

def compute_default_value_for_each_call(func):

    defaults = func.__defaults__

    if not defaults:

        return None

    defaults = tuple(copy.copy(x) for x in defaults)

 

    @functools.wraps(func)

    def wrapper(*args, **kwargs):

        if func.__defaults__ != defaults:

            func.__defaults__ = tuple(copy.copy(y) for y in
defaults)

        return func(*args, **kwargs)

 

    return wrapper

 

 

@compute_default_value_for_each_call

def foo(b, a=[]):

    if b:

        a.append(3)

    return a

 

import timeit

bf88必发唯一官网,复制代码

如此五次调用foo(1), 结果为:

 

[3]

[3]

本条decorator有对未修改私下认可参数值做优化,
在大家不对默许值修改的场合下(比如打字与印刷变量a的情节), 品质有十分的大升高:

 

复制代码

@compute_default_python函数暗中认可参数成效域,Python入门笔记02。value_for_each_call

def foo(b, a=[]):

    if b:

        a.append(3)

    return a

 

 

def foo2(b, a=None):

    a = a or []

    if b:

        a.append(3)

    return a

 

import timeit

 

print timeit.timeit(‘foo(1)’, setup=’from __main__ import foo’)

print timeit.timeit(‘foo(0)’, setup=’from __main__ import foo’)

print timeit.timeit(‘foo2(1)’, setup=’from __main__ import foo2′)

print timeit.timeit(‘foo2(0)’, setup=’from __main__ import foo2′)

复制代码

推行结果(调用一千000次的总时间)

 

4.32704997063

0.630109071732

0.445858955383

0.26370882988

天性上还过得去….

在调用时总括私下认可值
我们都知情python的默许值是在函数定义时计算出来的,
也正是说私下认可值只会预计壹次, 之后函数调用时, 固然参数…

 

 

1.1.可变和不可变参数

以身作则1:猜想一下,会输出什么??? 

2.① 、重新认识函数

不行变类型:

类似 c++ 的值传递,如
整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象自笔者。比如在
fun(a)内部修改 a 的值,只是修改另3个复制的对象,不会影响 a 本人。

def ddd(a,b=[]):
    b.append(a)
    return b

print(ddd(1))
print(ddd(2,['a','b','c']))
print(ddd(3))

bf88必发唯一官网 1

可变类型:

看似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la
真正的传过去,修改后fun外部的la也会受影响

引用。


 

     Python
中所谓的应用函数,正是把你要拍卖的对象放置四个名字背后的括号里。简而言之,函数正是那样使用的,往里面塞东西就能够获取处理结果。

1.2.必选参数

必选参数须以科学的次第传入函数。调用时的数码必须和证明时的一样。

例如:

def f(a,b):

print(‘jjjjjj’)

return a+b

print(f(1,2))

输出结果为:

jjjjjj


[1] 
[‘a’,’b’,’c’,’2′] [3]   ?????你是不是觉得是那般? 输出一向下探底望

 

1.3.私下认可参数

调用函数时,缺省参数的值借使没有传到,则被认为是暗中同意值

例如:

def f(a,b=100):

    print(‘********************’)

    return a+b

print(f(1))

print(f(1,b=20))

print(f(1,3))

print(‘############################$$$#############################’)

def f(a=100,b=200):

    print(‘****************’)

    return a+b

print(f(1,2))

print(3,2)

print(f())

print(f(3))

输出结果为:

********************

101

********************

21

********************

4

############################$$$#############################

****************

3

3 2

****************

300

****************

203


出口结果:

-python函数暗中认可参数成效域,Python入门笔记02。 Python 的 内建函数(Built-in Functions)

1.4.可变参数-元组

在Python函数中,还是能定义可变参数。顾名思义,可变参数就是流传的参数个数是可变的,可以是一个、三个到自由个,还足以是0个。参数组装成三个tutple

def calc(*numbers):

    sum = 0

   for n in numbers:

        sum = sum + n * n

        return sum

例如:

def f(*num):

    print(num)

f(1,2,3,4,5)

f(100,101)

f(111)

f([1,2,3,4],None,True,{‘a’:4})

f()

print(‘***********************************$$$**********************************’)

def f1(*args):

    print(sum(args))

num1=1

num2=2

num3=3

f1(num1,num2,num3)

ls=[1,2,3,4,5]

f1(ls[0],ls[1],ls[2],ls[3],ls[4])

ls=[i for i in range(10)]

f(*ls)

f(ls)

出口结果为:

(1, 2, 3, 4, 5)

(100, 101)

(111,)

([1, 2, 3, 4], None, True, {‘a’: 4})

()

***********************************$$$**********************************

6

15

(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],)

45


D:\Python27\python.exe D:/untitled1/temp5.py
[1]
['a', 'b', 'c', 2]
[1, 3]

 

1.5.可变参数-字典

变参数允许你传入0个或随意个参数,那几个可变参数在函数调用时自动组装为一个tuple。而首要字参数允许你传入0个或私自个含参数名的参数,那一个主要字参数在函数内部自行组装为四个dict。

def person(name, age, **kw):

    print(‘name:’, name, ‘age:’, age, ‘other:’, kw)

例如:

def f(**kvs):

    print(kvs)

f(a=1,b=’abc’,c=[1,2,3])

infos={‘a’:1,’b’:2}

f(**infos)

出口结果为:

{‘c’: [1, 2, 3], ‘a’: 1, ‘b’: ‘abc’}

{‘a’: 1, ‘b’: 2}

=


 

以 Python 3.60 版本为例,一共存在 68 个这么的函数,它们被统称为
内建函数(Built-in Functions)。

1.6.关键字参数

对于主要字参数,函数的调用者能够流传任意不受限制的重庆大学字参数。至于到底传入了怎么,就须要在函数内部通过kw检查。

专注:倘诺要限制重点字参数的名字,就足以用命名第②字参数。

def person(name, age, *, city, job):

    print(name, age, city, job)

例如:

def f(a,b):

    print(‘a=%s,b=%s’%(a,b))

f(b=1,a=2)

出口结果为:

a=2,b=1


看样子上述结果有如何想法,为啥吗???[1,
3]而不是[3],那么修改一下代码,输出b变量的内部存款和储蓄器地址看一下。小编想,能够找到本身要的答案

于是被称呼内建函数,并不是因为还有“外建函数”那个概念,“内建”的意味是在
Python 3.60 版本安装完结后,你不要创立就足以一贯动用那几个函数,即
表示这个函数是“自带”的而已。

1.7.参数组合

在Python中定义函数,能够用必选参数、暗中同意参数、可变参数、关键字参数和命名首要字参数,那5种参数都足以构成使用。不过请留意,参数定义的次第必须是:

必选参数、私下认可参数、可变参数。

例如:

def f(a,b=1,*c,**d):

print(a)

print(b)

print(c)

print(d)

f(1,2,3,4,5,6,dd=100,bb=30)

输出结果为:

1

2

(3, 4, 5, 6)

{‘bb’: 30, ‘dd’: 100}

=


def ddd(a,b=[]):
    b.append(a)
    print(id(b)) #查看内存地址
    return b

print(ddd(1))
print(ddd(2,['a','b','c']))
print(ddd(3))

 

1.8.变量成效域介绍

二个先后的具备的变量并不是在哪些岗位都得以访问的。访问权限决定于这么些变量是在哪里赋值的。

变量的作用域决定了在哪部分程序你能够访问哪个特定的变量名称。三种最宗旨的变量功用域如下:

输出结果:

Python 3.60 的 六拾四个 内建函数(Built-in Functions):

全局变量

D:\Python27\python.exe D:/untitled1/temp5.py
170580872
[1]
171586568
['a', 'b', 'c', 2]
170580872
[1, 3]
    Built-in Functions    
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()  
delattr() hash() memoryview() set()  

部分变量

从输出中,可以看来,除了,第②个print,别的三个内部存款和储蓄器是一们的。那么考虑一下为何第②个为被改成。结果肯定,因为第3个print改变了,b对象,重新创造了二个对象。

 

(1).局地变量

一对变量,就是在函数内部定义的变量

不等的函数,能够定义相同的名字的有的变量,不过各用个的不会产生影响

一些变量的功能,为了一时半刻保存数据要求在函数中定义变量来拓展仓库储存,那正是它的效劳

 

 

(2).全局变量

假使3个变量,既能在二个函数中央银行使,也能在其余的函数中动用,那样的变量就是全局变量

假如要再函数中期维修改全局变量,使用global申明。

例如:

a=100

print(a)

print(‘******************************’)

def f():

    a=200

f()

print(a)

上述代码中,定义了3个全局变量,a=100,定义了二个并未再次回到值和参数的函数f,在函数中定义了四个片段变量a=200。

输出结果为:

100

******************************

100

其次个结实,就算有一些变量可是并未被调用,调用的仍旧全局变量a=100.

def f(a):

    print(‘num=%s’%num)

num=111

f(100)

print(num)

输出结果为:

num=111

111

上述代码,定义了二个全局变量,而没有局地变量,num=111,当f=100时,会输出num=111.

def f(num):

    print(‘num=%s’%num)

num=111

f(100)

print(num)

输出结果为:

num=100

111

上述代码,定义了二个有些变量个1个全局变量,就近原则有限使用部分变量。

def f(num):

    num+=1

    print(‘num=%s’%num)

num=111

f(100)

print(num)

出口结果为:

num=101

111

上述代码,有三个有个别变量,和贰个全局变量,在函数运维时,调用了一部分变量,此时的全局变量并不曾变。

num=111

def f():

    global num

    print(‘num1=%s’%num)

    num+=1

    print(‘num2=%s’%num)

f()

print(‘num3=%s’%num)

输出结果为:

num1=111

num2=112

num3=112

上述代码中,global num
定义了二个全局变量,此时为全局变量。此时的全局变量已经济体改变。

=


那么只要不想出现,每趟调用,暗许值对象不变的问题,能够如此改一下:

2.二 、创设函数

1.9.全局和某个变量重名

假设全局变量的名字和一些变量的名字同样,那么使用的是局部变量

在函数外边定义的变量叫做全局变量

全局变量能够在为此的函数中展开访问

一旦在函数中期维修改全局变量,那么就要求采纳global进行宣示

只要全局变量的名字和有些变量的名字如出一辙,那么使用的是局地变量的,

小技巧强龙不压地头蛇

=


def ddd(a,b=None):
    if type(b).__name__!='list':
        b = []

    b.append(a)
    print(id(b)) #查看内存地址
    return b

print(ddd(1))
print(ddd(2,['a','b','c']))
print(ddd(3))

 

1.10.递归函数

假若3个函数在里面不调用其余的函数,而是本人本人的话,那几个函数即是递归函数。

满足递归的标准化:

有轮回的始末

有跳出的尺度

递归默许是有递归深度必要的。

=


初步值设置为None,通过项目判断来,实行内部处理理

– Python 成立函数的格式如下:

1.11.匿名函数

用lambda关键词能创制小型匿名函数。那种函数得名于不难了用def表明函数的标准步骤。

lambda函数的语法只含有叁个言辞,如下:

lambda [arg1 [,arg2,…..argn]]:expression

注意:

Lambda函数能接受任何数据的参数但只好回去3个表达式的值

 

 

小结:

bf88必发唯一官网 2

      
1.python定义def的时候,假设参数做为对象,那么,假设没有改观那些目的的前提下,那么即便,数次调用该函数也,不会成立新的靶子。

 

         
那么就汇合世数次调用函数,有大概都进行了处理。

 

  2.假若,没有非常须求,函数参数,尽量不应用对象,假设一有亟待,对象实行内部处理理。传暗许值None

★ 重 点:

 

  ① def(即 define
,定义)的含义是创建函数,也即是概念八个函数。

  ② 闭合括号前面包车型大巴 冒号( )必不可少。

  ③ 函数「缩进」前边的说话被称作
语句块(block),缩进是为着注明语句和逻辑的附属关系,是 Python
最醒指标风味之一。(超过二分之一语言会用大括号 { } 来注解那样从属关系)

  ④ return 即再次回到结果。在 Python 中 return 是可选的,要是没有 return
即函数的重临值为 ‘None’。 

 

☆ 注意:

  ① def 和 return 是 关键字(keyword),Python
正是靠识别那几个特定的要害字来精晓用户的来意,实现更为复杂的编程。

  ② 在 Python 中 return 是可选的(optional),那表示你在开创函数时不写 return 也足以万事大吉地定义八个函数并调用,只可是再次来到值 是 ‘None’ 罢了。

  ③ 我们把 使用函数 那种行为称为“调用”(call)。即 调用函数 。

 

bf88必发唯一官网 3

 

# 例子,温度的单位有 摄氏度 和 华氏度
,已知 摄氏度 与 华氏度 的转速公式为:F = 9/5*C+32 。

# 以往大家创造3个能实现 摄氏度 转化为
华氏度 的函数,并调用该函数落成转化:

 

def temp_converter(c):

return str(9/5*c+32) + ‘?F’

 

c_in = input(‘请输入摄氏温度:’)

c_in = int(c_in)

f = temp_converter(c_in)

print(‘华氏温度为:’ + f)

 

 

2.三 、传递参数与参数类型

 

– 地点参数 与 关键词参数

 

    根据不相同传递参数的艺术,可以分成:地方参数 (positional argument)
与 驷马难追词参数 (keyword argument)。

 

    在 调用函数 时,依照 该函数被创制时
各参数所在的职位顺序,分别把参数的值按顺序填到对应的地点,那样种传播参数的措施被称作「职位参数 (positional
argument)」。

 

    在 调用函数
时,在每一种参数名称后边赋予二个我们想要传入的值。那种以名称作为一一对应的参数字传送入格局被称作「重视词参数 (keyword
argument)」。

 

bf88必发唯一官网 4

 

# 例子,大家已知 梯形面积的计算公式为:S =
(a+b)*h/2

# 成立3个函数,总结梯形面积:

 

def tra_area(a,b,h):

return 1/2 * (a + b) * h

 

print(tra_area(h=3,b=2,a=1)) #
-成功,输出:4.5

print(tra_area(h=3,b=2,1)) #
-战败!原因:「地方参数」不可能在「关键词参数」之后出现!

print(tra_area(a=1,b=2,3)) # 
-退步!原因:「位置参数」无法在「关键词参数」之后出现!

print(tra_area(1,2,h=3)) #
-成功,输出:4.5

print(tra_area(1,2,b=3)) #
-战败!原因:同一个参数不能够被重新赋值!

 

☆ 注意:

    ①「关键词参数」能够不考虑地点顺序。

    ②「地方参数」不可能在「关键词参数」之后出现!

    ③ 同二个参数无法被再一次赋值!

 

#
大家今后给一组变量赋值,然后再调用函数,大家来看结果会有怎么样变化:

 

a = 1

b = 2

h = 3

print(tra_area(h,b,a)) # 输出:2.5

print(tra_area(h = h,b = b,a = a)) #
输出:4.5

 

☆ 注意:

    在 创设函数 时 设定的参数是「形参」,在 调用函数 时
填入的参数是「实参」,大家要搞了然那八个概念。

 

– 默 认 参 数

 

    暗中认可参数 就是函数中某些有暗许值的参数。调用函数时正是不授予填入参数,该函数照旧能照常运作。

 

  参数的暗许值能够被改成,即 暗许参数可以被另行赋值。

 

   
给多个参数设定暗中认可值(创制暗中认可参数)万分简单,我们只要求在概念参数的时候给参数赋值即可。如下:

 

def tra_area(a,b,h=3):

return 1/2 * (a + b) * h

 

print(tra_area(1,2)) # 输出:4.5

print(tra_area(1,2,6)) # 给默许参数重新赋值 6,输出:9.0

print(tra_area(1,2,h=6)) # 给私下认可参数重新赋值 6,输出:9.0

 

 ☆ print()函数的默许参数
sep(用于设定七个打字与印刷结果里面包车型地铁相间符号)的默许值为‘
’空格,可是我们能够将其重新设定为‘/n’ 即 换行
。也正是说将各种打字与印刷结果以换行符号进行划分。如下:

 

print(‘  *’,’ ***’,’*****’,’  |’,sep=’\n’)

”””””””””””””””””’

上述代码输出:

  *

 ***

*****

  |

”””””””””””””””””’

 

 

2.四 、设计自个儿的函数

 

  * 即便您将来何去何从 函数 和 方法
到底是怎么着关联的话,为了顺遂地以往开始展览,小编得以告知您 方法 便是 函数
的一种,只然则在区别的职位而已,使用原理和函数相当相像。

 

# 创建 file_create()
函数,成效:成立文件(尤其是.py文件)

# 该函数共有多个参数:

# namn -文件名

# content -文件内容

# extension -文件扩大名,即 后缀

# path -文件坐在的目录路径

def file_create(name,content,extension=’py’,path=’E:/PY_Test/New/’):

full_path = path + name + ‘.’ + extension

file = open(full_path,’w’)

file.write(content)

file.close()

print(‘文件 ‘ + name + ‘.’ + extension + ‘ 已被成立在 ‘ + path + ‘
中。’)

 

file_create(‘test’,’# hello world’) #
调用函数

 

 

# 创建 word_filter()
函数,功效:单词过滤器

# 该函数共有3个参数:

# content -内容

# target_word -要被过滤的单词

# new_word – 替换的单词

# 执行成功 再次来到被过滤后的始末(str类型)。

def word_filter(content,target_word=’lame’,new_word=’Awesome’):

return content.replace(target_word,new_word)

 

new_content = word_filter(‘Python is lame! is very lame!! is very very
lame!!!’) # 调用函数

print(new_content)

# 输出:Python is Awesome! is very
Awesome!! is very very Awesome!!!

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图