码迷,mamicode.com
首页 > 编程语言 > 详细

python内置函数

时间:2018-10-13 13:42:55      阅读:221      评论:0      收藏:0      [点我收藏+]

标签:表示   直接   false   odi   pen   sorted   比较   mysl   write   

我们一起来看看python里的内置函数。什么是内置函数?就是Python给你提供的,拿来直接用的函数,比如print,input等等。截止到python版本3.6.2,现在python一共为我们提供了68个内置函数。它们就是python提供给你直接可以拿来使用的所有函数。这些函数有些我们已经用过了,有些我们还没用到过,还有一些是被封印了。

技术分享图片

技术分享图片

一.其它中的12个

1.执行字符串类型代码的执行

eval:用来执行一个字符串表达式,并返回表达式的值。
技术分享图片
描述
eval() 函数用来执行一个字符串表达式,并返回表达式的值。

语法
以下是 eval() 方法的语法:

eval(expression[, globals[, locals]])
参数
expression -- 表达式。
globals -- 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
返回值
返回表达式计算结果。

实例
以下展示了使用 eval() 方法的实例:

>>>x = 7
>>> eval( 3 * x )
21
>>> eval(pow(2,2))
4
>>> eval(2 + 2)
4
>>> n=81
>>> eval("n + 4")
85
View Code
exce:执行存储在字符串或文件中的Python语句,相比于eval,exec可以执行更Python代码
技术分享图片
描述
exec 执行储存在字符串或文件中的Python语句,相比于 eval,exec可以执行更复杂的 Python 代码。

需要说明的是在 Python2 中exec不是函数,而是一个内置语句(statement),但是Python 2中有一个 execfile() 函数。可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了。

语法
以下是 exec 的语法:

exec obj
参数
obj -- 要执行的表达式。
返回值
exec 返回值永远为 None。

实例
以下展示了使用 exec 的实例:

# 实例 1
>>>exec print "Hello World"
Hello World
# 单行语句字符串
>>> exec "print ‘runoob.com‘"
runoob.com
 
#  多行语句字符串
>>> exec """for i in range(5):
...   print "iter time: %d" % i
... """
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4

# 实例 2
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
    y = 20
    exec(expr)
    exec(expr, {x: 1, y: 2})
    exec(expr, {x: 1, y: 2}, {y: 3, z: 4})
    
func()

输出结果:
60
33
34
View Code
- exec和eval都可以执行 字符串类型的代码

- eval有返回值 —— 有结果的简单计算

- exec没有返回值 —— 简单流程控制

- eval只能用在你明确知道你要执行的代码是什么
compile:将一个字符串编译为字节代码。
技术分享图片
ret=for i in range(5):print(i)
c=compile(ret,‘‘,exec)        #用exec执行,有返回值
exec(c)
ret=1+2+3+4
c=compile(ret,‘‘,eval)        #‘‘引号原本的功能是放
print(eval(c))                  # 用eval执行,没有返回值,所以需要打印
View Code

2.输入输出

input:接受一个标准输入数据,返回为 string 类型。
技术分享图片
>>>a = input("input:")
input:123                  # 输入整数
>>> type(a)
<type int>               # 整型
>>> a = input("input:")    
input:"runoob"           # 正确,字符串表达式
>>> type(a)
<type str>             # 字符串
>>> a = input("input:")
input:runoob               # 报错,不是表达式
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name runoob is not defined
<type str>
input3.x
技术分享图片
>>>a = raw_input("input:")
input:123
>>> type(a)
<type str>              # 字符串
>>> a = raw_input("input:")
input:runoob
>>> type(a)
<type str>              # 字符串
>>>
input2.x
print:方法用于打印输出,最常见的一个函数。

print 在 Python3.x 是一个函数,但在 Python2.x 版本不是一个函数,只是一个关键字。

技术分享图片
>>>print(1)  
1  
>>> print("Hello World")  
Hello World  
 
>>> a = 1
>>> b = runoob
>>> print(a,b)
1 runoob
 
>>> print("aaa""bbb")
aaabbb
>>> print("aaa","bbb")
aaa bbb
>>> 
 
>>> print("www","runoob","com",sep=".")  # 设置间隔符
www.runoob.com
View Code

3.内存相关

hash:用于获取取一个对象(字符串或者数值等)的哈希值。
技术分享图片
>>>hash(test)            # 字符串
2314058222102390712
>>> hash(1)                 # 数字
1
>>> hash(str([1,2,3]))      # 集合
1335416675971793195
>>> hash(str(sorted({1:1}))) # 字典
7666464346782421378
View Code
id:用于获取对象的内存地址。
技术分享图片
>>>a = runoob
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608
View Code

