(四)装饰器、re正则表达式,装饰器re正则表达式

本章内容:

  • 装饰器
  • re 正则表达式
装饰器

  装饰器是一个很著名的设计模式,经常被用于有切面需求的场景,较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能。

先定义一个基本的装饰器:

########## 基本装饰器 ##########
def orter(func):    #定义装饰器
    def inner():
        print("This is inner before.")
        s = func()    #调用原传入参数函数执行
        print("This is inner after.")
        return s        #return原函数返回值
    return inner      #将inner函数return给name函数

@orter    #调用装饰器(将函数name当参数传入orter装饰器)
def name():
    print("This is name.")
    return True        #name原函数return True 

ret = name()
print(ret)

输出结果:
This is inner before.
This is name.
This is inner after.
True

给装饰器传参数:

############ 装饰器传参数 ###########
def orter(func):
    def inner(a,b):      #接收传入的2个参数
        print("This is inner before.")
        s = func(a,b)    #接收传入的原函数2个参数
        print("This is inner after.")
        return s
    return inner

@orter
def name(a,b):    #接收传入的2个参数,并name整体函数当参数传入orter装饰器
    print("This is name.%s,%s"%(a,b))
    return True

ret = name('nick','jenny')    #传入2个参数
print(ret)

输出结果:
This is inner before.
This is name.nick,jenny
This is inner after.
True

给装饰器传万能参数:

########## 万能参数装饰器 ##########
def orter(func):
    def inner(*args,**kwargs):        #万能参数接收多个参数
        print("This is inner before.")
        s = func(*args,**kwargs)       #万能参数接收多个参数
        print("This is inner after.")
        return s
    return inner

@orter
def name(a,b,c,k1='nick'):        #接受传入的多个参数
    print("This is name.%s,%s"%(a,b))
    return True

ret = name('nick','jenny','car')
print(ret)

输出结果:
This is inner before.
This is name.nick,jenny
This is inner after.
True

一个函数应用多个装饰器方法:

########### 一个函数应用多个装饰器 #########

def orter(func):
    def inner(*args,**kwargs):
        print("This is inner one before.")
        print("This is inner one before angin.")
        s = func(*args,**kwargs)
        print("This is inner one after.")
        print("This is inner one after angin.")
        return s
    return inner

def orter_2(func):
    def inner(*args,**kwargs):
        print("This is inner two before.")
        print("This is inner two before angin.")
        s = func(*args,**kwargs)
        print("This is inner two after.")
        print("This is inner two after angin.")
        return s
    return inner

@orter            #将以下函数整体当参数传入orter装饰器  
@orter_2          #将以下函数当参数传入orter_2装饰器  
def name(a,b,c,k1='nick'):
    print("This is name.%s and %s."%(a,b))
    return True

ret = name('nick','jenny','car')
print(ret)

输出结果:
This is inner one before.
This is inner one before angin.
This is inner two before.
This is inner two before angin.
This is name.nick and jenny.
This is inner two after.
This is inner two after angin.
This is inner one after.
This is inner one after angin.
True

  图片 1

 

 

正则表达式

  正则表达式是用来匹配字符串非常强大的工具,在其他编程语言中同样有正则表达式的概念。就其本质而言,正则表达式(或
RE)是一种小型的、高度专业化的编程语言,(在Python中)它内嵌在Python中,并通过
re 模块实现。正则表达式模式被编译成一系列的字节码,然后由用 C
编写的匹配引擎执行。

#导入 re 模块
import re

s = 'nick jenny nice'

# 匹配方式(一)
b = re.match(r'nick',s)
q = b.group()
print(q)

# 匹配方式(二)
# 生成Pattern对象实例,r表示匹配源字符串
a = re.compile(r'nick')
print(type(a))               #<class '_sre.SRE_Pattern'>

b = a.match(s)
print(b)                     #<_sre.SRE_Match object; span=(0, 4), match='nick'>

q = b.group()
print(q)


#被匹配的字符串放在string中
print(b.string)              #nick jenny nice
#要匹配的字符串放在re中
print(b.re)                  #re.compile('nick')

  两种匹配方式区别在于:第一种简写是每次匹配的时候都要进行一次匹配公式的编译,第二种方式是提前对要匹配的格式进行了编译(对匹配公式进行解析),这样再去匹配的时候就不用在编译匹配的格式。

匹配规则:

  .
  "." 匹配任意字符(除了\n)
  \
  "\" 转义字符
  [...]
  "[...]" 匹配字符集
# "." 匹配任意字符(除了\n)
a = re.match(r".","95nick")
b = a.group()
print(b)

# [...] 匹配字符集
a = re.match(r"[a-zA-Z0-9]","123Nick")
b = a.group()
print(b)
  \d   
  匹配任何十进制数;它相当于类 [0-9]
  \D 
  匹配任何非数字字符;它相当于类 [^0-9]
  \s
  匹配任何空白字符;它相当于类 [\t\n\r\f\v]
  \S
  匹配任何非空白字符;它相当于类 [^\t\n\r\f\v]
  \w
  匹配任何字母数字字符;它相当于类 [a-zA-Z0-9]
  \W  
  匹配任何非字母数字字符;它相当于类 [^a-zA-Z0-9]
# \d \D 匹配数字/非数字
a = re.match(r"\D","nick")
b = a.group()
print(b)

# \s \S 匹配空白/非空白字符
a = re.match(r"\s"," ")
b = a.group()
print(b)

# \w \W 匹配单词字符[a-zA-Z0-9]/非单词字符
a = re.match(r"\w","123Nick")
b = a.group()
print(b)
a = re.match(r"\W","+-*/")
b = a.group()
print(b)
  *
   "*" 匹配前一个字符0次或者无限次
  +
   "+" 匹配前一个字符1次或者无限次
  ?
    "?" 匹配一个字符0次或者1次

   {m} {m,n}

    {m} {m,n} 匹配前一个字符m次或者m到n次

   *? +? ??

    *? +? ?? 匹配模式变为非贪婪(尽可能少匹配字符串)
# "*" 匹配前一个字符0次或者无限次
a = re.match(r"[A-Z][a-z]*","Aaaaaa123")    #可以只匹配A,123不会匹配上
b = a.group()
print(b)

