新浦京81707con > 软件下载 > 第十六章

原标题:第十六章

浏览次数:86 时间:2019-05-06

python基础(二):

新手教程基础知识批注的百般全面,内容采取本身以为的根本出口2次

1 怎么要有函数?

函数是团协会好的,可重复使用的,用来促成单1,或相关联效率的代码段。
函数能增加利用的模块性,和代码的双重利用率。你曾经知晓Python提供了累累内建函数,比方print()。但你也得以本身制造函数,这被誉为用户自定义函数。

函数:

不加区分地将具备机能的代码垒到1道,难题是:

 

概念二个函数:

您能够定义叁个由友好想要功效的函数,以下是简简单单的条条框框:

  

def fun(arg):
    pass
    return arg

# 函数调用语法
fun(arg)
  • arg:argument,参数(也叫prarmeter) ,任何传入参数和自变量必须放在圆括号中间,圆括号之间能够用于定义参数。
  • def:define,定义,创立函数 ,函数代码块以 def 关键词开头,后接函数标记符名称和圆括号 ()
  • 代码缩进表示语句块,表大顺码从属关系
  • return [表达式] 截止函数,选取性地赶回三个值给调用方。不带表明式的return相当于返回None。

 

 

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

1、语法

函数的调用:

  将参数传入已经定义好的函数中,便能够调用此函数

def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return

# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

以上实例输出结果:
我要调用用户自定义函数!
再次调用同一函数

 

 

什么缓和?
  函数即工具,事先希图工具的长河是概念函数,拿来就用指的正是函数调用

Python 定义函数使用 def 关键字,一般格式如下:

函数重临值:

  • 所谓“重回值”,正是程序中函数完毕壹件事情后,最终给调用者的结果
  • #定义函数

        def add2num(a, b):
            return a b
    
        #调用函数,顺便保存函数的返回值
        result = add2num(100,98)
    
        #因为result已经保存了add2num的返回值,所以接下来就可以使用了
        print (result) --->198
    

    函数重回值可以为两个:

  • def divid(a, b):

    ... shang = a//b
    ... yushu = a%b 
    ... return shang, yushu
    ...
    >>> sh, yu = divid(5, 2)
    >>> sh
    5
    >>> yu
    1
    

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

def 函数名(参数列表):
    函数体

 

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

 

 

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

暗许景况下,参数值和参数名称是按函数注脚中定义的的相继相称起来的。

四种函数的类型:

函数依照有没有参数,有未有再次回到值,能够并行结合,一共有4种

  • 无参数,无再次回到值

    •   

      # 函数定义,初级
      def numsum():
          a = 5
          b = 10
          c = a   b
          print(c)
      
      # 函数执行
      numsum() --->15
      

       

  • 无参数,有重临值

  • 有参数,无重返值

  • 有参数,有再次来到值

    • 输入参数:

      • 形参:形式参数,注明函数时,括号()中的参数
      • 实参:实际参数,调用函数是,括号()中的参数
      • 实参将值传给形参,本质上是变量赋值
      • 返回值:return

        • 会甘休函数试行(return是函数的末梢一句),并回到三个值给调用方
        • 不带表达式的return再次回到None
        • Print()不是重返值,只是输出音讯到分界面
        • # 函数定义,带输入输出

          def numsum2(a, b):
              c = a   b
              return c
          
          # 函数调用
          d = numsum2(10, 20)
          print(d)  --->30
          

           

  def:定义函数的重视字
  test:函数名
  ():内可定义形参
  "":文书档案描述(非须求,然而强烈提议为你的函数增多描述消息)
  x =一:泛指代码块或程序管理逻辑
  return:定义重回值

概念多少个由自个儿想要作用的函数,以下是归纳的平整:

函数中参数的类别:

  • 必备参数

    •   

      #可写函数说明
      def printme( str ):
         "打印任何传入的字符串"
         print (str)
         return
      
      #调用printme函数
      printme()
      

       

  • 第1字参数

    •   

      def about(name,course,site):
          print (name,course,site)
      
      about(site='www.baidu.com',name='green',course=100)   ##以关健字方式传入参数(可以不按顺序)
      
     
  • 暗许参数

    •   

      def about(name,course,site):
          print (name,course,site)
      
      about('jim','100','www.baidu.com')   ## 必须按顺序传参
      

       

  • 不定长参数

    •   

      • 非关键字可变参数(元组)

        • 献身私下认可值参数前面
        • 可将盛传的不明确数量的暗中认可参数会见为元组方便函数使用
        • def fun(a, b, *args):

              print(a)
              print(b)
              print(args)
              print("="*30)
              ret = a   b
              for i in args: #便利args中的元素
                  ret  = i
              return ret
          
          print(fun(1,2,3,4))
          
          结果:
          1
          2
          (3, 4)
          ==============================
          10
          

           

      • 第三字可变参数(字典)

        • 座落非关键字可变参数后边
        • 可将盛传的不显然数量的私下认可值参数集聚为字典方便函数使用
        • def fun(a, b, *args, **kwargs):

              print(a) 
              print(b)
              print(args)
              print(kwargs)
          
          fun(1, 2, 3, 4, name = "hello", age = 20)
          
          结果:
          1
          2
          (3, 4)
          {'name': 'hello', 'age': 20}
          
尽量避免多种参数格式混合(主要是两种可变参数)
多参数混合时注意顺序:
    一般顺序是:默认参数,默认值参数,非关键字可变参数,关键字可变参数
    注意:带关键字的参数必须放在最后

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

  • 函数代码块以 def 关键词开首,后接函数标记符名称和圆括号 ()。
  • 任何传入参数和自变量必须放在圆括号中间,圆括号之间能够用来定义参数。
  • 函数的第二行语句能够选拔性地应用文书档案字符串——用于存放函数表明。
  • 函数内容以冒号开首,并且缩进。
  • return [表达式] 甘休函数,采用性地回来二个值给调用方。不带表明式的return也正是再次来到None。

佚名函数:

  • 语义上讲,lambda 只是常见函数定义中的2个语法技能,书写代码更轻松(但不易懂)
  • lambda 是3个表明式(非代码块),比 def 轻巧,仅能封装有限的逻辑如if else分支,不可能利用多项分支和巡回,不相符复杂操作

    # 普通函数 def def_sum(a, b):

    return a   b
    

    def_sum(5, 10)

    # 无名氏函数:变量名 = lambda 参数... : 表明式计算lambda_sum = lambda a, b: a b lambda_sum(5, 10)

    --->15

    分支佚名函数

    # 普通函数 def def_gender(g):

    if g == 1:
        return '男性'
    else:
        return '女性'
    

    def_gender(0)

    # 无名函数:变量名 = lambda 参数... : 分支壹的值 if 判定规范 else 分支二的值 lambda_gender = lambda a: '男性' if a == 1 else '女性' lambda_gender(1) --->男性

    # 普通函数 def absum(a, b):

    return a   b
    

    def def_sum2(a, b, c):

    return absum(a, b)   c
    

    def_sum2(1,2,3)

    # 无名函数:变量名 = lambda 参数... : 别的函数组成的表达式 def absum(a, b):

    return a   b
    

    lambda_sum = lambda x, y, z: absum(x, y) z lambda_sum(1,2,3)

    --->6

 

 

佚名函数练习题:

将列表内的字典按照年龄进行排序:
infors = [{'name':'laowang','age':23},{'name':'ab','age':34},{'name':'bf','age':43}]

 

 

 

贰:函数的分类

实例:

  1.松手函数:built-in
  二.自定义函数:
    def 函数名(参数1,参数2,...):
      '''注释'''
      函数体

def hello():
    return 'Hello world'

def say(msg):
    print(msg)

def sun(num1, num2):
    print('num1   num2 =', num1, num2)

函数的使用:先定义,后调用
怎样定义函数之定义函数的二种方式
一定义无参函数:函数的实行不借助于于调用者传入的参数就能够进行时,需求定义为无参函数

 

def print_tag():
print('*************************')

二、函数调用

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

Python内置了无数有效的函数,大家能够直接调用。要调用四个函数,供给明白函数的称谓和参数,举例求相对值的函数abs,唯有1个参数:

main()

print('100的绝对值:', abs(100))
print('-20的绝对值:', abs(-20))

二定义有参数:函数的施行需求依附于调用者传入的参数能力施行时,须要定义为有参函数

以上代码,输出:

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

100的绝对值: 100
-20的绝对值: 20

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

概念1个函数:给了函数三个称号,钦定了函数里含有的参数,和代码块结构。
本条函数的中坚构造完结未来,你能够通过另2个函数调用推行,也能够一直从 Python 命令提醒符施行。

def func(x,y,z):
pass

三、参数字传送递 

