精华内容
下载资源
问答
  • 1. 函数的参数在Python中,函数的参数可以有默认值,也支持使用可变参数,所以Python并不需要像其他语言一样支持函数的重载,因为我们在定义一个函数的时候可以让它有多种不同的使用方式。# 在参数名前面的*表示args...

    1. 函数的参数

    在Python中,函数的参数可以有默认值,也支持使用可变参数,所以Python并不需要像其他语言一样支持函数的重载,因为我们在定义一个函数的时候可以让它有多种不同的使用方式。

    # 在参数名前面的*表示args是一个可变参数

    # 即在调用add函数时可以传入0个或多个参数

    def add(*args):

    total = 0

    for val in args:

    total += val

    return total

    print(add())

    print(add(1))

    print(add(1, 2))

    print(add(1, 2, 3))

    print(add(1, 3, 5, 7, 9))

    2. 变量作用域

    def foo():

    b = 'hello' # 函数中的局部变量(local variable)

    def bar(): # Python中可以在函数内部再定义函数

    c = True # 局部作用域

    nonlocal b

    print(a)

    print(b)

    print(c)

    bar()

    # print(c) # NameError: name 'c' is not defined

    if __name__ == '__main__':

    a = 100 # 全局变量(global variable)

    # print(b) # NameError: name 'b' is not defined

    foo()

    '''

    改变 全局变量(global variable)a 的值,需要使用 global关键字

    改变 局部变量(local variable)b 的值,需要使用 nonlocal 关键字

    '''

    在实际开发中,我们应该尽量减少对全局变量的使用,因为全局变量的作用域和影响过于广泛,可能会发生意料之外的修改和使用,除此之外全局变量比局部变量拥有更长的生命周期,可能导致对象占用的内存长时间无法被垃圾回收。事实上,减少对全局变量的使用,也是降低代码之间耦合度的一个重要举措。

    def main():

    # Todo: Add your code here

    pass

    if __name__ == '__main__':

    main()

    3. 面向对象

    class Person(object):

    # 限定Person对象只能绑定_name, _age和_gender属性

    __slots__ = ('_name', '_age', '_gender')

    def __init__(self, name, age):

    self._name = name

    self._age = age

    @property

    def name(self):

    return self._name

    @property

    def age(self):

    return self._age

    @age.setter

    def age(self, age):

    self._age = age

    def play(self):

    if self._age <= 16:

    print('%s正在玩飞行棋.' % self._name)

    else:

    print('%s正在玩斗地主.' % self._name)

    def main():

    person = Person('王大锤', 22)

    person.play()

    person._gender = '男'

    print(person._age)

    # AttributeError: 'Person' object has no attribute '_is_gay'

    # person._is_gay = True

    if __name__ == '__main__':

    main()

    3.1 @property装饰器

    将属性命名以单下划线开头,通过这种方式来暗示属性是受保护的,不建议外界直接访问,考虑使用@property包装器来包装getter和setter方法,属性的getter(访问器)和setter(修改器)方法进行对应的操作,使得对属性的访问既安全又方便。

    class Circle(object):

    def __init__(self, radius):

    self.radius=radius

    def getRadius(self):

    return self.radius

    def setRadius(self, value):

    if not isinstance(value,(int, float)):

    raise ValueError(' wrong type.')

    self.radius=float(value)

    def getArea(self):

    return self. radius ** 2 * 3.14

    # 通过property自动调用属性

    R = property(getRadius, setRadius)

    if __name__ == '__main__':

    c = Circle(3)

    print(c.radius)

    c.radius = 9

    print(c.radius)

    3.2 slots魔法

    通过在类中定义slots变量来进行限定自定义类型的对象只能绑定某些属性。

    通过@property的getter和setter属性保护age, name

    image.png

    通过__slots__限定Person对象只能绑定_name, _age, _gender属性

    4. 静态类

    网上说的比较多的是,静态类不需要实例化就可以直接调用内部的方法。但是什么时候用这个静态类说的却不是很详细,在这里给出了一个很好的使用范例:

    在计算三角形周长时,传入的三条边长未必能构造出三角形对象,因此我们可以先写一个方法来验证三条边长是否可以构成三角形,这个方法很显然就不是对象方法,因为在调用这个方法时三角形对象尚未创建出来(因为都不知道三条边能不能构成三角形),所以这个方法是属于三角形类而并不属于三角形对象的。

    from math import sqrt

    class Triangle(object):

    def __init__(self, a, b, c):

    self._a = a

    self._b = b

    self._c = c

    @staticmethod

    def is_valid(a, b, c):

    return a + b > c and b + c > a and a + c > b

    def perimeter(self):

    return self._a + self._b + self._c

    def area(self):

    half = self.perimeter() / 2

    return sqrt(half * (half - self._a) *

    (half - self._b) * (half - self._c))

    def main():

    a, b, c = 3, 4, 5

    # 静态方法和类方法都是通过给类发消息来调用的

    if Triangle.is_valid(a, b, c):

    t = Triangle(a, b, c)

    print(t.perimeter())

    # 也可以通过给类发消息来调用对象方法但是要传入接收消息的对象作为参数

    # print(Triangle.perimeter(t))

    print(t.area())

    # print(Triangle.area(t))

    else:

    print('无法构成三角形.')

    if __name__ == '__main__':

    main()

    展开全文
  • 16212评论:1在Python中,采用下面的语法定义函数:def 函数名(参数):# 内部代码return 表达式例如:def summer(lis):"""这里是函数的说明文档,doc的位置:param lis: 参数列表的说明:return: 返回值的说明"""total ...

    函数基础

    阅读: 16212

    评论:1

    在Python中,采用下面的语法定义函数:

    def 函数名(参数):

    # 内部代码

    return 表达式

    例如:

    def summer(lis):

    """

    这里是函数的说明文档,doc的位置

    :param lis: 参数列表的说明

    :return: 返回值的说明

    """

    total = 0

    for i in lis:

    total += i

    return total

    在定义函数的过程中,需要注意以下几点:

    函数代码块以def关键词开头,一个空格之后接函数标识符名称和圆括号(),再接个冒号。

    任何传入的参数必须放在圆括号中间。

    函数的第一行语句后可以选择性地使用文档字符串—用于存放函数说明。

    函数内容以冒号起始,并且缩进。

    使用return结束函数。默认返回None。

    return语句依然在函数体内部,不能回退缩进。直到函数的所有代码写完,才回退缩进,表示函数体结束。

    如何调用函数?

    函数编写出来就是给人调用的。要调用一个函数,必须使用函数名后跟圆括号的方式才能调用函数。调用的同时要根据函数的定义体,提供相应个数和类型的参数,每个参数之间用逗号分隔。Python由于动态语言的特点,在做语法和词法分析检查的时候,并不会对参数类型进行检查,但在执行过程中,如果参数类型不符合函数内部运行机制的话,会弹出相应的错误,例如:

    >>> all(0, -1, 3)

    Traceback (most recent call last):

    File "", line 1, in

    all(0, -1, 3)

    TypeError: all() takes exactly one argument (3 given)

    >>> all([0, -1, 3])

    False

    Python内置函数all()要求提供一个参数,但我们一开始给了3个。后面,我们将三个参数作为一个整体列表提供就没有问题了。

    return语句:

    return语句用于表示函数执行到此结束,并且返回return后面的对象。有时候,函数不需要返回任何值,此时可以不需要return语句,它在后台默认给你返回个None,并且不给任何提示。但是更多的时候我们还是需要return一些东西。一旦函数执行过程遇到return语句,那么之后函数体内的所有代码都会被忽略,直接跳出函数体。那怕你现在正在一个循环内。

    def func():

    pass

    return

    # 此时,后面的代码其实是永远无法执行的。

    # 但从语法和词法层面,这些没有错误。

    print(1)

    abs(-1)

    pass

    return可以返回什么?

    什么都不返回,仅仅return:return

    数字/字符串/任意数据类型: return 'hello'

    一个表达式:return 1+2

    一个判断语句:return 100 > 99

    一个变量:return a

    一个函数调用:return func()

    甚至是返回自己!:return self

    多个返回值,以逗号分隔:return a, 1+2, "hello"

    简而言之,函数可以return几乎任意Python对象。

    如何接收函数的返回值?

    我们在调用函数的时候,可以将函数的返回值保存在变量中。

    def func():

    pass

    return "something"

    result = func()

    而对于同时返回多个值的函数,需要相应个数的变量来接收,变量之间以逗号分隔:

    def func():

    return 1, [2, 3], "haha"

    a, b, c = func()

    参数的传递

    函数通常都有参数,用于将外部的实际数据传入函数内部进行处理。但是,在处理不同数据类型的参数时,会有不同的情况发生。这一切都是因为以下两点。

    Python的函数参数传递的是实际对象的内存地址。

    Python的数据类型分可变数据类型和不可变数据类型。

    看下面的例子

    a = 1

    def func(a):

    print("在函数内部修改之前,变量a的内存地址为:%s" % id(a))

    a = 2

    print("在函数内部修改之后,变量a的内存地址为:%s" % id(a))

    print("函数内部的a为:%s" % a)

    print("调用函数之前,变量a的内存地址为:%s" % id(a))

    func(a)

    print("函数外部的a为:%s" % a)

    打印结果为:

    调用函数之前,变量a的内存地址为: 1401140288

    在函数内部修改之前,变量a的内存地址为: 1401140288

    在函数内部修改之后,变量a的内存地址为: 1401140320

    函数内部的a为: 2

    函数外部的a为:1

    为什么当a = 2之后,函数内外的a的内存地址就不一样了呢?也就是说此后函数内外的a是两个不同的对象了。

    这是因为,当作为参数,a被传入函数时,将数字对象1的地址传递给了函数内部的a。执行第一句内部代码时,此时内部的a和外面的a其实是一个东西,因此打印出了同样的内存地址。而当a=2被执行后,创建了一个新的内部变量a,并赋值2,将数字对象2的内存地址赋给变量a。我们知道,首先,赋值语句具有创建新变量的功能,其次,函数由于存在作用域的概念(后面会介绍),在其内部的变量不受外部变量的影响,可以独立使用变量,相当于新的命名空间。因此,此时的a和外面的a没有一毛钱关系了,是两个不同的变量。同时,由于数字1和2是不可变的数字类型对象,是两个独立的,不同内存地址的对象,因此再次打印内存地址,当然就不一样了。

    上面的解释可能不太好理解。其实,很多时候,我们被这种类似的问题困惑是因为函数参数的命名不恰当造成的。如果我们把上面的参数名改为b,可能就好理解多了(注意其中文字的变化)。执行结果是一样的。

    a = 1

    def func(b):

    print("在函数内部修改之前,变量b的内存地址为:%s" % id(b))

    b = 2

    print("在函数内部修改之后,变量b的内存地址为:%s" % id(b))

    print("函数内部的b为:%s" % b)

    print("调用函数之前,变量a的内存地址为:%s" % id(a))

    func(a)

    print("函数外部的a为:%s" % a)

    刚才说的是不可变类型参数,如果是可变类型的,比如列表呢?

    a = [1, 2, 3]

    def func(b):

    print("在函数内部修改之前,变量b的内存地址为:%s" % id(b))

    b.append(4)

    print("在函数内部修改之后,变量b的内存地址为:%s" % id(b))

    print("函数内部的b为:%s" % b)

    print("调用函数之前,变量a的内存地址为:%s" % id(a))

    func(a)

    print("函数外部的a为:%s" % a)

    执行结果是:

    调用函数之前,变量a的内存地址为: 34875720

    在函数内部修改之前,变量b的内存地址为: 34875720

    在函数内部修改之后,变量b的内存地址为: 34875720

    函数内部的b为: [1, 2, 3, 4]

    函数外部的a为:[1, 2, 3, 4]

    调用函数时将列表对象a的地址传递给了函数内部的变量b。b.append(4)的时候,根据传进来的内存地址,找到[1,2,3]这个列表对象,在它的后面添加了4。

    可以看出,此时的a和b实际指向了同一个对象。为什么会这样?因为最关键的b.append(4)这句代码,它不同于“=”赋值语句,不会创建新的变量,而列表作为可变类型,具有append方法,这个方法只是对列表的一种调用而已。因此,a和b实际还是同一个对象。

    那么,如果用数字类型调用append方法,会是什么结果呢?很明显,这是不行的,因为数字类型没有append方法,不是Python官方不给它设计,而是因为数字类型是不可变类型,永远不能有append方法。

    评论总数: 1

    lis 不是可迭代对象

    By

    curitisyang   On

    2018年9月24日 07:26

    回复

    展开全文
  • Python匿名函数

    2019-01-19 18:24:45
    Python 匿名函数 ⽤lambda关键词能创建⼩型匿名函数。这种函数得名于数的标准步骤。lambda函数的语法只包含⼀个语句,如下: lambda [arg1 [,arg2argn]]:expressi 如下实例: sum = lambda arg1, arg2: arg1 + arg2 ...

    Python 匿名函数

    ⽤lambda关键词能创建⼩型匿名函数。这种函数得名于数的标准步骤。lambda函数的语法只包含⼀个语句,如下:
    lambda [arg1 [,arg2argn]]:expressi

    如下实例:

    sum = lambda arg1, arg2: arg1 + arg2
    

    #调⽤sum函数

    print "Value of total : ", sum( 10, 20 )
    print "Value of total : ", sum( 20, 20 )
    

    以上实例输出结果:

    Value of total : 30
    Value of total : 40
    

    Lambda函数能接收任何数量的参数但只能返回⼀个表达式的值
    匿名函数不能直接调⽤print,因为lambda需要⼀个表达式

    展开全文
  • Python用lambda语法定义匿名函数,只需用表达式而无需申明。(省略了用def声明函数的标准步骤)。 #定义匿名函数: sum = lambda arg1,arg2 : arg1+arg2 #调用sum函数 print(“Value of total:”,sum(10,20)) print...

    匿名函数
    匿名函数指一类无须定义标识符的函数或子程序。Python用lambda语法定义匿名函数,只需用表达式而无需申明。(省略了用def声明函数的标准步骤)。
    #定义匿名函数:
    sum = lambda arg1,arg2 : arg1+arg2
    #调用sum函数
    print(“Value of total:”,sum(10,20))
    print(“Value of total:”,sum(20,20))
    输出结果
    在这里插入图片描述

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

     	    	lambda[arg1,[arg2,.....argn]] :expression   
     		  
      arg1...argn:函数的参数列表,参数之间用逗号(,)分割。
      expression:被返回的表达式,且表达式只能有一个(注意: lambda 定义不包含 return 语句)。
      lambda 表达式构建的其实是一个函数对象
      lambda 函数能接收(任何数量的参数)但是只能返回(一个表达式)的值!
    

    函数作为参数传递实例:

    def fun(a,b =2,myfun = pow):
    	    """a接收,b接收,fun接收函数名"""  # pow: x**y
    	    print("a = ",a,end=";")
    	    print("b = ",b, end=";")
    	    print("result = ", myfun(a,b))
    	fun(5)
    	fun(5,3)
    	fun(5,3,lambda x,y:x**y)
    	fun(5,3,lambda x,y:x+y)
    输出结果:
    a =  5;b =  2;result =  25
    a =  5;b =  3;result =  125
    a =  5;b =  3;result =  125
    a =  5;b =  3;result =  8
    
    • 递归函数
      递归函数就是函数在内部调用自身。必须有一个明确的递归结束条件,称为递归出口。

    注意: 切勿忘记递归出口,避免函数无限调用。

    def fib(num):
        """
        斐波那契数列
        :param num:
        :return:
        """
        if num <= 2:
            return 1
        else:
            return fib(num - 1) + fib(num - 2)
    result = fib(4)
    print(result)
    

    阶乘的规律
    在这里插入图片描述
    代码实现如下:

    在这里插入图片描述
    汉诺塔问题

    moveCount = 0
    def hanoi(n, a='A', b='B', c='C'):
        """
        :param n:盘子个数
        :param a:初始塔
        :param b:缓存塔
        :param c:目标塔
        :return:移动次数
        """
        if n == 1:
            global moveCount
            moveCount += 1
            print(a, "--->", c)
        else:
            # 只是调用自己, 并没有真实的移动;
            # 1). 打开冰箱门
            hanoi(n - 1, a, c, b)   
            # 2). 把大象放进去
            hanoi(1, a, b, c)
            # 3). 把冰箱门close
            hanoi(n - 1, b, a, c)
    hanoi(3)
    print("移动次数:", moveCount)
    
    展开全文
  • python函数属性

    2019-09-26 19:26:29
    Python中,函数的参数可以有默认值,也支持使用可变参数,所以Python并不需要像其他语言一样支持函数的重载,因为我们在定义一个函数的时候可以让它有多种不同的使用方式。 # 在参数名前面的*表示args是一个可变...
  • Python求和函数sum()

    2021-02-03 22:59:48
    #Python求和函数sum() 若用求和函数sum()直接求几个int的和时会报错 就像这样 >>> total=sum(1,2,3) Traceback (most recent call last): File "<pyshell#14>", line 1, in <module> total=...
  • python匿名函数lambda

    2019-03-12 17:44:50
    #匿名函数 #匿名函数三个数寻找最大值和最小值 print((lambda a,b,c:c if c&gt;(a if a&gt;b else b) else (a if a&gt;b else b))(1,2,3)) #利用匿名函数实现多个数据求平均值 def fun2(total,count): ...
  • Python 函数

    2021-03-27 22:06:24
    Python中的函数可以定义 接受不确定数量的参数 ,这种参数被称为 '可变参数' 。可变参数有两种,即在参数前加 * 和 ** 1> 基于元组的可变参数(*可变参数) *可变参数在函数中被组装成一个元组。 示例代码如下...
  • # 先来看python函数定参数求和def dup1(m ,n ,l):total = 0total = m + n + lreturn totalprint(dup1(4 ,6 ,8))#打印 10#此时会发现参数不可变不是很好,没有很好的的拓展性。如在增加参数则无能为力,需要重新修改...
  • 我们在前面的章节中,很多次的看到了在函数中调用别的函数的情况...我们先看一个例子,典型的高斯求和问题,1+2+3+4+…+99+100,不使用递归的话,我们可以用循环,这么做:def sum_number(n):total = 0for i in range...
  • 在尝试将 range 生成的列表(感谢楼上的笔记)作为可变长参数元组传入函数的时候,发现列表会作为一个元组元素传入,因此要在使用的时候使用嵌套的 for 来遍历两次。..."""total = 0for i in ar...
  • 我已经编写了一个函数,它基本上计算文档的逆频率(logbase10(total编号文件/编号包含特定单词的文档)我的代码:def tfidf(docs,doc_freqs):res = []t = sum(isinstance(i, list) for i in docs)for key,val in doc_...
  • python函数

    2018-03-19 19:52:00
    return 语句 return语句[表达式]退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值,下例便告诉你怎么做: #!/usr/bin/python#-*- ...total=ar...
  • 函数,接收n个数字,求这些数字的和# 函数名不定义为sum,避免与内置函数冲突def sum_func(*args):total = 0for i in args:total += ireturn totalprint(sum_func(1, 3, 4, 33, 44, 66))2.代码中打印出来的a,b,c...
  • 刚学Python的时候,特别是看一些库的源码时,经常会看到func(args, kwargs)这样的函数定义,这个和让人有点费解。 有时你可能想定义的函数里面能够有任意数量的变量,也就是参数数量是可变的,这可以通过使用星号来实现...
  • 刚学Python的时候,特别是看一些库的源码时,经常会看到func(args, kwargs)这样的函数定义,这个和让人有点费解。 有时你可能想定义的函数里面能够有任意数量的变量,也就是参数数量是可变的,这可以通过使用星号来实现...
  • 引数据集data_socrestudentid course score1 math 892 english 76. . .问题:求各studentid总分方法1-一般写法:student_score_total={}f...
  • python函数多个返回值You can return many values from a function in Python. 您可以从Python中的函数返回许多值。 To achieve this, return a data structure with several values, such as a list of the total ...
  • 任务如下:Write a function called nine_lines that uses the function three_lines(provided below) to print a total of nine lines.Now add a function named clear_screen that uses a combination of the...
  • 英文文档: sum(iterable[,start]) ...Sumsstartand the items of aniterablefrom left to right and returns the total.startdefaults to0. Theiterable‘s items are normally numbers, and the start value is n...
  • python函数的编写

    2020-12-22 13:16:14
    简单函数 生成三位数 def f1(a,b=0,c=0): #默认指定参数 return a*100+b*10+c >>> f1(2,1,3) 213 =========================== 累加 def total_add(a,b): result = 0 for num in range(a,b+1): result += num ...
  • Python函数的变量域

    2018-05-06 18:32:11
    变量作用域 Python作用域一共分为四种,分别是: L 局部作用域 E 闭包函数外的函数中 ...Python中只有模块,累,以及函数def,lambda,才会引入新的工作域 实例: total = 0 n2 = 10 def sum(m,p): ...
  • python 函数 练习

    2018-11-02 14:47:00
    # 2、写函数,接收n个数字,求这些参数数字的和。 def sum_func(*args): total = 0 for i in args: total += i return total print(sum_func(1,2,3,8,23,6)) # 3、读代码,回答:代码中,打印出来的值a,...
  • 英文文档: sum(iterable[, start]...Sums start and the items of an iterable from left to right and returns the total. start defaults to 0. The iterable‘s items are normally numbers, and the start val...
  • ''' 想最快的入门Python吗?请搜索:"泉小朵",来学习Python最快入门教程。 也可以加入我们的Python学习...# 先来看python函数定参数求和 def dup1(m ,n ,l): total = 0 total = m + n + l return total print(du...
  • 《简明Python教程》第15章当中有这样一段代码: >>> def powersum(power,*args): '''Return the sum of each argument raised to specified prower.''' total = 0 for i in args: total += pow(i,power) ...
  • python 函数耗时

    千次阅读 2019-03-29 11:12:25
    import string import random import time import functools def list_from_2d_np(np_array): """ convert a 2d numpy array to a list """ shape = np_array.shape total = shape[0] * shape...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 431
精华内容 172
关键字:

pythontotal函数

python 订阅