# “+” 匹配前一个字符1次或者无限次
a = re.match(r"[_a-zA-Z]+","nick")
b = a.group()
print(b)

# “?” 匹配一个字符0次或者1次
a = re.match(r"[0-8]?[0-9]","95")   #(0-8)没有匹配上9
b = a.group()
print(b)

# {m} {m,n} 匹配前一个字符m次或者m到n次
a = re.match(r"[\w]{6,10}@qq.com","[email protected]")
b = a.group()
print(b)

# *? +? ?? 匹配模式变为非贪婪(尽可能少匹配字符串)
a = re.match(r"[0-9][a-z]*?","9nick")
b = a.group()
print(b)
a = re.match(r"[0-9][a-z]+?","9nick")
b = a.group()
print(b)
   ^  
   "^" 匹配字符串开头,多行模式中匹配每一行的开头
   $
   "$" 匹配字符串结尾,多行模式中匹配每一行的末尾
   \A
   \A 仅匹配字符串开头
    \Z

   \Z 仅匹配字符串结尾

    \b

   \b 匹配一个单词边界,也就是指单词和空格间的位置
# "^" 匹配字符串开头,多行模式中匹配每一行的开头。
li = "nick\nnjenny\nsuo"
a = re.search("^s.*",li,re.M)
b = a.group()
print(b)

# "$" 匹配字符串结尾,多行模式中匹配每一行的末尾。
li = "nick\njenny\nnick"
a = re.search(".*y$",li,re.M)
b = a.group()
print(b)

# \A 仅匹配字符串开头
li = "nickjennyk"
a = re.findall(r"\Anick",li)
print(a)

# \Z 仅匹配字符串结尾
li = "nickjennyk"
a = re.findall(r"nick\Z",li)
print(a)

# \b 匹配一个单词边界,也就是指单词和空格间的位置
a = re.search(r"\bnick\b","jenny nick car")
b = a.group()
print(b)
  |
  "|" 匹配左右任意一个表达式
  ab
  (ab) 括号中表达式作为一个分组
  \<number>
  \<number> 引用编号为num的分组匹配到的字符串
  (?P<key>vlaue)
  (?P<key>vlaue) 匹配到一个字典,去vlaue也可做别名
  (?P=name)
  (?P=name) 引用别名为name的分组匹配字符串
# "|" 匹配左右任意一个表达式
a = re.match(r"nick|jenny","jenny")
b = a.group()
print(b)

# (ab) 括号中表达式作为一个分组
a = re.match(r"[\w]{6,10}@(qq|163).com","[email protected]")
b = a.group()
print(b)

# \<number> 引用编号为num的分组匹配到的字符串
a = re.match(r"<([\w]+>)[\w]+</\1","<book>nick</book>")
b = a.group()
print(b)

# (?P<key>vlace) 匹配输出字典 
li = 'nick jenny nnnk'
a = re.match("(?P<k1>n)(?P<k2>\w+).*(?P<k3>n\w+)",li)
print(a.groupdict())
输出结果:
{'k2': 'ick', 'k1': 'n', 'k3': 'nk'}

# (?P<name>) 分组起一个别名
# (?P=name) 引用别名为name的分组匹配字符串
a = re.match(r"<(?P<jenny>[\w]+>)[\w]+</(?P=jenny)","<book>nick</book>")
b = a.group()
print(b)

 

 模块方法介绍:

  match

   从头匹配

  search
  匹配整个字符串,直到找到一个匹配
  findall
  找到匹配,返回所有匹配部分的列表

   finditer

  返回一个迭代器

  sub

  将字符串中匹配正则表达式的部分替换为其他值

  split

  根据匹配分割字符串,返回分割字符串组成的列表
######## 模块方法介绍 #########
# match 从头匹配

# search 匹配整个字符串,直到找到一个匹配

# findall 找到匹配,返回所有匹配部分的列表
# findall 加括号
li = 'nick jenny nick car girl'

r = re.findall('n\w+',li)
print(r)
#输出结果:['nick', 'nny', 'nick']
r = re.findall('(n\w+)',li)
print(r)
#输出结果:['nick', 'nny', 'nick']
r = re.findall('n(\w+)',li)
print(r)
#输出结果:['ick', 'ny', 'ick']
r = re.findall('(n)(\w+)(k)',li)
print(r)
#输出结果:[('n', 'ic', 'k'), ('n', 'ic', 'k')]
r = re.findall('(n)((\w+)(c))(k)',li)
print(r)
#输出结果:[('n', 'ic', 'i', 'c', 'k'), ('n', 'ic', 'i', 'c', 'k')]


# finditer 返回一个迭代器,和findall一样
li = 'nick jenny nnnk'
a = re.finditer(r'n\w+',li)
for i in a:
    print(i.group())

# sub 将字符串中匹配正则表达式的部分替换为其他值
li = 'This is 95'
a = re.sub(r"\d+","100",li)
print(a)

li = "nick njenny ncar ngirl"
a = re.compile(r"\bn")
b = a.sub('cool',li,3)      #后边参数替换几次
print(b)

#输出结果:
#coolick cooljenny coolcar ngirl

# split 根据匹配分割字符串,返回分割字符串组成的列表
li = 'nick,suo jenny:nice car'
a = re.split(r":| |,",li)   #或|
print(a)

li = 'nick1jenny2car3girl5'
a = re.compile(r"\d")
b = a.split(li)
print(b)

#输出结果:
#['nick', 'jenny', 'car', 'girl', '']   #注意后边空元素
  group()
  返回被 RE 匹配的字符串
  groups()
 

  返回一个包含正则表达式中所有小组字符串的元组,从 1 到所含的小组号
  groupdict()
 

  返回(?P<key>vlace)定义的字典
  start()
  返回匹配开始的位置
  end()
  返回匹配结束的位置
  span()
  返回一个元组包含匹配 (开始,结束) 的索引位置
li = 'nick jenny nnnk'

a = re.match("n\w+",li)
print(a.group())

a = re.match("(n)(\w+)",li)
print(a.groups())

a = re.match("(?P<k1>n)(?P<k2>\w+).*(?P<k3>n\w+)",li)
print(a.groupdict())

