python常见函数

1. `sort()`函数

描述：用于对原列表进行排序
语法：list.sort(key=None, reverse=False)

key 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse 排序规则，reverse=True降序，reverse=False升序（默认）

实例1：

data = ['b', 'd', 'a', 'hello', 'world']
data.sort()
print(data)

结果：

['a', 'b', 'd', 'hello', 'world']

实例2：

vowels = ['e', 'a', 'u', 'o', 'i']
vowels.sort(reverse=True)
print(vowels)

结果：

['u', 'o', 'i', 'e', 'a']

2. `id()`函数

描述：id() 函数返回对象的唯一标识符，标识符是一个整数。CPython 中 id() 函数用于获取对象的内存地址。

注意，是对象的唯一标识符

实例1：

print(id([3, 5, 8]))
print(id([1, 2, 3]))

输出：

2249368239936
2249368239936

实例2：

print(id('abc'))
print(id('bcd'))

输出：

1917415451376
1917419924272

实例3：

print(id({1, 2, 3}))
print(id({4, 5, 6}))

输出：

2096771123008
2096771123008

说明：对象一致，则id(object)一致，如列表、集合，不管里面内容是什么，id(object)一致

3. 可变参数`*args`和`**kwargs`

描述：参数*args在前，**kwargs在后，二者结合起来可以传入任意参数。

*args参数：可接受任意个位置参数，当函数调用时，所有未使用（未匹配）的位置参数会在函数内自动组装进一个tuple对象中，此tuple对象会赋值给变量名args。
**kwargs参数：可接受任意个关键字参数，当函数调用时，所有未使用（未匹配）的关键字参数会在函数内组装进一个dict对象中，此dict对象会赋值给变量名kwargs。

为什么使用*args和**kwargs可以接受任意参数？

a）定义函数

*参数收集所有未匹配的位置参数组成一个tuple对象，局部变量args指向此tuple对象
**参数收集所有未匹配的关键字参数组成一个dict对象，局部变量kwargs指向此dict对象

b) 调用函数

*参数用于解包tuple对象的每个元素，作为一个一个的位置参数传入到函数中
**参数用于解包dict对象的每个元素，作为一个一个的关键字参数传入到函数中

实例1：装饰器，定义内函数的时候，为了使其可以接受任意参数，给他传了参数*args和 **kwargs

# 通用装饰器
def wrapper(func):
    def inner(*args, **kwargs):
        pass

    return inner  # 闭包，外部函数返回值是内部函数

实例2：只有*args

def func(*args):
    """
    *参数收集所有未匹配的位置参数组成一个tuple对象，局部变量args指向此tuple对象
    """
    print('args类型：', type(args))
    print('args=', args)


func(1, 2, 3, 4) #调用函数1
tuple = (1, 2, 3, 4) # 调用函数2
func(*tuple)

结果输出：

args类型： <class 'tuple'>
args= (1, 2, 3, 4)
args类型： <class 'tuple'>
args= (1, 2, 3, 4)

结果分析：调用函数1，传入参数1, 2, 3, 4,没有匹配到位置参数，被装入到一个元组中，参数args指向这个元组对象；调用函数2，使用解包的方式，*tuple会将元组对象解包成一个一个位置参数传入到函数中

实例3：只有**kwargs

def func(**kwargs):
    """
    *参数收集所有未匹配的位置参数组成一个tuple对象，局部变量args指向此tuple对象
    """
    print('kwargs类型：', type(kwargs))
    print('kwargs=', kwargs)


func(a=1, b=2) #调用函数1
dic = {'a': 1, 'b': 2}# 调用函数2
func(**dic)

结果输出：

kwargs类型： <class 'dict'>
kwargs= {'a': 1, 'b': 2}
kwargs类型： <class 'dict'>
kwargs= {'a': 1, 'b': 2}

结果分析：调用函数1传入参数，没有匹配到关键字参数，被装入一个字典dic中，参数kwargs指向这个dic对象；调用函数2使用解包的方式，**dic会将字典对象解包成一个一个关键字参数传入到函数中。

实例4：包含*args和**kwargs

def func(argument, *args, **kwargs):
    print('argument = ', argument)
    print('argument = ', argument)
    print('args类型：', type(args))
    print('args = ', args)
    print('kwargs类型：', type(kwargs))
    print('kwargs = ', kwargs)


func(1, 2, 3, 4, a=1, b=2) #调用函数1
tuple = (1, 2, 3, 4)
dic = {'a': 1, 'b': 2}# 调用函数2
func(*tuple, **dic)

结果输出：

