Python入门必会的函数详解（附案例）

一、range函数

range()函数

在其他语言中，如果想要循环一个变量从1到100，要怎么写呢？

for(i = 1,i<=100,i++){
     }

python怎么实现这个功能呢？python设计了range()函数，直接实现了上面的功能。range是内置函数，无须导入。在任何地方都可以直接使用它。

for i in range(5): 
    print(i) 
0
1
2
3
4
从上面的执行结果，也可以看出来range函数的范围是从0-4。遵守左闭右开的原则。range默认是从0开始 的。当然也可以指定遍历的区间。 
for i in range(1,5): 
    print(i) 
1
2
3
4
还可以指定步长，就像切片一样。 
for i in range(1, 12, 2): 
    print(i) 
1
3
5
7
9
11
很多的时候是结合range()和len()函数，遍历一个序列的索引 
a = ['Google', 'Baidu', 'Huawei', 'Taobao', 'QQ'] 
for i in range(len(a)): 
    print(i, a[i])

点击获取Python全套零基础资料视频

二、匿名函数

匿名函数

当我们在创建函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。这省去了我们挖空心思为 函数命名的麻烦，也能少写不少代码，很多编程语言都提供这一特性。

Python语言使用 lambda 关键字来创建匿名函数。

所谓匿名，即不再使用 def 语句这样标准的形式定义一个函数。

• lambda只是一个表达式,而不是一个代码块，函数体比def简单很多。

• 仅仅能在lambda表达式中封装有限的逻辑。

• lambda 函数拥有自己的命名空间。

例如： lambda x: x * x 。它相当于下面的函数：

def f(x): 
    return x*x 
关键字lambda表示匿名函数，冒号前面的x表示函数参数，x*x是执行代码

匿名函数只能有一个表达式，不用也不能写return语句，表达式的结果就是其返回值。 匿名函数没有函数名字， 不必担心函数名冲突，节省字义空间。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量， 再利用变量来调用该函数：

f = lambda x: x * x 
f
<function <lambda> at 0x3216fef44> 
f(6) 
36
也可以把匿名函数作为别的函数的返回值返回 
def count(i,j): 
    return lambda : i*j
f = count(6,7) 
print(f())

匿名函数的应用

对列表中的字典进行排序

lis = [1,-2,4,-3] 
lis.sort(key=abs) 
print(lis) 