-----------------------------------------------
import re
a = "123abc456"
 re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0)   #123abc456,返回整体
 re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1)   #123
 re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2)   #abc
 re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3)   #456

 group(1) 列出第一个括号匹配部分,group(2) 列出第二个括号匹配部分,group(3)列出第三个括号匹配部分。

-----------------------------------------------
  re.I
  使匹配对大小写不敏感
  re.L
  做本地化识别(locale-aware)匹配
  re.M
  多行匹配,影响 ^ 和 $
  re.S  
  使 . 匹配包括换行在内的所有字符
  re.U
  根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
  re.X
 

  注释,会影响空格(无效了)
#re.I 使匹配对大小写不敏感
a = re.search(r"nick","NIck",re.I)
print(a.group())

#re.L 做本地化识别(locale-aware)匹配
#re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.

#re.S:.将会匹配换行符,默认.逗号不会匹配换行符
a = re.findall(r".","nick\njenny",re.S)
print(a)
输出结果:
['n', 'i', 'c', 'k', '\n', 'j', 'e', 'n', 'n', 'y']

#re.M:^$标志将会匹配每一行,默认^只会匹配符合正则的第一行;默认$只会匹配符合正则的末行
n = """12 drummers drumming,
11 pipers piping, 10 lords a-leaping"""

p = re.compile("^\d+")
p_multi = re.compile("^\d+",re.M)
print(re.findall(p,n))
print(re.findall(p_multi,n))

 

常见正则列子:

匹配手机号:

# 匹配手机号
phone_num = '13001000000'
a = re.compile(r"^1[\d+]{10}")
b = a.match(phone_num)
print(b.group())

匹配IPv4:

# 匹配IP地址
ip = '192.168.1.1'
a = re.compile(r"(((1?[0-9]?[0-9])|(2[0-4][0-9])|(25[0-5]))\.){3}((1?[0-9]?[0-9])|(2[0-4][0-9])|(25[0-5]))$")
b = a.search(ip)
print(b)

匹配email:

# 匹配 email
email = '[email protected]'
a = re.compile(r"(.*){0,26}@(\w+){0,20}.(\w+){0,8}")
b = a.search(email)
print(b.group())

 

本章内容: 装饰器 re 正则表达式 装饰器
装饰器是一个很著名的设计模式,经常被用于…

Python
第四篇:生成器、迭代器、装饰器、递归函数与正则表达式 

 迭代器

本章内容:

6.4、装饰器,6.4装饰器


Python迭代器和生成器 

迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退,不过这也没什么,因为人们很少在迭代途中往后退。另外,迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素,而在这之前或之后,元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合,比如几个G的文件

  • 装饰器
  • 迭代器 & 生成器
  • re 正则表达式
  • 字符串格式化

装饰器:

意义:在不能改变原函数的源代码,和在不改变整个项目中原函数的调用方式的情况下,给函数添加新的功能

 

由于不允许改变函数的源代码,在忽略调用方式的情况下,我们可能会有以下结果:

def decorator(func):
    func()
    print("logging")

def test1():
    print("test1")

def test2():
    print("Test2")

decorator(test1)
decorator(test2)

 

但这改变了原本的调用方式,原本是test1(),现在是decorator(test1)

 

 

那么如果我们为了使调用方式不变,是否可以使装饰好的函数decorator的返回值是一个我们需要的函数,再赋值给原来的函数名呢?

于是:

def timmer1(func):
    def warpper():
        start_time = time.time()
        func()
        stop_time=time.time()
        print("the func run time is %s"%(stop_time-start_time))
     return warpper

test3=timmer1(test3)

好像上面这段代码并没有改变原来的调用方式,调用原来的test3,相当于运行timmer1中的warpper

 

如果对于无参数的函数来说,上面的代码已经实现了我们的目的,但对于带参数的函数,上面的代码没有传入参数,所以仍然需要修改

 

于是:

def timmer2(func):
    def warpper(*args,**kwargs):
        start_time = time.time()
        func(*args,**kwargs)
        stop_time=time.time()
        print("the func run time is %s"%(stop_time-start_time))
    return warpper

在上上面的代码中,由于实质上,test3已经等于wrapper,所以可以直接使用,test3(参数)来传入参数,为了处理参数不确定数量问题,可以使用可变长度参数

 

 

上面代码还存在一个问题,无法获取原本函数中的返回值,那么我们还需要加上一些东西:

import time
def timmer2(func):
    def warpper(*args,**kwargs):
        start_time = time.time()
        res=func(*args,**kwargs)
        return res
        stop_time=time.time()
        print("the func run time is %s"%(stop_time-start_time))
    return warpper

使用一个变量记录下原函数的返回值。

 

 

这样我们就实现了装饰器的基本功能。


Python 迭代器、生成器、递归、正则表达式
(四)

特点:

装饰器

补充:

python提供了一个功能:

@装饰器名
def 目标装饰函数名():
    pass
#上面的效果是 目标装饰函数名=装饰器(目标装饰函数名)

所以在需要替换原函数的时候,可以在目标装饰函数定义的上一行加上@装饰器名

所以上面的代码会变成:

def timmer2(func):
    def warpper(*args,**kwargs):
        start_time = time.time()
        func(*args,**kwargs)
        stop_time=time.time()
        print("the func run time is %s"%(stop_time-start_time))
    return warpper

@timmer2
def test7():
    print("test7")

@timmer2
def test6(x):
    print(x)

test7()
test6(2)

import time
def timmer2(func):
    def warpper(*args,**kwargs):
        start_time = time.time()
        res=func(*args,**kwargs)
        return res
        stop_time=time.time()
        print("the func run time is %s"%(stop_time-start_time))
    return warpper

@timmer2
def test4():
    print("test4 run")
    return "test4 done"
test4()

print("--------")
print(test4())

 

 

第二个补充:

可以一个函数,可以使用多个装饰器

比如:

@装饰器1

@装饰器2

 

 


装饰器:
意义:在不能改变原函数的源代码,和在不改变整个项目中原函数的调用方式的情况下,给函数添加新的…