argument =  1
argument =  1
args类型： <class 'tuple'>
args =  (2, 3, 4)
kwargs类型： <class 'dict'>
kwargs =  {'a': 1, 'b': 2}
argument =  1
argument =  1
args类型： <class 'tuple'>
args =  (2, 3, 4)
kwargs类型： <class 'dict'>
kwargs =  {'a': 1, 'b': 2}

结果分析：调用函数1 传入参数，其中参数1传给未知参数argument，参数2,3,4没有匹配到位置参数，被传入到一个元组中，参数args指向这个元组对象，参数a=1，b=2没有匹配到对应的关键字参数，被装入到一个字典中，参数kwargs指向这个dic对象；
调用函数2 使用解包方式，*tuple会将元组对象解包成一个一个位置参数传入到函数中，**dic会将字典对象解包成一个一个关键字参数传入到函数中。

4. `@`的用法--装饰器

@是一个装饰器，针对函数，起调用传参的作用。有修饰和被修饰的区别，@function作为一个装饰器，用来修饰紧跟着的函数（可以是另一个装饰器，也可以是函数定义）

实例1：

def funA(desA):
    print("It's funA")


def funB(desB):
    print("It's funB")


@funA
def funC():
    print("It's funC")

结果：

It's funA

分析：@funA修饰函数定义 def funC()，将funC()赋值给funA()的形参。执行的时候由上而下，先定义funA、funB，然后运行funA(funC())。此时desA=funC(),然后funA()输出‘It's funA’

实例2：

def funA(desA):
 print("It's funA")
 
def funB(desB):
 print("It's funB")
 
@funB
@funA
def funC():
 print("It's funC")

结果输出：

It's funA
It's funB

分析：@funB修饰装饰器@funA，@funA修饰函数定义def funC()，将funC()赋值给funA()的形参，再将funA(funC())赋值给funB()。执行的时候由上而下，先定义funA、funB，然后运行funB(funA(funC()))。此时desA=funC()，然后funA()输出It's funA，desB = funA(funC())，然后funB()输出It's funB

实例3：

def funA(desA):
    print("It's funA")
    print('---')
    print(desA)
    desA()
    print('---')

def funB(desB):
    print("It's funB")

@funB
@funA
def funC():
    print("It's funC")

结果输出：

It's funA
---
<function funC at 0x000001C5B7D6C700>
It's funC
---
It's funB

分析：@funB修饰装饰器@funA，@funA修饰函数定义def funC()，将funC()赋值给funA()，再将funA(funC())赋值给funB()，由上而下执行，输出It's funA和---，
后面注意 print(desA)则是打印funC()的地址，即desA为函数desA()。
执行desA()即执行funC(),因为desB = funA(funC())，总是输出funB(desB)，因而输出It's funB

实例4：

def funA(desA):
 print("It's funA")
 
def funB(desB):
 print("It's funB")
 print('---')
 print(desB)
 
@funB
@funA
def funC():
 print("It's funC")

结果输出：

It's funA
It's funB
---
None

分析：@funB修饰装饰器@funA，@funA修饰函数定义def funC()，将funC()赋值给funA()，再将funA(funC())赋值给funB()，由上而下执行，先执行funA(funC())
得到结果是It's funA，再执行funB(funA(funC())),得到结果It's funB --- None，注意最后输出None，原因是‘装饰器’ 修饰 ‘装饰器’时，仅是调用函数

5. 装饰器(1)

def outer(f):
    def inner(*arg, **kargs):
        inner.co += 1
        return f(*arg, **kargs)
    inner.co = 0
    return inner

@outer
def cu():
    pass

if __name__ == '__main__':
    cu()
    cu()
    cu()
    print(cu.co)

结果输出：3

return inner不等于return inner()，返回的是函数名，因此cu已经被inner替代了，最终cu.co=inner.co，万物皆对象，函数也是一个对象，因此函数这个对象本身可以访问属性，而且赋值时可以增加一个属性

6. 装饰器(2)

def A(func):
    def inner():
        inner.i += 1
        print("i加1,i={0}".format(inner.i))

    inner.i = 0
    print("i赋值")
    return inner


@A
def B():
    pass


@A
def C():
    pass
B()
B()
B()
C()
C()
print(id(B), id(B.i))
print(id(C), id(C.i))

结果输出：

i赋值  # 第一个装饰器@A的时候输出
i赋值  # 第二个装饰器@A的时候输出
i加1,i=1 # 执行B()
i加1,i=2 # 执行B()
i加1,i=3 # 执行B()
i加1,i=1 # 执行C()
i加1,i=2 # 执行C()
2552387175472 2551889160560 # 执行print(id(B), id(B.i))
2552387175616 2551889160528 # 执行print(id(C), id(C.i))

