python通用函数 python中常用的函数

python有多少内置函数

Python内置函数有很多，为大家推荐5个神仙级的内置函数：

站在用户的角度思考问题，与客户深入沟通，找到水磨沟网站设计与水磨沟网站推广的解决方案，凭借多年的经验，让设计与互联网技术结合，创造个性化、用户体验好的作品，建站类型包括：成都网站建设、成都网站设计、企业官网、英文网站、手机端网站、网站推广、域名注册、虚拟空间、企业邮箱。业务覆盖水磨沟地区。

(1)Lambda函数

用于创建匿名函数，即没有名称的函数。它只是一个表达式，函数体比def简单很多。当我们需要创建一个函数来执行单个操作并且可以在一行中编写时，就可以用到匿名函数了。

Lamdba的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

利用Lamdba函数，往往可以将代码简化许多。

(2)Map函数

会将一个函数映射到一个输入列表的所有元素上，比如我们先创建了一个函数来返回一个大写的输入单词，然后将此函数应有到列表colors中的所有元素。

我们还可以使用匿名函数lamdba来配合map函数，这样可以更加精简。

(3)Reduce函数

当需要对一个列表进行一些计算并返回结果时，reduce()是个非常有用的函数。举个例子，当需要计算一个整数列表所有元素的乘积时，即可使用reduce函数实现。

它与函数的最大的区别就是，reduce()里的映射函数(function)接收两个参数，而map接收一个参数。

(4)enumerate函数

用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中。

它的两个参数，一个是序列、迭代器或其他支持迭代对象;另一个是下标起始位置，默认情况从0开始，也可以自定义计数器的起始编号。

(5)Zip函数

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表

当我们使用zip()函数时，如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

python中函数的作用

Python 函数定义以及参数传递

1.函数定义

#形如def func(args...):

doSomething123

以关键字def 开头，后面是函数名和参数下面是函数处理过程。

举例：

def add( a, b ):

return a+b12

参数可以设定默认值，如：

def add( a, b=10 ): #注意：默认值参数只会运算一次

return a+b12

默认值参数只会运算一次是什么意思？

def func( a, b=[] ): #b的默认值指向一个空的列表，每次不带默认值都会指向这块内存

b.append(a) return b

print(func(1))#向默认的空列表里加入元素1 ，默认列表里已经是[1]print(func(2))#向默认的列表里加入元素2,默认列表里已经是[1,2]print(func(3,[]))#向b指向的空列表里加入元素1 ，默认列表里还是[1,2]print(func(4))#向默认的列表里加入元素4,默认列表里已经是[1,2,4]'''

结果：

[1]

[1, 2]

[3]

[1, 2, 4]

'''12345678910111213141516

这下明白为什么默认参数只计算一次了吧，函数参数不传递时默认值总是指向固定的内存空间，就是第一次计算的空间。

2.参数传递

def func(a, b):

print('a=%d, b=%d' % (a,b) )12

在使用函数时可以如下方式,结果都是相同的

func(10,20) #不使用参数名，需要按参数顺序传递func(a=10,b=20) #使用参数名可以不按顺序传递func(b=20,a=10)#结果：a=10, b=20a=10, b=20a=10, b=201234567

如果函数定义形式如下方式：

def func(*args): #这种定义会把传递的参数包成元组

print(args,type(args))

func(10,20)#结果：#(10, 20) class 'tuple'1234567

举一个和上述过程相反的例子：

def func(a,b):

print('a=%d, b=%d' % (a,b) )

a = (10, 20)

func(*a) #在调用函数使用`*`则会把元组解包成单个变量按顺序传入函数#结果：a=10, b=20123456

总结：*号在定义函数参数时，传入函数的参数会转换成元组，如果 *号在调用时则会把元组解包成单个元素。

另一种定义：

def func(**kw):#使用**定义参数会把传入参数包装成字典dict

print(kw, type(kw) )

func(a=10,b=20)#这种函数在使用时必须指定参数值，使用key=value这种形式#结果：{'b': 20, 'a': 10} class 'dict'12345

相反的例子：

def func(a,b):

print('a=%d, b=%d' % (a,b) )

d = {'a':10, 'b':20 }

func(**d) #在调用时使用**会把字典解包成变量传入函数。12345

def func(*args, **kw):#这种形式的定义代表可以接受任意类型的参数

print(args,kw )12

总结：**号在定义函数参数时，传入函数的参数会转换成字典，如果 **号在调用时则会把字典解包成单个元素。

lambda表达式

lambda表达式就是一种简单的函数

形如 f = lambda 参数1，参数2： 返回的计算值

例如：

add = lambda x,y: x+y

print(add(1,2))'''