递归和迭代的区别

  1. 访问者不需要关心迭代器内部的结构,仅需通过next()方法不断去取下一个内容
  2. 不能随机访问集合中的某个值 ,只能从头到尾依次访问
  3. 访问到一半时不能往回退
  4. 便于循环比较大的数据集合,节省内存

  装饰器是一个很著名的设计模式,经常被用于有切面需求的场景,较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能。


图片 2图片 3

先定义一个基本的装饰器:

迭代器

1 a=iter([1,2,3,4,5])
2 print(a.__next__())
3 print(a.__next__())
4 print(a.__next__())
5 print(a.__next__())
6 print(a.__next__())
########## 基本装饰器 ##########
def orter(func):    #定义装饰器
    def inner():
        print("This is inner before.")
        s = func()    #调用原传入参数函数执行
        print("This is inner after.")
        return s        #return原函数返回值
    return inner      #将inner函数return给name函数

@orter    #调用装饰器(将函数name当参数传入orter装饰器)
def name():
    print("This is name.")
    return True        #name原函数return True 

ret = name()
print(ret)

输出结果:
This is inner before.
This is name.
This is inner after.
True

迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器

给装饰器传参数:

特点:

运行代码:

############ 装饰器传参数 ###########
def orter(func):
    def inner(a,b):      #接收传入的2个参数
        print("This is inner before.")
        s = func(a,b)    #接收传入的原函数2个参数
        print("This is inner after.")
        return s
    return inner

@orter
def name(a,b):    #接收传入的2个参数,并name整体函数当参数传入orter装饰器
    print("This is name.%s,%s"%(a,b))
    return True

ret = name('nick','jenny')    #传入2个参数
print(ret)

输出结果:
This is inner before.
This is name.nick,jenny
This is inner after.
True

访问者不需要关心迭代器内部的结构,仅需通过next()方法不断去取下一个内容

D:\Python34\python.exe
C:/Users/AMTF/PycharmProjects/S12/day1/ifelse.py
1
2
3
4
5

给装饰器传万能参数:

不能随机访问集合中的某个值 ,只能从头到尾依次访问

生成器generator
定义:一个函数调用时返回一个迭代器,那这个函数就叫做生成器(generator),如果函数中包含yield语法,那这个函数就会变成生成器

########## 万能参数装饰器 ##########
def orter(func):
    def inner(*args,**kwargs):        #万能参数接收多个参数
        print("This is inner before.")
        s = func(*args,**kwargs)       #万能参数接收多个参数
        print("This is inner after.")
        return s
    return inner

@orter
def name(a,b,c,k1='nick'):        #接受传入的多个参数
    print("This is name.%s,%s"%(a,b))
    return True

ret = name('nick','jenny','car')
print(ret)

输出结果:
This is inner before.
This is name.nick,jenny
This is inner after.
True

访问到一半时不能往回退

图片 4图片 5

一个函数应用多个装饰器方法:

便于循环比较大的数据集合,节省内存

 1 def cash_out(amount):
 2     while amount >0:
 3         amount -= 1
 4         yield 1
 5         print("擦,又来取钱了。。。败家子!")
 6 ATM = cash_out(5)
 7 print("取到钱 %s 万" % ATM.__next__())
 8 print("花掉花掉!")
 9 print("取到钱 %s 万" % ATM.__next__())
10 print("取到钱 %s 万" % ATM.__next__())
11 print("花掉花掉!")
12 print("取到钱 %s 万" % ATM.__next__())
13 print("取到钱 %s 万" % ATM.__next__())
14 print("取到钱 %s 万" % ATM.__next__()) #到这时钱就取没了,再取就报错了
15 print("取到钱 %s 万" % ATM.__next__())
########### 一个函数应用多个装饰器 #########

def orter(func):
    def inner(*args,**kwargs):
        print("This is inner one before.")
        print("This is inner one before angin.")
        s = func(*args,**kwargs)
        print("This is inner one after.")
        print("This is inner one after angin.")
        return s
    return inner

def orter_2(func):
    def inner(*args,**kwargs):
        print("This is inner two before.")
        print("This is inner two before angin.")
        s = func(*args,**kwargs)
        print("This is inner two after.")
        print("This is inner two after angin.")
        return s
    return inner

@orter            #将以下函数整体当参数传入orter装饰器  
@orter_2          #将以下函数当参数传入orter_2装饰器  
def name(a,b,c,k1='nick'):
    print("This is name.%s and %s."%(a,b))
    return True

ret = name('nick','jenny','car')
print(ret)

输出结果:
This is inner one before.
This is inner one before angin.
This is inner two before.
This is inner two before angin.
This is name.nick and jenny.
This is inner two after.
This is inner two after angin.
This is inner one after.
This is inner one after angin.
True

生成器generator

生成器

  图片 6

一个函数调用时返回一个迭代器,那这个函数就叫做生成器(generator),如果函数中包含yield语法,那这个函数就会变成生成器。

 运行代码:

迭代器 & 生成器

取到钱 1 万
花掉花掉!
擦,又来取钱了。。。败家子!
取到钱 1 万
擦,又来取钱了。。。败家子!
取到钱 1 万
花掉花掉!
擦,又来取钱了。。。败家子!
取到钱 1 万
擦,又来取钱了。。。败家子!
取到钱 1 万
擦,又来取钱了。。。败家子!
Traceback (most recent call last):
  File “C:/Users/AMTF/PycharmProjects/S12/day1/ifelse.py”, line 18, in
<module>
    print(“取到钱 %s 万” % ATM.__next__())
#到这时钱就取没了,再取就报错了
StopIteration

 1、迭代器

作用:

  迭代器只不过是一个实现迭代器协议的容器对象。

这个yield的主要效果呢,就是可以使函数中断,并保存中断状态,中断后,代码可以继续往下执行,过一段时间还可以再重新调用这个函数,从上次yield的下一句开始执行。 

特点:

图片 7图片 8

  1. 访问者不需要关心迭代器内部的结构,仅需通过next()方法不断去取下一个内容
  2. 不能随机访问集合中的某个值
    ,只能从头到尾依次访问
  3. 访问到一半时不能往回退
  4. 便于循环比较大的数据集合,节省内存

    a = iter([1,2,3,4,5])
    a

    a.next()
    1
    a.next()
    2
    a.next()
    3
    a.next()
    4
    a.next()
    5
    a.next()
    Traceback (most recent call last):
    File ““, line 1, in
    StopIteration #末尾生成StopIteration异常

 1 import time
 2 def consumer(name):
 3     print("%s 准备吃包子了!"%name)
 4     while True:
 5         baozi=yield
 6         print(("包子【%s】来了,被[%s]吃了")%(baozi,name))
 7 def producer(name):
 8     c=consumer("a")
 9     c2=consumer("b")
10     c.__next__()
11     c2.__next__()
12     print("老子开始做包子了!")
13     for i in range(1,4):
14         time.sleep(1)
15         print("做了两个包子!")
16         c.send(i)
17         c2.send(i)
18 producer("alex")

2、生成器

使用yield实现单线程的一部并发效果

  一个函数调用时返回一个迭代器,那这个函数就叫做生成器(generator);如果函数中包含yield语法,那这个函数就会变成生成器。

 

def xran():
    print("one")
    yield 1
    print("two")
    yield 2
    print("sr")
    yield 3

ret = xran()
#print(ret)      #<generator object xran at 0x00000000006ED308>

result = ret.__next__()
print(result)

result = ret.__next__()
print(result)

result = ret.__next__()
print(result)

# ret.__next__()  #循环完毕抛出StopIteration
#
# ret.close()     #关闭生成器

运行代码:

生成器表达式

a 准备吃包子了!
b 准备吃包子了!
老子开始做包子了!
做了两个包子!
包子【1】来了,被[a]吃了
包子【1】来了,被[b]吃了
做了两个包子!
包子【2】来了,被[a]吃了
包子【2】来了,被[b]吃了
做了两个包子!
包子【3】来了,被[a]吃了
包子【3】来了,被[b]吃了 

>>>a=[7,8,9]
>>>b=[i**2 for i in a]
>>>b
[49, 64, 81]
>>>ib=(i**2 for i in a)
>>>ib
<generator object <genexpr> at 0x7f72291217e0>
>>>next(ib)
49
>>>next(ib)
64
>>>next(ib)
81
>>>next(ib)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

装饰器

 

 

正则表达式

图片 9图片 10

  正则表达式是用来匹配字符串非常强大的工具,在其他编程语言中同样有正则表达式的概念。就其本质而言,正则表达式(或
RE)是一种小型的、高度专业化的编程语言,(在Python中)它内嵌在Python中,并通过
re 模块实现。正则表达式模式被编译成一系列的字节码,然后由用 C
编写的匹配引擎执行。

1 def login(canshu):
2     print("已经通过验证")
3     return canshu
4 def tv():
5     print("%s已经进入tv模式")
6 tv=login(tv)
7 tv()
#导入 re 模块
import re

s = 'nick jenny nice'

# 匹配方式(一)
b = re.match(r'nick',s)
q = b.group()
print(q)

# 匹配方式(二)
# 生成Pattern对象实例,r表示匹配源字符串
a = re.compile(r'nick')
print(type(a))               #<class '_sre.SRE_Pattern'>

b = a.match(s)
print(b)                     #<_sre.SRE_Match object; span=(0, 4), match='nick'>

q = b.group()
print(q)


#被匹配的字符串放在string中
print(b.string)              #nick jenny nice
#要匹配的字符串放在re中
print(b.re)                  #re.compile('nick')

装饰器

  两种匹配方式区别在于:第一种简写是每次匹配的时候都要进行一次匹配公式的编译,第二种方式是提前对要匹配的格式进行了编译(对匹配公式进行解析),这样再去匹配的时候就不用在编译匹配的格式。

运行代码:
已经通过验证
%s已经进入tv模式

匹配规则:

 

  .
  "." 匹配任意字符(除了\n)
  \
  "\" 转义字符
  [...]
  "[...]" 匹配字符集

图片 11图片 12

# "." 匹配任意字符(除了\n)
a = re.match(r".","95nick")
b = a.group()
print(b)

# [...] 匹配字符集
a = re.match(r"[a-zA-Z0-9]","123Nick")
b = a.group()
print(b)
1 a=[[x for x in range(4)] for y in range(4)]
2 for i in a:print(i)
3 jishu2=0
4 for jishu1 in range(4):
5     jishu2=jishu1+1
6     for jishu2 in range(jishu2,4):
7         a[int(jishu1)][int(jishu2)],a[int(jishu2)][int(jishu1)]=a[int(jishu2)][int(jishu1)],a[int(jishu1)][int(jishu2)]
8 print("\n")
9 for y in a:print(y)
  \d   
  匹配任何十进制数;它相当于类 [0-9]
  \D 
  匹配任何非数字字符;它相当于类 [^0-9]
  \s
  匹配任何空白字符;它相当于类 [\t\n\r\f\v]
  \S
  匹配任何非空白字符;它相当于类 [^\t\n\r\f\v]
  \w
  匹配任何字母数字字符;它相当于类 [a-zA-Z0-9]
  \W  
  匹配任何非字母数字字符;它相当于类 [^a-zA-Z0-9]

二维数组旋转90度

# \d \D 匹配数字/非数字
a = re.match(r"\D","nick")
b = a.group()
print(b)

# \s \S 匹配空白/非空白字符
a = re.match(r"\s"," ")
b = a.group()
print(b)

# \w \W 匹配单词字符[a-zA-Z0-9]/非单词字符
a = re.match(r"\w","123Nick")
b = a.group()
print(b)
a = re.match(r"\W","+-*/")
b = a.group()
print(b)

运行代码:

  *
   "*" 匹配前一个字符0次或者无限次
  +
   "+" 匹配前一个字符1次或者无限次
  ?
    "?" 匹配一个字符0次或者1次

   {m} {m,n}

    {m} {m,n} 匹配前一个字符m次或者m到n次

   *? +? ??

    *? +? ?? 匹配模式变为非贪婪(尽可能少匹配字符串)

[0, 1, 2, 3]
[0, 1, 2, 3]
[0, 1, 2, 3]
[0, 1, 2, 3]

