【4858.com】函数初识,全栈开荒

By admin in 4858.com on 2019年4月15日
*—*—python函数初识—*—*
一、函数的初识
若我们不使用len方法,该如何实现求字符串的长度?
答:使用for循环

s = 'tiancai'
count = 0
for i in s:
    count += 1    
print(count)

执行输出:
7

list列表

lis = ['aa','bb',11,22,'abc','天才']
count = 0
for i in lis:
    count += 1
print(count)

执行输出:
6

前天我们来学习函数。
爆发的因由,若未有函数,会显得重复代码多,可读性差,也会促成重复造轮子的风貌。
故发生了函数,用来封装好1个作用,它是以职能为导向的。

python 全栈开荒,Day伍,python开采day5

一 为何要有函数?

 

一、【函数的体制】

诸如自个儿定义三个函数:
def my_len():
def python中的关键字,用来声称和定义几个函数;
my_len 函数名,命名规范与变量命名的如出一辙;
def与函数名中级要隔多少个空格;
函数名+”()”+”:”,括号加冒号,括号里填的要你想要设置函数调用者传递的参数;
紧接着正是缩进的函数体(首要成效完成部分);

例,以下自定义的盘算可迭代对象成分长度的函数:

my_len():
def my_len(l):
    count = 0
    for i in l:
        count += 1
    return count

li = [1, 2, 3, 4, 5]
print(my_len(li))

函数的试行,函数名+”()”就会去调用推行。
函数的再次来到值,定义函数时,不要在函数中写print语句(调试的时候能够如此做),因为函数是以效果为导向的,必要回到输出的值时使用return将值重回给函数的调用者就足以了。
在函数在那之中碰到return时就会完毕试行函数(结合if语句用就会有像循环中break的感到)。

函数重临的值有以下两种:
1)无return语句,返回None;
2)使用了return,返回None;
叁)return钦点再次回到贰个值,该值是怎么样,就直接重临给函数调用者;
四)return重临两个值,将多少个值放置到贰个元组中,重返给函数调用者。

python之函数初识

不加区分地将具备功用的代码垒到联合,难点是:

 

贰、【安慕希运算】

例,在偏下自定义一个用于相比较四个整数大小的函数体中,就应用了安慕希运算:

# 普通的比较两数大小,谁的值大返回谁的函数:
def max_min(a, b):
    if a > b:
        return a
    else:
        return b

print(max_min(290,355))

# 使用了三元运算优化代码:
def max_min(a,b):
    return a if a > b else b

print(max_min(45, 56))
retrun a if a > b else b 的意思是判断如果a > b 就返回a,否则返回b。

1、什么是函数?

今昔有如此个意况:python中的len方法不让用了,你怎么做?

来测试一下‘hello word’ 的长度:

用for循环完毕

s1 = "hello world"
length = 0
for i in s1:
    length = length+1

print(length)

执行输出: 1一

OK,完事儿了,万分周全。但是老板又建议二个必要,要计算两外3个字符串的长度:‘hello
china’,

于是乎你的代码就造成了这么:

用for循环完结

s1 = "hello world"
length = 0
for i in s1:
    length = length+1

print(length)

s2 = "hello china"
length = 0
for i in s2:
    length = length+1

print(length)

施行输出

11
11

如此实在能够兑现len方法的功效,然则总感觉不是那么完美?为何呢?

首先,此前假使我们施行len方法就足以一贯获得三个字符串的长度了,现在为了完毕平等的作用大家把同样的代码写了成都百货上千遍
—— 代码冗余

说不上,此前大家只写两句话读起来也很简短,壹看就精通那两句代码是在测算长度,不过恰恰的代码却不那么轻巧读懂
—— 可读性差

由此,大家就想能还是无法用一段代码,来落到实处均等的功力,比如,我们也写二个len()叫做my_len()能够取代len()的艺术,既消除了代码冗余,有让其可读性好,用什么格局吧?
那就引出了大家前日讲的—-函数。

