Was sind die Python-Funktionen?

Wir können einen Teil des Codes verwenden, um die von uns benötigte Funktionalität zu erreichen, aber wenn wir diesen Code wiederverwenden müssen, ist das Kopieren und Einfügen keine coole Methode. Wir können Funktionen verwenden, um diesen Bedarf zu erreichen

1 . Funktionsdefinition

Eine Funktion ist eine Programmiermethode, die logisch strukturiert und prozedural ist. Ein Funktionsname kapselt eine Reihe von Codes, die zum Ausführen einer bestimmten Funktion verwendet werden

Funktionsdefinition:

def Funktionsname (Parameter 1, Parameter 2...):

''Kommentar''

Funktionskörper

def func1():　　#定义函数print('this is a function')　　#函数体
func1()　　#调用函数

(%)

(%(func1())　

--> Egon ist ein guter Mann

　Keine

Vorteile von Funktionen: 1. Code Wiederverwendung

2. Behalten Sie Konsistenz und einfache Wartung bei

3. Gute Skalierbarkeit

Hinweis: 1. Die Funktion muss zuerst definiert werden, bevor sie verwendet wird Bei Verwendung vor der Definition wird ein Fehler gemeldet

2. Die Funktion erkennt Syntaxfehler nur während der Definitionsphase und führt den Code nicht aus. Selbst wenn der Funktionskörper undefinierte Variablennamen enthält, Es wird kein Fehler gemeldet, bevor die Funktion aufgerufen wird

3. Der Rückgabewert der Funktion kann von beliebigem Typ sein. Wenn mehrere Werte zurückgegeben werden, muss er in Form eines Tupels vorliegen

4. Die Funktion von return besteht darin, zu beenden. Bei der Ausführung der Funktion wird return nur einmal ausgeführt und der nachfolgende Inhalt wird nicht ausgeführt

2. Funktionsparameter

Die Parameter Die Funktion wird in formale Parameter und tatsächliche Parameter unterteilt. Nach dem Funktionsnamen werden die formalen Parameter beim Aufruf der Funktion übergeben. Formale Parameter sind nur innerhalb der Funktion gültig und können nicht extern referenziert werden.

1. Formale Parameter

1) Positionsparameter: Parameter definiert in der Reihenfolge von links nach rechts def foo(x,y,z)

Positionsparameter Werte müssen übergeben werden, und mehr oder weniger wird nicht funktionieren

2) Standardparameter: Den formalen Parametern wurden während der Funktionsdefinitionsphase Werte zugewiesen. Wenn während der Aufrufphase keine Werte zugewiesen werden wird ein Standardwert sein def foo(x,y= 10)

Wenn sich der Wert häufig ändert, wird er normalerweise als Positionsparameter definiert. Wenn sich der Wert jedoch in den meisten Fällen nicht ändert, kann dies der Fall sein als Standardparameter definiert

Hinweis:

a. Standardparameter müssen nach Positionsparametern platziert werden

b. Standardparameter werden normalerweise als unveränderliche Typen definiert

c. Standardparameter werden nur einmal zugewiesen, wenn sie definiert werden

3) Benannte Schlüsselwortparameter: def register(*,name,age) *Die später definierten formalen Parameter müssen als Wert übergeben werden, und der Wert muss in Form von Schlüsselwörtern übergeben werden

2. Tatsächliche Parameter

1) Positionelle tatsächliche Parameter: Eins-zu-eins-Entsprechung mit Positionsparametern

2) Schlüsselwortparameter: Wann Die eigentlichen Parameter sind definiert, sie werden in Form von Schlüsselwerten definiert

def foo( x,y)

foo(x=1,y=2)

Schlüsselwortparameter müssen nicht eins zu eins mit formalen Parametern wie Positionsparametern übereinstimmen und können die Reihenfolgebeschränkung aufheben

Hinweis: a Parameter müssen vor den Schlüsselwortparametern stehen

b Es kann entweder ein Positionsparameter oder ein Schlüsselwortparameter sein. Ein formaler Parameter kann jedoch nur einmal einen Wert übergeben

3) Variable-. Längenparameter:

Durch die Position definierte Parameter variabler Länge werden durch * dargestellt

Durch Schlüsselwörter definiert Parameter vom Variablentyp werden durch ** dargestellt

def func(x,y,*args):print(x,y,args)
func(1,2,3,4,5)　　--->1 2 (3 4 5)

# Wenn * angetroffen wird, handelt es sich um einen Positionsparameter. Teilen Sie alle nach * auf und gleichen Sie sie einzeln ab. Der Überschuss liegt in Form von Tupeln vor. Speichern Sie sie zusammen # Wenn ** auftritt, wird alles nach ** in Schlüsselwörter aufgeteilt und der Überschuss wird in Wörterbuchform gespeichert.

def wrapper(*args, **kwargs): kann Parameter jeder Form und Länge akzeptieren

