pair函数python python pairs

Python正则问题一例

1. 这里用到pair函数python了反引用( back reference )

.*(.).*\1 中 .* 表示匹配任意多个字符(可以为0个字符), (.) 表示匹配任意一个字符, .*任意多字符, \1 表示匹配前面(.)捕获到pair函数python的内容, 也就是说, 匹配一对字母( 记为 A ), A之间可以有任意多个字符, 且第一个A之前可以有任意多个字符(或者没有字符)

2. 这里涉及正则匹配pair函数python的匹配原则, 手册上关于 re.groups 最后说的很清楚: 如果有多个匹配到的组,则返回最后一个(If a group is contained in a part of the pattern that matched multiple times,

the last match is returned.).

因此re.match(r".*(.).*\1", "7676k").groups() 可以匹配到7和6, 返回最后一个6

相关问答

Q1: Python判断列表是否已排序的各种方法及其性能

本节判断列表排序的函数名格式为IsListSorted_XXX()。为简洁起见pair函数python，除代码片段及其输出外，一律以_XXX()指代。

2.1 guess

def IsListSorted_guess(lst):

listLen = len(lst) if listLen = 1: return True

#由首个元素和末尾元素猜测可能的排序规则

if lst[0] == lst[-1]: #列表元素相同

for elem in lst: if elem != lst[0]: return False

elif lst[0] lst[-1]: #列表元素升序

for i, elem in enumerate(lst[1:]): if elem lst[i]: return False

else: #列表元素降序

for i, elem in enumerate(lst[1:]): if elem lst[i]: return False

return True

_guess()是最通用的实现，几乎与语言无关。值得注意的是，该函数内会猜测给定列表可能的排序规则，因此无需外部调用者指明排序规则。

2.2 sorted

def IsListSorted_sorted(lst):

return sorted(lst) == lst or sorted(lst, reverse=True) == lst

_sorted()使用Python内置函数sorted()。由于sorted()会对未排序的列表排序，_sorted()函数主要适用于已排序列表。

若想判断列表未排序后再对其排序，不如直接调用列表的sort()方法，因为该方法内部会判断列表是否排序。对于已排序列表，该方法的时间复杂度为线性阶O(n)——判断为O(n)而排序为O(nlgn)。

2.3 for-loop

def IsListSorted_forloop(lst, key=lambda x, y: x = y):

for i, elem in enumerate(lst[1:]): #注意，enumerate默认迭代下标从0开始

if not key(lst[i], elem): #if elem lst[i]更快，但通用性差

return False

return True

无论列表是否已排序，本函数的时间复杂度均为线性阶O(n)。注意，参数key表明缺省的排序规则为升序。

2.4 all

def IsListSorted_allenumk(lst, key=lambda x, y: x = y):

return all(key(lst[i], elem) for i, elem in enumerate(lst[1:]))import operatordef IsListSorted_allenumo(lst, oCmp=operator.le):

return all(oCmp(lst[i], elem) for i, elem in enumerate(lst[1:]))def IsListSorted_allenumd(lst):

return all((lst[i] = elem) for i, elem in enumerate(lst[1:]))def IsListSorted_allxran(lst, key=lambda x,y: x = y):

return all(key(lst[i],lst[i+1]) for i in xrange(len(lst)-1))def IsListSorted_allzip(lst, key=lambda x,y: x = y):

from itertools import izip #Python 3中zip返回生成器(generator)，而izip被废弃

return all(key(a, b) for (a, b) in izip(lst[:-1],lst[1:]))

lambda表达式与operator运算符速度相当，前者简单灵活，后者略为高效(实测并不一定)。但两者速度均不如列表元素直接比较(可能存在调用开销)。亦即，_allenumd()快于_allenumo()快于_allenumk()。

若使用lambda表达式指示排序规则，更改规则时只需要改变x和y之间的比较运算符pair函数python；若使用operator模块指示排序规则，更改规则时需要改变对象比较方法。具体地，lt(x, y)等效于x y，le(x, y)等效于x = y，eq(x, y)等效于x == y，ne(x, y)等效于x != y，gt(x, y)等效于x y，ge(x, y)等效于x = y。例如，_allenumo()函数若要严格升序可设置oCmp=operator.lt。

此外，由all()函数的帮助信息可知，_allenumk()其实是_forloop()的等效形式。

2.5 numpy

def IsListSorted_numpy(arr, key=lambda dif: dif = 0):

import numpy try: if arr.dtype.kind == 'u': #无符号整数数组执行np.diff时存在underflow风险

arr = numpy.int64(lst) except AttributeError: pass #无dtype属性，非数组

