python 中 help 、dir用法，内置的高阶函数用法:map, filter, sorted 和递归调用、break、continue用法

最新推荐文章于 2022-03-22 16:45:43 发布

原创最新推荐文章于 2022-03-22 16:45:43 发布 · 263 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#map #filter #sorted #break #continue

Python 专栏收录该内容

20 篇文章

订阅专栏

查看python当前安装的所有模块的方法

python内置的高阶函数用法:map, filter, sorted 、递归调用、break、continue用法

help用法:

1、>>>help()

help>>modules

pyhton控制台打开自己想要的模块

3、例如：re模块

>>>import re

>>>help(re)

查看模块路径:

>>>re.__file__

dir()用法:

dir()函数可以查看对像内所有属于及方法

什么是高阶函数:
满足下列条件中的一个的函数即为高阶函数

     1. 函数接收一个或多个函数作为参数传入
     2.  函数返回一个函数

python内置的高阶函数:
map, filter, sorted

map函数:
map(func, *iterable) 返回一个可迭代对象,此可迭代对象用函数func对可迭代对象iterable中的每一个元素作为参数计算后得到新的数据

# 求: 1 ** 2 + 2 ** 2 + 3 ** 2 + ...+7**2的和
def power(x):
    return x**2
sum_ = 0
for i in map(power,range(1,8)):
    sum_ += i
print(sum_)

filter 函数:
filter(function, iterable)
作用:

筛选可迭代对象iterable中的数据,返回一个可迭代对象,此可迭代对象只返回iterable中附合条件的数据
function将对iterable中提供的每个数据进行求布尔值，如果为True则保留，返回False 则丢弃此数据
```
 求1~10之间所有的素数放入到列表L中 print(L)  # [2, 3, 5, 7]
def isprime(x):
    if x<2:
        return False
    for i in range(2,x):
        if x%2 == 0:
            return False
        return True
L = list(filter(isprime,range(1,11)))
print(L)
```
sorted 函数
作用:
将原可迭代对象的数据进行排序，生成排序后的列表
函数参数格式:
sorted(iterable, key=None, reverse=False)
说明:
iterable 可迭代对象
key 函数是用来提供一个值，这个值将作为排序的依据，如果不给出key函数，则用原数据的值进行比较和排序
reverse 标志用来设置是否降序排序
```
#对 L = [1,3,-7,2,6] 按升序 排列
L = [1,3,-7,2,6]
L1 = sorted(L, key = abs, reverse=False)
print(L1)
```

递归函数 recursion
递归是指函数直接或间接的调用自身

递归示例:

函数直接调用自身

def f():
f() # 直接调用自身
f()
print(“递归完成”)

函数间接调用自身

def fa():
fb()
def fb():
fa()
fa()
print(“递归完成”)

递归说明:
递归一定要控制递归的层数，当符合某一条件时要终止递归调用
几乎所有的递归都能用while循环来代替

递归的优缺点:
优点：
可以把问题简单化，让思路理会为清晰，代码更简洁
缺点:
递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果
递归调用分为两个阶段:
递推阶段:
从原问题出发，按递归公式递推，从未知到已知，最终达到递归终止条件
回归阶段:
按递归终止条件求出结果，逆向逐步代入递归公式，回归到原问题求解

# 限制递归层数的示例:
def recursion(param):
    print("递归进入第", param, "层")
    if param == 3:
        return
    recursion(param + 1)
    print("递归退出第", param, "层")

recursion(1)
print("程序结束")

输出结果:
递归进入第 1 层
递归进入第 2 层
递归进入第 3 层
递归退出第 2 层
递归退出第 1 层
程序结束

计算  n! = 1*2*3*4*....*n 阶乘
#1、用循环实现阶乘
def factorial_1(param):
    s = 1
    for i in range(1,param+1):
        s *= i
    return s

print(factorial_1(5)) #120

# 用递归来实现
# 5!  = 5 * 4!
# 5!  = 5 * 4 * 3!
# 5!  = 5 * 4 * 3　* 2!
# 5!  = 5 * 4 * 3　* 2 * 1!
# 5!  = 5 * 4 * 3　* 2 * 1
# 5!  = 5 * 4 * 3　* 2
# 5!  = 5 * 4 * 6
# 5!  = 5 * 24
# 5!  = 120
#2、用递归实现阶乘
def factorial_2(param):
    if param == 1:
        return 1
    return param * factorial_2(param - 1)

print(factorial_2(5)) #120

# 计算 1*1+2*2+...+10*10

#递归实现:
def mysum(n):
    if n == 1:
        return 1
    return n * n + mysum(n - 1)
print(mysum(10))  # 385

#for 循环实现
def mysum(n):
    sum_1 = 0
    for i in range(1, n + 1):
        sum_1 += i * i
    return sum_1

print(mysum(10)) #385

#while 循环实现
def mysum(n):
    i = 0
    sum_1 = 0
    while i < n:
        i += 1
        sum_1 += i * i
    return sum_1

print(mysum(10))  # 385


python中break与continue区别
continue：是跳出本次循环，进入到下一次循环中；
break:是直接跳出循环，终止执行；
例1：    
for i in range(7):
    if i==3:
        break
    print(i)#012   
print(i)#3

例2：
for i in range(7):
    if i==3:
        continue
    print(i)#012456
print(i)#6