python-内置函数和特殊函数

最新推荐文章于 2020-12-06 07:06:05 发布

dream_135

最新推荐文章于 2020-12-06 07:06:05 发布

阅读量349

点赞数 1

分类专栏： python 编程文章标签： python lambda

本文链接：https://blog.csdn.net/qq_40650558/article/details/105445418

版权

编程同时被 2 个专栏收录

25 篇文章 0 订阅

订阅专栏

python

23 篇文章 0 订阅

订阅专栏

文章目录

1、内置函数
2、特殊函数

1、内置函数

（1）作用域相关

locals()和globals()

（2）迭代器/生成器相关

iter([可迭代对象]) 返回迭代器，和__iter__()一样

next([迭代器]) 等同于__next__()

In [1]: l = [1, 2, 3]

In [2]: l_iter = iter(l)

In [3]: type(l_iter)
Out[3]: list_iterator

In [4]: next(l_iter)
Out[4]: 1

In [5]: next(l_iter)
Out[5]: 2

In [6]: next(l_iter)
Out[6]: 3

In [7]: next(l_iter)
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-7-43aece5a3964> in <module>()
----> 1 next(l_iter)

StopIteration:

（3）其它

输入输出
- print() 返回None
- input() 返回字符串
内存相关
- id() 返回内存地址
- hash([不可变对象]) 返回一串数字，目的是存储（）
  - 实际上字典的键就是以hash值存储的，查找的时候不用遍历，直接根据hash值查找
文件操作相关
- open()
模块相关
- __import__("模块") 动态加载模块，即在程序运行期间加载模块
帮助
- help() 返回帮助文档
调用相关
- callable([变量]) 返回True/False，查看该变量是否能被调用
查看内置属性
- dir()
字符串类型代码的执行
- eval() 动态执行一段字符串类型的代码，如s = eval("5 + 6 - 1")
  - 服务器和浏览器之间只能传输字符串，如"{"name":"dream", "age":19}"
  - 可以用eval()返回，把字符串还原成代码
- exec() 动态执行代码，没有返回值
- complie() 将一个字符串编译成字节代码
  - 第一个参数，resource，要执行的代码
  - 第二个参数，代码存放的文件名，有第一个参数时为空，即""
  - 第三个参数，模式
    - 模式1，exec，一帮放一些流程语句
    - 模式2，eval，只放一个求值代码
    - 模式3，single，代码有交互时使用
- 例子：
```
In [8]: eval("3*5 - (2+8)/10 + 21")
Out[8]: 35.0

In [9]: exec("print('这是exec执行的代码')")
这是exec执行的代码
```

（4）和数字相关

数据类型
- bool() int() float() 类型转换
- complex() 创建复数
进制转换
- bin() 十进制转换为二进制，返回0b···
- oct() 十进制转换为八进制，返回0o···
- hex() 十进制转换为十六进制，返回0x···
数学运算
- abs() sum([可迭代对象]) min([可迭代对象]) max([可迭代对象])
- divmod() 计算商和余数，如divmod(5, 2)
- round() 返回四舍五入后的数据（准确说不是四舍五入，而是另一种更科学的舍入规则，详细请百度）
- pow() 求次幂，第三个参数为求余数，如pow(2, 3, 5)

例子

In [10]: bin(15)
Out[10]: '0b1111'

In [11]: oct(15)
Out[11]: '0o17'

In [12]: hex(15)
Out[12]: '0xf'

In [13]: divmod(17, 4)
Out[13]: (4, 1)

In [17]: round(2.49, 1)  # round的第二个参数是保留位数
Out[17]: 2.5

In [18]: round(2.51, 1)
Out[18]: 2.5

In [19]: round(2.55, 1)  # 从这个例子中也可以看出round的规则并不是四舍五入
Out[19]: 2.5

（5）数据结构相关

<1>序列相关函数

列表和元组
- list(), tuple() 创建类型或类型转换

<2>数据集合相关函数

字典：dict()
集合：
- set()
- fronzenset()使集合不可变

<3>其它相关内置函数

len() 计算长度

enumerate() 对于列表同时取出索引和数据

In [77]: lis = ['a', 'b', 'c']

In [78]: for i, ele in enumerate(lis):
    ...:     print(i, ': ', ele)
    ...:     
0 :  a
1 :  b
2 :  c

all() 所有参数相与（只能接受一个参数）

In [75]: all([False, True, True, True])
Out[75]: False

In [76]: all([True, True, True])
Out[76]: True

any() 同all()，所有参数相或

zip([可迭代对象]) 合并打包，具体用法见例子

In [79]: lis1 = [100, 200, 300]

In [80]: lis2 = ['a', 'b']

In [81]: lis3 = ['aaa', 'bbb', 'ccc']

In [82]: s = zip(lis1, lis2, lis3)

In [83]: for ele in s:
    ...:     print(ele)
    ...:     
