Python函数模板

def test(*vary):
    print("参数的长度是:",len(vary))
    print("第三个参数是:",vary[2])

test(123,‘ccd‘,[1,2,3,4],‘23546‘)

print()#输出时空了一格
def test2(*vary,exp):
    print("exp这个参数是:",exp)
    print("收集参数的第二个参数是:",vary[1])

test2(23,"hello",[1,2,3,4],"it‘s you",exp="EXP")

print()
def test2(*vary,exp="EXP"):
    print("exp这个参数是:",exp)
    print("收集参数的第二个参数是:",vary[1])

test2(23,"hello",[1,2,3,4],"it‘s you","EXP")

>>> def hello():
    print("hello world")    
>>> temp = hello()
hello world
>>> temp
>>> print(temp)
None
>>> type(temp)
class ‘NoneType‘>
>>> #就算无return语句Python还是会返回东西的函数要么返回return要么返回none
>>> 

返回多个值
>>> def back():
    return 1,‘one‘,3.1414

>>> back()
(1, ‘one‘, 3.1414)
>>> 

count = 5
def MyFun():
    global count
    count=10
    print(‘aaa‘)

print(count)#输出5
print()
MyFun()
print(count)#在调用了函数后 输出10

#内嵌函数
def fun1():
    print("这里是fun1函数")
    def fun2():
        print("这里是fun2函数")
    fun2()#!没这句话fun2不可能输出的

fun1()
#并且出了fun1的地盘就无法再调用fun2函数了
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
#函数 闭包fun2函数就是个闭包 同理不可在fun1外的地盘使用
def fun1(x):
    def fun2(y):
        return x*y
    return fun2 #由于Pyhon万物皆对象所以这里就这么写就好

result = fun1(8)(5)#!!!!方式
print(result)
、、、、、、、、、、、、、、、、、、、

count = 5
def text():
    count=count+1
    print(count)

text()
#报错 因为此时你在修改全局变量count就申请了一个新的临时变量但是直接++并没有初始值
所以:
def fun1():
    x = 5
    def fun2():
        nonlocal x#!!!为了能用 强硬申请不是局部变量
        x*=x
        return x
    return fun2()#!这里要加()的呀

print(fun1())

#在lambda表达式 冒号前面是原函数的参数冒号后面是原函数的返回值
def ds(x):
    return 2*x+1

print(ds(5))
print()
g = lambda x:2*x+2
print(g(5))
##############两个参数
def add(x,y):
    return x+y
print(add(1,2))

g = lambda x,y:x+y
print(g(1,2))

、、、、、、、、、、、、、、、、、、
#filter过滤器就是把任何非true的东西过滤掉
list1 = list(filter(None,[0,1,True,False]))#首参数是None或者funcion(自己想筛啥)
print(list1)
#输出:[1, True]
print()
def odd(x):
    return x%2 #找奇数

temp = range(10)
show=filter(odd,temp) #这里函数只写函数名就好不用加()
#此时show是一个对象 可以用list表达的
print(list(show)) #输出[1, 3, 5, 7, 9]

#用lambda 实现
print(list(filter(lambda x:x%2,range(10))))
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
#map过滤器 参数仍然是函数和可迭代序列
#序列的每一个元素作为函数的参数运算加工，直到可迭代序列元素加工完毕，返回新序列
print(list(map(lambda x:2*x,range(10))))
#输出[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

for i in "ilovekk":
    print(i)
print()
directions = {"菜":‘c‘,              ‘徐‘:‘x‘,              ‘坤‘:‘k‘}
for each in directions:
    print("%s -> %s" %(each,directions[each]))
print()
string = "ilove菜菜"
it = iter(string)#it是一个迭代器了(获得字符串容器的迭代器)
print(next(it))#i
print(next(it))#l
print(next(it))#o
print(next(it))#v
print(next(it))#e
print(next(it))#菜
print(next(it))#菜
print(next(it))#迭代器没有东西可以返回了 弹出stopiteration
print()
string = ‘fishc‘
it = iter(string)
while True:
    try:
        each = next(it)
    except StopIteration:
        break
    print(each)

>>> def mygun():
    print("生成器被执行")
    yield 1
    yield 2
    #yield语句一加，表明函数为生成器，yield相当于return 只是yield会返回后面的参数，并且暂停在这个位置 下次从下一局开始    
>>> myg = mygun()
>>> next(myg)
生成器被执行
1
>>> next(myg)
2
>>> next(myg)
Traceback (most recent call last):
  File "", line 1, in 
    next(myg)
StopIteration
>>> 
>>> for i in mygun():
    print(i)    
生成器被执行
1
2
>>> def libs():
    a = 0
    b = 1
    while True:#看起来是个死循环因为一直是true但是这是个生成器随时可以中断挂起并且你一次执行到底了下一次在执行函数时肯定可以执行啊就从头开始呗
        a,b=b,a+b
        yield a

>>> for each in libs():
    if each > 100:
        break;
    else:
        print(each, end=" ")

        
1 1 2 3 5 8 13 21 34 55 89