python常用知识点笔记-函数

导入函数：

def IsInstence(x):#数据类型检查，如果不是给定类型中的一种则抛出异常。

    if not isinstance(x,(int,float)):

        print("true\n")

    else:

        raise TypeError('bad operand type')    

IsInstence(3)

import math

def test():

    return math.pi,math.e,math.inf

print(type(test()),test())#<class 'tuple'> (3.141592653589793, 2.718281828459045, inf)

注意返回类型是一个tuple，这和input的返回是一致的。

def test():

    pass

print(type(test()),test())#<class 'NoneType'> None

无返回类型则自动返回None，注意None是一个单独的类型。

def test(x,y=1):

    return  x,y

print(test(1,0))

print(test(1))

print(test(1,y=3))

注意基础参数传递

def test(L=[]):

    L.append(1)

    return L

test([1])

print(test([1]))#1,1

这里的值并非是想要的结果，遇到此类问题时只需要遵照默认参数必须指向不可变对象。因为默认参数也是一个变量，他指向了一个对象,如这里指向的对象就是[ ]，如：

def test(L=""):

L=("L")

可变参数：

def test(L):

    sum = 0

    for i in L:

        sum+=i

    return sum

print(test([1,2,3]))

print(test((1,2,3)))

def test(*L):

    print(type(L))#注意L的类型是tuple

    sum = 0

    for i in L:

        sum+=i

    return sum

print(test(1,2,3))

print(test(1,2,3))

L1=[1,3]

print(test(*L1))

关键字参数：

def person(name, age, **kw):

    print('name:', name, 'age:', age, 'other:', kw)

person('Bob', 35, city='Beijing')

person('Bob', 35)

extra = {'city': 'Beijing', 'job': 'Engineer'}

person('Bob', 35, **extra)

命名关键字参数：指定扩展参数名字唯一，不能传入其他名字参数：

def person(name, age, *,x):

    print('name:', name, 'age:', age, 'x:', x)

person('Bob', 35, x='Beijing')#如果是x以外关键字则报错。不传递x也会报错，如果x具有默认参数则不报错。此外这里的*并不是参数，只是修饰符。

*args 是可变参数，args 接收的是一个 tuple； **kw 是关键字参数，kw 接收的是一个 dict。

对于任意函数，都可以通过类似 func(*args, **kw)的形式调用它。无论它的参数是如何定义的。比如：

x=[1,2]

y={"name":'xxx','age':18}

print(x,y)

切片：

str="abcdefgh"

print(str[0:len(str):2])#aceg

如果给定一个 list 或 tuple，我们可以通过 for 循环来遍历这个 list 或 tuple，这种遍历我们称为迭代（Iteration）。在 Python 中，迭代是通过 for ... in 来完成的。

for ch in 'ABC':

       print(ch)

判断类型是否可迭代：

str="abcdefgh"

a= 1

from collections.abc import Iterable

print(isinstance(str, Iterable))

print(isinstance(a, Iterable))

下标：如果迭代时想知道下标值

str="abcdefgh"

for i,value in enumerate(str):# 内置的 enumerate 函数可以把一个 list 变成索引-元素对

    print(i,value)

列表生成：就是使用简单办法生成列表，如：

L=[]

for i in range(1,10):

    L.append(i)

print(L)#[1, 2, 3, 4, 5, 6, 7, 8, 9]

或者：

L1=[i for i in range(1,10)]

L1=[i*i for i in range(1,10)]#生成平方

L1=[i*i for i in range(1,10) if i%2!=0]#i不能是偶数

注意生成器是一次性创建，比如：

L1=[i for i in range(1,10000000)]

这里的创建1到1千万个元素，占用空间非常巨大；所以如果有一个方法能以按照某种算法推算出来，那我们就可以在循 环的过程中不断推算出后续的元素，这就是生成器。

L = [x * x for x in range(10)]#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

g = (x * x for x in range(10))#<generator object <genexpr> at 0x000002446E1C8F20>

print(L)

print(g)

#print(next(g),next(g),next(g))#0 1 4

也可以使用：这样可以把g全部打印出来

for iter in g:

print(iter)

函数式生成器：

def f(x):

    x=x+2

    return x

print(f(2))#4

print(f(4))#6

print(f(6))#8

print(f(8))#10

print(f(10))#12

这里的目的是生成4到12之间的偶数。但多次调用特别麻烦也不方便遍历。注意函数是遇到return则返回，这里yield生成器遇到yield就返回。

def f(x):

    for i in range(5):

        x=x+2

        yield x

    return x

o=f(2)

for i in o:

print (i)

可以直接作用于 for 循环的数据类型有以下几种： 一类是集合数据类型，如 list、tuple、dict、set、str 等； 一类是 generator，包括生成器和带 yield 的 generator function。 这些可以直接作用于 for 循环的对象统称为可迭代对象：Iterable。

而生成器不但可以作用于 for 循环，还可以被 next()函数不断调用并返 回下一个值，直到最后抛出 StopIteration 错误表示无法继续返回下一个 值了。 可以被 next()函数调用并不断返回下一个值的对象称为迭代器： Iterator。

生成器都是 Iterator 对象，但 list、dict、str 虽然是 Iterable，却不是 Iterator（可迭代对象）。

Python 的 Iterator 对象表示的是一个数据流，Iterator 对象可 以被 next()函数调用并不断返回下一个数据，直到没有数据时抛出 StopIteration 错误。可以把这个数据流看做是一个有序序列，但我们却 不能提前知道序列的长度，只能不断通过 next()函数实现按需计算下一 个数据，所以 Iterator 的计算是惰性的，只有在需要返回下一个数据时 它才会计算。 Iterator 甚至可以表示一个无限大的数据流，例如全体自然数。而使用 list 是永远不可能存储全体自然数的。

For循环的本质其实是不断通过next实现的。

print(abs)# <built-in function abs>

f = abs#函数名复制，函数名也是变量。函数名其实也是指向函数的变量。

print(f(-1))