结果：3

'''12345

Python基础入门-函数的定义与使用

通过关键字def来创建函数，def的作用是实现python中函数的创建

函数定义过程：

函数名+()小括号执行函数

函数体内对全局变量只能读取，不能修改

局部变量，无法在函数体外使用

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

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 8个常用内置函数解说

8个超好用内置函数set（），eval（），sorted（），reversed（），map（），reduce（），filter（），enumerate（）

python中有许多内置函数，不像print那么广为人知，但它们却异常的强大，用好了可以大大提高代码效率。

这次来梳理下8个好用的python内置函数

1、set()

当需要对一个列表进行去重操作的时候，set()函数就派上用场了。

用于创建一个集合，集合里的元素是无序且不重复的。集合对象创建后，还能使用并集、交集、差集功能。

2、eval()之前有人问如何用python写一个四则运算器，输入字符串公式，直接产生结果。用eval()来做就很简单：eval(str_expression)作用是将字符串转换成表达式，并且执行。

3、sorted()在处理数据过程中，我们经常会用到排序操作，比如将列表、字典、元组里面的元素正/倒排序。这时候就需要用到sorted() ，它可以对任何可迭代对象进行排序，并返回列表。对列表升序操作：

对元组倒序操作：

使用参数：key，根据自定义规则，按字符串长度来排序：

根据自定义规则，对元组构成的列表进行排序：

4、reversed()如果需要对序列的元素进行反转操作，reversed()函数能帮到你。reversed()接受一个序列，将序列里的元素反转，并最终返回迭代器。

5、map()做文本处理的时候，假如要对序列里的每个单词进行大写转化操作。这个时候就可以使用map()函数。

map()会根据提供的函数，对指定的序列做映射，最终返回迭代器。也就是说map()函数会把序列里的每一个元素用指定的方法加工一遍，最终返回给你加工好的序列。举个例子，对列表里的每个数字作平方处理：

6、reduce()前面说到对列表里的每个数字作平方处理，用map()函数。那我想将列表里的每个元素相乘，该怎么做呢？这时候用到reduce()函数。

reduce()会对参数序列中元素进行累积。第一、第二个元素先进行函数操作，生成的结果再和第三个元素进行函数操作，以此类推，最终生成所有元素累积运算的结果。再举个例子，将字母连接成字符串。

你可能已经注意到，reduce()函数在python3里已经不再是内置函数，而是迁移到了functools模块中。这里把reduce()函数拎出来讲，是因为它太重要了。

7、filter()一些数字组成的列表，要把其中偶数去掉，该怎么做呢？

filter()函数轻松完成了任务，它用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象。filter()函数和map()、reduce()函数类似，都是将序列里的每个元素映射到函数，最终返回结果。我们再试试，如何从许多单词里挑出包含字母w的单词。

8、enumerate()这样一个场景，同时打印出序列里每一个元素和它对应的顺序号，我们用enumerate()函数做做看。

enumerate翻译过来是枚举、列举的意思，所以说enumerate()函数用于对序列里的元素进行顺序标注，返回(元素、索引)组成的迭代器。再举个例子说明，对字符串进行标注，返回每个字母和其索引。

python 通用的方法 都有哪些

一些常用的方法

1. 逆转字符串的三种方法

1.1. 模拟C++中方法， 定义一个空字符串来实现

通过设置一个空字符串， 然后讲参数中的字符串从后往前遍历， 使用字符串的加法合并为新的字符串

复制代码 代码如下:

def reverse(text) :

str = ''

index = len(text) - 1

while index = 0 :

str += text[index]

index -= 1

return str

1.2. 使用切片法

这个是Python中的一个特性， 切片可以取负值，这是采用切片的方法，设置步长为-1，这样就实现了反过来排序。

复制代码 代码如下:

def reverse_1(text) :

return text[::-1]

1.3. 使用列表

采用列表的reverse方法，先将text转换为列表，然后通过reverse方法反转，然后在通过join连接为字符串。

复制代码 代码如下:

def reverse_2(text) :

temp = list(text)

temp.reverse()

return ''.join(temp)

2. 使用reduce

使用匿名函数和reduce()

复制代码 代码如下:

def reverse_3(text) :

return reduce(lambda x, y : y + x, text)

print reverse_3("Hello")

3. 遍历字典的四种方法

复制代码 代码如下:

dict={"a":"apple","b":"banana","o":"orange"}

print "##########dict######################"

for i in dict:

print "dict[%s]=" % i,dict[i]

print "###########items#####################"

for (k,v) in dict.items():

print "dict[%s]=" % k,v

print "###########iteritems#################"

for k,v in dict.iteritems():

print "dict[%s]=" % k,v

print "###########iterkeys,itervalues#######"

for k,v in zip(dict.iterkeys(),dict.itervalues()):

print "dict[%s]=" % k,v

4. 遍历list的三种方法

复制代码 代码如下:

for key in lst :

print key

for i in range(len(lst)) :

print lst[i]

for index, key in enumerate(lst) :

print key //index是list的索引

5. 字典排序的方法

字典按照value的值从大到小的顺序来排序(默认从小到排序)。

复制代码 代码如下:

dic = {'a':31, 'bc':5, 'c':3, 'asd':4, 'aa':74, 'd':0}

dict= sorted(dic.iteritems(), key=lambda d:d[1], reverse = True)

print dict

//输出的结果：

[('aa', 74), ('a', 31), ('bc', 5), ('asd', 4), ('c', 3), ('d', 0)]

下面我们分解下代码

print dic.iteritems() 得到[(键，值)]的列表。

然后用sorted方法，通过key这个参数，指定排序是按照value，也就是第一个元素d[1的值来排序。reverse = True表示是需要翻转的，默认是从小到大，翻转的话，那就是从大到小。

对字典按键（key）排序：

复制代码 代码如下:

dic = {'a':31, 'bc':5, 'c':3, 'asd':4, 'aa':74, 'd':0}

dict= sorted(dic.iteritems(), key=lambda d:d[0]) # d[0]表示字典的键

print dict

#sorted中第三个可选参数为reverse, True表示从大到小排序

#默认reverse = False

6. 子类和父类

子类构造函数调用父类的初始化构造函数

复制代码 代码如下:

class A(object) :

def __init__(self) :

print "testA

class B(A) :

def __init__(self) :

A.__init__(self)

子类调用父类的同名函数

复制代码 代码如下:

super().fuleifunction()

7. 更灵活的参数传递方式

复制代码 代码如下:

func2(a=1, b=2, c=3) #默认参数

func3(*args) #接受任意数量的参数, 以tuple的方式传入

func4(**kargs) #把参数以键值对字典的形式传入

在变量前加上星号前缀（*），调用时的参数会存储在一个 tuple（）对象中，赋值给形参。在函数内部，需要对参数进行处理时，只要对这个

tuple 类型的形参（这里是 args）进行操作就可以了。因此，函数在定义时并不需要指明参数个数，就可以处理任意参数个数的情况。

复制代码 代码如下:

def calcSum(*args):

sum = 0

for i in args:

sum += i

print sum

#调用：

calcSum(1,2,3)

calcSum(123,456)

calcSum()

#输出：

6

579

#################################

def printAll(**kargs):

for k in kargs:

print k, ':', kargs[k]

printAll(a=1, b=2, c=3)

printAll(x=4, y=5)

#输出：

a : 1

c : 3

b : 2

y : 5

x : 4

python的中参数可以多种形式进行组合, 在混合使用时，首先要注意函数的写法，必须遵守:

1.带有默认值的形参(arg=)须在无默认值的形参(arg)之后

2.元组参数(*args)须在带有默认值的形参(arg=)之后

3.字典参数(**kargs)须在元组参数(*args)之后

在函数被调用时，参数的传递过程为：

1.按顺序把无指定参数的实参赋值给形参

2.把指定参数名称(arg=v)的实参赋值给对应的形参

3.将多余的无指定参数的实参打包成一个 tuple 传递给元组参数(*args)

4.将多余的指定参数名的实参打包成一个 dict 传递给字典参数(**kargs)

8. lambda 表达式

lambda 表达式可以看做一种匿名函数

lambda 表达式的语法格式：

lambda 参数列表: 表达式 #参数列表周围没有括号，返回值前没有 return 关键字，也没有函数名称

复制代码 代码如下:

def fn(x):

return lambda y: x + y

#调用

a = fn(2)

print a(3)

#输出

5

分析

: fn(2)调用后, 相当于a = lambda y: 2 + y, 然后a(3)被调用时.

相当于 print lambda y: 2 + 3

本文题目：python通用函数 python中常用的函数
浏览地址：http://6mz.cn/article/hhoihs.html