函数是团队好的,可重复使用的,用来落实单壹,或相关联功能的代码段。

函数能提升使用的模块性,和代码的双重利用率。你已经掌握Python提供了广大内建函数,比如print(),len()等。但您也足以友善创办函数,那被称之为用户自定义函数。

  代码可读性差
  代码冗余
  代码可扩充差

如上写法有二点糟糕的地点:

三、【函数的传参】

分两大方面:实参和形参。
上例中的max_min(四五,5陆)那里的四五和5陆就属于实际传递过去的参数,所以便是实参;
而def中定义函数时现身的max_min(a,b)中的a,b就属于方式上的参数,用于对应参照的,正是形参。

实参角度:
一、地点传参,与形参的职责与个数壹一对应,按梯次,个数无法少也不可能多;
二、关键字传参,同样与形参1一对应,但能够不按顺序,因为有关键字,例如上例在实参中央直机关接填写b=5六,a=45那样。
3、混合传参,正是地方参数和根本字参数混合使用,但要注意的是享有的根本字参数都要放在最前边,也正是岗位参数要在重中之重字参数在此以前。

形参角度:
一、地方传参,按顺序和个数与实参形成梯次对应提到;
贰、默许参数,首要!设置好暗中认可参数后,要是实参中有传递参数过来,就依据实参的参数,假若没有,就径直依照私下认可的预设的值。省事又利落。暗许参数恒久要在岗位参数的末尾。
三、动态参数,后天权且不去询问。

end
2018-3-28

二、函数的定义与调用

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)

#函数调用  
mylen()

实行输出: 11

上边便是我们写了二个函数,并且成功的调用了它。

 

概念:def
关键词开端,空格之后接函数称号和圆括号(),最终还有二个”:”。

4858.com ,   def 是平素的,无法变,他正是概念函数的重点字。

   空格
为了将def关键字和函数名分别,必须空(肆声),当然你能够空2格、三格要么你想空多少都行,但平常人依然空一格。

   函数名:函数名只好分包字符串、下划线和数字且不可能以数字早先。尽管函数名能够不管起,但我们给函数起名字或然要尽只怕轻易,并能表达函数功用

   括号:是必须加的,先别问何故要有括号,同理可得丰盛括号就对了!

疏解:每贰个函数都应当对效益和参数实行对应的表明,应该写在函数上面第贰行。以狠抓代码的可读性。

调用:就是 函数名() 要记得加上括号。

 

怎样缓解?
  函数即工具,事先准备工具的长河是概念函数,拿来就用指的正是函数调用

1.重新的代码多

3、函数的重返值

大家用len()方法时,获得的结果会赋值给2个变量,然后拿走结果:

str_len = len('hello,world')
print(str_len)

推行输出: 1一

不过我们写的那个函数,并不会博得这么的结果,怎么着让他和len函数一样,有重回值呢?

那正是在函数的末段加上一个return,return 后边写你要求的再次回到值就能够了。

return返回值

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length

#函数调用
str_len = mylen()
print('str_len : %s'%str_len)

实践输出: 

str_len : 11

下边大家首要琢磨return关键字的意义:

return关键字的机能

  return
是四个首要字,在pycharm里,你会看出它成为黄绿了。你不能不一字不差的把这么些单词给背下来。

  这些词翻译过来就是“重返”,所以大家管写在return前边的值叫“重返值”

要讨论再次回到值,大家还要领悟再次来到值有三种意况:分别是从未有过重临值、重回3个值、再次来到两个值

从未有过再次来到值

【4858.com】函数初识,全栈开荒。  不写return的情事下,会暗中同意再次来到四个None:大家写的第3个函数,就从未写return,那就是从未再次回到值的1种情况。 

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)

#函数调用
str_len = mylen()
#因为没有返回值,此时的str_len为None
print('str_len : %s'%str_len)

实施输出:

11
str_len : None

 

  只写return,前边不写其余内容,也会回去None,有的同学会离奇,既然未有要赶回的值,完全能够不写return,为啥还要写个return呢?这里我们要说一下return的其余用法,正是若果遇见return,甘休全数函数。

def ret_demo():
    print(111)
    return
    print(222)

ret = ret_demo()
print(ret)

实施输出:

111
None

 

  return None:和地点情状一致,大家1般不这么写。

 

重返贰个值

无独有偶大家早已写过三个赶回二个值的景况,只需在return前面写上要回到的情节就能够。

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length

#函数调用
str_len = mylen()
print('str_len : %s'%str_len)

  施行输出:

str_len : 11

 

回去多个值

  能够回来任意三个、任意数据类型的值

def ret_demo1():
    '''返回多个值''' 
    return 1,2,3,4


def ret_demo2():
    '''返回多个任意类型的值'''
    return 1,['a','b'],3,4

ret1 = ret_demo1()
print(ret1)
ret2 = ret_demo2()
print(ret2)

推行输出:

(1, 2, 3, 4)
(1, [‘a’, ‘b’], 3, 4)

 

  重回的多少个值会被公司成元组被再次回到,也足以用两个值来接受

def ret_demo2():
    return 1,['a','b'],3,4

#返回多个值,用一个变量接收
ret2 = ret_demo2()
print(ret2)

#返回多个值,用多个变量接收
a,b,c,d = ret_demo2()
print(a,b,c,d)

#用多个值接收返回值:返回几个值,就用几个变量接收
a,b,c,d = ret_demo2()
print(a,b,c,d)

实行输出:

(1, [‘a’, ‘b’], 3, 4)
1 [‘a’, ‘b’] 3 4
1 [‘a’, ‘b’] 3 4

 

  结论:函数使用必须是:先定义,后调用

二.代码的可读性差

肆、函数的参数

  未来,咱们已经把函数再次回到值相关的事体切磋清楚了,我们相濡相呴已经做到了叁个得以回去字符串长度的函数。可是今后以此函数依然不圆满,以前大家应用len函数的时候得是length
= len(“hello
world”),那样本人得以想计算何人就总括何人的长度。但是未来我们写的那个函数,只可以总结二个“hello
world”的长短,换贰个字符串好像正是相当了。那可咋做?

带参数的函数

#函数定义
def mylen(s1):
    """计算s1的长度"""
    length = 0
    for i in s1:
        length = length+1
    return length

#函数调用
str_len = mylen("hello world")
print('str_len : %s'%str_len)

执行输出:

str_len : 11

咱俩告知mylen函数要计算的字符串是什么人,这些历程就叫做
传递参数,简称传参,大家调用函数时传递的那么些“hello
world”和概念函数时的s1正是参数

实参加形参

参数还某个:

咱俩调用函数时传递的这一个“hello
world”被称为实则参数,因为这几个是事实上的要提交函数的内容,简称实参

概念函数时的s一,只是叁个变量的名字,被叫做款式参数,因为在概念函数的时候它只是1个试样,表示那里有一个参数,简称形参。 

传递四个参数

参数能够传递七个,多少个参数之间用逗号分割。

def mymax(x,y):
    the_max = x if x > y else y
    return the_max

ma = mymax(10,20)
print(ma)

施行输出:20

 

职位参数

  站在实参角度

    一.依照职位传值

def mymax(x,y):
    #此时x=10,y=20
    the_max = x if x > y else y
    return the_max

ma = mymax(10,20)
print(ma)

推行输出: 20

 

    二.安分守纪重点字传值

def mymax(x,y):
    #此时x = 20,y = 10
    print(x,y)
    the_max = x if x > y else y
    return the_max

ma = mymax(y = 10,x = 20)
print(ma)

举办输出:

20 10
20

 

    三.职位、关键字情势混着用

def mymax(x,y):
    #此时x = 10,y = 20
    print(x,y)
    the_max = x if x > y else y
    return the_max

ma = mymax(10,y = 20)
print(ma)