# "*" 匹配前一个字符0次或者无限次
a = re.match(r"[A-Z][a-z]*","Aaaaaa123")    #可以只匹配A,123不会匹配上
b = a.group()
print(b)

# “+” 匹配前一个字符1次或者无限次
a = re.match(r"[_a-zA-Z]+","nick")
b = a.group()
print(b)

# “?” 匹配一个字符0次或者1次
a = re.match(r"[0-8]?[0-9]","95")   #(0-8)没有匹配上9
b = a.group()
print(b)

# {m} {m,n} 匹配前一个字符m次或者m到n次
a = re.match(r"[\w]{6,10}@qq.com","630571017@qq.com")
b = a.group()
print(b)

# *? +? ?? 匹配模式变为非贪婪(尽可能少匹配字符串)
a = re.match(r"[0-9][a-z]*?","9nick")
b = a.group()
print(b)
a = re.match(r"[0-9][a-z]+?","9nick")
b = a.group()
print(b)

[0, 0, 0, 0]
[1, 1, 1, 1]
[2, 2, 2, 2]
[3, 3, 3, 3]

   ^  
   "^" 匹配字符串开头,多行模式中匹配每一行的开头
   $
   "$" 匹配字符串结尾,多行模式中匹配每一行的末尾
   \A
   \A 仅匹配字符串开头
    \Z

   \Z 仅匹配字符串结尾

    \b

   \b 匹配一个单词边界,也就是指单词和空格间的位置

递归:

# "^" 匹配字符串开头,多行模式中匹配每一行的开头。
li = "nick\nnjenny\nsuo"
a = re.search("^s.*",li,re.M)
b = a.group()
print(b)

# "$" 匹配字符串结尾,多行模式中匹配每一行的末尾。
li = "nick\njenny\nnick"
a = re.search(".*y$",li,re.M)
b = a.group()
print(b)

# \A 仅匹配字符串开头
li = "nickjennyk"
a = re.findall(r"\Anick",li)
print(a)

# \Z 仅匹配字符串结尾
li = "nickjennyk"
a = re.findall(r"nick\Z",li)
print(a)

# \b 匹配一个单词边界,也就是指单词和空格间的位置
a = re.search(r"\bnick\b","jenny nick car")
b = a.group()
print(b)

图片 13图片 14

  |
  "|" 匹配左右任意一个表达式
  ab
  (ab) 括号中表达式作为一个分组
  \<number>
  \<number> 引用编号为num的分组匹配到的字符串
  (?P<key>vlaue)
  (?P<key>vlaue) 匹配到一个字典,去vlaue也可做别名
  (?P=name)
  (?P=name) 引用别名为name的分组匹配字符串
 1 def digui(arg1,arg2,jieshu3):
 2 
 3     arg3=arg1+arg2
 4     if arg1==0:
 5         print(arg1,arg2,end=' ')
 6     print(arg3,end=" ")
 7     if jieshu3>arg3:
 8         return digui(arg2,arg3,jieshu3)
 9     return
10 digui(0,1,30)
# "|" 匹配左右任意一个表达式
a = re.match(r"nick|jenny","jenny")
b = a.group()
print(b)

# (ab) 括号中表达式作为一个分组
a = re.match(r"[\w]{6,10}@(qq|163).com","630571017@qq.com")
b = a.group()
print(b)

# \<number> 引用编号为num的分组匹配到的字符串
a = re.match(r"<([\w]+>)[\w]+</\1","<book>nick</book>")
b = a.group()
print(b)

# (?P<key>vlace) 匹配输出字典 
li = 'nick jenny nnnk'
a = re.match("(?P<k1>n)(?P<k2>\w+).*(?P<k3>n\w+)",li)
print(a.groupdict())
输出结果:
{'k2': 'ick', 'k1': 'n', 'k3': 'nk'}

# (?P<name>) 分组起一个别名
# (?P=name) 引用别名为name的分组匹配字符串
a = re.match(r"<(?P<jenny>[\w]+>)[\w]+</(?P=jenny)","<book>nick</book>")
b = a.group()
print(b)

递归

 

运行代码:
0 1 1 2 3 5 8 13 21 34

 模块方法介绍:

正则表达式:

  match

   从头匹配

  search
  匹配整个字符串,直到找到一个匹配
  findall
  找到匹配,返回所有匹配部分的列表

   finditer

  返回一个迭代器

  sub

  将字符串中匹配正则表达式的部分替换为其他值

  split

  根据匹配分割字符串,返回分割字符串组成的列表

图片 15图片 16

######## 模块方法介绍 #########
# match 从头匹配

# search 匹配整个字符串,直到找到一个匹配

# findall 找到匹配,返回所有匹配部分的列表
# findall 加括号
li = 'nick jenny nick car girl'

r = re.findall('n\w+',li)
print(r)
#输出结果:['nick', 'nny', 'nick']
r = re.findall('(n\w+)',li)
print(r)
#输出结果:['nick', 'nny', 'nick']
r = re.findall('n(\w+)',li)
print(r)
#输出结果:['ick', 'ny', 'ick']
r = re.findall('(n)(\w+)(k)',li)
print(r)
#输出结果:[('n', 'ic', 'k'), ('n', 'ic', 'k')]
r = re.findall('(n)((\w+)(c))(k)',li)
print(r)
#输出结果:[('n', 'ic', 'i', 'c', 'k'), ('n', 'ic', 'i', 'c', 'k')]


# finditer 返回一个迭代器,和findall一样
li = 'nick jenny nnnk'
a = re.finditer(r'n\w+',li)
for i in a:
    print(i.group())

# sub 将字符串中匹配正则表达式的部分替换为其他值
li = 'This is 95'
a = re.sub(r"\d+","100",li)
print(a)

li = "nick njenny ncar ngirl"
a = re.compile(r"\bn")
b = a.sub('cool',li,3)      #后边参数替换几次
print(b)

#输出结果:
#coolick cooljenny coolcar ngirl

# split 根据匹配分割字符串,返回分割字符串组成的列表
li = 'nick,suo jenny:nice car'
a = re.split(r":| |,",li)   #或|
print(a)

li = 'nick1jenny2car3girl5'
a = re.compile(r"\d")
b = a.split(li)
print(b)

