函数__迭代,二分法

一.内置函数。

二.递归

三、二分法。

一.内置函数.

1)reversed()  反转.返回值是个迭代器,打出来需要用list()一下

huiwen = "不是上海自来水来自海上"
s = huiwen[::-1]
it = reversed(huiwen) # 返回的是迭代器
s = ""
for el in it:  #这样使用拼接的方法,打出来就是一个字符串了.好看
    s += el
print(s)
输出结果为:上海自来水来自海上是不

第二种.是迭代打出来的,不咋好看
huiwen = "不是上海自来水来自海上"
s = huiwen[::-1]
it = reversed(huiwen) # 返回的是迭代器
print(list(s))
输出结果为:
[‘上‘, ‘海‘, ‘自‘, ‘来‘, ‘水‘, ‘来‘, ‘自‘, ‘海‘, ‘上‘, ‘是‘, ‘不‘]

2)slice()  切片,不常用

lst = ["河南话", "四川话", "东北", "山东", "上海"]
s = slice(3,5) # 切片. 麻烦
print(lst[s])
输出结果:
[‘山东‘, ‘上海‘]

3)format()  格式化输出.该函数可不限参数个数,位置可以不按顺序.

语法:"{}{}".format("参数1","参数2")
"{} {}".format("hello", "world")    # 不设置指定位置,按默认顺序
输出结果为:‘hello world‘

"{0} {1}".format("hello", "world")  # 设置指定位置
输出结果为:‘hello world‘

"{1} {0} {1}".format("hello", "world")  # 设置指定位置
输出结果为:‘world hello world‘

3.1)format() 数字格式化,不常用

print(format("门神", "^20"))  #长度20,居中
print(format("门神", "<20"))    #长度20,居左
print(format("门神", ">20"))    #长度20,居右

3.2)format()  浮点数

print(format(123456789, ‘e‘))   # 科学计数法. 默认保留6位小数
 print(format(123456789, ‘0.2e‘))   # 科学计数法. 保留2位小数(?小写)
 print(format(123456789, ‘0.2E‘))   # 科学计数法. 保留2位小数(?大写)
 print(format(1.23456789, ‘f‘))   # 小数点计数法. 保留6位小数
 print(format(1.23456789, ‘0.2f‘))   # 小数点计数法. 保留2位?小数
 print(format(1.23456789, ‘0.10f‘))   # 小数点计数法. 保留10位小数
 print(format(1.23456789e+10000, ‘F‘))   # 小数点计数法输出结果为:

1.234568e+08
1.23e+08
1.23E+08
1.234568
1.23
1.2345678900
INF  #超界限了,打印不出来,就显示该数为无限


4)ord()  拿字找位置(索引值),返回的是该字符在编码的位置.对应的是unicode码

chr()  拿数找字,返回的是该数在码里面的字,对应的是unicode码,中国字65536个数字位置

5)ascii()  判断是否在ascii码里,在就打印出该参数在ascii里的码区码位.

print(ascii("饕髢"))
输出结果为:
‘\u9955\u9ae2‘

6)repr()  将字符串还原为底层C语言认识的合理语法.(python是C语言写的)

\n 换行
\t tab 制表符
\r 回车
\"   双引号
\‘  单引号
\\    \转义
print(‘你好, 我叫周杰伦.我来自\\n台湾. 我老婆叫昆凌‘)
repr() # 还原字符串最官方的效果
print(repr("你好. \\n我叫\周杰伦"))  # python接收到内容  交给  repr()翻译,之后交给 cpython,处理完之后才能显示出来

题外话:如何原封不动的显示字符串内容,就在这个字符串前面加个r
print(r"\n\t范德萨发生\r\b\ffdsaf")  # 原封不动的显示字符串

name = "xiaoli"print(f"我叫{name},我来自地球")  #这里的f是格式化输出的意思,如果是fr就是就是两者的混合体打印结果:我叫xiaoli,我来自地球

二.递归.

函数自己调用自己

def func():
    print("我是递归")
    func()

func()   # 递归,官方显示最大为1000次,你永远跑不到1000, 我实测998

下面介绍下用函数递归打印出所有的文间目录