实施输出:

10 20
20

 

      正确用法

      难点壹:地方参数必须在第2字参数的前面

      难点2:对于二个形参只可以赋值一遍

    

  站在形参角度

    地方参数必须传值

def mymax(x,y):
    #此时x = 10,y = 20
    print(x,y)
    the_max = x if x > y else y
    return the_max

#调用mymax不传递参数
ma = mymax()
print(ma)

  实践输出:

TypeError: mymax() missing 2 required positional arguments: ‘x’ and ‘y’

 

默许参数

    1.符合规律化使用

      使用格局

      为啥要有默许参数:将转移比较小的值设置成暗中同意参数

    贰.私下认可参数的概念

def stu_info(name,sex = "male"):
    """打印学生信息函数,由于班中大部分学生都是男生,
        所以设置默认参数sex的默认值为'male'
    """
    print(name,sex)

stu_info('alex')
stu_info('eva','female')

进行输出:

alex male
eva female

 

    三.参数陷阱:暗许参数是一个可变数据类型

def defult_param(a,l = []):
    l.append(a)
    print(l)

defult_param('alex')
defult_param('egon')

施行输出:

[‘alex’]
[‘alex’, ‘egon’]

动态参数:

*args和 **kwargs

def trans_para(*args,**kwargs):
    print(args,type(args))
    print(kwargs,type(kwargs))
trans_para("jinxin",12,[1,2,3,4],[3,4,],(1,4,7),{"a":"123","c":456},country="china")

进行输出:

(‘jinxin’, 12, [1, 2, 3, 4], [3, 4], (1, 4, 7), {‘a’: ‘123’, ‘c’:
456}) <class ‘tuple’>
{‘country’: ‘china’} <class ‘dict’>

 

  动态参数,也叫不定长传参,正是您供给传给函数的参数繁多,不定个数,那那种气象下,你就用*args,**kwargs接收,args是元祖情势,接收除了键值对以外的装有参数,kwargs接收的只是键值对的参数,并保留在字典中。

全栈开辟,Day伍,python开荒day5python之函数初识 一、什么是函数?
以后有如此个状态:python中的len方法不让用了,你如何是好?
来测试1…

python中等高校函授数定义方法:

 

    def test(x):
    ”The function definitions”
    x+=1
    return x

写代码应当防止重复代码,以简化代码为荣。

  def:定义函数的重中之重字
  test:函数名
  ():内可定义形参
  ””:文书档案描述(非供给,不过强烈提出为你的函数增添描述音讯)
  x+=一:泛指代码块或程序处理逻辑
  return:定义重回值

对于那种地方,出现了函数这么个东东

调用运维:能够带参数也得以不带
函数名()

函数是包裹好的,拿来就足以选拔,用来促成单1或相关联功能的代码段。

 

函数:函数正是里面封装了八个效率的代码片段。

二:函数的归类

 

  一.置于函数:built-in
  贰.自定义函数:
    def 函数名(参数1,参数2,…):
      ”’注释”’
      函数体

def func():
    #def 函数名(): 定义一个函数
    #函数名的书写规则跟变量一样
    #def与函数名直接有一个空格
    #def 函数名():冒号用来将函数名与函数体隔开,不能少,括号用来传参
    #函数体是函数里面的逻辑代码
    print(666)
    print(999)

函数的行使:先定义,后调用
怎么样定义函数之定义函数的二种情势
壹定义无参函数:函数的实施不正视于调用者传入的参数就能实施时,需求定义为无参函数

 

def print_tag():
print(‘*************************’)

代码是由上往下相继实施的,实施到def func()时

def main():
print_tag(‘*’,20,3)
print_msg(‘hello world’)
print_tag(‘*’,20,3)

将func这几个函数名加载到方今内部存储器中,不奉行。

main()

那正是说函数怎么样推行吗?

2定义有参数:函数的实践需求正视于调用者传入的参数手艺实行时,要求定义为有参函数