(100, 'a', 'aaa')
(200, 'b', 'bbb')

In [84]: lis1 = [100, 200, 300]

In [85]: lis2 = ['a', 'b', 'c', 'd']

In [86]: lis3 = ['aaa', 'bbb', 'ccc']

In [87]: s = zip(lis1, lis2, lis3)

In [88]: for ele in s:
    ...:     print(ele)
    ...:     
(100, 'a', 'aaa')
(200, 'b', 'bbb')
(300, 'c', 'ccc')

2、特殊函数

（1）lambda匿名函数

语法：lambda 参数: 返回值
- 如lambda m, n: (m, n) # 返回(m, n)元组
访问函数名字：__name__
- 如在函数传参中，把函数作为参数传递，可以用__name__查看传进来的实参是什么
- 匿名函数的__name__都是<lambda>

例子

In [1]: def cal(func, a, b):
   ...:     return func(a, b)
   ...: 
   ...: 

In [2]: cal(lambda m,n: m+n, 5, 10)
Out[2]: 15

In [3]: cal(lambda m,n: m*n, 5, 10)
Out[3]: 50

In [4]: func = lambda m,n: m+n

  
# 查看函数的名字
In [5]: func.__name__
Out[5]: '<lambda>'
 
In [9]: def cal(func, a, b):
   ...:     print(func.__name__)
   ...:     return func(a, b)
   ...: 
   ...: 

In [8]: def add(a, b):
   ...:     return a+b
   ...: 
   ...: 

In [10]: cal(add, 1, 2)
add
Out[10]: 3

In [11]: cal(lambda m,n: m+n, 1, 2)
<lambda>
Out[11]: 3

（2）排序函数sorted()

sorted([可迭代对象], [key], [reverse=True/False])
- key 是一个函数，sorted函数内部会把可迭代对象中的每一个元素拿出来交给后面的key来处理，
  key计算出一个数字，把这个数值作为当前这个元素的权重，然后根据权重排序，例子如下
```
In [18]: lst = ["aaa", "aaaa", "aa", "a"]

In [19]: ll = sorted(lst, key=len, reverse=False)  #这个例子就是以元素的长度为权重
# 或者可以 ll = sorted(lst, key=lambda s:len(s), reverse=False)

In [20]: ll
Out[20]: ['a', 'aa', 'aaa', 'aaaa']
```

（3）过滤函数filter()

filter([一个函数], [可迭代对象]) 用于过滤数据，返回迭代器，例子如下

In [21]: lst = ["a1", "a2", "b1", "b2", "c1"]

In [22]: ll = filter(lambda el:el[0] != "a", lst)
# filter把lst（可迭代）的元素拿出来传参给lambda，通过返回的bool值进行筛选

In [23]: ll
Out[23]: <filter at 0x109dce668>

In [25]: list(ll)
Out[25]: ['b1', 'b2', 'c1']

（4）映射函数map()

map([一个函数], [可迭代对象])
- 可以对可迭代对象的每一个元素进行映射，分别去交给传入的函数执行，map返回函数执行结果（返回迭代器），例子如下
```
In [31]: lis = [1, 2, 3]

In [32]: m = map(lambda x: x*x, lis)

In [33]: list(m)
Out[33]: [1, 4, 9]
```

（5）递归（recursion）

递归调用存在递归深度（<1000）

例子：递归遍历某一文件夹下所有文件（如/tmp/testFotRecursion）

In [34]: import os

In [35]: def func(filepath, n):
    ...:     files = os.listdir(filepath)  # 列出当前目录下所有文件或文件夹（不递归）
    ...:     for file in files:
    ...:         file_p = os.path.join(filepath, file)   # 获取当前文件file的绝对路径
    ...:         if os.path.isdir(file_p):
    ...:             print("\t"*n, file, ":")
    ...:             func(file_p, n+1)
    ...:         else:
    ...:             print("\t"*n, file_p)
    ...:             

In [37]: func("/tmp/testFotRecursion", 1)
	 /tmp/testFotRecursion/file2
	 dir2 :
	 dir3 :
		 tttt :
		 /tmp/testFotRecursion/dir3/f2
		 /tmp/testFotRecursion/dir3/f1
	 /tmp/testFotRecursion/file1
	 dir1 :
		 /tmp/testFotRecursion/dir1/file222
		 /tmp/testFotRecursion/dir1/file111

dream_135

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
python-内置函数和特殊函数

文章目录1、内置函数（1）作用域相关（2）迭代器/生成器相关（3）其它（4）和数字相关（5）数据结构相关<1>序列相关函数<2>数据集合相关函数<3>其它相关内置函数2、特殊函数（1）lambda匿名函数（2）排序函数sorted()（3）过滤函数filter()（4）映射函数map()（5）递归（recursion）1、内置函数（1）作用域相关loca...
复制链接

扫一扫