def func(x,y,**kwargs):print(x,y,kwargs)
func(1,y=2,z=3,a=1,b=2)---->1 2 {'z': 3, 'a': 1, 'b': 2}

Parameterdefinitionsreihenfolge: x, y=1, *args ,z,**kwargs, sind Positionsparameter, Standardparameter, Positionsparameter variabler Länge, benannte Schlüsselwortparameter, Variablentypparameter

, es ist jedoch zu beachten, dass diese Parameter nicht alle gleichzeitig angezeigt werden

3. Der Namespace speichert die Bindungsbeziehung zwischen Namen und Werten in Form eines Schlüsselwerts

Geben Sie den Befehl in die Windows-Eingabeaufforderung ein: Importieren Sie dies. In der letzten Zeile wird dieser Satz angezeigt:

Namespaces sind eine wirklich tolle Idee – machen wir mehr davon!

Es gibt drei Arten von Namespaces:

1) Integrierter Namespace: Python ist im Lieferumfang enthalten, z. B. print, int, len.... Wenn der Python-Interpreter startet, wird der integrierte Namensraum generiert

2) Globaler Namensraum: Auf Dateiebene definierte Namen werden im globalen Namensraum gespeichert, der bei der Ausführung generiert wird ein Python-Programm. Einfach ausgedrückt handelt es sich um einen Variablennamen ohne Einrückung

3) Lokaler Namensraum: definiert in einer Funktion (oder einem Modul, einer Klasse) Der interne Name wird nur wirksam, wenn die Funktion (Modul, Klasse) wird aufgerufen und nach Abschluss des Aufrufs freigegeben

Die Ladesequenz ist: integrierter Namespace --> lokaler Name Die Wertereihenfolge der Leerzeichen

ist: lokaler Namespace --> integrierter Namespace

4. Funktionsverschachtelung und -bereich

1 .Funktionsverschachtelung umfasst verschachtelte Aufrufe von Funktionen und verschachtelte Definitionen von Funktionen

Verschachtelte Funktionsaufrufe können am Beispiel der Ermittlung des Maximalwerts veranschaulicht werden:

函数嵌套定义：

def f1():def f2():def f3():print('from f3')print('from f2')
        f3()print('from f1')
    f2()# print(f1)f1()

2.作用域

1）全局作用域：内置名称空间与全局名称空间的名字属于全局范围，在整个文件的任意位置都能引用

2）局部作用域：属于局部范围，只在函数内部可以被引用，局部有效

一定要注意局部变量和全局变量的作用范围，在局部修改全局变量会出错，在全局范围引用局部变量也会出错

作用域在函数定义时就已经固定了，不会因调用位置而改变

但是如果一定要在局部修改全局变量，也是用办法的，就是在要修改的变量前加一个global

x=1def foo():
    x=10print(x)        

foo()       #10print(x)    #1

x=1def foo():global x
    x=10print(x)

foo()       #10print(x)    #10

def foo():
    x=1def f2():
        x+=xreturn xreturn f2()print(foo())        #会报错UnboundLocalError: local variable 'x' referenced before assignmentdef foo():
    x=1def f2():
        nonlocal x　　#告诉Python解释器，这里的x不是局部变量，只会找函数内部的，不会修改全局变量
        x+=xreturn xreturn f2()print(foo())    #会打印出修改后的x的值，2

五、闭包函数

定义在函数内部的函数，该内部函数包含对外部作用域，而非全局作用域的名字的引用，那么该内部函数称为闭包函数

name===func()

闭包函数的特点：a.自带作用域，b.延迟计算（f只是拿到了函数的内存地址，什么时候用，加括号就可以运行）

闭包函数最基本的形式：

def 外部函数名（）：

　　内部函数需要的变量

　　def 内部函数名（）：

　　　　引用外部变量

　　return 内部函数名

六、装饰器

1.开放封闭原则：对扩展是开放的，对修改是封闭的

2.装饰器本质是任意可调用的对象，被装饰对象也是任意可调用的对象

3.装饰器的功能是：在不修改被装饰对象源代码及调用方式的前提下，为其添加新的功能

4.装饰器语法：在被装饰对象的正上方的单独一行，写上@装饰器名字

5.有多个装饰器的时候，每行一个，执行时从上往下运行

6.被装饰函数有参数的情况：写成（*args,**kwargs）的形式

装饰器示例一：

#实现缓存网页内容的功能，下载的页面存放于文件中，如果文件内有值（文件大小不为0），# 就优先从文件中读取网页内容，否则，就去下载，然后存到文件中from urllib.request import urlopenimport os

cache_path=r'C:\untitled\0615Python第8天\cache_file.txt'def make_cache(func):def wrapper (*args,**kwargs):if os.path.getsize(cache_path):#有缓存print('\033[45m========>有缓存\033[0m')
            with open(cache_path,'rb') as f:
                res=f.read()else:
            res=func(*args,**kwargs)#下载with open(cache_path,'wb') as f:#制作缓存                f.write(res)return resreturn wrapper


