python莫比乌斯环_python基础|函数

1 函数

在python中的函数，内置函数有很多，如：int(), str(), list(), dict(), set() 等内置整形函数，bool()内置布尔值函数，len()内置长度计算函数 ，等等。在使用这些内置函数时，直接调用即可，且这些函数功能明确，十分方便简单。但是这些内置函数在我们写项目时仍然不够我们使用，有些地功能相同，重复写相同功能的代码，代码冗余，还十分费力，这就需要我们自己写函数了。

定义函数的基本形式

#定义函数的基本形式

def xxx(a): #def固定语法 xxx函数名 a函数参数

代码1 #函数内执行代码

代码2

代码3

...

retuen y#y返回值

在python中定义一个函数，固定语法 def ，执行时表示这是一个定义的函数。空格一下与函数名区分开，(xxx)再取函数名，函数名的起名规则与变量相同。后加() 和 ：a 括号内可加不加参数。

另起一行，缩进四个空格，表示下面的代码是此函数的子代码快。写代码。函数结束需要 return 关键字，表示函数执行完毕。y retuen后空格写返回值，这个返回值是执行此函数之后，得到的值。

在调用函数时有三种方式

xxx() #直接调用

a= xxx() #赋值形式调用

a

b= xxx #赋值函数名,再调用

b()

1.1 函数返回值

函数的返回值有四种形式

#函数不写retuen

deffun():

a= 1+2rec=fun()print(rec)>>>None#函数返回值为空

deffun1():

a= 1+2

returnrec1=fun1()print(rec1)>>>None#函数返回值有一个值

deffun2():

a= 1+2

returna

rec2=fun2()print(rec2)>>> 3

#函数返回值有多个值

deffun3():

a= 1+2b= 1-2

returna, b

rec3=fun3()print(rec3)>>>(3, -1)

1.2 函数的参数

函数的参数分为形参和实参。实参是调用函数时函数内的参数，形参在定义函数内的参数。函数的实参和形参在函数结束之后随之结束。

函数的参数类型

位置参数

#位置参数

def fun(x, y): 函数形参第一参数是x, 其次是y。则按照位置对应赋值x = 20, y = 100x+= 1y+= 1

returnx, y

fun(20, 100) #调用函数，函数内第一个参数值是20，其次是100

位置参数形式，传入实参的个数必须与形参个数保持一致。

默认参数

#形参默认参数形式

def fun(x, y = 100): #x = 10 ,y默认为100

pass

returnx, y

fun(20) #函数第一个位置传入20

fun(1, 30) #x = 1, y 不在使用默认值100，y = 30

deffunc(x, y):pass

returnx, y

fun(y=10, x=20) #不在受位置的约束，直接指定赋值，这种传参方式，如果有位置参数，赋值参数必须在位置参数后面

#形参默认参数补充

m= 3

def func(x, y = m): #默认参数以变量名传参，变量在定义函数前被定义

pass

returnx, y

rec= func(10, 30)

可变参数

当位置参数实参有多个值需要传入形参中，可以使用可变参数

def func(x, *y):pass

returnx, y

rec= func(0, 1, 2, 3, 4, 5)print(rec)>>>0, (1, 2, 3, 4, 5) #溢出的参数将会以元组的形式保存，元组名是y

当实参是一个一个容器类型，要把里面的值传入形参

deffunc(x, y, z):pass

returnx, y, z

rec= func(*[1, 2, 3]) #将容器打散，以位置参数形式送入。容器可以是字符串类型，列表类型， 元组类型以及集合

print(rec)>>> 1, 2, 3

实参赋值，有多个需要传入

def func(**z)： #将赋值变量转成字典/ z={'a': 0, 'b': 1, 'c': 2}

pass

returnx, y

rec= func(a = 0, b = 1, c =2)

# 反之

def func(a, b, c): # 将赋值变量转成字典

pass

return a, b, c

z = {'a': 0, 'b': 1, 'c': 2}

rec = func(**z) # 将字典打撒赋值，给形参

print(rec)

可变参数使用十分频繁。通常我使用的形式是

def func(*args, **kwargs): #python中推荐这样使用，是实参不管传入多少值都可以被形参接收

print(args, kwargs)

2 函数对象

函数有函数名，函数名指向的值，称之为函数对象。

deffunc():print('这是func函数')return

print(func)

>>> # 函数名指向的值

函数对象可以被引用，可以被当作参数传给另一个变量。也可以当作函数返回值，还可以当作容器类型的元素。

#可以被引用

deffunc():print('这是func函数')return