#输出结果:
#['nick', 'jenny', 'car', 'girl', '']   #注意后边空元素
 1 import re
 2 f=re.sub("\d+","#","d12li3weig4u444o5555g&g66666&6EFss",count=5)
 3 if f:
 4     print(f)
 5 
 6 f1=re.match("[0-9]{0,10}","4334ge4325ftt&^%kjf35")
 7 if f1:
 8     print(f1.group())
 9 
10 f2=re.findall("[0-9]{1,10}","4334ge4325asdfa&*%ff35")
11 if f1:
12     print(f2)
13 
14 f3=re.findall("[a-zA-Z]+","4334ge4325asdfa&*%ff35")
15 if f1:
16     print(f3)
17 
18 f4=re.findall("[*]+","4334ge4**325asdfa&*%ff35")
19 if f1:
20     print(f4)
  group()
  返回被 RE 匹配的字符串
  groups()
 

  返回一个包含正则表达式中所有小组字符串的元组,从 1 到所含的小组号
  groupdict()
 

  返回(?P<key>vlace)定义的字典
  start()
  返回匹配开始的位置
  end()
  返回匹配结束的位置
  span()
  返回一个元组包含匹配 (开始,结束) 的索引位置

正则表达式

li = 'nick jenny nnnk'

a = re.match("n\w+",li)
print(a.group())

a = re.match("(n)(\w+)",li)
print(a.groups())

a = re.match("(?P<k1>n)(?P<k2>\w+).*(?P<k3>n\w+)",li)
print(a.groupdict())

-----------------------------------------------
import re
a = "123abc456"
 re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0)   #123abc456,返回整体
 re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1)   #123
 re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2)   #abc
 re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3)   #456

 group(1) 列出第一个括号匹配部分,group(2) 列出第二个括号匹配部分,group(3)列出第三个括号匹配部分。

-----------------------------------------------

运行代码:

  re.I
  使匹配对大小写不敏感
  re.L
  做本地化识别(locale-aware)匹配
  re.M
  多行匹配,影响 ^ 和 $
  re.S  
  使 . 匹配包括换行在内的所有字符
  re.U
  根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
  re.X
 

  注释,会影响空格(无效了)

d#li#weig#u#o#g&g66666&6EFss
4334
[‘4334’, ‘4325’, ’35’]
[‘ge’, ‘asdfa’, ‘ff’]
[‘**’, ‘*’]

#re.I 使匹配对大小写不敏感
a = re.search(r"nick","NIck",re.I)
print(a.group())

#re.L   做本地化识别(locale-aware)匹配
#re.U   根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.

#re.S:.将会匹配换行符,默认.逗号不会匹配换行符
a = re.findall(r".","nick\njenny",re.S)
print(a)
输出结果:
['n', 'i', 'c', 'k', '\n', 'j', 'e', 'n', 'n', 'y']

#re.M:^$标志将会匹配每一行,默认^只会匹配符合正则的第一行;默认$只会匹配符合正则的末行
n = """12 drummers drumming,
11 pipers piping, 10 lords a-leaping"""

