Python基础之函数,列表推导式,匿名函数,递归

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/Scrat_Kong/article/details/81950338

1.函数

函数:具有独立功能的代码块。

  • 使用包含两个步骤:1.定义函数  2.调用函数
  • 函数的作用:开发时,提高编写效率。

函数的参数:分为形参(可理解为变量),实参。

  • 默认参数:不赋的时候才生效。
  • 关键字参数:实参可以指定对应的形参。   printinfo(name,age)  -----> printinfo(age=9,name='miki')

可变参数:

  *args:接收任意数量的参数。(本质:将传递的参数包装成了元组)

def sum_num(a, b, *args):
    result = a + b
    for temp in args:
        result += temp
    return result
sum_num(1, 2, 3, .., n)

**kwargs  : 可接收不存在的关键字的参数, 将不存在的关键字包装成字典。

def sum_num(a, b, *args, **kwargs):
    print(a)
    print(b)
    print(args)
    print(kwargs)
sum_num(1, 2, 3, .., n, mm=5, nn=6)

 

拆包:除了对元组,对列表,字典也可拆包

def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age

# result = get_my_info()
# print(result)

my_high, my_weight, my_age = get_my_info()
print(my_high)
print(my_weight)
print(my_age)

函数返回值: 在函数执行结束后,告诉调用者一个结果,便于调用者进行后续处理  。  

                       调用的一方可以通过变量来接收结果。

 

组包,拆包:

        如果有多个return ,则只有第一个生效。返回多个数据时,Python会自动将数据组包。如使用多个变量接收返回      值,则Python会自动进行拆包。

 

函数的类型,根据参数及返回值分为:

  1. 无参数,无返回值。
  2. 无参数,无返回值。
  3. 有参数,无返回值。
  4. 有参数,有返回值。

 

根据作用域,函数变量可以分为:

  • 局部变量:函数内部定义的变量。不同函数内可以定义相同名字的局部变量。

                         用于存储临时保存的数据。

  • 全局变量:函数外边定义的变量叫做全局变量。全局变量能够在所有的函数中进行访问。

                         函数内修改全局变量,需要用global

 

引用:  Python中可以用ID来查看引用是否为同一个内存空间,如果返回值相同,说明引用相同。Python中值是靠引用传递的

>>> a = 1
>>> b = a
>>> id(a)
13033816
>>> id(b) # 注意两个变量的id值相同
13033816
>>> a = 2
>>> id(a) # 注意a的id值已经变了
13033792
>>> id(b) # b的id值依旧
13033816
>>> a = [1, 2]
>>> b = a
>>> id(a)
139935018544808
>>> id(b)
139935018544808
>>> a.append(3)
>>> a
[1, 2, 3]
>>> id(a)
139935018544808
>>> id(b) # 注意a与b始终指向同⼀个地址
139935018544808

 

2.类型

可变类型与不可变类型:

  • 可变:列表,字典,集合。
  • 不可变,数值,字符串,元组。

可变对象与不可变对象:

  • 不可变对象,该对象所指向的内存中的值不能被改变。当改变某个变量时候,由于其所指的值不能被改变,相当于把原来的值复制一份后再改变,这会开辟一个新的地址,变量再指向这个新的地址。
  • 可变对象,该对象所指向的内存中的值可以被改变。变量(准确的说是引用)改变后,实际上是其所指的值直接发生改变,并没有发生复制行为,也没有开辟新的出地址,通俗点说就是原地改变

 

3.模块

模块好比工具包,要想使用工具包,需要导入import

  • 每一个以扩展名py结尾的Python源代码文件都是一个模块
  • 在模块中定义的全局变量,函数都是模块能够提供给外界直接使用的工具
  • 可以 在⼀个 Python ⽂件 中 定义 变量 或者 函数,然后在 另外⼀个⽂件中 使⽤  import  导⼊这个模块
  • 导⼊之后,就可以使⽤  模块名.变量  /  模块名.函数  的⽅式,使⽤这个模块中定义的变量或者函数

模块名也是⼀个标识符

  • 标示符可以由 字⺟、下划线 和 数字 组成
  • 不能以数字开头
  • 不能与关键字重名

注意:如果在给 Python ⽂件起名时,以数字开头是⽆法在  PyCharm  中通过导⼊这个模块的

 

4.列表推导式:           

快速生成列表元素的表达形式。

推导式的基本格式:

  • [ 计算公式  for 循环 if 判断 ]

特点:

  • 每循环一次,将计算公式的结果添加到列表中。
  • 计算公式可以使用遍历出的数据。
  • for遍历出的数据必须满足if判断,才会使用计算公式生成元素。
a = [x for x in range(4)]   ->  [0,1,2,3]

a = [x for x in range(3,10) if x % 2 != 0]

a = [(x,y)  for x in range(1,3)  for y in range(3)]

练习:

  • 请写出⼀段 Python 代码实现分组⼀个 list ⾥⾯的元素,⽐如 [1,2,3,...100]变成 [[1,2,3],[4,5,6]....]

参考答案:

a = [x for x in range(1,101)]
b = [ a[ x:x+3 ] for x in range(0,len(a),3)]

 

5.匿名函数

定义:⽤lambda关键词能创建⼩型匿名函数。这种函数得名于省略了⽤def声明函数的标准步骤
lambda函数的语法只包含⼀个语句,如下:

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

实例:

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需要⼀个表达式
 

应用场合:

1. 函数作为参数传递
 ⾃⼰定义函数

>>> def fun(a, b, opt):
... print("a = " % a)
... print("b = " % b)
... print("result =" % opt(a, b))
...
>>> fun(1, 2, lambda x,y:x+y)
a = 1
b = 2
result = 3

2. 作为内置函数的参数
想⼀想,下⾯的数据如何指定按age或name排序?

匿名函数
stus = [
{"name": "zhangsan", "age": 18},
{"name": "lisi", "age": 19},
{"name": "wangwu", "age": 17}
]
按name排序:
>>> stus.sort(key = lambda x: x['name'])
>>> stus
[{'age': 19, 'name': 'lisi'}, {'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}]
按age排序:
>>> stus.sort(key = lambda x: x['age'])
>>> stus
[{'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}, {'age': 19, 'name': 'lisi'}]

 

6.递归函数

⼀个函数可以调⽤其他函数, 如果函数在内部调⽤其本身,这个函数就是递归函数

递归函数的作⽤ 举个例⼦,我们来计算阶乘 n! = 1 2 3 ... n

1! = 1

2! = 2 × 1 = 2 × 1!

3! = 3 × 2 × 1 = 3 × 2!

4! = 4 × 3 × 2 × 1 = 4 × 3!

...

n! = n × (n-1)! 

# 如果定义step_num函数实现了阶乘,相当于step_num(n) = n * step_num(n-1)

def step_num(num): 
    if num > 1: 
        return num * stp_num(num - 1)
    else:
        return 1

递归函数⼀般都需要⼀个条件判断来打破死循环,否则会导致到达最⼤嵌套次数,程序报错 。

展开阅读全文

没有更多推荐了,返回首页