print(func)#可以被赋值

f =func

f()#可以当作函数返回值

deffunc():print('这是func函数')return func #返回值 func

#可以当作容器类型的参数

lis = [1, 2, 3, func]

3 函数嵌套

函数的嵌套有两种形式。一种是在调用函数的内部在调用另一个函数。另一种是，在函数内部定义一个函数，并调用。

#函数调用的第一种形式

deff1():print('这是f1函数')deff2():

f1()print('这是f2函数')

f2()>>>这是f1函数

这是f2函数#第二种形式

deff1():deff2():print('这是f2函数')print('这是f1函数')returnf2

rec=f1()

rec()>>>这是f1函数

这是f2函数

4 名称空间

名称空间就是名字存在的空间。python中有三种名称空间。分别是内置名称空间，全局名称空间和局部名称空间。内置空间是python解释器运行时的空间，在启动python整个过程始终在其中运作，len , str, int bool, break等这这内置函数名都在内置空间。全局名称空间是py文件运行时的变量名称 ，局部空间是自定义函数内的变量名称。

在调用一个值是，需要一个变量名来绑定，通过变量名可以调用该值。对于变量名的查找，python有自己的规定。程序执行顺序是，内置---->全局--->局部。查找名称的顺序则是反着来的且与查找位置有关。如果在局部需要调用该值，查找该值的名称的顺序是先从局部--->全局--->内置。如果在全局调用该值，那么查找改制变量名的顺序是先从全局--->内置。

名称空间中的变量名有作用域。主要有全局作用域，和局部作用域，全局作用域包含内置空间变量名和全局空间变量名，在全局作用都有效。局部作用域就是在局部空间的变量名，在局部空间有效。

在局部要修改全局作用域变量内的值。需要使用global, nonlocal

#在局部修改全局作用域的值#修改一个可变类型

lis =[]deffunc():

lis.append('meKing')print(lis)>>>['meking']#修改一个不可变类型

a = 10

deffunc():global a #在局部声明，变量来自全局空间。(变量必须为不可变类型)

a = 20func()print(a)>>>20

# 在局部的局部内内修改局部变量(变量为不可变类型)

def func():

a = 20

def f1():

nonlocal a

a = 30

f1()

print(a)

func()

4 闭包函数

闭包函数定义在函数内部，引用外部函数的全局作用域变量名。

#闭包函数

defoutter():def inner(): #定义在函数内部的函数

