python3 标准库一些总结

import collections
text1 = "asbgewgrg2121aaassbsbgeeeegwwrr"
c = collections.Counter(text1)
print(c)
print(collections.Counter({‘a‘:3,‘b‘:2}))
print(collections.Counter(a=6,b=5))
##########输出如下#######
Counter({‘g‘: 5,‘e‘: 5,‘a‘: 4,‘s‘: 4,‘b‘: 3,‘w‘: 3,‘r‘: 3,‘2‘: 2,‘1‘: 2})
Counter({‘a‘: 3,‘b‘: 2})
Counter({‘a‘: 6,‘b‘: 5})

sample_text = """
Ridiculously fast.
Django was designed to help developers take applications from concept to completion as quickly as possible.

Reassuringly secure.
Django takes security seriously and helps developers avoid many common security mistakes.

Exceedingly scalable.
Some of the busiest sites on the Web leverage Django’s ability to quickly and flexibly scale.
"""

import textwrap
print(textwrap.fill(sample_text,width=50))
#
dedented_text = textwrap.dedent(sample_text)
print(‘Dedented:‘)
print(dedented_text)
#
dedented2_text = textwrap.dedent(sample_text).strip()
for width in [45,60]:
    print(‘{} Columns:n‘.format(width))
    print(textwrap.fill(dedented2_text,width=width))
    print()
#
dedented3_text = textwrap.dedent(sample_text)
wrapped = textwrap.fill(dedented3_text,width=50)
wrapped += ‘nnSecond garagraph after a blank line.‘
final = textwrap.indent(wrapped,‘>‘)
print(‘Quoted block:n‘)
print(final)

import re

pattern = "this"
text = "Does this text match the pattern?"

match = re.search(pattern,text)
print(type(match))
s = match.start()
e = match.end()

print(‘Found "{}"nin "{}"nfrom {} to {} ("{}")‘.format(match.re.pattern,match.string,s,e,text[s:e]))
#
print("#" * 20+str(2) + "#" * 20)
#2
import re
regexes = [
    re.compile(p) for p in [‘this‘,‘that‘]
]
text = ‘Does this text match the pattern?‘
print(‘text: {!r}n‘.format(text))

for regex in regexes:
    print(‘Seeking "{}" ->‘.format(regex.pattern),end=‘ ‘)
    if regex.search(text):
        print(‘match!‘)
    else:
        print("no match")

print("#" * 20+str(3) + "#" * 20)
#3
import re
text = ‘abbaaabbbbaaaaa‘
pattern = ‘ab‘
for match in re.findall(pattern,text):
    print(‘Found {!r}‘.format(match))
print("#" * 20+str(3.2) + "#" * 20)
for match in re.finditer(pattern,text):
    s = match.start()
    e = match.end()
    print(‘Found {!r} at {:d}:{:d}‘.format(text[s:e],e))
print("#" * 20 + str(4) + "#" * 20)
################输出#####################
<class ‘re.Match‘>
Found "this"
in "Does this text match the pattern?"
from 5 to 9 ("this")
####################2####################
text: ‘Does this text match the pattern?‘

Seeking "this" -> match!
Seeking "that" -> no match
####################3####################
Found ‘ab‘
Found ‘ab‘
####################3.2####################
Found ‘ab‘ at 0:2
Found ‘ab‘ at 5:7