@make_cachedef get(url):return urlopen(url).read()print(get(''))

装饰器示例二：

#为多个函数加上认证的功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码db_dic={'egon':'123','alex':'alex3714','yuanhao':'smallb'}


db_path=r'C:\untitled\0615Python第8天\db_dic.txt'with open(db_path,'w',encoding='utf-8') as f:
    f.write(str(db_dic))

login_dic={'user':None,'status':False,
}def auth(func):def wrapper(*args,**kwargs):#加一个验证状态的字典，如果已经登录成功，下次使用就不用重新验证if login_dic['user'] and login_dic['status']:
            res=func(*args,**kwargs)return reselse:
            name=input('name:')
            password=input('password:')
            with open(db_path, 'r', encoding='utf-8') as f:
                auth_dic = eval(f.read())if name in auth_dic and password==auth_dic[name]:print('login ok')
                login_dic['user']=name
                login_dic['status']=True
                res=func(*args,**kwargs)return reselse:print('error')return wrapper

@authdef index():print('welcom to the page')

@authdef home(name):print('welcom  to %s\'s home page'%name)


index()
home('egon')

七、迭代器

1.对于字符串、列表、元组的数据类型，我们可以依据索引来实现迭代的效果，但是字典、集合这种没有索引的数据类型，就需要其他方式

2.Python为了提供一种不依赖索引的迭代方式，为一些对象内置了__iter__方法，obj.__iter__()得到的结果就是迭代器

得到的迭代器既有.__iter__方法，又有.__next__方法

3.迭代器的优点：

　　a.提供了一种不依赖索引的取值方式

　　b.惰性计算，节省内存

4.迭代器的缺点：

　　a.取值不如按照索引取值方便

　　b.一次 性的，取值只能往后走，不能往前退

　　c.无法获取迭代器的长度

5.for循环实际上会默认调用.__iter__方法

6.判断是否是可迭代对象和迭代器，可以用命令

print(isinstance(str1,Iterable)) --->判断是否为可迭代对象

print(isinstance(str1,Iterator)) --->判断是否为迭代器

八、生成器函数（语句形式和表达式形式）

1.生成器函数：函数体内包含有yield关键字，该函数的执行结果就是生成器

2.生成器实际就是迭代器的一种

3.yield的功能：

　　a.与return类似，都可以返回值，但不一样的地方在于yield返回多次值，而return只能返回一次值
　　b.为函数封装好了__iter__和__next__方法，把函数的执行结果做成了迭代器
　　c.遵循迭代器的取值方式obj.__next__（），触发的函数的执行，函数暂停与再继续的状态都是由yield保存的
4.生成器语句形式应用实例

 1 #模拟linux中tail -f a.txt|grep 'error' |grep '404'的功能 2 import time 3 def tail(filepath,encoding='utf-8'): 4     with open(filepath,encoding='utf-8') as f: 5         f.seek(0,2)  #以末尾为开始位，第0个 6         while True: 7             line=f.readline() 8             if line: 9                 yield line10             else:11                 time.sleep(0.5)12 13 def grep(lines,pattern):14     for line in lines:15         if pattern in line:16             # print(line)17             yield line18 19 g1=tail('a.txt')20 g2=grep(g1,'error')21 g3=grep(g2,'404')22 23 for i in g3:24     print(i)

View Code

5.生成器的表达式形式

def foo():print('starting')while True:
        x=yield #默认就是yield Noneprint('value ：',x)

g=foo() 
next(g)　　#初始化，等同于g.send(None)
g.send(2)　　

将yield赋值给一个变量如x=yield,然后用send()传值，但注意要先做一个类似初始化的操作

g.send(2)的操作实际是先把2传值给yield,再由yield传值给x，send()既有传值的效果，又有next()的效果

生成器表达式形式应用示例

 1 def init(func): 2     def wrapper(*args,**kwargs): 3         g=func(*args,**kwargs) 4         next(g) 5         return g 6     return wrapper 7 @init 8 def eater(name): 9     print('%s ready to eat' %name)10     food_list=[]11     while True:12         food=yield food_list#return None13         food_list.append(food)14         print('%s start to eat %s' %(name,food))15 16 17 e=eater('alex')18 print(e.send('狗屎'))19 print(e.send('猫屎'))20 print(e.send('alex屎'))21 22 23 def make_shit(people,n):24     for i in range(n):25         people.send('shit%s' %i)26 27 e=eater('alex')28 make_shit(e,5)29 #from egon30 #egon老师的例子有味道，但是我又忍不住不用这个

View Code

九、三元表达式

res= x if x>y else y----->判断条件x>y是否为真，为真则把x赋给res,否则把y赋给res

十、列表解析

s='hello'res=[i.upper() for i in s]print(res)          #['H', 'E', 'L', 'L', 'O']

Das obige ist der detaillierte Inhalt vonWas sind die Python-Funktionen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!