print('这是inner函数‘)

returninner

rec= outter() #内部函数inner引用全局作用域的变量名rec

函数传参两种方式

#函数传参的第一种方式

deffunc():

x= 1y= 2

definnner()print(x, y)returninner

func()#闭包函数传参的第二种方式

deffun1(x , y):definner1():print(x, y)returninner

fun1(1, 2)

# 这两种传参的效果是一样的，但是方式二在参数变动时需要修改，明显比方式一更有优势

闭包函数传参应用

#

import requests #requsets,爬虫的一个库

f = requests.get('https://www.jd.com') #爬取京东网页数据

if f.status_code == 200:print(len(f.text)) #打印网页字符串长度

#如果要多次爬取，我们这样输入，很麻烦。#

defindex():

f=requests.get(url)if f.status_code == 200:print(len(f.text))

indx(url)#如果要多次爬，且有不同的网站，这也有点麻烦#

importrequestsdefintto(url):defindex():

f=requests.get(url)if f.status_code == 200:print(len(f.text))returnindex

get_jd= intto('京东地址')

get_baidu= intto('百度地址’)

get_jd()

get_baidu()#这样爬取次数和，不同内容都比较方便

装饰器

在不改变原函数的基础上给原函数添加一个新功能。这就需要装饰器。装饰器的特点对外扩展功能开发，对内修改封闭。在使用装饰器原则是，不改变源码，不改变被装饰对象。

#简单的python装饰器

defintto(func):definner()print('这是内层函数inner')

func()returninner

index=intto(index)defindex():print('这是index函数')

index()>>>这是内层函数inner>>>这是index函数

语法糖

装饰器有一个简便的用法。那就是语法糖。是用@装饰函数，程序会将最近的下一个函数名做变量名送如装饰函数中运行，函数返回的内部定义函数的函数名，下一个最近的函数的函数名会接受。在调用原函数的函数名，实质是在调用装饰函数内定义的函数。

defintto(func):definner()print('这是内层函数inner')

func()returninner

@intto#等价于：index = intto(index)

defindex():print('这是index函数')

index()

装饰器使用时，我们打印indexd的时候会出现这样一个信息.inner at 0x00000236268BBB70>。显示index其实是inner函数。装饰的函数还是不能和真的一样。可以用python中的一个方法。

from functools importwrapsdefintto(func):

@wraps(func)definner():print('这是内层函数inner')

func()returninner

@intto#等价于：index = intto(index)

defindex():print('这是index函数')print(index)

>>> # 和原函数一模一样。如假包换。

1 #无参装饰器

2 from functools importwraps3 defintto(func):4 @wraps(func)5 def inner(*args, **kwargs):6 print('被装饰函数执行之前操作！')7 res = func(*args, **kwargs) #被装饰函数执行

8 print('被装饰函数执行之后操作！')9 returnres10 returninner11 @intto12 defindex():13 print('被装饰函数')14

15 #有参装饰器

16 from functools importwraps17 defouter(data):18 defintto(func):19 @wraps(func)20 def inner(*args, **kwargs):21 print('被装饰函数执行之前操作！', data)22 res = func(*args, **kwargs) #被装饰函数执行

23 print('被装饰函数执行之后操作！')24 returnres25 returninner26 returnintto27 @outer('参数')28 defindex():29 print('被装饰函数')

有参与无参装饰器

5 函数递归

函数的的递归就是函数在调用阶段直接或间接调用自己。在python中函数的递归有最大的递归深度， 在997到998之间。在查看递归深度可以使用sys模块，import sys，在打印sys.getrecursionlimit(),即可查看递归深度。当函数递归按理论上讲可以无限递归，但是这中递归没有任何意义，反而会占用大量内存资料，影响计算机的使用。所以跑python需要着这种递归深度。还可扩大递归深度，也是用sys模块，sys.setrecursionlimit(n),n是设置的递归深度。

有意义的函数递归应该包含回溯和递推。回溯是一次次重复的过程，但是重复就应该使问题复杂度下降，逐渐到达最终结束条件。递归：将结果往回推到结果。

# 将列表中的数字打印出来

l1= [1, [2, [3, [4, [5, [6, [7, [8, [9, [10]]]]]]]]]]

def index(lis):for i inlis:if type(i) is int: # 是数字就打印

print(i)else:

index(i) # 否者调用函数index

index(l1)

算法之二分法。算法解决问题是方法。数学王子高斯，在小学时老师让全班同学计算从1到100的和。当大家都在奋笔疾书取算时，高斯已经算出来了。他发现所有的数，1+100=101，2+99=101...首位相加都是一样的，这样的数有50个，就很快算出来5050。对于计算机也一样，算法的好坏，使计算机执行效率更高。就拿着来说计算1到1亿的和，使用while循环，和使用数列计算公式，明显感觉数列计算公式更加快捷。二分法是算法中的一种，在一个升序或降序数列中。寻找一个数，常规查找是一个一个顺序查找，这样可以找到，如果这个数在最后面，但无疑需要很大工作量。这个就可以用二分法了。被查找值与数列中间的值作比较，如果被查招数大于中间数，就切分列表，往中间数升序方向切分，否则，降序方向切分，切分后的列表在如此，如果找到便结束。这样就算法的过程就减少了很多。

# 查找列表中某个值

l1= [i for i in range(1, 101)]

def fine(l1, a):

print(l1)ifnot l1: # 如果列表为空，退出

print('不在此列表')returnj= len(l1)//2

if a >l1[j]:

l1= l1[j+1:]

fine(l1, a)

elif a

l1= l1[0:j]

fine(l1, a)else:

print('fine it', a)

fine(l1,98) # 列表l1， 查找98

#列表生成式

li = [i for i in range(100) if i //2 == 0] #0到99之间所有偶数元素，组成的列表

li1 = list('abcdef')

li2= [i for i in li1 if i != 'b'] #'a'到'f'的元素，且没有'b'#字典生成式

li1 = list('abcdef')

dict_1= {k:v for k,v inenumerate(li1)}print(dict_1)

6 匿名函数及应用

匿名函数和普通函数一样有固定的语法：lambda 参数：运算方法。结果便是返回值。lambda是关键字和普通函数的def相同，是固定的也是必须的的。函数的参数可以是任意类型单个或多个值。运算方法的结果便是返回值。匿名函数只写一行。

x = 1lambda_1= lambda x : x+1

print((lambda_1)(1)) #和函数调用相同,在后面加括号，此函数需要一个参数，传入1

>>>2匿名函数的应用#匿名函数和max()，min()

dict_1 = {'a': 4, 'b': 3, 'c': 5, 'd': 2}print(max(dict_1)) #对字典经行排序，但max函数是查值遍历方式查最大值，但是只能访问到字典的键，无法访问字典的值。所以一键大小来排

print(max(dict_1, key=lambdakey: dict_1[key]))>>>d>>>c#python中A到Z对应数字是65到90，a到z对于数字是97到122

dict_1 = {'a': 4, 'b': 3, 'c': 5, 'd': 2}print(min(dict_1))print(min(dict_1, key=lambda key: dict_1[key]))

#匿名函数与filter 过滤可迭代对象的一些值

l1 = [i for i in range(9) if i > 4]print(filter(lambda x: x != 7, l1)) #这是一个生成器

print(list(filter(lambda x:x != 7, l1))) #遍历l1中的值，但条件为假直接跳过，开始下次遍历

#匿名函数与reduce

from functools importreduce

li= [i for i in range(5)]print(reduce(lambda x, y: x + y, li)) #第一次将数列前两个数送入x, y；得到x+y结果送入参数中，与li下一个参数相加，

# 如此，指导列表中元素没有位置。得到列表元素和

>>>10

#匿名函数与map#map 映射

li = [i for i in range(5)]print(map(lambda x: x+1, li)) #利用map遍历，遍历对象就是列表li,每次遍历一个值送给x，匿名函数返回x+1的值。这是一个生成器

print(list(map(lambda x: x+1, li)))>>>

>>>[1, 2, 3, 4, 5]

#zip 拉链

l1 = [i for i in range(9) if i > 4]

l2= list('abcdefg')

rec1=zip(l2,l1)

l3=dict(rec1)print(l3)>>>{'a': 5, 'b': 6, 'c': 7, 'd': 8}

6 迭代器与生成器

迭代器是常见的一种可以迭代取值的工具，更新重复但每次更新都是基于上一次的结果。在python中可迭代对象的类型有，字符串，列表，元组，字典，集合和文件对象。

判断是否是可迭代对象，这个可根据双下iter来判断。迭代器对象可根据双下next来判断

#可迭代对象，双下iter来判断

str_1 = 'abcdefg'str_1.__iter__() #可迭代对象

str_1 = 'abcdefg's= str_1.__iter__()

s.__next__() #迭代器对象

在python中迭代器对象一定是可迭代对象，但可迭代对象不一定是迭代器对象。文件对象是迭代器对象。

#双下iter和双下next的使用

str_1 = 'abcdefg's= str_1.__iter__() # 传成迭代器对象print(s.__next__())print(s.__next__())print(s.__next__())print(s.__next__())>>>a

b

c

d

for循环与迭代器

for循环就是经in后面的可迭代对象用__iter__转成可迭代对象。再使用__next__迭代取值。当取到最后一个值，经行异常处理。

str_1 = '123456789'

for i instr_1:print(i, end=',')deffunc(n):

rec= n.__iter__()whileTrue:try: #异常捕获

print(rec.__next__())exceptStopIteration:breakfunc(str_1)

小结：可迭代对象内置有__iter__方法，迭代器对象既内置有__iter__也有__next__方法。迭代取值是不依赖索引取值，在内存之占一份空间，对内存资源占小。但是取值的时候只能一个个取，不能取指定元素，取完会报错StopIteration。

生成器，自定义的迭代器。自定义的迭代器需要用到关键字yield。当函数执行到yield时，会暂停，使用双下next是打印出来，会打印yield后面的值，为空默认为None.

deffunc():for i in range(1, 101):yield f'{i}号球衣'g=func() # 生成器print(g.__next__()) #发衣服

print(g.__next__())print(g.__next__())print(g.__next__())

#for i in range(1, 10, 2): print(i) 实际执行过程

deffunc(start, end, step):while start

start+=step

g= func(1, 10, 2)whileTrue:try:print(g.__next__())exceptStopIteration:break

yield可以传值。需要使用send函数。

deffunc():whileTrue:

color= yield

print(f'{color}衣服')

g=func()

g.__next__() #使程序运行到yield

g.send('红色') #给yield赋值

g.send('黄色')

红色衣服

黄色衣服

yield与return都在函数中。他们都有返回值，并且返回多个值时都是以元组的方式。区别也要很重要。函数执行到return会立即结束。但执行到yield会暂停，且yield还可以传值。

生成器表达式。例：s = (i for i in range(10))。这里的s就是一个生成器。可以查看s只是一个生成器地址。

生成器的取值不会不会主动，需要用双下next来取值。