菜单

Python入门笔记02

2019年3月31日 - 金沙编程资讯

输出结果:

a = 1

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的暗中同意值是在函数定义时计算出来的,
也等于说暗许值只会总括3遍, 之后函数调用时, 如若参数没有交给,

同贰个值会赋值给变量, 那会招致, 假诺我们想要二个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′)

复制代码

实践结果(调用一千000次的总时间)

 

4.32704997063

0.630109071732

0.445858955383

0.26370882988

品质上还过得去….

在调用时计算暗中同意值
大家都知晓python的暗中认可值是在函数定义时计算出来的,
也等于说默许值只会总计二次, 之后函数调用时, 假使参数…

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

 

1.2.必选参数

必选参数须以科学的一一传入函数。调用时的数据必须和声明时的均等。

例如:

def f(a,b):

print(‘jjjjjj’)

return a+b

print(f(1,2))

出口结果为:

jjjjjj


         
那么就会产出反复调用函数,有大概都进展了处理。

# 创立3个函数,总计梯形面积:

(1).局部变量

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

分裂的函数,可以定义相同的名字的部分变量,不过各用个的不会暴发震慑

部分变量的效益,为了一时半刻保存数据须要在函数中定义变量来进行仓库储存,那正是它的机能

那正是说只要不想出现,每便调用,暗许值对象不变的题材,能够那样改一下:

澳门金沙国际 1

1.参数的牵线

(1)可变和不可变参数

(2)必选参数

(3)私下认可参数

(4)可变参数

(5)关键字参数


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

 

有些变量

 

 

可变类型:

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

引用。


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(tra_area(1,2,b=3)) #
-退步!原因:同二个参数不可能被重新赋值!

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}

=


演示1:估计一下,会输出什么??? 

  参数的默许值能够被改动,即 暗许参数可以被重新赋值。

1.11.匿名函数

用lambda关键词能创制小型匿名函数。那种函数得名于简单了用def评释函数的正经步骤。

lambda函数的语法只含有二个讲话,如下:

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

注意:

拉姆da函数能接收任何数据的参数但只好回到3个表明式的值

当def函数参数默许值为指标时,例如列表[],字典{}

 

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.python定义def的时候,如若参数做为对象,那么,倘诺没有更改这几个目标的前提下,那么固然,数次调用该函数也,不会创立新的靶子。

f = temp_converter(c_in)

1.4.可变参数-元组

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


 

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

全局变量

 

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

1.1.可变和不可变参数

[1] 
[‘a’,’b’,’c’,’2′] [3]   ?????你是还是不是觉得是这么? 输出一向下探底视

☆ 注意:

1.9.全局和部分变量重名

要是全局变量的名字和一部分变量的名字同样,那么使用的是一对变量

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

全局变量能够在就此的函数中举行走访

假设在函数中期维修改全局变量,那么就要求使用global进行宣示

一旦全局变量的名字和有个别变量的名字一样,那么使用的是一对变量的,

小技巧强龙不压地头蛇

=


 

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

不可变类型:

类似 c++ 的值传递,如
整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象自小编。比如在
fun(a)内部修改 a 的值,只是修改另2个复制的对象,不会潜移默化 a 自己。

从出口中,能够观看,除了,第一个print,另外多个内部存款和储蓄器是一们的。那么考虑一下为啥第二个为被更改。结果肯定,因为第2个print改变了,b对象,重新成立了二个目标。

  |

(2).全局变量

假设3个变量,既能在1个函数中使用,也能在别的的函数中应用,那样的变量正是全局变量

一旦要再函数中期维修改全局变量,使用global注解。

例如:

a=100

print(a)

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

def f():

    a=200

f()

print(a)

以上代码中,定义了一个全局变量,a=100,定义了1个不曾重临值和参数的函数f,在函数中定义了2个局地变量a=200。

输出结果为:

100

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

100

其次个结实,即便有一些变量但是尚未被调用,调用的依旧全局变量a=100.

def f(a):

    print(‘num=%s’%num)

num=111

f(100)

print(num)

输出结果为:

num=111

111

以上代码,定义了1个全局变量,而从不局地变量,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:\Python27\python.exe D:/untitled1/temp5.py
170580872
[1]
171586568
['a', 'b', 'c', 2]
170580872
[1, 3]

# content -文件内容

1.10.递归函数

借使贰个函数在里面不调用其余的函数,而是本身自个儿的话,那些函数正是递归函数。

满意递归的标准:

有轮回的内容

有跳出的规范

递归私下认可是有递归深度须求的。

=


 

c_in = int(c_in)

1.8.变量功用域介绍

贰个程序的有所的变量并不是在哪些岗位都能够访问的。访问权限决定于那些变量是在哪个地方赋值的。

变量的成效域决定了在哪部分先后你能够访问哪个特定的变量名称。二种最中央的变量作用域如下:

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

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

因此被号称内建函数,并不是因为还有“外建函数”那么些概念,“内建”的意趣是在
Python 3.60 版本安装完结后,你绝不创立就足以平昔动用那一个函数,即
表示那几个函数是“自带”的而已。

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


出口结果:

☆ 注意:

小结:

# namn -文件名

 

 

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

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

  2.万一,没有优异需要,函数参数,尽量不行使对象,如若一有亟待,对象开始展览内处理。传私下认可值None

# content -内容

开首值设置为None,通过项目判断来,举行内部处理理

☆ 注意:

二、函数

    ①「关键词参数」可以不考虑地方顺序。

 

def tra_area(a,b,h):

 

print(tra_area(a=1,b=2,3)) # 
-退步!原因:「地点参数」不能够在「关键词参数」之后出现!

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

print(tra_area(h=3,b=2,1)) #
-失利!原因:「地点参数」无法在「关键词参数」之后出现!

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

以上代码输出:

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

2.四 、设计本身的函数

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

相关文章

发表评论

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

网站地图xml地图