3:函数的利用标准
  函数的施用必须根据:先定义后选择的规范化
  函数的概念,与变量的定义是一般的,假使未有先行定义函数而直接引用就相当于在引用四个不存在变量名  

在 python 中,类型属于对象,变量是一向不项指标:

#概念阶段:只检查测试语法,不施行代码

a=[1,2,3]

a="Python"

def func():
if 1>2
print('hahahahahahah')
def func():       #语法没难题,逻辑有毛病,引用三个不存在的变量名
asdfasdfasdfasdfasdf

如上代码中,[1,2,3] 是 List 类型,"Python" 是 String 类型,而变量 a 是不曾项目,它独自是2个对象的引用(1个指南针),能够是 List 类型对象,也得以针对 String 类型对象。

#调用阶段

 

foo()

python 函数的参数字传送递:

重临值:能够回来任性档期的顺序

  • 不得变类型:类似 c 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,未有影响a对象自己。比如在 fun(a)内部修改 a 的值,只是修改另1个复制的对象,不会影响 a 本身。
  • 可变类型:类似 c 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响

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

python 中一切都是对象,严厉意义大家不可能说值传递如故引用传递,大家应该说传不可变对象和传可变对象。

return的效能:只好回到三遍值,终止函数的进行

 

返回值:

怎么是可改造(mutable)与不可改换(immutable)对象?

   重临值数=0:再次回到None

在 python 中,str, tuple, 和 number 是不行更动的目的,而 list,dict 等则是能够修改的靶子。举个例子:

   重回值数=一:重返object

不可变类型:变量赋值 a=五 后再赋值 a=拾,这里其实是新兴成1个 int 值对象 十,再让 a 指向它,而 5 被撇下,不是改换a的值,相当于新生成了a。

   重临值数>一:重回tuple

可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第七个成分值更改,自个儿la未有动,只是其内部的壹部分值被涂改了。

4:函数参数

 

图片 1

不可变对象在函数里修改了参数,原始的参数是不会转移的。举个例子:

一.形参变量唯有在被调用时才分配内部存款和储蓄器单元,在调用截至时,立时释放所分配的内部存款和储蓄器单元。因而,形参只在函数内部有效。函数调用截至重临主调用函数后则无法再使用该形参变量

def ChangeInt(a):
    a = 10

b = 2
ChangeInt(b)
print(b) # 结果是 2

二.实参得以是常量、变量、表达式、函数等,无论实参是何连串型的量,在进展函数调用时,它们都不能够不有明确的值,以便把那一个值传送给形参。因而应优先用赋值,输入等艺术使参数得到鲜明值

实例中有 int 对象 二,指向它的变量是 b,在传递给 ChangeInt 函数时,按传值的办法复制了变量 b,a 和 b 都指向了同贰个 Int 对象,在 a=拾 时,则新生成2个 int 值对象 拾,并让 a 指向它。

三.岗位参数和关键字(标准调用:实参与形参地方一一对应;关键字调用:地点不要求固定)

 

肆.私下认可参数

可变对象在函数里修改了参数,那么原来的参数也被改成了。比方:

5.参数组

# 可写函数说明
def changeme(mylist):
    "修改传入的列表"
    mylist.append([1, 2, 3, 4])
    print("函数内取值: ", mylist)
    return


# 调用changeme函数
mylist2 = [10, 20, 30]
changeme(mylist2)
print("函数外取值: ", mylist2)

函数参数分类:

传扬函数的和在最后增加新内容的靶子用的是同三个引用。故输出结果如下:

 1、位置参数(形参、实参)

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

职位参数:依照从左到右的11依次定义的参数
  def foo(x,y):
  print(x)
  print(y)
按任务定义的形参,必须被传值,多二个老大,少二个也尤其
  foo(1,2,3)===>报错
按岗位定义的实参,与形参一1对应
  foo(2,10)

 

2、关键字参数 (实参)

4、参数

关键字参数:实参在概念时,依据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)   ===>报错

 

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

如何是少不了参数?必需参数须以科学的次第传入函数。调用时的数额必须和注明时的如出1辙。下边包车型地铁实例中调用say()函数,你必须传入多少个参数,不然会见世语法错误:

本文由新浦京81707con发布于软件下载,转载请注明出处:第十六章

关键词: 新浦京81707con Python Python开发

上一篇:关于log4net日志的配置流程,log4net日志流程

下一篇:没有了