p = re.compile("^\d+")
p_multi = re.compile("^\d+",re.M)
print(re.findall(p,n))
print(re.findall(p_multi,n))
匹配格式
模式描述
^匹配字符串的开头
$匹配字符串的末尾。
.匹配任意字符,除了换行符,当re.DOTALL标记被指定时,则可以匹配包括换行符的任意字符。
[...]用来表示一组字符,单独列出:[amk] 匹配 'a','m'或'k'
[^...]不在[]中的字符:[^abc] 匹配除了a,b,c之外的字符。
re*匹配0个或多个的表达式。
re+匹配1个或多个的表达式。
re?匹配0个或1个由前面的正则表达式定义的片段,非贪婪方式
re{ n} 
re{ n,}精确匹配n个前面表达式。
re{ n, m}匹配 n 到 m 次由前面的正则表达式定义的片段,贪婪方式
a| b匹配a或b
(re)G匹配括号内的表达式,也表示一个组
(?imx)正则表达式包含三种可选标志:i, m, 或 x 。只影响括号中的区域。
(?-imx)正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)类似 (...), 但是不表示一个组
(?imx: re)在括号中使用i, m, 或 x 可选标志
(?-imx: re)在括号中不使用i, m, 或 x 可选标志
(?#...)注释.
(?= re)前向肯定界定符。如果所含正则表达式,以 ... 表示,在当前位置成功匹配时成功,否则失败。但一旦所含表达式已经尝试,匹配引擎根本没有提高;模式的剩余部分还要尝试界定符的右边。
(?! re)前向否定界定符。与肯定界定符相反;当所含表达式不能在字符串当前位置匹配时成功
(?> re)匹配的独立模式,省去回溯。
\w匹配字母数字
\W匹配非字母数字
\s匹配任意空白字符,等价于 [\t\n\r\f].
\S匹配任意非空字符
\d匹配任意数字,等价于 [0-9].
\D匹配任意非数字
\A匹配字符串开始
\Z匹配字符串结束,如果是存在换行,只匹配到换行前的结束字符串。c
\z匹配字符串结束
\G匹配最后匹配完成的位置。
\b匹配一个单词边界,也就是指单词和空格间的位置。例如, 'er\b' 可以匹配"never" 中的 'er',但不能匹配 "verb" 中的 'er'。
\B匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er',但不能匹配 "never" 中的 'er'。
\n, \t, 等.匹配一个换行符。匹配一个制表符。等
\1...\9匹配第n个分组的子表达式。
\10匹配第n个分组的子表达式,如果它经匹配。否则指的是八进制字符码的表达式。 
  
正则表达式常用5种操作
re.match(pattern, string)     # 从头匹配
re.search(pattern, string)    # 匹配整个字符串,直到找到一个匹配
re.split()            # 将匹配到的格式当做分割点对字符串分割成列表

 

 

常见正则列子:

匹配手机号:

# 匹配手机号
phone_num = '13001000000'
a = re.compile(r"^1[\d+]{10}")
b = a.match(phone_num)
print(b.group())

匹配IPv4:

# 匹配IP地址
ip = '192.168.1.1'
a = re.compile(r"(((1?[0-9]?[0-9])|(2[0-4][0-9])|(25[0-5]))\.){3}((1?[0-9]?[0-9])|(2[0-4][0-9])|(25[0-5]))$")
b = a.search(ip)
print(b)

匹配email:

# 匹配 email
email = '630571017@qq.com'
a = re.compile(r"(.*){0,26}@(\w+){0,20}.(\w+){0,8}")
b = a.search(email)
print(b.group())

 

字符串格式化

1、百分号方式

%[(name)][flags][width].[precision]typecode

 

 

  • (name)  
    可选,用于选择指定的key
  • flags    可选,可供选择的值有:width
            可选,占有宽度

      • +    
        右对齐;正数前加正好,负数前加负号;
      • –    
        左对齐;正数前无符号,负数前加负号;
      • 空格
         右对齐;正数前加空格,负数前加负号;
      • 0    
        右对齐;正数前无符号,负数前加负号;用0填充空白处
    • .precision
       可选,小数点后保留的位数
  • typecode    必选

      • s,获取传入对象的__str__方法的返回值,并将其格式化到指定位置
      • r,获取传入对象的__repr__方法的返回值,并将其格式化到指定位置
      • c,整数:将数字转换成其unicode对应的值,10进制范围为 0
        <= i <=
        1114111(py27则只支持0-255);字符:将字符添加到指定位置
      • o,将整数转换成 八
         进制表示,并将其格式化到指定位置
      • x,将整数转换成十六进制表示,并将其格式化到指定位置
      • d,将整数、浮点数转换成 十
        进制表示,并将其格式化到指定位置
      • e,将整数、浮点数转换成科学计数法,并将其格式化到指定位置(小写e)
      • E,将整数、浮点数转换成科学计数法,并将其格式化到指定位置(大写E)
      • f,
        将整数、浮点数转换成浮点数表示,并将其格式化到指定位置(默认保留小数点后6位)
      • F,同上
      • g,自动调整将整数、浮点数转换成
        浮点型或科学计数法表示(超过6位数用科学计数法),并将其格式化到指定位置(如果是科学计数则是e;)
      • G,自动调整将整数、浮点数转换成
        浮点型或科学计数法表示(超过6位数用科学计数法),并将其格式化到指定位置(如果是科学计数则是E;)
      • %,当字符串中存在格式化标志时,需要用
        %%表示一个百分号

    常用格式化:

    tpl = “i am %s” % “nick”

    tpl = “i am %s age %d” % (“nick”, 18)

    tpl = “i am %(name)s age %(age)d” % {“name”: “nick”, “age”: 18}

    tpl = “percent %.2f” % 99.97623

    tpl = “i am %(pp).2f” % {“pp”: 123.425556, }

    tpl = “i am %.2f %%” % {“pp”: 123.425556, }

2、Format方式

[[fill]align][sign][#][0][width][,][.precision][type]

 

 

  • fill  
     【可选】空白处填充的字符
  • align  
    【可选】对齐方式(需配合width使用)

    • <,内容左对齐
    • >,内容右对齐(默认)
    • =,内容右对齐,将符号放置在填充字符的左侧,且只对数字类型有效。
      即使:符号+填充物+数字
    • ^,内容居中

sign    【可选】有无符号数字

    • +,正号加正,负号加负;
    •  -,正号不变,负号加负;
    • 空格
      ,正号空格,负号加负;

#      
【可选】对于二进制、八进制、十六进制,如果加上#,会显示
0b/0o/0x,否则不显示

,    
 【可选】为数字添加分隔符,如:1,000,000

width   【可选】格式化位所占宽度

.precision
【可选】小数位保留精度

type    【可选】格式化类型

    • 传入” 字符串类型
      “的参数

      • s,格式化字符串类型数据
      • 空白,未指定类型,则默认是None,同s
    • 传入“ 整数类型 ”的参数
      • b,将10进制整数自动转换成2进制表示然后格式化
      • c,将10进制整数自动转换为其对应的unicode字符
      • d,十进制整数
      • o,将10进制整数自动转换成8进制表示然后格式化;
      • x,将10进制整数自动转换成16进制表示然后格式化(小写x)
      • X,将10进制整数自动转换成16进制表示然后格式化(大写X)
    • 传入“
      浮点型或小数类型 ”的参数

      • e,
        转换为科学计数法(小写e)表示,然后格式化;
      • E,
        转换为科学计数法(大写E)表示,然后格式化;
      • f ,
        转换为浮点型(默认小数点后保留6位)表示,然后格式化;
      • F,
        转换为浮点型(默认小数点后保留6位)表示,然后格式化;
      • g,
        自动在e和f中切换
      • G,
        自动在E和F中切换
      • %,显示百分比(默认显示小数点后6位)

    常用格式化:

    tpl = “i am {}, age {}, {}”.format(“nick”, 18, ‘jenny’)

    tpl = “i am {}, age {}, {}”.format(*[“nick”, 18, ‘jenny’])

    tpl = “i am {0}, age {1}, really {0}”.format(“nick”, 18)

    tpl = “i am {0}, age {1}, really {0}”.format(*[“nick”, 18])

    tpl = “i am {name}, age {age}, really {name}”.format(name=”nick”, age=18)

    tpl = “i am {name}, age {age}, really {name}”.format(**{“name”: “nick”, “age”: 18})

    tpl = “i am {0[0]}, age {0[1]}, really {0[2]}”.format([1, 2, 3], [11, 22, 33])

    tpl = “i am {:s}, age {:d}, money {:f}”.format(“nick”, 18, 88888.1)

    tpl = “i am {:s}, age {:d}, money {:0.2f}”.format(“nick”, 18, 88888.111111111111)

    tpl = “i am {:s}, age {:d}”.format(*[“nick”, 18])

    tpl = “i am {name:s}, age {age:d}”.format(name=”nick”, age=18)

    tpl = “i am {name:s}, age {age:d}”.format(**{“name”: “nick”, “age”: 18})

    tpl = “numbers: {:b},{:o},{:d},{:x},{:X}, {:%}”.format(15, 15, 15, 15, 15, 15.87623, 2)

    tpl = “numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}”.format(15)

    tpl = “numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}”.format(num=15)

  

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图