4.文件操作

open:函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。
技术分享图片
r:
    以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。

rb:
    以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。

r+:
    打开一个文件用于读写。文件指针将会放在文件的开头。

rb+:
    以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。

w:
    打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。

wb:
    以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。

w+:
    打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。

wb+:
    以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。

a:
    打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。

ab:   
    以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。

a+:
    打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。

ab+:
    以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。
模式

file 对象方法

技术分享图片
file.read([size]):size 未指定则返回整个文件,如果文件大小 >2 倍内存则有问题,f.read()读到文件尾时返回""(空字串)。

file.readline():返回一行。

file.readlines([size]) :返回包含size行的列表, size 未指定则返回全部行。

for line in f: print line :通过迭代器访问。

f.write("hello\n"):如果要写入字符串以外的数据,先将他转换为字符串。

f.tell():返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。

f.seek(偏移量,[起始位置]):用来移动文件指针。

偏移量: 单位为比特,可正可负
起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
f.close() 关闭文件
View Code
技术分享图片
RUNOOB1
RUNOOB2
>>>f = open(test.txt)
>>> f.read()
RUNOOB1\nRUNOOB2\n
示例

5.调用相关

callable :用于检查一个对象是否是可调用的。如果返回True,object仍然可能调用失败;但如果返回False,调用对象ojbect绝对不会成功。

对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。

技术分享图片
>>>callable(0)
False
>>> callable("runoob")
False
 
>>> def add(a, b):
...     return a + b
... 
>>> callable(add)             # 函数返回 True
True
>>> class A:                  #
...     def method(self):
...             return 0
... 
>>> callable(A)               # 类返回 True
True
>>> a = A()
>>> callable(a)               # 没有实现 __call__, 返回 False
False
>>> class B:
...     def __call__(self):
...             return 0
... 
>>> callable(B)
True
>>> b = B()
>>> callable(b)               # 实现 __call__, 返回 True
True
View Code

6.模块相关

__import__:用于动态加载类和函数,如果一个模块经常变化就可以使用 __import__() 来动态载入。
技术分享图片
#!/usr/bin/env python    
#encoding: utf-8  
 
import os  
 
print (在 a.py 文件中 %s % id(os))
a.py
技术分享图片
#!/usr/bin/env python    
#encoding: utf-8  
 
import sys  
__import__(a)        # 导入 a.py 模块
test.py

7.帮助

help:用于查看函数或模块用途的详细说明。
技术分享图片
>>>help(sys)             # 查看 sys 模块的帮助
……显示帮助信息……
 
>>>help(str)             # 查看 str 数据类型的帮助
……显示帮助信息……
 
>>>a = [1,2,3]
>>>help(a)                 # 查看列表 list 帮助信息
……显示帮助信息……
 
>>>help(a.append)          # 显示list的append方法的帮助
……显示帮助信息……
View Code

8.查看内置属性

dir:不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。
技术分享图片
>>>dir()   #  获得当前模块的属性列表
[__builtins__, __doc__, __name__, __package__, arr, myslice]
>>> dir([ ])    # 查看列表的方法
[__add__, __class__, __contains__, __delattr__, __delitem__, __delslice__, __doc__, __eq__, __format__, __ge__, __getattribute__, __getitem__, __getslice__, __gt__, __hash__, __iadd__, __imul__, __init__, __iter__, __le__, __len__, __lt__, __mul__, __ne__, __new__, __reduce__, __reduce_ex__, __repr__, __reversed__, __rmul__, __setattr__, __setitem__, __setslice__, __sizeof__, __str__, __subclasshook__, append, count, extend, index, insert, pop, remove, reverse, sort]
View Code

二.基础数据类型相关 38个

1.1数字类型

数据类型

bool:用于将给定参数转换为布尔类型,如果没有参数,返回 False。
技术分享图片
>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
>>> issubclass(bool, int)  # bool 是 int 子类
True
View Code
 int:用于将一个字符串或数字转换为整型。
技术分享图片
>>>int()               # 不传入参数时,得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int(12,16)        # 如果是带参数base的话,12要以字符串的形式进行输入,12 为 16进制
18
>>> int(0xa,16)  
10  
>>> int(10,8)  
8
View Code
float:用于将整数和字符串转换成浮点数。
技术分享图片
>>>float(1)
1.0
>>> float(112)
112.0
>>> float(-123.6)
-123.6
>>> float(123)     # 字符串
123.0
View Code
complex:用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数。
技术分享图片
>>>complex(1, 2)
(1 + 2j)
 
>>> complex(1)    # 数字
(1 + 0j)
 
