python函数暗中同意参数成效域

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))

 

python 在调用时计算默认值

大家都知道python的默认值是在函数定义时计算出来的,
也就是说默认值只会计算一次, 之后函数调用时, 如果参数没有给出,

同一个值会赋值给变量, 这会导致, 如果我们想要一个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

复制代码

这样两次调用foo(1), 结果为:

 

[3]

[3]

这个decorator有对未修改默认参数值做优化,
在我们不对默认值修改的情况下(比如打印变量a的内容), 性能有很大提升:

 

复制代码

@compute_default_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′)

复制代码

执行结果(调用1000000次的总时间)

 

4.32704997063

0.630109071732

0.445858955383

0.26370882988

性能上还过得去….

在调用时计算默认值
大家都知道python的默认值是在函数定义时计算出来的,
也就是说默认值只会计算一次, 之后函数调用时, 如果参数…

1.1.可变和不可变参数

  2.如果,没有特殊需求,函数参数,尽量不采用对象,如果一有需要,对象进行内处理。传默认值None

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

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}

=


那么如果不想出现,每次调用,默认值对象不变的问题,可以这样改一下:

# namn -文件名

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


 

file.write(content)

1.4.可变参数-元组

在Python函数中,还可以定义可变参数。顾名思义,可变参数就是传入的参数个数是可变的,可以是1个、2个到任意个,还可以是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


输出结果:

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

(1).局部变量

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

不同的函数,可以定义相同的名字的局部变量,但是各用个的不会产生影响

局部变量的作用,为了临时保存数据需要在函数中定义变量来进行存储,这就是它的作用

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

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

# 创建 word_filter()
函数,作用:单词过滤器

不可变类型:

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

初始值设置为None,通过类型判断来,进行内处理

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

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


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

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

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

1.2.必选参数

必选参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

例如:

def f(a,b):

print(‘jjjjjj’)

return a+b

print(f(1,2))

输出结果为:

jjjjjj


看到以上结果有什么想法,为什么呢???[1,
3]而不是[3],那么修改一下代码,输出b变量的内存地址看一下。我想,可以找到我要的答案

 

可变类型:

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

引用。


 

 

局部变量

      
1.python定义def的时候,如果参数做为对象,那么,如果没有改变这个对象的前提下,那么即使,多次调用该函数也,不会创建新的对象。

 ***

1.9.全局和局部变量重名

如果全局变量的名字和局部变量的名字相同,那么使用的是局部变量

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

全局变量能够在所以的函数中进行访问

如果在函数中修改全局变量,那么就需要使用global进行声明

如果全局变量的名字和局部变量的名字相同,那么使用的是局部变量的,

小技巧强龙不压地头蛇

=


D:Python27python.exe D:/untitled1/temp5.py
170580872
[1]
171586568
['a', 'b', 'c', 2]
170580872
[1, 3]

以上代码输出:

全局变量

小结:

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

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}

=


[1] 
[‘a’,’b’,’c’,’2′] [3]   ?????你是否认为是这样? 输出一下看看

c_in = int(c_in)

1.10.递归函数

如果一个函数在内部不调用其它的函数,而是自己本身的话,这个函数就是递归函数。

满足递归的条件:

有循环的内容

有跳出的条件

递归默认是有递归深度要求的。

=


 

*****

(2).全局变量

如果一个变量,既能在一个函数中使用,也能在其他的函数中使用,这样的变量就是全局变量

如果要再函数中修改全局变量,使用global声明。

例如:

a=100

print(a)

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

def f():

    a=200

f()

print(a)

以上代码中,定义了一个全局变量,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

以上代码,定义了一个局部变量个一个全局变量,就近原则有限使用局部变量。

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
定义了一个全局变量,此时为全局变量。此时的全局变量已经改变。

=


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

 

1.参数的介绍

(1)可变和不可变参数

(2)必选参数

(3)默认参数

(4)可变参数

(5)关键字参数


 

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

1.11.匿名函数

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

lambda函数的语法只包含一个语句,如下:

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

注意:

Lambda函数能接收任何数量的参数但只能返回一个表达式的值

输出结果:

 

1.8.变量作用域介绍

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下:

当def函数参数默认值为对象时,例如列表[],字典{}

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

 

     Python
中所谓的使用函数,就是把你要处理的对象放到一个名字后面的括号里。简单来说,函数就是这么使用的,往里面塞东西就可以得到处理结果。

         
那么就会出现多次调用函数,有可能都进行了处理。

# 该函数共有3个参数:

示例1:猜测一下,会输出什么??? 

 

 

– Python 的 内建函数(Built-in Functions)

从输出中,可以看出,除了,第二个print,其它两个内存是一们的。那么考虑一下为什么第二个为被改变。结果显而易见,因为第二个print改变了,b对象,重新创建了一个对象。

 

 

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

– Python 创建函数的格式如下:

2.4、设计自己的函数

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

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

 

 

图片 1

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

– 位置参数 与 关键词参数

Python 3.60 的 68个 内建函数(Built-in Functions):

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

发表评论

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