def func(lujing, n): # "d:/a/"
    lst = os.listdir(lujing) # 打开文件夹. 列出该文件夹内的所有文件名, 返回指定的文件夹包含的文件或文件夹的名字的列表,此列表以字母排序
    for el in lst: # el是文件的名字.  b, c
        # 还原文件路径
        path = os.path.join(lujing, el) # "d:/a/b"   把目录和文件名合成一个路径,说白了,就是做拼接的,给出绝对路径
        if os.path.isdir(path): # 判断路径是否是文件夹
            print("..." * n,el) # 显示文件夹的名字
            func(path, n + 1)  # 在来一次  ################
        else:
            print("\t" * n,el) # 显示文件
func("d:/a", 0)

新词解析:

os.path  模块主要用于获取文件的属性。
os.listdir()  方法用于返回指定的文件夹包含的文件或文件夹的名字的列表,此列表以字母排序,它不包括 ‘.‘ 和‘..‘ 即使它在文件夹中。
os.path.join()  #把目录和文件名合成一个路径,说白了,就是做拼接的,给出绝对路径
os.path.isdir(path)    判断路径是否为目录(就是文件夹),需提供绝对路径
os.path.isfile(path)    判断路径是否为文件(文件是某种执行格式),需提供绝对路径
目录文件”指的是某些“文件”,“目录”只是定义这些文件存放的位置。文件是有具体内容或用途的,通常电脑有多种不同功用的文件,有可执行文件,数据文件,类或库文件,文本文件,图像文件等等

三、二分法.

特点:掐头去尾取中间,查找效率很高,但是局限性比较大,必须是有序序列才可以用此方法

二分法查找 (需要你明白和掌握)
lst = [1,3,5,7,12,36,68,79]
n = int(input("请输入一个数"))

left = 0
right = len(lst) - 1

while left <= right:
    mid = (left + right)//2
    if n > lst[mid]:
        left = mid + 1
    elif n < lst[mid]:
        right = mid - 1
    else:
        print("存在")
        break

else:
    print("不存在")

第二种(需要理解掌握)

def func(n, lst, left, right): # 递归找到什么是可以变的. 什么是不可以变的
    if left <= right:
        mid = (left + right) // 2
        if n > lst[mid]:
            left = mid + 1
            return func(n, lst, left, right)
        elif n < lst[mid]:
            right = mid - 1
            return func(n, lst, left, right) # 递归如果有返回值. 所有调用递归的地方必须写return
        else:
            print("找到了")
            return mid  # 难点
    else:
        print("找不到")
        return -1

第三种(了解下即可)

def func(n, lst):
    left = 0
    right = len(lst) - 1
    if lst != []:
        mid = (left + right)//2
        if n > lst[mid]:
            func(n, lst[mid+1:]) # 改变列表
        elif n < lst[mid]:
            func(n, lst[:mid])
        else:
            print("找到了")
            return
    else:
        print("没找到")
        return
n = int(input("请输入你要查找的数:"))
func(n, [1,3,5,7,12,36,68,79]) # 78

最快的查找(了解即可)  此方法最节省空间和时间的.先创建一个最大值的列表,全部为0,把存在的数据当作这个列表的下标,把对应的小标改成1,最后,用户查找的时候,以输入的值为这个列表的下标,如果该下标对应的值为1,说明存在,否则不存在

lst = [1,3,55,98,37,41,2,5,1,4]
new_lst = []
for i in range(99):
    new_lst.append(0)
for i in lst:
    new_lst[i] = 1
print(new_lst)
i = int(input("输入你要找的数据:"))
if new_lst[i]==0:
    print("不存在")
else:
    print("存在")

原文地址:https://www.cnblogs.com/lgw1171435560/p/10116928.html

时间: 2024-10-09 06:49:01

函数__迭代,二分法的相关文章

Python匿名函数/排序函数/过滤函数/映射函数/递归/二分法

一. lamda匿名函数 为了解决一些简单的需求而设计的一句话函数 # 计算n的n次方 def func(n): return n**n print(func(10)) f = lambda n: n**n print(f(10)) lambda表示的是匿名函数. 不需要用def来声明, 一句话就可以声明出一个函数 语法: 函数名 = lambda 参数: 返回值 注意: 1. 函数的参数可以有多个. 多个参数之间用逗号隔开 2. 匿名函数不管多复杂. 只能写一行, 且逻辑结束后直接返回数据 3