infors = [{
     'name':'cangls','age':18},{
     'name':'bols','age':20},{
     'name':'jtls','a 
ge':25}] 

infors.sort(key = lambda x:x['name']) 

print(infors)

匿名函数当做实参

def test(a,b,func): 
    result = func(a,b) 
    return result 

nums = test(11,22,lambda x,y:x+y) 
print(nums)

三、推导式

Python语言有一种独特的推导式语法，相当于语法糖的存在，可以帮你在某些场合写出比较精简酷炫的代码。

列表推导式

列表推导式是一种快速生成列表的方式。其形式是用方括号括起来的一段语句。

lis = [x * x for x in range(1, 10)] 
print(lis) 
------------------------------------ 
结果：[1, 4, 9, 16, 25, 36, 49, 64, 81] 
------------------------------------------- 
如果不用推导式，如何完成这个功能 
lis = [] 
for i in range(10): 
    lis.append(i*i) 
print(lis) 
打印结果： 
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 
------------------------------------------- 
列表推导式，还可以增加一些条件，其核心语法是用中括号[]将生成逻辑封装起来 
lis = [i*i for i in range(10) if i%2 == 0] 
print(lis) 
打印结果： 
[0, 4, 16, 36, 64] 
------------------------------------------- 
多重循环 
lis = [a+b for a in '123' for b in 'abc'] 
print(lis) 
同时循环a和b两个变量，在进行拼接 
打印结果： 
['1a', '1b', '1c', '2a', '2b', '2c', '3a', '3b', '3c'] 
-------------------------------------------
更多用法 
dic = {
     "k1":'v1','k2':'v2'} 
lis = [k+":"+v for k,v in dic.items()] 
print(lis) 
打印结果： 
['k1:v1', 'k2:v2']

字典推导式

有列表推导式，那有没有字典推导式呢？答案是有的，使用{}就可以定义了。

dic = {
     i:i**3 for i in range(5)} 
print(dic) 
i的三次方 
打印结果： 
{
     0: 0, 1: 1, 2: 8, 3: 27, 4: 64}

集合推导式

大括号除了能用作字典推导式，还可以用作集合推导式，两者仅仅在细微处有差别。

s = {
     i for i in 'abasrdfsdfa' if i not in 'abc'} 
print(s) 
把abc排除剩余字符串 
打印结果： 
{
     'r', 'f', 's', 'd'}

有同学会说还有元组推导式，但是在python中元组被用作生成器了。是没有元组推导式的

tup = (x for x in range(9)) 
print(tup) 
print(type(tup)) 
打印结果 
<generator object <genexpr> at 0x000000000255DA98> 
<class 'generator'> 
----------------------------------------------------- 
tup = tuple(x for x in range(9)) 
print(tup) 
print(type(tup)) 

打印结果： 
(0, 1, 2, 3, 4, 5, 6, 7, 8) 
<class 'tuple'>

面试真题

看下面代码回答输出的结果是什么?为什么？

result = [lambda x: x + i for i in range(10)] 
print(result[0](10))

分析：

result = [lambda x: x + i,lambda x: x + i,lambda x: x + i,....] 
print((lambda x: x + i)(10)) 
f = lambda x: x + i 
f(10)

点击获取Python全套零基础资料视频

四、迭代器

在介绍迭代器之前，先说明下迭代的概念：

迭代：通过for循环遍历对象的每一个元素的过程。

Python的for语法功能非常强大，可以遍历任何可迭代的对象。

在Python中， list/tuple/string/dict/set/bytes 都是可以迭代的数据类型。

可以通过collections模块的 Iterable 类型来判断一个对象是否可迭代：

from collections import Iterable 
isinstance('abc', Iterable)            # str是否可迭代 
True 
isinstance([1,2,3], Iterable)         # list是否可迭代 
True 
isinstance(123, Iterable)            # 整数是否可迭代 
False

迭代器

迭代器是一种可以被遍历的对象，并且能作用于next()函数。迭代器对象从集合的第一个元素开始访问，直到所 有的元素被访问完结束。 迭代器只能往后遍历不能回溯，不像列表，你随时可以取后面的数据，也可以返回头取 前面的数据。迭代器通常要实现两个基本的方法： iter() 和 next() 。

字符串，列表或元组对象，甚至自定义对象都可用于创建迭代器：

from collections import Iterable,Iterator 

print(isinstance([],Iterable))       是否可迭代 
print(isinstance([],Iterator))       是否是迭代器 

lis=[1,2,3,4] 
it = iter(lis)         # 使用Python内置的iter()方法创建迭代器对象
next(it) # 使用next()方法获取迭代器的下一个元素 
1
next(it) 
2
next(it) 
3
next(it) 
4
next(it)            # 当后面没有元素可以next的时候，弹出错误 
Traceback (most recent call last): 
  File "", line 1, in <module> 
next(it) 
StopIteration 
------------------------------------------------- 
或者使用for循环遍历迭代器： 
lis = [1,2,3,4] 
it = iter(lis)           # 创建迭代器对象 
for x in it:             # 使用for循环遍历迭代对象 
    print (x, end=" ")

总结：Python的迭代器表示的是一个元素流，可以被next()函数调用并不断返回下一个元素，直到没有元素时抛 出StopIteration错误。可以把这个元素流看做是一个有序序列，但却不能提前知道序列的长度，只能不断通过 next()函数得到下一个元素，所以迭代器可以节省内存和空间。 迭代器(Iterator)和可迭代(Iterable)的区别：

• 凡是可作用于for循环的对象都是可迭代类型；
• 凡是可作用于next()函数的对象都是迭代器类型；
• list、dict、str等是可迭代的但不是迭代器，因为next()函数无法调用它们。可以通过iter()函数将它们转换成 迭代器。
• Python的for循环本质上就是通过不断调用next()函数实现的。

五、生成器

有时候，序列或集合内的元素的个数非常巨大，如果全制造出来并放入内存，对计算机的压力是非常大的。比 如，假设需要获取一个10**20次方如此巨大的数据序列，把每一个数都生成出来，并放在一个内存的列表内，这 是粗暴的方式，有如此大的内存么？如果元素可以按照某种算法推算出来，需要就计算到哪个，就可以在循环的 过程中不断推算出后续的元素，而不必创建完整的元素集合，从而节省大量的空间。在Python中，这种一边循环 一边计算出元素的机制，称为生成器：generator。

生成生成器：

g = (x * x for x in range(1, 4)) 
g
<generator object <genexpr> at 0x1022ef630>

可以通过next()函数获得generator的下一个返回值，这点和迭代器非常相似：

next(g) 
1
next(g) 
4
next(g) 
9
next(g) 
Traceback (most recent call last): 
  File "", line 1, in <module> 
    next(g) 
StopIteration 
------------------------------------------------ 
但更多情况下，我们使用for循环。 
for i in g: 
    print(i)

除了使用生成器推导式，我们还可以使用 yield 关键字。

def createNums(): 
    print("----func start------") 
    a,b = 0,1 
    for i in range(5): 
        # print(b) 
        print("--1--") 
        yield b 
        print("--2--") 
        a,b = b,a+b # a,b = 1, 1 a,b = 1,2 
        print("--3--") 
    print("----func end------") 
g= createNums() 
next(g)          # 如果想得到yield的值,可以打印next(g)

在 Python中，使用yield返回的函数会变成一个生成器（generator）。 在调用生成器的过程中，每次遇到yield 时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次执行next()方法时从当前位置继续运行。

# 斐波那契函数 
def fibonacci(n): 
    a = 0 
    b = 1 
    counter = 0 
    while True: 
        if counter > n: 
            return 
        yield a # yield让该函数变成一个生成器 
        a, b = b, a + b 
        counter += 1 

fib = fibonacci(10) # fib是一个生成器 
print(type(fib)) 
for i in fib: 
    print(i, end=" ")

生成器是可以循环的,相比next来说,for循环更友好。

a = createNums() 
这两种取值方式是一样的！！！ 
a.__next__() 
next(a) 

for i in a: 
    print(i)

send

def test(): 
    i = 0 
    while i<5: 
        temp = yield i 
        print(temp) 
        i+=1 

t = test() 
next(t) 
next(t) 
t.send("juran") 
next(t) 
-------------------------------------------- 
t = test() 
t.send("juran") 
Traceback (most recent call last): 
  File "/Users/binbin/Desktop/Python/demo.py", line 179, in <module> 
    t.send("juran") 
TypeError: can't send non-None value to a just-started generator 

如何解决这个错误? 
> next(t) 
  t.send("juran") 

> send(None)

生成器的应用

实现多任务

def test1(): 
    while True: 
        print("--1--") 
        yield None 

def test2(): 
    while True: 
        print("--2--") 
        yield None 

t1 = test1() 
t2 = test2() 
while True: 
    next(t1) 
    next(t2)

六、装饰器

装饰器（Decorator）：从字面上理解，就是装饰对象的器件。可以在不修改原有代码的情况下，为被装饰的对 象增加新的功能或者附加限制条件或者帮助输出。装饰器有很多种，有函数的装饰器，也有类的装饰器。装饰器 在很多语言中的名字也不尽相同，它体现的是设计模式中的装饰模式，强调的是开放封闭原则。装饰器的语法是 将@装饰器名，放在被装饰对象上面。

@dec 
def func(): 
    pass

在介绍装饰器之前，先要了解几个知识点
重名函数会怎么样？

def test(): 
    print('1') 
def test(): 
    print('2') 
test() 
这个时候会输出什么？ 
会输出2，后面的会覆盖前面的函数 
----------------------------------- 
def foo(): 
    print('test') 
foo = lambda x:x+1 
foo() 
此时foo()的执行结果是什么？ 
foo会执行匿名函数的内容，而不会执行函数foo，打印test

接下来就是一个比较经典的案例了，有一个大公司，下属的基础平台部负责内部应用程序及API的开发。另外还有上百个业务部门负责不同的业务，这些业务部门各自调用基础平台部提供的不同函数，也就是API处理自己的 业务，情况如下：

基础平台部门提供的功能如下：

def f1(): 
    print("业务部门1的数据接口......") 
def f2(): 
    print("业务部门2的数据接口......") 
def f3(): 
    print("业务部门3的数据接口......") 
def f100(): 
    print("业务部门100的数据接口......") 
各部门分别调用基础平台提供的功能 
f1() 
f2() 
f3() 
f100()

目前公司发展壮大，但是以前没有考虑到验证相关的问题，即：基础平台提供的功能可以被任何人使用。现在需 要对基础平台的所有功能进行重构，为平台提供的功能添加验证机制，执行功能前，先进行验证 老大把工作交给 A，他是这么做的： 跟每个业务部门交涉，每个业务部门自己写代码，调用基础平台的功能之前先验证。这样一 来基础平台就不需要做任何修改了。 当前A被老大开除了 老大又把工作交给B，他是这么做的：

def f1(): 
    # 验证1 
    # 验证2 
    # 验证3 
def f2(): 
    # 验证1 
    # 验证2 
    # 验证3 
过了一周B也被开除了。。。。。。。。。。

老大又把工作交给C，他是这么做的：

def check_login() 
    # 验证1 
    # 验证2 
    # 验证3 
def f1(): 
    check_login() 
def f2(): 
    check_login()

老大说写代码要遵循开放封闭的原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来 说，已经实现的功能不允许修改，但可以被扩展 。

封闭：已实现的功能代码块

开放：对扩展开发

老大给出了方案， 
def foo(): 
    def inner(): 
        验证1 
        验证2 
        验证3 
        result = func() 
        return result 
return inner 

@foo 
def f1(): 
    pass 
@foo 
def f2(): 
    pass

看不懂？没关系，接下来写一个简单点的:

def w1(func): 
    def inner(): 
        print('正在验证权限') 
        func() 
    return inner 

def f1(): 
    print('f1') 

innerFunc = w1(f1)      # innerFunc = inner 
innerFunc()             # inner() 

f1 = w1(f1) 
f1()

def outer(func): 
    def inner(): 
        print("认证成功！") 
        result = func() 
        print("日志添加成功")
    return inner 

@outer # f1 = outer(f1) = inner 
def f1(): 
    print("业务部门1数据接口......") 

f1() 

1 程序开始运行，从上往下解释，读到def outer(func):的时候，发现这是个“一等公民”函数，于是把 函数体加载到内存里，然后过。 
2 读到@outer的时候，程序被@这个语法糖吸引住了，知道这是个装饰器，按规矩要立即执行的，于是程序 开始运行@后面那个名字outer所定义的函数。 
3 程序返回到outer函数，开始执行装饰器的语法规则。 规则是：被装饰的函数的名字会被当作参数传递给装饰函数。装饰函数执行它自己内部的代码后，会将它的 返回值赋值给被装饰的函数。原来的f1函数被当做参数传递给了func，而f1这个函数名之后会指向inner 函数

两个装饰器

def makeBold(fn): 
    def wrapped(): 
        return "" + fn() + "" 
    return wrapped 

def makeItalic(fn): 
    def wrapped(): 
        return "" + fn() + "" 
    return wrapped 


@makeBold      # test3 = makeBold(test3) = wrapped 
@makeItalic    # test3 = makeItalic(test3) = wrapped 
def test3(): 
    return "hello world" 

print(test3())

装饰器的执行时间

def w1(func): 
    print("--正在装饰--") 
    def inner(): 
        print("--正在权限验证--") 
        func() 
    return inner
# 只要Python解释器执行到了这个代码，那么就会自动的进行装饰，而不是等到调用的时候才进行装饰 
@w1     # f1 = w1(f1) 
def f1(): 
    print("--f1--") 

# 在调用f1前已经装饰了 
f1()

练习

def w1(func): 
    print("正在装饰1") 
    def inner(): 
        print("正在验证权限1") 
        func() 
    return inner() 

def w2(func): 
    print("正在装饰2") 
    def inner(): 
        print("正在验证权限2") 
        func() 
    return inner() 

@w1 
@w2 
def f1(): 
    print("--f1--") 
f1()

七、内置函数

前面使用过一些函数，有的同学会疑问我没有导入这个函数，为什么可以直接使用？

因为这些函数都是一个叫做 builtins 模块中定义的函数，而 builtins 模块默认在Python环境启动的时 候就自动导入，所以你可以直接使用这些函数。

我们可以在IDLE 进行输出

globals() 
{
     '__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <c lass '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {
     }, '__builtins__': <module 'builtins' (built-in)>} 

dir(__builtins__) 
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'Block ingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessErr or', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'Co nnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'Environment Error', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'Floating PointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'Impor tWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryE rror', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNo tFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'Not ImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'Pe rmissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'Reso urceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIter ation', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning' , 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__ name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval','exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubcl ass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', ' min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit' , 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 's taticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']

builtins模块里有接近80个内置函数，60多个内置异常，还有几个内置常数，特殊名称以及模块相关的属性。 接下来给大家介绍一些工作中常用的一些内置函数：

abs()

绝对值函数。如abs（-1）= 1

abs(-10) 
10
f = abs 
f(-1) 
1
abs=id 
abs(1) 
1869788224 
以abs()函数为例，展示两个特性。一是，内置函数是可以被赋值给其他变量的，同样也可以将其他对象赋 值给内置函数，这时就完全变了。
所以，内置函数不是Python关键字，要注意对它们的保护，不要使用和 内置函数重名的变量名，这会让代码混乱，容易发生难以排查的错误。

all()

接收一个可迭代对象，如果对象里的所有元素的bool运算值都是True，那么返回True，否则False

all([1,1,1]) 
True 
all([1,1,0]) 
False

any()

接收一个可迭代对象，如果迭代对象里有一个元素的bool运算值是True，那么返回True，否则False。与all()是一 对兄弟。

any([0,0,1]) 
True 
any([0,0,0]) 
False

bin()、oct()、hex()

三个函数是将十进制数分别转换为2/8/16进制。

i = 10 
bin(i) 
'0b1010'      # 0b表示2进制 
oct(i) 
'0o12'        # 0o表示8进制 
hex(i) 
'0xa'         # 0x表示16进制

bool()

测试一个对象或表达式的执行结果是True还是False。

bool(1==2) 
False 
bool(abs(-1)) 
True 
bool(None) 
False

bytes()

将对象转换成字节类型。例如： s = ‘张三’;m = bytes(s,encoding=‘utf-8’)

i=2 
bytes(i) 
b'\x00\x00' 
s = 'haha' 
bytes(s) 
Traceback (most recent call last): 
  File "", line 1, in <module> 
    bytes(s) 
TypeError: string argument without an encoding 
bytes(s, encoding="utf-8") 
b'haha' 
bytes(s, encoding="GBK") 
b'haha' 
s = "juran" 
s.encode()                 # 将字符串转换成bytes

str()

将对象转换成字符串类型，同样也可以指定编码方式。例如： str(bytes对象，encoding=‘utf-8’)

i = 2 
str(i) 
'2' 
b = b"haha" 
str(b)      # 注意！ 
"b'haha'" 
str(b,encoding="gb2312") 
'haha' 
str([1,2,3,]) 
'[1, 2, 3]' 

b = b'juran' 
b.decode()               # 将bytes转换成str 
Bytes和string之间的互相转换，更多使用的是encode()和decode()方法。

chr()

返回某个十进制数对应的ASCII字符，例如： chr(99) = ‘c’ 。 它可以配合 random.randint(65，90) 随机方法，生成随机字符，用于生产随机验证码。

import random 
for i in range(10): 
    a = random.randint(65,90)            # 65-90是ASCII表中A-Z 
    c = chr(a) 
    print(c,end='') 
print('')

ord()

与chr()相反，返回某个ASCII字符对应的十进制数，例如， ord(‘A’) = 65

ord("A") 
65
ord("\n") 
10

compile()

将字符串编译成Python能识别或执行的代码。

s = "print('helloworld')" 
r = compile(s,"","exec")
r
<code object <module> at 0x000001B23E6BE660, file "", line 1> 
r() 
Traceback (most recent call last): 
  File "", line 1, in <module> 
    r() 
TypeError: 'code' object is not callable 
exec(r)             # 执行的话需要用exec 
helloworld 
eval(r)             # eval也可以 
helloworld

complex()

通过数字或字符串生成复数类型对象。

complex(1,2) 
(1+2j)

dir()

显示对象所有的属性和方法。

dir([1,2,]) 
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__' , '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__' , '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__ reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr_ _', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clea r', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', ' sort']

divmod()

除法，同时返回商和余数的元组。

divmod(10,3) 
(3, 1) 
divmod(11,4) 
(2, 3)

format()

执行format()，其实就是调用该对象所属类的 format 方法 。

format("324324") 
'324324' 
format([1,2,3]) 
'[1, 2, 3]'

globals()

列出当前环境下所有的全局变量。注意要与global关键字区分！

hash()

为不可变对象，例如字符串生成哈希值的函数！

hash("i am jack") 
5602200374213231465 
hash(1) 
1
hash(100000) 
100000 
hash([1,2,3,]) 
Traceback (most recent call last): 
  File "", line 1, in <module> 
    hash([1,2,3,]) 
TypeError: unhashable type: 'list' 
hash((1,2,3)) 
2528502973977326415

id()

返回对象的内存地址,常用来查看变量引用的变化，对象是否相同等。常用功能之一！

id(0) 
1456845856 
id(True) 
1456365792 
a = "Python" 
id(a) 
37116704

iter()

制造一个迭代器，使其具备next()能力。

lis = [1, 2, 3] 
next(lis) 
Traceback (most recent call last): 
  File "", line 1, in <module> 
    next(lis) 
TypeError: 'list' object is not an iterator 
i = iter(lis) 
i
<list_iterator object at 0x0000000002B4A128> 
next(i) 
1

len()

返回对象的长度。不能再常用的函数之一了。

max min

返回给定集合里的最大或者最小的元素。可以指定排序的方法！

lis = ['abcaaaa','abcd','abcde'] 
max(lis) 
指定按照长度返回 
max(lis,key=len)

next()

通过调用迭代器的 next() 方法，获取下一个元素。

open()

打开文件的方法。在Python2里，还有一个file()方法，Python3中被废弃了 。

pow()

幂函数。

>>> pow(3, 2) 
9

reversed()

反转，逆序对象

>>> reversed            # reversed本身是个类 
<class 'reversed'> 
>>> reversed([1,2,3,4,5])           # 获得一个列表反转器 
<list_reverseiterator object at 0x0000022E322B5128> 
>>> a = reversed([1,2,3,4,5]) 
>>> a 
<list_reverseiterator object at 0x0000022E32359668> 
>>> list(a)              # 使用list方法将它转换为一个列表 
[5, 4, 3, 2, 1]

round()

四舍五入．

round(1.5) 
2
round(1.4) 
1

sum()

求和．

>>> sum(1,2,3)         # 需要传入一个可迭代的对象 
Traceback (most recent call last): 
  File "", line 1, in <module> 
    sum(1,2,3) 
TypeError: sum expected at most 2 arguments, got 3 
>>> sum([1,2,3])        # 传入一个列表 
6
>>> sum({
     1:1,2:2})      # 突发奇想，作死传入一个字典 
3

type()

显示对象所属的数据类型。常用方法！前面已经展示过。

filter()

过滤器，用法和map类似。在函数中设定过滤的条件，逐一循环对象中的元素，将返回值为True时的元素留下 （注意，不是留下返回值！），形成一个filter类型的迭代器。

def f1(x): 
    if x > 3:
        return True 
    else:
        return False 
li = [1,2,3,4,5] 
data = filter(f1,li) 
print(type(data)) 
print(list(data)) 
---------------------------- 
运行结果： 
<class 'filter'> 
[4, 5]

zip()

组合对象。将对象逐一配对。

list_1 = [1,2,3] 
list_2 = ['a','b','c'] 
s = zip(list_1,list_2) 
print(list(s)) 
-------------------------------- 
运行结果： 

[(1, 'a'), (2, 'b'), (3, 'c')]

组合3个对象：

list_1 = [1, 2, 3, 4] 
list_2 = ['a', 'b', 'c', "d"] 
list_3 = ['aa', 'bb', 'cc', "dd"] 
s = zip(list_1, list_2, list_3) 
print(list(s)) 

运行结果： 
[(1, 'a', 'aa'), (2, 'b', 'bb'), (3, 'c', 'cc'), (4, 'd', 'dd')]

那么如果对象的长度不一致呢？多余的会被抛弃！以最短的为基础！

list_1 = [1,2,3] 
list_2 = ['a','b','c',"d"] 
s = zip(list_1,list_2)
print(list(s)) 
-------------------------------- 
运行结果： 
[(1, 'a'), (2, 'b'), (3, 'c')]

sorted()

排序方法。有key和reverse两个重要参数。
基础用法: 直接对序列进行排序

>>> sorted([36, 5, -12, 9, -21]) 
[-21, -12, 5, 9, 36]

指定排序的关键字。关键字必须是一个可调用的对象。例如下面的例子，规则是谁的绝对值大，谁就排在后面。

>>> sorted([36, 5, -12, 9, -21], key=abs) 
[5, 9, -12, -21, 36]

指定按反序排列。下面的例子，首先按忽略大小写的字母顺序排序，然后倒序排列。

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) 
['Zoo', 'Credit', 'bob', 'about']

最后

人生苦短，Python当歌！！！