7. 装饰器(3)

计算2-10000的所有质数

import time
def is_prime(num):
    if num < 2:
        return False
    elif num == 2:
        return True
    else:
        for i in range(2, num):
            if num % i == 0:
                return False
        return True


def prime_num():
    t1 = time.time()
    for i in range(2, 10000):
        if is_prime(i):
            print(i)
    t2 = time.time()
    print(t2 - t1)


prime_num()

结果输出：

...
9931
9941
9949
9967
9973
0.27100205421447754

使用装饰器进行改进

def display_time(func): # 参数为函数
    def wrapper():
        t1 = time.time()
        func()
        t2 = time.time()
        print(t2 - t1)
    return wrapper


def is_prime(num):
    if num < 2:
        return False
    elif num == 2:
        return True
    else:
        for i in range(2, num):
            if num % i == 0:
                return False
        return True

@display_time # 使用装饰器
def prime_num():
    for i in range(2, 10000):
        if is_prime(i):
            print(i)

prime_num()

结果：

...
9931
9941
9949
9967
9973
0.2570345401763916

可以看到和上面的结果一致

如果使用装饰器有返回值

import time
def display_time(func):
    def wrapper(*args):
        t1 = time.time()
        result = func(*args)
        t2 = time.time()
        print("Total time: {:.4} s".format(t2 - t1)) # 保留4位小数
        return result
    return wrapper


def is_prime(num):
    if num < 2:
        return False
    elif num == 2:
        return True
    else:
        for i in range(2, num):
            if num % i == 0:
                return False
        return True

@display_time
def count_prime_num(maxnum):
    count = 0
    for i in range(2, maxnum):
        if is_prime(i):
            count = count + 1
    return count


count = count_prime_num(10000)
print(count)

结果输出：

Total time: 0.252 s
1229

8. 多层装饰器(1)

def dec_a(function): # 7. function就是inner_func
    print("aaa")    # 8. 打印“aaa”
    def inner_func(): # 9. 定义了inner_func
        print("bbb")  # 10. 打印“bbb”
        function()
    return inner_func

def dec_b(function): # 2. function是testMulDecorator运行function函数
    print("ccc")     # 3. 打印“ccc” dec_b函数定义不用看代码函数体代码，所以下一步return
    def inner_func():
        function()   # 11.执行testMulDecorator
        print("ddd") # 13. 打印 “ddd”
    return inner_func # 4. testMulDecorator返回值是inner_func，inner_func成了函数名，再次触发dec_a

@dec_a # 6. inner_func会传到dec_a里运行
@dec_b # 1. testMulDecorator传给dec_b，所以dec_b(index)括号优先级执行  5. inner_func = dec_b（testMulDecorator）
def testMulDecorator():
    print("wegwrtegw") # 12. 打印wegwrtegw

testMulDecorator()

结果输出：

ccc
aaa
bbb
wegwrtegw
ddd

9. 多层装饰器(2)

def A(func):
    def _A():
        print("A now")
        func()
    return _A

def B(func):
    def _B():
        func()
        print("B now")
    return _B

@A
@B
def test1():
    print("do something")

test1()

结果输出：

A now
do something
B now

10. re.match和re.search

a) re.match() 从开始位置开始往后查找，返回第一个符合规则的对象,如果开始位置不符合匹配队形则返回None

def match(pattern, string, flags=0)
    '''Try to apply the pattern at the start of the string, returning
    a Match object, or None if no match was found. '''
    return _compile(pattern, flags).match(string)

里面有3个参数

pattern : 匹配的规则内容
string ：要匹配的字符串
flags ：标志位（可选参数），用于控制正则表达式的匹配方式，如是否区分大小写，多行匹配等
实例1：

import re

result_sum = 0
pattern = 'back'
print(re.match(pattern, 'back.txt'))

结果输出：

<re.Match object; span=(0, 4), match='back'>

说明 span范围，左闭右开，match为匹配的内容

实例2：

import re

result_sum = 0
pattern = 'back'
print(re.match(pattern, 'cack.txt'))

结果输出：

None #说明没匹配上

实例3：

import re

result_sum = 0
pattern = 'back'
print(re.match(pattern, 'back.txt').span())

结果输出：

(0, 4) #输出匹配内容的范围，左闭右开

实例4：group的使用

import re

result_sum = 0
pattern = 'back'
print(re.match(pattern, 'back.txt').group())

结果输出：

back # 直接得到匹配的内容， ==注意== 如果匹配上内容，可以使用`group`，如果匹配不上使用`group`则会报错

实例5：