函数的实行措施:函数名()

def print_tag(tag,count,line_num):
for i in range(line_num):
print(tag*count)

#执行函数
func()

三 定义空函数:函数体为pass

 当见到func(),唯有见到()时,程序才会基于函数名从内部存款和储蓄器中找到函数体,然后推行它。一向不括号是不会推行的。

def func(x,y,z):
pass

 

3:函数的采取规范
  函数的运用必须比照:先定义后使用的准绳
  函数的概念,与变量的概念是形似的,如若未有优先定义函数而直白引用就一定于在引用2个不设有变量名  

 **二、函数的返回值 return**

#概念阶段:只检查实验语法,不进行代码

   
写函数,不要在函数内写print()

def func():
if 1>2
print(‘hahahahahahah’)
def func():
      #语法没难题,逻辑不平日,引用一个不存在的变量名
asdfasdfasdfasdfasdf

   
函数是以作用为导向,一般只有在测试中才得以写print()

#调用阶段

 return再次来到的值需求print能力打字与印刷呈现出来

foo()

 

重返值:能够重返任意档次

    一.在函数当中,遭受return立即终止函数 。

没有return:None
return value: value
return val1,val2,val3 :(val1,val2,val3)

def func():
    print(666)
    return
    print(999)
func()

return的魔法:只好回去一次值,终止函数的进行

实践输出:

返回值:

666

   重临值数=0:重回None

 

   再次来到值数=一:再次回到object

二.将重返值重回给函数调用者。

   再次来到值数>1:重返tuple

def func():
    s = '天才'
    return s
print(func())

四:函数参数

实行输出:

4858.com 1

天才

1.形参变量唯有在被调用时才分配内存单元,在调用甘休时,马上释放所分配的内部存款和储蓄器单元。因而,形参只在函数内部有效。函数调用停止再次来到主调用函数后则不能够再采用该形参变量

 

贰.实参方不过常量、变量、表明式、函数等,无论实参是何体系型的量,在张开函数调用时,它们都不能够不有鲜明的值,以便把这么些值传送给形参。因此应事先用赋值,输入等办法使参数获得分明值

return的三种情景

三.地方参数和要害字(标准调用:实参预形参地点一一对应;关键字调用:地方无需固定)

  1.无return 
返回None

肆.暗许参数

def func():
    print(123)
print(func())

5.参数组

实践输出:

函数参数分类:

None

 一、地方参数(形参、实参)

 

岗位参数:依照从左到右的各种依次定义的参数
  def foo(x,y):
  print(x)
  print(y)
按岗位定义的形参,必须被传值,多三个十分,少一个也非凡
  foo(1,2,3)===>报错
按职责定义的实参,与形参壹壹对应
  foo(2,10)

  2.有return 返回None  

二、关键字参数 (实参)

def func():
    return None  #没有意义
print(func())

最首要字参数:实参在概念时,依据key=value形式定义
  def foo(x,y):
  print(x)
  print(y)
  # foo(y=10,x=1)
  foo(y=10,x=1)
#重要字参数能够不用像地方实参同样与形参壹一对应,指名道姓地传值

实施输出:

  #  foo(1,z=20,10)  
===>报错

None

  # foo(1,y=2,z=10)
 
===>报错**

 

留神的标题一:地方实参必须在根本字实参的近期
注意的难点二:实参的花样既能够用地点实参又可以是非同儿戏字实参,可是多个形参不可能重新传值

  叁.return 单个值
该值是怎么,就径直回到给函数的调用者——函数名()
 

 三、暗中认可参数(形参)

def func():
    return 1  #return单个值
print(func())    

def fun():
    return [1,2,3]  #return单个值[1,2,3]
print(fun())

默许参数:在概念函数阶段,就曾经为形参赋值,定义阶段有值,调用阶段能够不用传值

施行输出:

定义:

1

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

[1,2,3]

调用:

 

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

  四.return 三个值