>>> complex("1")  # 当做字符串处理
(1 + 0j)
 
# 注意:这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错
>>> complex("1+2j")
(1 + 2j)
View Code

进制转换

bin:返回一个整数 int 或者长整数 long int 的二进制表示。
技术分享图片
>>>bin(10)
0b1010
>>> bin(20)
0b10100
View Code
oct:将一个整数转换成8进制字符串
技术分享图片
>>>oct(10)
012
>>> oct(20)
024
>>> oct(15)
017
>>>
View Code
hex:用于将10进制整数转换成16进制,以字符串形式表示。
技术分享图片
>>>hex(255)
0xff
>>> hex(-42)
-0x2a
>>> hex(1L)
0x1L
>>> hex(12)
0xc
>>> type(hex(12))
<class str>      # 字符串
View Code

数学运算

abs:返回数字的绝对值。
技术分享图片
#!/usr/bin/python
 
print "abs(-45) : ", abs(-45)
print "abs(100.12) : ", abs(100.12)
print "abs(119L) : ", abs(119L)


# 运行结果
abs(-45) :  45
abs(100.12) :  100.12
abs(119L) :  119
View Code
divmod:把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。在 python 2.3 版本之前不允许处理复数。
技术分享图片
>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)
View Code
round:方法返回浮点数x的四舍五入值。
技术分享图片
print "round(80.23456, 2) : ", round(80.23456, 2)
print "round(100.000056, 3) : ", round(100.000056, 3)
print "round(-100.000056, 3) : ", round(-100.000056, 3)


# 运行结果
round(80.23456, 2) :  80.23
round(100.000056, 3) :  100.0
round(-100.000056, 3) :  -100.0
View Code
sum:方法对系列进行求和计算。
技术分享图片
>>>sum([0,1,2])  
3  
>>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
10
>>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
12
View Code
min:方法返回给定参数的最小值,参数可以为序列。
技术分享图片
print "min(80, 100, 1000) : ", min(80, 100, 1000)
print "min(-20, 100, 400) : ", min(-20, 100, 400)
print "min(-80, -20, -10) : ", min(-80, -20, -10)
print "min(0, 100, -400) : ", min(0, 100, -400)


# 运行结果
min(80, 100, 1000) :  80
min(-20, 100, 400) :  -20
min(-80, -20, -10) :  -80
min(0, 100, -400) :  -400
View Code
max:方法返回给定参数的最大值,参数可以为序列。
技术分享图片
#!/usr/bin/python
 
print "max(80, 100, 1000) : ", max(80, 100, 1000)
print "max(-20, 100, 400) : ", max(-20, 100, 400)
print "max(-80, -20, -10) : ", max(-80, -20, -10)
print "max(0, 100, -400) : ", max(0, 100, -400)


# 运行结果
max(80, 100, 1000) :  1000
max(-20, 100, 400) :  400
max(-80, -20, -10) :  -10
max(0, 100, -400) :  100
View Code
pow:方法返回 xy(x的y次方) 的值。
技术分享图片
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
import math   # 导入 math 模块
 
print "math.pow(100, 2) : ", math.pow(100, 2)
# 使用内置,查看输出结果区别
print "pow(100, 2) : ", pow(100, 2)
 
print "math.pow(100, -2) : ", math.pow(100, -2)
print "math.pow(2, 4) : ", math.pow(2, 4)
print "math.pow(3, 0) : ", math.pow(3, 0)


# 运行结果
math.pow(100, 2) :  10000.0
pow(100, 2) :  10000
math.pow(100, -2) :  0.0001
math.pow(2, 4) :  16.0
math.pow(3, 0) :  1.0
View Code

列表和元组 可以强转

tuple:将列表转换为元组。
技术分享图片
>>>tuple([1,2,3,4])
 
(1, 2, 3, 4)
 
>>> tuple({1:2,3:4})    #针对字典 会返回字典的key组成的tuple
 
(1, 3)
 
>>> tuple((1,2,3,4))    #元组会返回元组自身
 
(1, 2, 3, 4)
View Code
list:方法用于将元组转换为列表。

注:元组与列表是非常类似的,区别在于元组的元素值不能修改,元组是放在括号中,列表是放于方括号中。

技术分享图片
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
aTuple = (123, xyz, zara, abc);
aList = list(aTuple)
 
print "列表元素 : ", aList
View Code

1.2相关内置函数

reverse:用于反向列表中元素。
技术分享图片
aList = [123, xyz, zara, abc, xyz]

aList.reverse()
print "List : ", aList