import re
line = "Cats are smarter than dogs"
matchObj = re.match(r'(.*) are (.*?) .*', line, re.M | re.I)
if matchObj:
    print("matchObj.group() : ", matchObj.group())
    print("matchObj.group(1) : ", matchObj.group(1))
    print("matchObj.group(2) : ", matchObj.group(2))
else:
    print("No match!!")

结果输出：

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

实例6： flag的使用

import re

result_sum = 0
pattern = 'back'
print(re.match(pattern, 'Back.txt', re.I).group()) # 忽略大小写

结果输出：

Back  # 返回匹配内容

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 为了增加可读性，忽略空格和#后面的注释

实例7：

import re
sentence = 'we are humans'
matched = re.match(r'(.*)(.*)(.*)', sentence)
print(matched)
print(matched.group())
print(type(matched.group()))

结果输出：

<re.Match object; span=(0, 13), match='we are humans'>
we are humans
<class 'str'>

b) re.search 会在字符串内查找模式匹配,只到找到第一个匹配然后返回，如果字符串没有匹配，则返回None

def search(pattern, string, flags=0)
    '''Scan through string looking for a match to the pattern, returning
    a Match object, or None if no match was found.'''
    return _compile(pattern, flags).search(string)

里面有3个参数

pattern : 匹配的规则内容
string ：要匹配的字符串
flags ：标志位（可选参数），用于控制正则表达式的匹配方式，如是否区分大小写，多行匹配等

实例1：

import re
text = 'Tab.com is a good Python website'
m = re.search(r'Python', text)
print(m)

结果输出：

<re.Match object; span=(18, 24), match='Python'>  # 18是第一个匹配上的字符坐标，24是最后一位的坐标，采用左闭右开的方式

实例2：

import re
text = 'PythonTab.com is a good Python website'
m = re.search(r'Python', text)
print(m)

结果输出：

<re.Match object; span=(0, 6), match='Python'>

实例3：

import re

content = "abcabcabc"
rex = re.search("c", content)
print(rex)

结果输出：

<re.Match object; span=(2, 3), match='c'>

实例4：

import re

content = "abcabcabc"
rex = re.search("c", content)
print(rex.group())

结果输出：

c     #获取匹配的内容，使用group(匹配的整个表达式的字符串)

实例5：

import re

content = "abcabcabc"
rex = re.search("c", content)
print(rex.span())

结果输出：

(2, 3)  # 获取匹配的下标可以使用span

c) search结合compile使用
实例1：

import re

content = "abc123abc"
rex_content = re.compile("\d+")  # 编译正则表达式
rex = rex_content.search(content)
print(rex.group())

结果输出：

实例2：

import re

content = "abc123def"
rex_compile = re.compile("([a-z]*)([0-9]*)([a-z]*)")
rex = rex_compile.search(content)
print(rex)
print(rex.group())
print(rex.group(0))  # group()和group(0) 一样匹配的是整体
print(rex.group(1))  # 匹配第一个小括号的内容
print(rex.group(2))  # 匹配第二个小括号的内容
print(rex.group(3))  # 匹配第三个小括号的内容

结果输出：

<re.Match object; span=(0, 9), match='abc123def'>
abc123def
abc123def
abc
123
def

d) re.sub的函数原型re.sub(pattern, repl, string, count) 替换字符串中的匹配项
实例1：

import re
text = "osc ring efuse info"
print (re.sub(r'\s+', '_', text))

结果输出：

osc_ring_efuse_info  # 将空格替换为下划线

实例2：

import re
text = "am_ring_osc_clk_out_ee[0]       :1859     KHz"
print (re.sub(r'\s+', '', text)) # 将空格去掉

结果输出：

am_ring_osc_clk_out_ee[0]:1859KHz

总结：

re.match(pattern, string, flag=0) 从第一个字符开始比较
re.search(pattern, string, flag=0) 在字符串中查找，第一个字符可以不满足，等同于在re.match的正则表达式前增加^.*?，匹配任意的开头
re.sub(pattern, repl, string, count) 用于替换字符串中的匹配项

11. 正则表达式模式