15 .内置函数(二),递归函数,二分法

14. 前 方 高能-内置函数 二 本节主要内容: lamda匿匿名函数 sorted() filter() map() 递归函数 一. lamda匿匿名函数为了了解决 一些简单的需求 而设计的 一句句话函数 # 计算n的n次 方 def func(n): return n**n print(func(10)) f = lambda n: n**n print(f(10)) lambda表 示的是匿匿名函数. 不需要 用def来声明,  一句句话就可以声明出 一个函数 语法: 函数名 = lam

递推函数的迭代形式与递归形式

有一函数 f() 遵守以下规则: 当 n < 3 时, f(n) = n 当 n >= 3 时, f(n) = f(n - 1) + 2f(n - 2) + 3f(n - 3) 用迭代和递归的形式分别写出 计算 f(n) 的过程. 递归形式: (define (f n) (if (< n 3) n (+ (f (- n 1)) (* 2 (f (- n 2))) (* 3 (f (- n 3)))))) 迭代形式: (define (f n) (if (< n 3) n (f-it

函数递归与二分法(python3入门)

1 import sys 2 3 print(sys.getrecursionlimit()) # 查询递归保护限制次数 4 5 # 函数递归:在调用函数的过程中又 直接或者间接的调用该函数本身,称之为函数的递归调用 6 7 # 函数递归必须满足: 8 # 1 必须有一个明确的结束条件 9 # 2 每进入下一层递归,问题的规模都应该有所减少 10 11 # 由上述两个条件可以推导出递归应该有两个明确的阶段: 12 # 1 回溯:一层一层的递归调用下去 13 # 2 递推:在某一层结束掉递归,开始

函数递归,算法二分法

函数的递归 # 函数递归调用是函数嵌套调用的一种特殊形式,函数在调用时,直接或间接调用了自身,就是递归调用 # 调用函数会产生局部的名称空间,占用内存,因为上述这种调用会无需调用本身,python解释器的内存管理机制为了防止其无限制占用内存,对函数的递归调用做了最大的层级限制 #查看递归次数上限和修改次数上限 import sys # print(sys.getrecursionlimit()) # 结果不是很精确997次左右 # sys.setrecursionlimit(2000) 参数是上

函数的迭代

前言 典例剖析 例1[2018凤翔中学高三文科数学冲刺模拟第10套第8题]已知\(f(x)=\begin{cases}1,&x\in[0,1]\\x-3,&x\notin[0,1]\end{cases}\),则使得\(f(f(x))=1\)成立的\(x\)的取值范围是[] $A.[0,1]$ $B.[0,1]\cup\{7\}$ $C.[0,1]\cup [3,4]$ $D.[0,1]\cup[3,4]\cup\{7\}$ 分析:本题目属于求解分段函数方程,可以将\(f(x)\)这个整体视

C语言:编写折半查找函数,即二分法

#include<stdio.h>#include <stdlib.h>int main(){     int ret=0;     int arr[]={1,2,5,6,88,99,456,666};     ret= binsearch(666,arr,0,sizeof(arr) / sizeof(arr[0])-1);    if(ret!=-1)   {       printf("%d",ret);      }   else   {      pri

C run-time函数总览

Argument Access(参数访问):变长参数列表.这个模块提供了三个宏:va_arg.va_end和va_start,用来实现变长参数列表的访问. Buffer Manipulation(内存操作):按字节处理内存区域.主要函数:memcpy.memmove.memset等. Byte classification(字节分类):用来测试在多字节字符中满足一定条件的特殊字节.例如:isleadbyte.感觉用途不是很广,暂且忽略. Character classification(字符分类

04_内置函数(二)

内置函数(二) 1.1 callable() 功能:函数是否可调用 示例1: def f1(): pass f1() f2 = 123 f2() # 输出结果 TypeError: 'int' object is not callable 示例2: def f1(): pass # f1() f2 = 123 # f2() print(callable(f1)) print(callable(f2)) # 输出结果 True False 1.2 chr() 功能:数字转字母,返回对应的ASCII