python函数专题 python函数概念
Python 几个重要的内置函数
在学习Python的过程中,有几个比较重要的内置函数:help()函数、dir()函数、input()与raw_input()函数、print()函数、type()函数。
创新互联公司成立与2013年,是专业互联网技术服务公司,拥有项目成都网站建设、做网站网站策划,项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命,1280元新野做网站,已为上家服务,为新野各地企业和个人服务,联系电话:18980820575
第一、help()函数
Help()函数的参数分为两种:如果传一个字符串做参数的话,它会自动搜索以这个字符串命名的模块、方法等;如果传入的是一个对象,就会显示这个对象的类型的帮助。比如输入help(‘print’),它就会寻找以‘print’为名的模块、类等,找不到就会看到提示信息;而print在Python里是一个保留字,和pass、return同等,而非对象,所以help(print)也会报错。
第二、dir()函数
dir()函数返回任意对象的属性和方法列表,包含模块对象、函数对象、字符串对象、列表对象、字典对象等。尽管查找和导入模块相对容易,但是记住每个模块包含什么却不是这么简单,您并不希望总是必须查看源代码来找出答案。Python提供了一种方法,可以使用内置的dir()函数来检查模块的内容,当你为dir()提供一个模块名的时候,它返回模块定义的属性列表。dir()函数适用于所有对象的类型,包含字符串、整数、列表、元组、字典、函数、定制类、类实例和类方法。
第三、input与raw_input函数
都是用于读取用户输入的,不同的是input()函数期望用户输入的是一个有效的表达式,而raw_input()函数是将用户的输入包装成一个字符串。
第四、Print()函数
Print在Python3版本之间是作为Python语句使用的,在Python3里print是作为函数使用的。
第五、type()函数
Type()函数返回任意对象的数据类型。在types模块中列出了可能的数据类型,这对于处理多种数据类型的函数非常有用,它通过返回类型对象来做到这一点,可以将这个类型对象与types模块中定义类型相比较。
Python的函数都有哪些?
Python 函数
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。
定义一个函数
你可以定义一个由自己想要功能的函数,以下是简单的规则:
函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始,并且缩进。
return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法
def functionname( parameters ): "函数_文档字符串"
function_suite
return [expression]
默认情况下,参数值和参数名称是按函数声明中定义的顺序匹配起来的。
实例
以下为一个简单的Python函数,它将一个字符串作为传入参数,再打印到标准显示设备上。
实例(Python 2.0+)
def printme( str ): "打印传入的字符串到标准显示设备上"
print str
return
函数调用
定义一个函数只给了函数一个名称,指定了函数里包含的参数,和代码块结构。
这个函数的基本结构完成以后,你可以通过另一个函数调用执行,也可以直接从Python提示符执行。
如下实例调用了printme()函数:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 定义函数def printme( str ): "打印任何传入的字符串"
print str
return
# 调用函数printme("我要调用用户自定义函数!")printme("再次调用同一函数")
以上实例输出结果:
我要调用用户自定义函数!再次调用同一函数
参数传递
在 python 中,类型属于对象,变量是没有类型的:
a=[1,2,3]
a="Runoob"
以上代码中,[1,2,3] 是 List 类型,"Runoob" 是 String 类型,而变量 a 是没有类型,她仅仅是一个对象的引用(一个指针),可以是 List 类型对象,也可以指向 String 类型对象。
可更改(mutable)与不可更改(immutable)对象
在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。
不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变a的值,相当于新生成了a。
可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。
python 函数的参数传递:
不可变类型:类似 c++ 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。
可变类型:类似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响
python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。
python 传不可变对象实例
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
def ChangeInt( a ): a = 10
b = 2ChangeInt(b)print b # 结果是 2
实例中有 int 对象 2,指向它的变量是 b,在传递给 ChangeInt 函数时,按传值的方式复制了变量 b,a 和 b 都指向了同一个 Int 对象,在 a=10 时,则新生成一个 int 值对象 10,并让 a 指向它。
传可变对象实例
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明def changeme( mylist ): "修改传入的列表"
mylist.append([1,2,3,4])
print "函数内取值: ", mylist
return
# 调用changeme函数mylist = [10,20,30]changeme( mylist )print "函数外取值: ", mylist
实例中传入函数的和在末尾添加新内容的对象用的是同一个引用,故输出结果如下:
函数内取值: [10, 20, 30, [1, 2, 3, 4]]函数外取值: [10, 20, 30, [1, 2, 3, 4]]
参数
以下是调用函数时可使用的正式参数类型:
必备参数
关键字参数
默认参数
不定长参数
必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数,你必须传入一个参数,不然会出现语法错误:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printme( str ): "打印任何传入的字符串"
print str
return
#调用printme函数printme()
以上实例输出结果:
Traceback (most recent call last):
File "test.py", line 11, in module
printme()TypeError: printme() takes exactly 1 argument (0 given)
关键字参数
关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printme( str ): "打印任何传入的字符串"
print str
return
#调用printme函数printme( str = "My string")
以上实例输出结果:
My string
下例能将关键字参数顺序不重要展示得更清楚:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printinfo( name, age ): "打印任何传入的字符串"
print "Name: ", name
print "Age ", age
return
#调用printinfo函数printinfo( age=50, name="miki" )
以上实例输出结果:
Name: mikiAge 50
默认参数
调用函数时,默认参数的值如果没有传入,则被认为是默认值。下例会打印默认的age,如果age没有被传入:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printinfo( name, age = 35 ): "打印任何传入的字符串"
print "Name: ", name
print "Age ", age
return
#调用printinfo函数printinfo( age=50, name="miki" )printinfo( name="miki" )
以上实例输出结果:
Name: mikiAge 50Name: mikiAge 35
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述2种参数不同,声明时不会命名。基本语法如下:
def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串"
function_suite
return [expression]
加了星号(*)的变量名会存放所有未命名的变量参数。不定长参数实例如下:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明def printinfo( arg1, *vartuple ): "打印任何传入的参数"
print "输出: "
print arg1
for var in vartuple: print var
return
# 调用printinfo 函数printinfo( 10 )printinfo( 70, 60, 50 )
以上实例输出结果:
输出:10输出:706050
匿名函数
python 使用 lambda 来创建匿名函数。
lambda只是一个表达式,函数体比def简单很多。
lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间,且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,.....argn]]:expression
如下实例:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数print "相加后的值为 : ", sum( 10, 20 )print "相加后的值为 : ", sum( 20, 20 )
以上实例输出结果:
相加后的值为 : 30相加后的值为 : 40
return 语句
return语句[表达式]退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值,下例便告诉你怎么做:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明def sum( arg1, arg2 ): # 返回2个参数的和."
total = arg1 + arg2
print "函数内 : ", total
return total
# 调用sum函数total = sum( 10, 20 )
以上实例输出结果:
函数内 : 30
变量作用域
一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下:
全局变量
局部变量
全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。如下实例:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
total = 0 # 这是一个全局变量# 可写函数说明def sum( arg1, arg2 ): #返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量.
print "函数内是局部变量 : ", total
return total
#调用sum函数sum( 10, 20 )print "函数外是全局变量 : ", total
以上实例输出结果:
函数内是局部变量 : 30函数外是全局变量 : 0
python 函数参数类型
python 的函数参数类型分为4种:
1.位置参数:调用函数时根据函数定义的参数位置来传递参数,位置参数也可以叫做必要参数,函数调用时必须要传的参数。
当参数满足函数必要参数传参的条件,函数能够正常执行:
add(1,2) #两个参数的顺序必须一一对应,且少一个参数都不可以
当我们运行上面的程序,输出:
当函数需要两个必要参数,但是调用函数只给了一个参数时,程序会抛出异常
add(1)
当我们运行上面的程序,输出:
当函数需要两个必要参数,但是调用函数只给了三个参数时,程序会抛出异常
add(1,2,3)
当我们运行上面的程序,输出
2.关键字参数:用于函数调用,通过“键-值”形式加以指定。可以让函数更加清晰、容易使用,同时也清除了参数的顺序需求。
add(1,2) # 这种方式传参,必须按顺序传参:x对应1,y对应:2
add(y=2,x=1) #以关健字方式传入参数(可以不按顺序)
正确的调用方式
add(x=1, y=2)
add(y=2, x=1)
add(1, y=2)
以上调用方式都是允许的,能够正常执行
错误的调用方式
add(x=1, 2)
add(y=2, 1)
以上调用都会抛出SyntaxError 异常
上面例子可以看出:有位置参数时,位置参数必须在关键字参数的前面,但关键字参数之间不存在先后顺序的
3.默认参数:用于定义函数,为参数提供默认值,调用函数时可传可不传该默认参数的值,所有位置参数必须出现在默认参数前,包括函数定义和调用,有多个默认参数时,调用的时候,既可以按顺序提供默认参数,也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时,需要把参数名写上
默认参数的函数定义
上面示例第一个是正确的定义位置参数的方式,第二个是错误的,因为位置参数在前,默认参数在后
def add1(x=1,y) 的定义会抛出如下异常
默认参数的函数调用
注意:定义默认参数默认参数最好不要定义为可变对象,容易掉坑
不可变对象:该对象所指向的内存中的值不能被改变,int,string,float,tuple
可变对象,该对象所指向的内存中的值可以被改变,dict,list
这里只要理解一下这个概念就行或者自行百度,后续会写相关的专题文章讲解
举一个简单示例
4.可变参数区别:定义函数时,有时候我们不确定调用的时候会多少个参数,j就可以使用可变参数
可变参数主要有两类:
*args: (positional argument) 允许任意数量的可选位置参数(参数),将被分配给一个元组, 参数名前带*,args只是约定俗成的变量名,可以替换其他名称
**kwargs:(keyword argument) 允许任意数量的可选关键字参数,,将被分配给一个字典,参数名前带**,kwargs只是约定俗成的变量名,可以替换其他名称
*args 的用法
args 是用来传递一个非键值对的可变数量的参数列表给函数
语法是使用 符号的数量可变的参数; 按照惯例,通常是使用arg这个单词,args相当于一个变量名,可以自己定义的
在上面的程序中,我们使用* args作为一个可变长度参数列表传递给add()函数。 在函数中,我们有一个循环实现传递的参数计算和输出结果。
还可以直接传递列表或者数组的方式传递参数,以数组或者列表方式传递参数名前面加(*) 号
理解* * kwargs
**kwargs 允许你将不定长度的键值对, 作为参数传递给函数,这些关键字参数在函数内部自动组装为一个dict
下篇详细讲解 *args, **kwargs 的参数传递和使用敬请关注
python函数问题
Python函数:
函数是组织好的,可重复使用的,用来实现单一或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。已经知道Python提供了许多内建函数,比如print()。但也可以自己创建函数,这被叫做用户自定义函数。
函数调用:
定义一个函数只给了函数一个名称,指定了函数里包含的参数,和代码块结构。
这个函数的基本结构完成以后,可以通过另一个函数调用执行,也可以直接从Python提示符执行。
python常用函数包有哪些?
一些python常用函数包:
1、Urllib3
Urllib3是一个 Python 的 HTTP 客户端,它拥有 Python 标准库中缺少的许多功能:
线程安全
连接池
客户端 SSL/TLS 验证
使用分段编码上传文件
用来重试请求和处理 HTTP 重定向的助手
支持 gzip 和 deflate 编码
HTTP 和 SOCKS 的代理支持
2、Six
six 是一个是 Python 2 和 3 的兼容性库。这个项目旨在支持可同时运行在 Python 2 和 3 上的代码库。它提供了许多可简化 Python 2 和 3 之间语法差异的函数。
3、botocore、boto3、s3transfer、awscli
Botocore是 AWS 的底层接口。Botocore是 Boto3 库(#22)的基础,后者让你可以使用 Amazon S3 和 Amazon EC2 一类的服务。Botocore 还是 AWS-CLI 的基础,后者为 AWS 提供统一的命令行界面。
S3transfer(#7)是用于管理 Amazon S3 传输的 Python 库。它正在积极开发中,其介绍页面不推荐人们现在使用,或者至少等版本固定下来再用,因为其 API 可能发生变化,在次要版本之间都可能更改。Boto3、AWS-CLI和其他许多项目都依赖s3transfer。
4、Pip
pip是“Pip Installs Packages”的首字母递归缩写。
pip很容易使用。要安装一个包只需pip install package name即可,而删除包只需pip uninstall package name即可。
最大优点之一是它可以获取包列表,通常以requirements.txt文件的形式获取。该文件能选择包含所需版本的详细规范。大多数 Python 项目都包含这样的文件。
如果结合使用pip与virtualenv(列表中的 #57),就可以创建可预测的隔离环境,同时不会干扰底层系统,反之亦然。
5、Python-dateutil
python-dateutil模块提供了对标准datetime模块的强大扩展。我的经验是,常规的Python datetime缺少哪些功能,python-dateutil就能补足那一块。
6、Requests
Requests建立在我们的 #1 库——urllib3基础上。它让 Web 请求变得非常简单。相比urllib3来说,很多人更喜欢这个包。而且使用它的最终用户可能也比urllib3更多。后者更偏底层,并且考虑到它对内部的控制级别,它一般是作为其他项目的依赖项。
7、Certifi
近年来,几乎所有网站都转向 SSL,你可以通过地址栏中的小锁符号来识别它。加了小锁意味着与该站点的通信是安全和加密的,能防止窃听行为。
8、Idna
根据其 PyPI 页面,idna提供了“对 RFC5891 中指定的应用程序中国际化域名(IDNA)协议的支持。”
IDNA的核心是两个函数:ToASCII和ToUnicode。ToASCII会将国际 Unicode 域转换为 ASCII 字符串。ToUnicode则逆转该过程。在IDNA包中,这些函数称为idna.encode()和idna.decode()
9、PyYAML
YAML是一种数据序列化格式。它的设计宗旨是让人类和计算机都能很容易地阅读代码——人类很容易读写它的内容,计算机也可以解析它。
PyYAML是 Python 的YAML解析器和发射器,这意味着它可以读写YAML。它会把任何 Python 对象写成YAML:列表、字典,甚至是类实例都包括在内。
10、Pyasn1
像上面的IDNA一样,这个项目也非常有用:
ASN.1 类型和 DER/BER/CER 编码(X.208)的纯 Python 实现
所幸这个已有数十年历史的标准有很多信息可用。ASN.1是 Abstract Syntax Notation One 的缩写,它就像是数据序列化的教父。它来自电信行业。也许你知道协议缓冲区或 Apache Thrift?这就是它们的 1984 年版本。
11、Docutils
Docutils是一个模块化系统,用来将纯文本文档处理为很多有用的格式,例如 HTML、XML 和 LaTeX 等。Docutils能读取reStructuredText格式的纯文本文档,这种格式是类似于 MarkDown 的易读标记语法。
12、Chardet
你可以用chardet模块来检测文件或数据流的字符集。比如说,需要分析大量随机文本时,这会很有用。但你也可以在处理远程下载的数据,但不知道用的是什么字符集时使用它。
13、RSA
rsa包是一个纯 Python 的 RSA 实现。它支持:
加密和解密
签名和验证签名
根据 PKCS#1 1.5 版生成密钥
它既可以用作 Python 库,也能在命令行中使用。
14、Jmespath
JMESPath,发音为“James path”,使 Python 中的 JSON 更容易使用。它允许你声明性地指定如何从 JSON 文档中提取元素。
15、Setuptools
它是用于创建 Python 包的工具。不过,其文档很糟糕。它没有清晰描述它的用途,并且文档中包含无效链接。最好的信息源是这个站点,特别是这个创建 Python 包的指南。
16、Pytz
像dateutils一样,这个库可帮助你处理日期和时间。有时候,时区处理起来可能很麻烦。幸好有这样的包,可以让事情变得简单些。
17、Futures
从 Python 3.2 开始,python 提供current.futures模块,可帮助你实现异步执行。futures 包是该库适用于 Python 2 的 backport。它不适用于 Python3 用户,因为 Python 3 原生提供了该模块。
18、Colorama
使用 Colorama,你可以为终端添加一些颜色:
更多Python知识请关注Python自学网
Python常用的正则表达式处理函数详解
正则表达式是一个特殊的字符序列,用于简洁表达一组字符串特征,检查一个字符串是否与某种模式匹配,使用起来十分方便。
在Python中,我们通过调用re库来使用re模块:
import re
下面介绍Python常用的正则表达式处理函数。
re.match函数
re.match 函数从字符串的起始位置匹配正则表达式,返回match对象,如果不是起始位置匹配成功的话,match()就返回None。
re.match(pattern, string, flags=0)
pattern:匹配的正则表达式。
string:待匹配的字符串。
flags:标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。具体参数为:
re.I:忽略大小写。
re.L:表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境。
re.M:多行模式。
re.S:即 . ,并且包括换行符在内的任意字符(. 不包括换行符)。
re.U:表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库。
re.X:为了增加可读性,忽略空格和 # 后面的注释。
import re #从起始位置匹配 r1=re.match('abc','abcdefghi') print(r1) #不从起始位置匹配 r2=re.match('def','abcdefghi') print(r2)
运行结果:
其中,span表示匹配成功的整个子串的索引。
使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
group(num):匹配的整个表达式的字符串,group() 可以一次输入多个组号,这时它将返回一个包含那些组所对应值的元组。
groups():返回一个包含所有小组字符串的元组,从 1 到 所含的小组号。
import re s='This is a demo' r1=re.match(r'(.*) is (.*)',s) r2=re.match(r'(.*) is (.*?)',s) print(r1.group()) print(r1.group(1)) print(r1.group(2)) print(r1.groups()) print() print(r2.group()) print(r2.group(1)) print(r2.group(2)) print(r2.groups())
运行结果:
上述代码中的(.*)和(.*?)表示正则表达式的贪婪匹配与非贪婪匹配。
re.search函数
re.search函数扫描整个字符串并返回第一个成功的匹配,如果匹配成功则返回match对象,否则返回None。
re.search(pattern, string, flags=0)
pattern:匹配的正则表达式。
string:待匹配的字符串。
flags:标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。
import re #从起始位置匹配 r1=re.search('abc','abcdefghi') print(r1) #不从起始位置匹配 r2=re.search('def','abcdefghi') print(r2)
运行结果:
使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
group(num=0):匹配的整个表达式的字符串,group() 可以一次输入多个组号,这时它将返回一个包含那些组所对应值的元组。
groups():返回一个包含所有小组字符串的元组,从 1 到 所含的小组号。
import re s='This is a demo' r1=re.search(r'(.*) is (.*)',s) r2=re.search(r'(.*) is (.*?)',s) print(r1.group()) print(r1.group(1)) print(r1.group(2)) print(r1.groups()) print() print(r2.group()) print(r2.group(1)) print(r2.group(2)) print(r2.groups())
运行结果:
从上面不难发现re.match与re.search的区别:re.match只匹配字符串的起始位置,只要起始位置不符合正则表达式就匹配失败,而re.search是匹配整个字符串,直到找到一个匹配为止。
re.compile 函数
compile 函数用于编译正则表达式,生成一个正则表达式对象,供 match() 和 search() 这两个函数使用。
re.compile(pattern[, flags])
pattern:一个字符串形式的正则表达式。
flags:可选,表示匹配模式,比如忽略大小写,多行模式等。
import re #匹配数字 r=re.compile(r'\d+') r1=r.match('This is a demo') r2=r.match('This is 111 and That is 222',0,27) r3=r.match('This is 111 and That is 222',8,27) print(r1) print(r2) print(r3)
运行结果:
findall函数
搜索字符串,以列表形式返回正则表达式匹配的所有子串,如果没有找到匹配的,则返回空列表。
需要注意的是,match 和 search 是匹配一次,而findall 匹配所有。
findall(string[, pos[, endpos]])
string:待匹配的字符串。
pos:可选参数,指定字符串的起始位置,默认为0。
endpos:可选参数,指定字符串的结束位置,默认为字符串的长度。
import re #匹配数字 r=re.compile(r'\d+') r1=r.findall('This is a demo') r2=r.findall('This is 111 and That is 222',0,11) r3=r.findall('This is 111 and That is 222',0,27) print(r1) print(r2) print(r3)
运行结果:
re.finditer函数
和 findall 类似,在字符串中找到正则表达式所匹配的所有子串,并把它们作为一个迭代器返回。
re.finditer(pattern, string, flags=0)
pattern:匹配的正则表达式。
string:待匹配的字符串。
flags:标志位,用于控制正则表达式的匹配方式,如是否区分大小写,多行匹配等。
import re r=re.finditer(r'\d+','This is 111 and That is 222') for i in r: print (i.group())
运行结果:
re.split函数
将一个字符串按照正则表达式匹配的子串进行分割后,以列表形式返回。
re.split(pattern, string[, maxsplit=0, flags=0])
pattern:匹配的正则表达式。
string:待匹配的字符串。
maxsplit:分割次数,maxsplit=1分割一次,默认为0,不限次数。
flags:标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等。
import re r1=re.split('\W+','This is 111 and That is 222') r2=re.split('\W+','This is 111 and That is 222',maxsplit=1) r3=re.split('\d+','This is 111 and That is 222') r4=re.split('\d+','This is 111 and That is 222',maxsplit=1) print(r1) print(r2) print(r3) print(r4)
运行结果:
re.sub函数
re.sub函数用于替换字符串中的匹配项。
re.sub(pattern, repl, string, count=0, flags=0)
pattern:正则中的模式字符串。
repl:替换的字符串,也可为一个函数。
string:要被查找替换的原始字符串。
count:模式匹配后替换的最大次数,默认0表示替换所有的匹配。
import re r='This is 111 and That is 222' # 删除字符串中的数字 r1=re.sub(r'\d+','',r) print(r1) # 删除非数字的字符串 r2=re.sub(r'\D','',r) print(r2)
运行结果:
到此这篇关于Python常用的正则表达式处理函数详解的文章就介绍到这了,希望大家以后多多支持!
本文题目:python函数专题 python函数概念
分享路径:http://ybzwz.com/article/hppodi.html