将多少个值放到多少个元组里,重临给函数的调用者。

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

 

 形参的施用:值平时转移的内需定义成职责形参,值大大多景况下都如出壹辙,须要定义成暗中同意参数

def func():
    return 1,'a',[11,12]
print(func())

暗中同意参数要求留意的标题一:必须放在地点形参后边
暗中认可参数须要留意的题目贰:暗中同意参数经常要定义成不可变类型
暗中同意参数必要注意的标题3:暗许参数只在概念阶段被赋值3次

 

四、可变长参数

实行输出:

可变长参数:可变长指的是实参的个数不固定

(1, ‘a’, [11, 12])

按岗位定义的非关键字可变长度的实参:*     *args

 

按重要性字定义的可变长度的实参:**        **kwargs

lis = [1,2,3,'aaa','天才']
def func_len():
    count = 0
    for i in lis:
        count +=1
    return count
print(func_len())

非关键字可变长度的实参:*

试行输出:

概念2个函数的时候,须要求先行定义那个函数须求有些个参数(也许说还可以多少个参数)。1般意况下那是没难题的,不过也有在概念函数的时候,不可能驾驭参数个数的气象(想1想C语言里的printf函数),在Python里,带*的参数正是用来经受可变多少参数的。看三个例子

5

def funcD(a, b, *c):
  print a
  print b
  print “length of c is: %d ” % len(c)
  print c
调用funcD(1, 2, 3, 4, 5, 6)结果是
1
2
length of c is: 4
(3, 4, 5, 6)

 

  前面三个参数被a、b接受了,剩下的多少个参数,全体被c接受了,c在此处是一个tuple。大家在调用funcD的时候,至少要传送三个参数,1个以上的参数,都放到c里了,假设唯有多个参数,那么c正是一个empty
tuple。

my_len()和len()方法,看起来好像有点近乎,都能回来变量的尺寸,但是和len()有分别。len能够传参数,比如len(‘abc’)

 

 

 关键字定义的可变长度的实参:**

3、函数的传参

def my_len(l): # l 形式参数,形参
    print(l) #实际对应就是s
    count = 0
    for i in l:
        count += 1
    return count

s = 'tiancai'
print(my_len(s)) #括号里面的是实际参数,实参

施行输出:

tiancai

7

 

实参角度:

  一.职位传参。按梯次,一壹对应。**

def func(a,b,c):
    print(a)
    print(b)
    print(c)
func('tiancai',3,4)

进行输出:

tiancai

3

4

 

那就是说,少传八个参数会怎么样呢?

def func(a,b,c):
    print(a)
    print(b)
    print(c)
func(1,2)

TypeError: func() missing 1 required positional argument: ‘c’

无法不逐项对应,不然报错

 

  二.重大字传参,不按梯次,1一对应。

def func(a,b):
    print(a)
    print(b)
    print(a,b)
func(b =2, a =1)

施行输出:

1
2
1 2

 

  3.混合传参,关键字参数在最后面

def func1(a,b,c,d):
    print(a)
    print(b)
    print(c)
    print(d)
func1(1,2,c=3,4)

实行输出:

SyntaxError: positional argument follows keyword argument

 

正确使用姿势

def func1(a,b,c,d):
    print(a)
    print(b)
    print(c)
    print(d)
func1(1,2,c =3, d =4)

实行输出:

1
2
3
4

 

形参角度:

  一.岗位传参。依据顺序依次对应。

def func(a,b,c):
    print(a)
    print(b)
    print(c)
func('天才',3,4)

实施输出:

天才
3
4

 

  二.暗中同意参数。传参则覆盖,不传则暗中同意,私下认可参数永世在地方参数前边

def func(a,b=123):
    print(a,b)
func(1,2)

实施输出:

1 2

 

def func(a,b=123):
    print(a,b)
func(1)

施行输出:一 12三

 

场合应用:

职员和工人音讯表录入