# 运行结果
List :  [xyz, abc, zara, xyz, 123]
View Code
reversed:保留原列表,得到一个反向迭代器
技术分享图片
l2=reversed(l)  #生成器
print(l2)    #<list_reverseiterator object at 0x018539D0>
for i in l2:
    print(i)    #4,6,3,1
View Code
slice:实现切片对象,主要用在切片操作函数里的参数传递。
技术分享图片
>>>myslice = slice(5)    # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice]         # 截取 5 个元素
[0, 1, 2, 3, 4]
>>>
View Code

1.3字符串

format:可以接受不限个参数,位置可以不按顺序。

Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

技术分享图片
>>>"{} {}".format("hello", "world")    # 不设置指定位置,按默认顺序
hello world
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
hello world
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
world hello world
View Code

也可以设置参数

技术分享图片
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
print("网站名:{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名:{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = [菜鸟教程, www.runoob.com]
print("网站名:{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的


# 运行结果
网站名:菜鸟教程, 地址 www.runoob.com
网站名:菜鸟教程, 地址 www.runoob.com
网站名:菜鸟教程, 地址 www.runoob.com
View Code

也可以像str.format()传入对象:

技术分享图片
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print(value 为: {0.value}.format(my_value))  # "0" 是可选的


# 运行结果
value 为: 6
View Code

数字格式化:

技术分享图片
>>> print("{:.2f}".format(3.1415926));
3.14
View Code
bytes:编码转换
技术分享图片
需求把gbk编码的转换为utf-8,python是unicode编码,需要先把你好转为gbk 形式
print(bytes(美丽,encoding=GBK))                                    #等价于==print(‘美丽‘.encode(‘gbk‘)) #  #b‘\xc4\xe3\xba\xc3‘把unicode转换为gbk的bytes类型
print((bytes(美丽,encoding=gbk)).decode(gbk).encode(utf-8))    #转换成功
注释:
网页编程是二进制存储
照片视频也是二进制
html网页爬取也是二进制
View Code
bytearray:返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256。
技术分享图片
b_bytes=bytearray(你好,encoding=utf-8)
print(b_bytes)    #‘\xe4\xbd\xa0\xe5\xa5\xbd‘)
print(b_bytes[0])   #228
print(b_bytes[1])   #189
View Code
memoryview:视觉展示,只是给我们看,不占用内存,但是要调用是时候还是会占用内存,用处比较少
技术分享图片
memoryview(bytes(hello,eva,encoding=utf-8)
View Code
ord :字符按照unicode转数字
技术分享图片
print(ord())    #20320
print(ord(1))    #49
print(ord(A))    #65
print(ord(?))    #10084
View Code
chr:数字按照unicode转字符, 但是从65(A的数字对应65)开始才能转换
技术分享图片
print(chr(97))    #a
print(chr(98))    #
print(chr(65))    #A
View Code
ascii:字符在ascii码中的内容就打印出来,不是就转换成\u
技术分享图片
print(ascii()     #‘\u4f60‘
print(ascii(A) )    #‘A‘
View Code
repr 用于%r格式化输出 ,不同于print的是:会将打印内容的数据类型也一起打印出来
技术分享图片
name=egg
print(你好%s%name)   #你好egg
print(你好%r%name)   #你好‘egg‘
print(repr(1))     #‘1‘
print(1)       #1
print(repr(1))   #1
View Code

1.4字符串

dict:用于创建一个字典。
技术分享图片
>>>dict()                        # 创建空字典
{}
>>> dict(a=a, b=b, t=t)     # 传入关键字
{a: a, b: b, t: t}
>>> dict(zip([one, two, three], [1, 2, 3]))   # 映射函数方式来构造字典
{three: 3, two: 2, one: 1} 
>>> dict([(one, 1), (two, 2), (three, 3)])    # 可迭代对象方式来构造字典
{three: 3, two: 2, one: 1}
View Code
set:创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。
技术分享图片
>>>x = set(runoob)
>>> y = set(google)
>>> x, y
(set([b, r, u, o, n]), set([e, o, g, l]))   # 重复的被删除
>>> x & y         # 交集
set([o])
>>> x | y         # 并集
set([b, e, g, l, o, n, r, u])
>>> x - y         # 差集
set([r, b, u, n])
View Code
frozenset:返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。
技术分享图片
>>>a = frozenset(range(10))     # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset(runoob) 
>>> b
frozenset([b, r, u, o, n])   # 创建不可变集合
View Code
len:方法返回对象(字符、列表、元组等)长度或项目个数。
技术分享图片
>>>str = "runoob"
>>> len(str)             # 字符串长度
6
>>> l = [1,2,3,4,5]
>>> len(l)               # 列表元素个数
5
View Code
enumerate:函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
技术分享图片
dic={a:b,c:d}
for k,i in enumerate(dic,1):
    print(k,i)
View Code

1.5相关内置函数

 all:判断是否有bool值是Flase的值,---一假均假---用中括号写进要判断的值,
技术分享图片
print(all([ ,ni,]))    #True
print(all([‘‘,ni,]))    #Flase
    特殊情况 : print(all([]))    #Ture
print(all([‘‘]))  #Flase
View Code
any:判断bool值是否有True的值-----一真均真
技术分享图片
>>>any([a, b, c, d])  # 列表list,元素都不为空或0
True
 
>>> any([a, b, ‘‘, d])   # 列表list,存在一个为空的元素
True
 
>>> any([0, ‘‘, False])        # 列表list,元素全为0,‘‘,false
False
 
>>> any((a, b, c, d))  # 元组tuple,元素都不为空或0
True
 
>>> any((a, b, ‘‘, d))   # 元组tuple,存在一个为空的元素
True
 
>>> any((0, ‘‘, False))        # 元组tuple,元素全为0,‘‘,false
False
  
>>> any([]) # 空列表
False
 
>>> any(()) # 空元组
False
View Code
zip:返回一个迭代器,拉链功能
技术分享图片
a=[a,b]  #列表
b=[c,d]
ret=zip(a,b)
for i in ret:    #(‘a‘, ‘c‘)(‘b‘, ‘d‘)
    print(i)

a={a,b}   #字典
b={c,d}
ret=zip(a,b)
for i in ret:
    print(i)     ##(‘a‘, ‘c‘)(‘b‘, ‘d‘)和上面效果一样
#简化:
a=[a,b]
b=[c,d]
c=[e,f]
for i in zip(a,b,c):      #(‘a‘, ‘c‘, ‘e‘)(‘b‘, ‘d‘, ‘f‘)
    print(i)
#字典、列表、元祖混用拉链
a=[a,b,g]    #不是一一对应的话,自动去除多余的
b={c,d]}  #dict   list   tuple 都可以用zip 来拉链
c=(e,f])
for i in zip(a,b,c):      #(‘a‘, ‘c‘, ‘e‘)(‘b‘, ‘d‘, ‘f‘)
    print(i)
View Code
filter:用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。

该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。

技术分享图片
def f(x):
    return x%2==0
g=filter(f,[1,3,5,6,7,8])    #filter 得到是一个迭代器
for i in g:
    print(i)               #6 8
filter过滤的功能

def a(z):
    return z%2==1     #函数返回值为Ture,则放到新的迭代器中
ret=filter(a,[1,2,3,4,5,6])   #函数名不加括号,因为前面filter要来调用函数名,得到的ret是一个迭代器
for i in ret:      #不调用不打印
    print(i)
功能解析:把可迭代的值传给某个函数,函数来执行

def a(z):
    return z%2==0
ret=filter(a,[1,2,3,4,5,6])
for i in ret:
    print(i)
上面那个filter方法等于这个列表推导式的功能
c=[i for i in [1,2,3,4,5,6] if i%2==1]
for i in c:
    print(i)

取出0到100中能够开方的整数
from math import sqrt
def num(s):
    if sqrt(s)%1==0:
        return True
ret=filter(num,range(0,101))
for i in ret:
    print(i)
View Code
map:Python中的map函数应用于每一个可迭代的项,返回的是一个结果list。如果有其他的可迭代参数传进来,map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数,一个是函数,一个是序列,map将传入的函数依次作用到序列的每个元素,并把结果作为新的list返回。
技术分享图片
>>>def square(x) :            # 计算平方数
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
 
# 提供了两个列表,对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
View Code

结论:filter()之后元素个数会发生改变,map()之后元素个数不会改变。filter只管筛选,不会改变原来的值 map值会改变

sorted:对所有可迭代的对象进行排序操作。

sort与sorted区别:

sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作,无返回值,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。

技术分享图片
>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
 
>>> L=[(b,2),(a,1),(c,3),(d,4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[(a, 1), (b, 2), (c, 3), (d, 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[(a, 1), (b, 2), (c, 3), (d, 4)]
 
 
>>> students = [(john, A, 15), (jane, B, 12), (dave, B, 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[(dave, B, 10), (jane, B, 12), (john, A, 15)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[(john, A, 15), (jane, B, 12), (dave, B, 10)]
View Code

三.匿名函数

为了解决那些功能很简单的需求而设计的一句话函数

技术分享图片
#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))
View Code

 

python内置函数

标签:表示   直接   false   odi   pen   sorted   比较   mysl   write   

原文地址:https://www.cnblogs.com/xiaohei001/p/9782149.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!