return (key(numpy.diff(arr))).all() #numpy.diff(x)返回相邻数组元素的差值构成的数组

NumPy是用于科学计算的Python基础包，可存储和处理大型矩阵。它包含一个强大的N维数组对象，比Python自身的嵌套列表结构(nested list structure)高效得多。第三节的实测数据表明，_numpy()处理大型列表时性能非常出色。

在Windows系统中可通过pip install numpy命令安装NumPy包，不建议登录官网下载文件自行安装。

2.6 reduce

def IsListSorted_reduce(iterable, key=lambda x, y: x = y):

cmpFunc = lambda x, y: y if key(x, y) else float('inf') return reduce(cmpFunc, iterable, .0) float('inf')

reduce实现是all实现的变体。累加器(accumulator)中仅存储最后一个检查的列表元素，或者Infinity(若任一元素小于前个元素值)。

前面2.1~2.5小节涉及下标操作的函数适用于列表等可迭代对象(Iterable)。对于通用迭代器(Iterator)对象，即可以作用于next()函数或方法的对象，可使用_reduce()及后面除_rand()外各小节的函数。迭代器的计算是惰性的，只有在需要返回下一个数据时才会计算，以避免不必要的计算。而且，迭代器方式无需像列表那样切片为两个迭代对象。

2.7 imap

def IsListSorted_itermap(iterable, key=lambda x, y: x = y):

from itertools import imap, tee

a, b = tee(iterable) #为单个iterable创建两个独立的iterator

next(b, None) return all(imap(key, a, b))

2.8 izip

def IsListSorted_iterzip(iterable, key=lambda x, y: x = y):

from itertools import tee, izip

a, b = tee(iterable) next(b, None) return all(key(x, y) for x, y in izip(a, b))def pairwise(iterable):

from itertools import tee, izip

a, b = tee(iterable) next(b, None) return izip(a, b) #"s - (s0,s1), (s1,s2), (s2, s3), ..."def IsListSorted_iterzipf(iterable, key=lambda x, y: x = y):

return all(key(a, b) for a, b in pairwise(iterable))

第三节的实测数据表明，虽然存在外部函数调用，_iterzipf()却比_iterzip()略为高效。

2.9 fast

def IsListSorted_fastd(lst):

it = iter(lst) try:

prev = it.next() except StopIteration: return True

for cur in it: if prev cur: return False

prev = cur return Truedef IsListSorted_fastk(lst, key=lambda x, y: x = y):

it = iter(lst) try:

prev = it.next() except StopIteration: return True

for cur in it: if not key(prev, cur): return False

prev = cur return True

_fastd()和_fastk()是Stack Overflow网站回答里据称执行最快的。实测数据表明，在列表未排序时，它们的性能表现确实优异。

2.10 random

import randomdef IsListSorted_rand(lst, randNum=3, randLen=100):

listLen = len(lst) if listLen = 1: return True

#由首个元素和末尾元素猜测可能的排序规则

if lst[0] lst[-1]: #列表元素升序

key = lambda dif: dif = 0

else: #列表元素降序或相等

key = lambda dif: dif = 0

threshold, sortedFlag = 10000, True

import numpy if listLen = threshold or listLen = randLen*2 or not randNum: return (key(numpy.diff(numpy.array(lst)))).all() from random import sample for i in range(randNum):

sortedRandList = sorted(sample(xrange(listLen), randLen))

flag = (key(numpy.diff(numpy.array([lst[x] for x in sortedRandList])))).all()

sortedFlag = sortedFlag and flag return sortedFlag

_rand()借助随机采样降低运算规模，并融入其他判断函数的优点。例如，猜测列表可能的排序规则，并在随机采样不适合时使用相对快速的判断方式，如NumPy。

通过line_profiler分析可知，第20行和第21行与randLen有关，但两者耗时接近。因此randLen应小于listLen的一半，以抵消sorted开销。除内部限制外，用户可以调节随机序列个数和长度，如定制单个但较长的序列。

注意，_rand()不适用于存在微量异常数据的长列表。因为这些数据很可能被随机采样遗漏，从而影响判断结果的准确性。

Q2: python的lambda形式的理解

lambda 创建一个匿名函数。冒号前面是传入参数，后面是一个处理传入参数的单行表达式。

调用lambda函数返回表达式的结果。

list的sort 同于内建函数sorted。它有三个参数cmp，key，reverse，均有默认值。

cmp是一个比较器，自定义比较器的话传入两个参数x，y，返回值限制为1(xy), 0(x=y)， -1(xy)。默认是常规比较，数字比较，字符串比较等等。