while True:
    username = input('请输入姓名: ').strip()
    sex = input('请输入性别: ').strip()
    with open('name_list',encoding='utf-8',mode='a') as f1:
        f1.write('{}\t{}\n'.format(username,sex))

试行输出:

4858.com 2

 

查看文件内容

4858.com 3

 

完了以下三个要求

一.儿女一样多

②.实现函数功用

 

修改如下

def Infor_entry(username,sex='男'):
    with open('name_list',encoding='utf-8',mode='a') as f1:
        f1.write('{}\t{}\n'.format(username,sex))

while True:
    username = input('请输入姓名(男生以1开头):').strip()
    if '1' in username:
        #去除1
        username = username[1:]
        Infor_entry(username)
    else:
        Infor_entry(username,'女')

实行输出:

4858.com 4

查看文件:

4858.com 5

 

  就算叁个函数定义中的最后2个形参有 **
(双星号)前缀,所有正规形参之外的别样的重点字参数都将被停放在二个字典中传送给函数,比如:

四、长富运算

元正运算就是足以在给一个变量赋值的时候,能够平昔加判别再赋值

s = 值1 if 条件 else 值2

例如:

 

a =100
b = 99
c= a if a>50 else b #如果a大于50的话,c=a,否则c=b
print(c)

 

施行输出:

100

 

写一个独具比尺寸功效的函数,重返数值较大的数

def max_min(a,b):
    if int(a) > int(b):
        return a
    else:
        return b
print(max_min(1,5))

执行输出:

5

 

上边那样写代码太low了,大家得以用优雅的三元运算实行优化,代码如下

def max_min(a,b):
    return a if a > b else b

 

练习题:待续

 

def funcF(a, **b):
  print a
  for x in b:
    print x + “: ” + str(b[x])
调用funcF(十0, c=’你好’, b=200),实施结果
100
c: 你好
b: 200

  大家能够见见,b是二个dict对象实例,它承受了根本字参数b和c。

构成一同行使:

# def wrapper(*args,**kwargs): #可以接受任意情势,任意长度的参数
# print(args)
# print(kwargs)
#
#
# wrapper(1,2,3,3,3,3,3,x=1,y=2,z=3)  
===>(1,2,3,3,3,3,3,)   {‘x’:1,’y’=2,’z’=3}

命名首要字参数:定义在*后的形参,必须被传值,而且须求实参必须是以重点字的款型来传值

即:

  形参:  *args,z=10

或:

  实参:z=10

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

 结果:

4858.com 6

 

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

 结果:

4858.com 7

 

 总计:形参:地方形参,暗中同意参数,*args,命名第2字参数,**kwargs

 5、函数嵌套

#函数的嵌套调用
#
# 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

”’

函数对象:

4858.com 8

 

 六、命名空间

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

名称空间分为三种

  放到名称空间:python解释器自带的名字,python解释器运转就会扭转

  大局名称空间:文件等级定义的名字都会存放与全局名称空间,实行python文件时会产生

  壹些名称空间:定义在函数内部的名字,局地名称空间唯有在调用函数时才会立竿见影,函数调用截至则失效

三者的加载顺序:内置名称空间->全局名称空间->局地名称空间

三者的取值顺序:局地名称空间->全局名称空间->内置名称空间

七、作用域

作用域:

意义范围:

大局功能域:内置名称空间与大局名称空间的名字属于全局范围,
        #在壹切文件的私行地方都能被引述,全局有效
局地效用域:局地名称空间的名字属于有个别范围,
        #只在函数内部能够被引用,局地有效

成效域在概念函数时就曾经稳固住了,不会趁着调用地方的更换而改动

 1 name='alex'
 2 def foo():
 3     name='lhf'
 4     def bar():
 5         name='wupeiqi'
 6         print(name)
 7         def tt():
 8             name='hedeyong'
 9             print(name)
10         return tt
11     return bar
12 
13 func=foo()
14 func()()       #==> bar()() ==>tt()
  '''
  hedeyong
  '''

 

发表评论

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

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有