模式	描述
`^`	匹配字符串的开头
`$`	匹配字符串的末尾
`.`	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
`*`	代表匹配0次或者多次
`?`	惰性匹配，非贪婪性匹配，尽可能少的匹配
`[...]`	用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
`[^...]`	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
`\w`	匹配字母数字及下划线
`\W`	匹配非字母数字及下划线
`\s`	匹配任意空白字符，等价于 [ \t\n\r\f]
`\S`	匹配任意非空字符
`\d`	匹配任意数字，等价于 [0-9].
`\D`	匹配任意非数字
`\A`	匹配字符串开始
`\Z`	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
`re*`	匹配0个或多个的表达式
`re+`	匹配1个或多个的表达式。
`re?`	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
`re{ n}`	精确匹配 n 个前面表达式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的两个 o。
`re{ n,}`	匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。
`re{ n, m}`	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
`a\|b`	匹配a或b
`(?imx)`	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
`(?-imx)`	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
`(?: re)`	类似 (...), 但是不表示一个组
`(?imx: re)`	在括号中使用i, m, 或 x 可选标志
`(?-imx: re)`	在括号中不使用i, m, 或 x 可选标志

实例1:

import re
nStr = '123'
p = re.compile('^\d+$', re.S) # `\d`匹配任意数字，`+`匹配1个或多个的表达式
print(p.match(nStr))

结果输出：

<re.Match object; span=(0, 3), match='123'>

实例2：

import re
nStr = 'hello world'
p = re.compile('\s+')
print(p.search(nStr))

结果输出：

<re.Match object; span=(5, 6), match=' '>

实例2：

import re
nStr = ' hello world'
p = re.compile('\s+')
print(p.match(nStr))

结果输出：

<re.Match object; span=(0, 1), match=' '>

实例3：

import re
msg = "It's raining cats and dogs, cats is wet"
match = re.search(r"cats", msg)
print(match.group())
print(match.start())
print(match.end())

结果输出：

cats # 贯穿整个字符串，第一次匹配的内容
13   # 匹配字符串的首位坐标
17   # 匹配字符串的尾位坐标

实例4：

import re
msg = "It's raining cats and dogs, cats is wet"
match = re.search(r"cats", msg)
print(match.groups()) # 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号

结果输出：

()

实例5

import re
text = "abc123def456"
pattern = "(\d+)(\w+)"
match = re.search(pattern, text)
print(match.group())
print(match.group(0))
print(match.group(1))
print(match.group(2))
print(match.groups())

结果输出：

123def456
123def456
123
def456
('123', 'def456')

实例6：
re.findall

def findall(pattern, string, flags=0):
    """Return a list of all non-overlapping matches in the string.

    If one or more capturing groups are present in the pattern, return
    a list of groups; this will be a list of tuples if the pattern
    has more than one group.

    Empty matches are included in the result."""

    return _compile(pattern, flags).findall(string)

返回string中所有与pattern匹配的全部字符串, 返回形式为数组(列表)
a)

import re
kk = re.compile(r'\d+')
print(kk.findall('one1two2three3four4'))

结果输出：

['1', '2', '3', '4']

import re
kk = re.compile(r'\d+')
print(re.findall(kk,"one123"))

结果输出：

['123']

import re
str = 'aabbabaabbaa'
print(re.findall(r'a.b', str)) # 一个"."就是匹配除 \n (换行符)以外的任意一个字符

结果输出：

['aab', 'aab']

import re
str = 'aabbabaabbaa'
print(re.findall(r'a.b', str))  # 一个"."就是匹配除 \n (换行符)以外的任意一个字符
print(re.findall(r'a*b', str))  # *前面的字符出现0次或以上
print(re.findall(r'a.*b', str))  # 贪婪，匹配从.*前面为开始到后面为结束的所有内容
print(re.findall(r'a.*?b', str))  # 非贪婪，遇到开始和结束就进行截取，因此截取多次符合的结果，中间没有字符也会被截取
print(re.findall(r'a(.*?)b', str))  # 非贪婪，与上面一样，只是与上面的相比多了一个括号，只保留括号的内容

结果输出：

['aab', 'aab']
['aab', 'b', 'ab', 'aab', 'b']
['aabbabaabb']
['aab', 'ab', 'aab']
['a', '', 'a']

12. `filter`函数

filter函数的基本语法
filter(function or None, iterable)

function：函数，作用是对iterable中的每个元素判断是否符合特定条件。
None：不调用任何函数，只对可迭代对象中的元素本身判断真假，保留为真的元素。
iterables：可迭代对象(序列、字典等)。

示例：

nums = [-10, 28, 9, -5, 30, 5]
filter(lambda x: x>0, nums)

得到：

<filter at 0x27950dbb9d0>

返回一个惰性计算的filter对象或迭代器，接下来使用list函数进行转换，得到列表

nums = [-10, 28, 9, -5, 30, 5]
list(filter(lambda x: x>0, nums))

返回结果：

[28, 9, 30, 5]

filter函数可以做可迭代对象的过滤操作。

posted @ 2023-03-21 09:25 Bonne_chance 阅读(118) 评论(0) 收藏举报

刷新页面返回顶部

Bonne_chance

python常见函数