key是对序列元素处理（比如问题中序列元素仍是序列，就可以再对序列取索引值），也就是sort的比较器实际接收到值是key处理后的结果（问题中实际参与比较的是1,2,3,4）。

reverse默认是False，意思是从小到大排序，传入True，就从大到小排。

Q3: python问题，我是按照书中所说的打出来的，为什么会报错呢?

应该是你运行这个python脚本时，没有带必要参数。

假设你的脚本文件名为search.py，你应该这样运行：

search.py name='apple'

这样sys.argv[1]的值就会是 name='apple'

Q4: 怎样python 写一个扑克和骰子的程序，模拟的5骰子的滚动，至多三次，具体要求如下：

参考下面的代码.

play 可能有问题，主要是没说清楚在保留牌的时候， 输入Ace 或者 "Ace Ace" 有什么区别，到底是输入一次 Ace 保留手上所有的 Ace 还是只保留一个，这个没说清楚。看例子，这两种用法都有，我按照输入了几个就保留几个来做的。

simulate 没问题，和图片中的结果完全一样

必须用 python 3

import random

import collections

_dice_type = ['Ace', 'King', 'Queen', 'Jack', '10', '9']

_hand_mapping = collections.OrderedDict([

    ('5kind',    'Five of a kind'),

    ('4kind',    'Four of a kind'),

    ('full',     'Full house'),

    ('straight', 'Straight'),

    ('3kind',    'Three of a kind'),

    ('2pair',    'Two pair'),

    ('1pair',    'One pair'),

    ('bust',     'Bust'),

])

def _check_hand(dices):

    counter = collections.Counter(dices)

    if len(counter) == 1:

        return '5kind'

    sorted5 = counter.most_common(5)

    if sorted5[0][1] == 4:

        return '4kind'

    if sorted5[0][1] == 3:

        if sorted5[1][1] == 2:

            return 'full'

        else:

            return '3kind'

    if sorted5[0][1] == 2:

        if sorted5[1][1] == 2:

            return '2pair'

        else:

            return '1pair'

    if len(counter) == 5:

        dtype = sorted5[0][0]

        for x in sorted5:

            if dtype != x[0]:

                break

            dtype += 1

        else:

            return 'straight'

            

    return 'bust'

def play():

    dices = []

    retry = 0

    while True:

        remain = 5 - len(dices)

        if remain = 0:

            break

            

        dices.extend([random.randint(0,5) for x in range(remain)])

        

        print("The roll is: {}".format(

            " ".join([_dice_type[d] for d in sorted(dices)])

        ))

        print("It is a {}".format(_hand_mapping[_check_hand(dices)]))

        if retry  1:

            break

        

        prompt = "Which dice do you want to keep for the {} roll? ".format(

            "second" if retry == 0 else "third"

        )

        while True:

            answer = input(prompt).lower()

            if answer == 'all':

                break

            answer = [x.capitalize() for x in answer.split()]

            if set(answer).issubset(set(_dice_type)):

                break

            print("That is not possible, try again!")

        retry += 1

        if answer == 'all':

            print("Ok, done")

            break

        tmp = dices

        dices = []

        for x in tmp:

            if _dice_type[x] in answer:

                dices.append(x)

                answer.remove(_dice_type[x])

def simulate(n, debug=False):

    result = dict.fromkeys(_hand_mapping.keys(), 0)

    for _ in range(n):

        dices = [random.randint(0,5) for x in range(5)]

        if debug:

            print("DEBUG:", " ".join([_dice_type[d] for d in sorted(dices)]))

        result[_check_hand(dices)] += 1

    for k, v in _hand_mapping.items():

        cnt = result[k]

        print("{:16s}: {:.2f}%".format(v, 100*cnt/n))

Q5: python Lambda 形式的使用？

4.7.5. Lambda 形式

出于实际需要pair函数python，有几种通常在函数式编程语言例如 Lisp 中出现的功能加入到pair函数python了 Python。通过 lambda 关键字pair函数python，可以创建短小的匿名函数。这里有一个函数返回它的两个参数的和： lambda a, b: a+b。 Lambda 形式可以用于任何需要的函数对象。出于语法限制，它们只能有一个单独的表达式。语义上讲，它们只是普通函数定义中的一个语法技巧。类似于嵌套函数定义，lambda 形式可以从外部作用域引用变量:

def make_incrementor(n):

... return lambda x: x + n

...

f = make_incrementor(42)

f(0)

42

f(1)

43

上面的示例使用 lambda 表达式返回一个函数。另一个用途是将一个小函数作为参数传递:

pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]

pairs.sort(key=lambda pair: pair[1])

pairs

[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two

pair函数python的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于python pairs、pair函数python的信息别忘了在本站进行查找喔。