内置函数
---------------------------------------------------------------------------------
接下来,我们就一起来看看python里的内置函数,到现在,python为我们提供了68个函数
让我们来了解了解有哪些内置函数.
Built-in Functions abs() dict() help() min() setattr() all() dir() hex() next() slice() any() divmod() id() object() sorted() ascii() enumerate() input() oct() staticmethod() bin() eval() int() open() str() bool() exec() isinstance() ord() sum() bytearray() filter() issubclass() pow() super() bytes() float() iter() print() tuple() callable() format() len() property() type() chr() frozenset() list() range() vars() classmethod() getattr() locals() repr() zip() compile() globals() map() reversed() __import__() complex() hasattr() max() round() delattr() hash() memoryview() set()
上面就是内置函数的表,68个函数都在这儿了
下面是流程图的网址
https://www.processon.com/mindmap/5be404c4e4b012807692bcc6
而主要的那些都是啥哪?
1)range(起始位置,终止位置,步长) *****
for i in range(10): print(i) for i in range(1,10): print(i) for i in range(10,0,-1): print(i)
2)next (迭代器)是内置函数 ***
__next__是迭代器的方法
g.__next__()带双下划线的魔术方法一般情况下不直接用
next(g) 之前所有的__next__都应该替换成next(g)
带下划线所有的方法都可能和内置的函数有千丝万缕的联系
3)iter (可迭代的) 写法:__iter__ ***
迭代器=可迭代的.__iter__()
迭代器=iter(可迭代的)
4)open (打开) ***
写法:1.f=open('文件名',mode='模式',encoding='编码')
2.with open('文件名',mode='模式',enconding='编码')as f
5)input *****
变量名=input('你要输入的内容')
money=input('我的金额:')
6)print 显示你输出的内容 *****
print('hi')
7)import 导入别人写好的模板 *****
import time 时间模块 import os 文件模块 import sys 操作系统模块 import random 数字模块
8)hash 函数 ***
可哈希(不可变数据类型)
不可哈希(可变数据类型)
哈希是一种算法,导致了字典的快速算法
所有的数据想要得到不变的hash值,必须是一个不可变的数据类型
t = (1,2,3) l = [1,2,3] print(hash(t)) #可hash print(hash(l)) #会报错
9)dir 函数 ***
特殊的需求/研究或者了解一个新的数据类型/面向对象之后会介绍的数据类型
print(dir(list)) #查看列表的内置方法 print(dir(int)) #查看整数的内置方法 print(dir(__builtins__))#内置名字
10)eval( ) ***
可以将字符串数据类型的python代码执行,通过拼接字符串的方式执行不同的代码-----简化代码
eval('print(1+2+3+4)') # 有返回值 ret = eval('1+2/3*4') print(ret) print(eval('1+2+3+4'))
11)exec() *
跟上面一样----只是没有返回值
exec('print(1+2+3+4)') # 没有返回值 ret = exec('1+2/3*4') print(ret)
12)compile 能够节省时间工具 *
先编译 python----编译--->字节码(bytes)---解释--->机器码0101010101
code3 = 'name = input("please input your name:")' compile3 = compile(code3,'','single') exec(compile3) print(name)
13)help() 帮助你了解python的 *
方式一:
输入help()进入帮助页面,输入数据类型,帮助我们打印具体的帮助信息
'123'.startswith()
输入Q退出帮助
方式二:
print(help(str)) print(help('abc'))
14)callable 判断某一变量是否可调用 *
def func():pass print(callable(func)) #参数是函数名，可调用，返回True print(callable(123)) #参数是数字，不可调用，返回False
15)locals() 本地作用域/局部作用域 会随着位置的变换而变换 ***
查看局部作用域中的变量和函数名
16)globals 查看全局作用域中的变量和函数名 ****
a = 10 def func(): global a a = 20 print(a) func() print(a)
17)nonlocal ****
改变父集变量,如果上级没有能够改变的就继续向上走,直到最外层函数就停止了
def f(): a=1 def f1(): nonlocal a a=2 f1() print(a) f()
18)complex 复数 *
实数(有理数和无理数) 世界存在的数
虚数:j
某一个数的平方是-1,那么这个数就是一个虚数的基础单位j
复数=实数+虚数=a+bj
选择题 :(对你的数学有要求的公司都会考) # 复数不能比较大小 # 共轭复数 : a+bj 和 a-bj是一对共轭复数 # a+bj 和 a+bJ都是复数
19)bin 十进制
oct 二进制
hex 八进制
20)divmod 商余函数 ***
print(divmod(10,3)) 结果:(3,1)
21)round(小数,保留几位小数) -----小数精确 ***
ret=round(2.5464464,2) print(ret) 结果:2.54
22)pow 幂运算 *
print(pow(2,3)) #(数字,幂) print(pow(3,2)) #(数字,幂) print(pow(5,3,2)) #(数字,幂,取膜)
23)min/max ***
print(min(1,2,3)) print(max(1,2,3))
24)sum (可迭代的数字集,start) start从哪个数开始加 ***
print(sum((1,2,3,4))) print(sum([1,2,3,4])) print(sum(range(10)))
25)reversed(list/tuple) 返回一个迭代器,节省内存 ***
l = [1,2] l.reverse() print(l) ret = reversed([1,2,3]) # iterator print(list(ret))
reverse是在原基础上修改
reversed不修改原基础,不直接返回列表而返回迭代器,为了不占用更多的内存
26) slice 切片 ***
l=[1,2,3,4,5] ret=slice(1,4) #切得范围不包括第一个元素(1) print(l[ret])
27)format 空格 *
print(format('aaa','>20')) print(format('aaa','<20'),'bbb')
28)bytes 字节
str ------bytes
网络上传输的数据:bytes
文件存储 网络+文件 图片视频都是字节
29)bytearray
把一个字符串编程一个字节数组,较长的字符串的修改节省内存,修改行为必须依靠编码
ret=bytearray('abc'*30,encoding='utf-8') print(ret)
30)repr( ) 打印的时候输出这个变量的数据类型
a=1 b='1' print(repr(a),repr(b))
31)len( ) 计算长度 ***
print(len('sdsds'))
32)enumerate 枚举函数 *
for i in enumerate(['a','b','c'],1): print(i)
结果:(1,'a')
(2,'b')
(3,'c')
33)all/any 参数,iterable 只要一个为假返回False/只要一个为真返回True *
print(all((1,2,3,4,0))) 结果:False print(any((1,2,3,4,0))) 结果:True
34)zip( ) 拉链函数 返回迭代器-----节省内存 *****
a=(1,2,3) b=('a','b','c') ret=zip(a,b) # print(dict(ret)) #字典 for i in ret: print(i) #元组
35)filter 筛选 *****
ret=filter(None,[1,2,3,0,False]) #(条件,取得值) print(ret) for i in ret: print(i)
36)map() *****
一个迭代器中的每一个元素都需要去做同一个操作并返回一个结果组成一个新列表的时候map来处理
L = [1,2,3,4,] def pow2(x): return x*x print(list(map(pow2,L))) # [1, 4, 9, 16]
37)sorted( ) 排序 *****
根据key对应的函数的返回值的大小来排序的,由于必须要知道的值是谁,才能拍出顺序,所以结果就是排序后的结果而不是迭代器.
l1 = [1,3,5,-2,-4,-6] l2 = sorted(l1,key=abs) #abs 绝对值 print(l1) print(l2)
定义:匿名函数的内存地址=lambda 参数:参数 返回值/返回值的表达式
接收返回值=匿名函数的内存地址(参数)
res = filter(lambda x:x>10,[5,8,11,9,15]) for i in res: print(i) 输出 11 15
递归函数---------------在一个函数的内部调用他自己
import sys print(sys.getrecursionlimit()) #查看递归的最大深度
官网上 源代码中设置是:1000
自己实际测试是:998
注意:如果你的递归每次都要超过限制,不适合用递归来解决
return 能够帮你停止递归,并且把最内层的结果一层一层的返回到外层
在最内层函数的返回值,返回的时候永远离最内层最近的上一层才能收到返回值.
阶乘
def func(n): if n==1: return 1 return func(n-1)*n ret=func(6) print(ret)
基础版
l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88] def func(l,aim): mid = (len(l)-1)//2 if l: if aim > l[mid]: func(l[mid+1:],aim) elif aim < l[mid]: func(l[:mid],aim) elif aim == l[mid]: print("bingo",mid) else: print('找不到') func(l,66) func(l,6)
终极版
def search(num,l,start=None,end=None): start = start if start else 0 end = end if end is None else len(l) - 1 mid = (end - start)//2 + start if start > end: return None elif l[mid] > num : return search(num,l,start,mid-1) elif l[mid] < num: return search(num,l,mid+1,end) elif l[mid] == num: return mid
广义上的算法:计算某一个结果所使用的方法
狭义上的算法:计算一个结节所使用的简单方法,更高效的方法