Section 9 Fonctions
Une fonction est un groupe d'instructions qui complète une fonction spécifique. Ce groupe d'instructions peut être utilisé comme une unité et recevoir un nom.
peut être exécuté plusieurs fois à différents endroits du programme via le nom de la fonction (c'est ce qu'on appelle généralement un appel de fonction), mais il n'est pas nécessaire de répéter ces instructions partout.
Fonction personnalisée
Fonction Python prédéfinie
Certaines fonctions sont fournies avec le système, ainsi que certaines fonctions écrites par des tiers, telles que certaines fonctions écrites par d'autres programmeurs. Les utilisateurs peuvent utiliser directement ces fonctions prêtes à l'emploi.
Pourquoi utiliser des fonctions
Définition et appel de fonctions
-
Lorsque nous définissons nous-mêmes une fonction, nous utilisons généralement l'instruction def, dont la syntaxe est la suivante :
def 函数名 (参数列表): #可以没有参数函数体
def add(a, b):
print a + b
Copier après la connexion
-
La forme générale d'appel d'une fonction est :
函数名（参数列表）
add(1, 2)
Copier après la connexion
Paramètres formels et paramètres réels
Lors de la définition d'une fonction, le nom de la variable entre parenthèses après la fonction est appelé "paramètre formel", ou simplement "paramètre formel"
Lors de l'appel de la fonction, après le nom de la fonction Les noms de variables entre parenthèses sont appelés "paramètres réels", ou simplement "paramètres réels"
Paramètres par défaut (paramètres par défaut)
Variables locales et globales
Toute variable en Python a sa portée spécifique.
Les variables définies dans une fonction ne peuvent généralement être utilisées que dans la fonction. Ces variables qui ne peuvent être utilisées que dans des parties spécifiques du programme sont appelées variables locales.
-
Les variables définies en haut d'un fichier peuvent être appelées par n'importe quelle fonction du fichier. Ces variables qui peuvent être utilisées par l'ensemble du programme sont appelées variables globales.
x = 100 #全局变量，可以在文件任何地方调用
def func():
x = 200 #局部变量，只能在函数内部调用
print x
func() #输出200
print x #输出100
Copier après la connexion
déclaration globale
function Valeur de retour
Une fois la fonction appelée, elle renverra une valeur spécifiée
Une fois la fonction appelée, elle renvoie Aucun par défaut
retour de la valeur de retour
La valeur de retour peut être de n'importe quel type
retour après exécution , la fonction se termine
-
Distinguer la valeur de retour et l'impression
def add(a, b):
return a + b
ret = add(1, 2) #将函数返回结果赋值给变量ret
print ret #输出3
Copier après la connexion
Passer les tuples et les dictionnaires à la fonction
-
func (*args)
def func(x, y):
print x, y
t = (1, 2)
func(*t)
Copier après la connexion
-
func (**kw)
def func(name='jack', age=30):
print name,age
d = {'age': 22, 'name' : 'mike'};
func(**d)Copier après la connexion
Gestion des arguments redondants
-
def func(*args, **kw)
def func(x, *args, **kw):
print x
print args
print kw
func(1, 2, 3, 4, 5, y=10, z=20)
#输出
1
(2, 3, 4, 5)
{'y': 10, 'z': 20}Copier après la connexion
expression lambda
Fonction anonyme
-
La fonction lambda est une fonction minimale qui définit rapidement une seule ligne, empruntée à Lisp, et peut être utilisée partout où une fonction est nécessaire.
lambda x,y:x*y
Copier après la connexion
Lors de l'utilisation de Python pour écrire certains scripts d'exécution, l'utilisation de lambda peut enregistrer le processus de définition des fonctions et rationaliser le code.
Pour certaines fonctions abstraites qui ne seront pas réutilisées ailleurs, il est parfois difficile de nommer la fonction. Lorsque vous utilisez lambda, vous n'avez pas besoin de considérer les problèmes de nommage.
L'utilisation de lambdas rend parfois le code plus facile à comprendre.
les bases de lambda
-
Dans l'instruction lambda, il y a des paramètres avant les deux points, il peut y en avoir plusieurs, séparés par des virgules, sur le côté droit de la valeur de retour du côlon. L'instruction lambda construit en fait un objet fonction
g = lambda x:x**2
print g
<function <lambda> at 0x0000000002643A58>
Copier après la connexion
instance d'application lambda
instruction switch
L'instruction switch est utilisée pour écrire des programmes avec des structures multi-branches, similaires à if...elif ... sinon déclaration.
switch语句表达的分支结构比if...elif...else语句表达的更清晰，代码的可读性更高。
但是python并没有提供switch语句
switch实现
函数调用
-
通过字典调用函数
def add(a, b):
return a + b
def sub(a, b):
return a - b
def mul(a, b):
return a * b
def div(a, b):
return a / b
operator = {'+': add, '-': sub, '*': mul, '/': div} #通过字典实现switch语句的功能
def calc(a, o, b):
return operator.get(o)(a, b)
print calc(4, '+', 2)
print calc(4, '-', 2)
print calc(4, '*', 2)
print calc(4, '/', 2)Copier après la connexion
第十节 内置函数
help函数可以用来查看函数的用法
help(range)
#输出结果
Help on built-in function range in module __builtin__:
range(...)
range(stop) -> list of integers
range(start, stop[, step]) -> list of integers
Return a list containing an arithmetic progression of integers.
range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
When step is given, it specifies the increment (or decrement).
For example, range(4) returns [0, 1, 2, 3]. The end point is omitted!
These are exactly the valid indices for a list of 4 elements.
Copier après la connexion
常用函数
abs(number): 绝对值
max(iterable[, key=func]): 最大值
min(iterable[, key=func]): 最小值
len(collection): 取得一个序列或集合的长度
divmod(x, y): 求两个数的商和模，返回一个元组(x//y, x%y)
pow(x, y[, z]): 求一个数的幂运算
round(number[, ndigits]): 对一个数进行指定精度的四舍五入
callable(object): 判断一个对象是否可调用
isinstance(object, class-or-type-or-tuple)：判断对象是否为某个类的实例
cmp(x, y): 比较两个数或字符串大小
range(start [,stop, step]): 返回一个范围数组，如range(3), 返回[0,1,2]
xrange(start [,stop, step]): 作用与range相同，但是返回一个xrange生成器，当生成范围较大的数组时，用它性能较高
类型转换函数
-
type()
type(object) -> the object's type
type(name, bases, dict) -> a new type
Copier après la connexion
-
int()
int(x=0) -> int or long
int(x, base=10) -> int or long
Copier après la connexion
-
long()
long(x=0) -> long
long(x, base=10) -> long
Copier après la connexion
-
float()
float(x) -> floating point number
Copier après la connexion
-
complex()
complex(real[, imag]) -> complex number
Copier après la connexion
-
str()
str(object='') -> string
Copier après la connexion
-
list()
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
Copier après la connexion
-
tuple()
tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable's items
Copier après la connexion
-
hex()
hex(number) -> string
Copier après la connexion
-
oct()
oct(number) -> string
Copier après la connexion
-
chr()
chr(i) -> character
Copier après la connexion
-
ord()
ord(c) -> integer
Copier après la connexion
string函数
-
str.capitalize()
>>> s = "hello"
>>> s.capitalize()
'Hello'
Copier après la connexion
-
str.replace()
>>> s = "hello"
>>> s.replace('h', 'H')
'Hello'Copier après la connexion
-
str.split()
>>> ip = "192.168.1.123"
>>> ip.split('.')
['192', '168', '1', '123']Copier après la connexion
序列处理函数
-
len()
>>>l = range(10)
>>> len(l)
10
Copier après la connexion
-
max()
>>>l = range(10)
>>> max(l)
9
Copier après la connexion
-
min()
>>>l = range(10)
>>> min(l)
0
Copier après la connexion
-
filter()
>>>l = range(10)
>>> filter(lambda x: x>5, l)
[6, 7, 8, 9]
Copier après la connexion
-
zip()
>>> name=['bob','jack','mike']
>>> age=[20,21,22]
>>> tel=[131,132]
>>> zip(name, age)
[('bob', 20), ('jack', 21), ('mike', 22)]
>>> zip(name,age,tel)
[('bob', 20, 131), ('jack', 21, 132)] #如果个数不匹配会被忽略Copier après la connexion
-
map()
>>> map(None, name, age)
[('bob', 20), ('jack', 21), ('mike', 22)]
>>> map(None, name, age, tel)
[('bob', 20, 131), ('jack', 21, 132), ('mike', 22, None)] #个数不匹配时，没有值的会被None代替
>>> a = [1,3,5]
>>> b = [2,4,6]
>>> map(lambda x,y:x*y, a, b)
[2, 12, 30]Copier après la connexion
-
reduce()
>>> reduce(lambda x,y:x+y, range(1,101))
5050
Copier après la connexion
lambda -> 列表表达式
-
map的例子，可以写成
print map(lambda x:x*2+10, range(1,11))
print [x*2+10 for x in range(1,11)]
Copier après la connexion
-
非常的简洁，易懂。filter的例子可以写成：
print filter(lambda x:x%3==0, range(1,11))
print [x for x in range(1,11) if x%3 == 0]
Copier après la connexion
第十一节 模块
简介
包
python的模块可以按目录组织为包
创建一个包的步骤是：
建立一个名字为包名字的文件夹
在该文件夹下创建一个__init__.py文件
根据需要在该文件夹下存放脚本文件、已编译扩展及子包
import pack.m1, pack.m2, pack.m3
模块
总结
模块是一个可以导入的python脚本文件
包是一堆目录组织的模块和子包，目录下的__init__.py文件存放了包的信息
-
可以用import, import as, from import等语句导入模块和包
#假设有一个模块名为calc.py
import calc
import calc as calculate
from calc import add
Copier après la connexion
第十二节 正则表达式
目标
案例
简介
字符匹配
普通字符
-
元字符
. ^ $ * + ? {} [] \ | ()Copier après la connexion
其中m和n是十进制整数。该限定符的意思是至少有m个重复，至多到n个重复
忽略m会认为下边界是0，而忽略n的结果将是上边界为无穷大（实现上是20亿）
{0,}等同于*，{1,}等同于+，而{0,1}则与?相同。如果可以的话，最好使用*，+或?
匹配一次或零次，你可以认为它用于标识某事物是可选的
表示匹配一次或更多次
注意和+之间的不同：匹配零或更多次，所以可以根本不出现，而+则要求至少出现一次
指定前一个字符可能被匹配零次或更多次，而不是只有一次。匹配引擎会试着重复尽可能多的次数（不超过整数界定范围，20亿）
常用来指定一个字符集：[abc] [a-z]
元字符在字符集中不起作用：[akm$]
-
补集匹配不在区间范围内的字符：[^5]
import re
regExp = r't[0-9]p'
print re.findall(regExp, 't1p t2p')
Copier après la connexion
[]
^
$
\
重复
*
+
?
{m,n}
使用正则表达式
反斜杠的麻烦
-
字符串前加"r"反斜杠就不会被任何特殊方式处理
字符 阶段
\section 要匹配的字符串
\\section 为re.compile取消反斜杠的特殊意义
"\\\\section" 为"\\section"的字符串实值（string literals）取消反斜杠的特殊意义
Copier après la connexion
执行匹配
模块级函数
编译标志-flags
标志 含义
DOTALL, S 使.匹配包括换行在内的所有字符
IGNORECASE, I 使匹配对大小写不敏感
LOCALE, L 做本地化识别（local-aware）匹配.法语等
MULTILINE, M 多行匹配，影响^和$
VERBOSE, X 能够使用REs的verbose状态，使之被组织得更清晰易懂
charref = re.compile(r"""
(
[0-9]+[^0-9] #Decimal form
| 0[0-7]+[^0-7] #Octal form
| x[0-9a-fA-F]+[^0-9a-fA-F] #Hexadecimal form
)
""", re.VERBOSE)
Copier après la connexion
分组()
email = r"\w+@\w+(\.com|\.cn)"
Copier après la connexion
一个小爬虫
-
下载贴吧或空间中所有图片
import re
import urllib
def getHtml(url):
page = urllib.urlopen(url)
html = page.read()
return html
def getImg(html):
reg = r'src="(.*?\.jpg)" width'
imgre = re.compile(reg)
imglist = re.findall(imgre, html)
x = 0
for imgurl in imglist:
urllib.urlretrieve(imgurl, '%s.jpg' % x)
x++
getImg(getHtml(url))
Copier après la connexion
第十三章 python对内存的使用
浅拷贝和深拷贝
所谓浅拷贝就是对引用的拷贝（只拷贝父对象）
所谓深拷贝就是对对象的资源的拷贝
-
解释一个例子：
import copy
a = [1,2,3,['a','b','c']]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
Copier après la connexion
第十四章 文件与目录
目标
文件的打开和创建
文件读取
文件写入
内容查找和替换
文件删除、复制、重命名
目录操作
案例
python文件读写
| r |
只读 |
| r+ |
读写 |
| w |
写入，先删除原文件，在重新写入，如果文件没有则创建 |
| w+ |
读写，先删除原文件，在重新写入，如果文件没有则创建（可以写入输出） |
| a |
写入，在文件末尾追加新的内容，文件不存在，创建之 |
| a+ |
读写，在文件末尾追加新的内容，文件不存在，创建之 |
| b |
打开二进制文件。可以与r、w、a、+结合使用 |
| U |
支持所有的换行符号。"\r"、"\n"、"\r\n" |
文件对象方法
close
关闭文件，关闭前，会将缓存中的数据先写入文件。
FileObject.close()
格式
说明
readline
readlines
read
next
返回当前行，并将文件指针到下一行
FileObject.next()
格式
说明
write
writelines
seek
选项=0时，表示将文件指针指向从文件头部到“偏移量”字节处。
选项=1时，表示将文件指针指向从文件的当前位置，向向移动“偏移量”字节。
选项=2时，表示将文件指针指向从文件的尾部，向前移动“偏移量”字节。
FileObject.seek(偏移量，选项)
格式
说明
flush
提交更新
FileObject.flush()
格式
说明
文件查找和替换
目录操作
| mkdir(path[,mode=0777]) |
创建单个目录 |
| makedirs(name,mode=511) |
创建多层级目录 |
| rmdir(path) |
删除单个目录 |
| removedirs(path) |
删除多层级目录 |
| listdir(path) |
列出目录 |
| getcwd() |
取得当前目录 |
| chdir(path) |
切换目录 |
| walk(top, topdown=True, onerror=None) |
|
第十五章 异常处理
异常以及异常抛出
抛出机制
如果在运行时发生异常的话，解释器会查找相应的处理语句（称为handler）。
要是在当前函数里没有找到的话，它会将异常传递给上层的调用函数，看看那里能不能处理。
如果在最外层（全局“main”）还是没有找到的话，解释器就会退出，同时打印出traceback以便让用户找出错误产生的原因。
注意：虽然大多数错误会导致异常，但一个异常不一定代表错误。有时候它们只是一个警告，有时候它们可能是一个终止信号，比如退出循环等。
finally子句
raise抛出异常
常见的python异常
| AssertionError |
assert语句失败 |
| AttributeError |
试图访问一个对象没有的属性 |
| IOError |
输入输出异常，基本是无法打开文件 |
| ImportError |
无法引入模块或者包，基本是路径问题 |
| IndentationError |
语法错误，代码没有正确的对齐 |
| IndexError |
下标索引超出序列边界 |
| KeyError |
试图访问你字典里不存在的键 |
| KeyBoardInterrupt |
Ctrl+C被按下 |
| NameError |
使用一个还未赋予对象的变量 |
| SyntaxError |
python代码逻辑语法出错，不能执行 |
| TypeError |
传入的对象类型与要求不符 |
| UnboundLocalError |
试图访问一个还未设置的全局变量，基本上是由于另有一个同名的全局变量，导致你以为在访问 |
| ValueError |
传入一个不被期望的值，即使类型正确 |
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
