Python基础第五天

双层装饰器

字符串格式化

Python字符串格式有2种方式：百分号方式、format方式；建议使用format方式

1.百分号方式

　格式：%[(name)][flags][width].[precision]typecode

　1）顺序传参数

　2）指定名称传入参数

　3）保留小数点后几位

　4）如果出现占位符，则写%%，打印时%

（name）可选，用来选择指定的key或者变量

>>> s = "my name is %(name)s" % {"name":'xiaoming'}

>>> print(s)

my name is xiaoming

flags 可选，可使用值如下（依赖width宽度）：

　　+ 右对齐；正数前加正好，负数前加负号

>>> s = "my name is %+10d "  % (8) # 10代表右对齐10个空格

>>> print(s)

my name is         +8              # 正数前面加+号

>>> s = "my name is %10d "  % (-8)

>>> print(s)

my name is         -8　　　　　　　　# 负数前面加-号

　　- 左对齐；正数前无符号，负数前加负号；

>>> s = "my name is %-5d number "  % (8)   # 5代表5个空格

>>> print(s)

my name is 8     number　　　　　　　　　　　 # 正数前面不加符号

>>> s = "my name is %-5d number "  % (-8)

>>> print(s)

my name is -8    number                    # 负数前面加-号

　　空格右对齐；正数前加空格，负数前加负号；

>>> s = "my name is % 3d number "  % (8)

>>> print(s)

my name is   8 number                                   # 正数前面不加符号

>>> s = "my name is % 3d number "  % (-8)

>>> print(s)

my name is  -8 number                                   # 负数前面加-号

　　0 右对齐；正数前无符号，负数前加负号；用0填充空白处;

>>> s = "my name is %010d number "  % (8)

>>> print(s)

my name is 0000000008 number

>>> s = "my name is %010d number "  % (-8)

>>> print(s)

my name is -000000008 number

.precision 可选，小数点后保留的位数；

>>> s = "my name is %.2f number "  % (8.19932109765)

>>> print(s)

my name is 8.20 number

# .2 代表取浮点数后面2位数，并且是四舍五入

width 可选，占有宽度
typecode 必选，可选参数如下：

　　s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置

>>> s = "my name is %s number "  % ('abc')

>>> print(s)

my name is abc number

　　r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
　　c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
　　o，将整数转换成八进制表示，并将其格式化到指定位置
　　x，将整数转换成十六进制表示，并将其格式化到指定位置

>>> s = "my name is %c %o %x number "  % (65,15,15)

>>> print(s)

my name is A 17 f number

# %o 转换unicode %c转换十进制 %x转换十六进制

　　d，将整数、浮点数转换成十进制表示，并将其格式化到指定位置

>>> s = "my name is %d number "  % (123456789)

>>> print(s)

my name is 123456789 number

　　e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
　　E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）

>>> s = "my name is %e number "  % (100)

>>> print(s)

my name is 1.000000e+02 number

>>> s = "my name is %e number "  % (100)

>>> print(s)

my name is 1.000000e+02 number

# %e %E 算次方

　　f，将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）

>>> s = "my name is %f number "  % (1.123456789)

>>> print(s)

my name is 1.123457 number

　　F，同上
　　g，自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
　　G，自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
　　%，当字符串中存在格式化标志时，需要用 %%表示一个百分号

>>> s = "my name is %s %% number "  % ('abc')

>>> print(s)

my name is abc % number

# %% 第一%相当于一个转义符

2.百分号方式

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

fill 可选，空白处填充的字符

align 可选，对齐方式（需配合width使用）

　　　　<,左对齐

　　　　>,右对齐

　　　　=,内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。即使：符号+填充物+数字

　　　　^，内容居中

>>> s = "my name is {:@<20}".format('xiaoming')    	# : 是格式，后面@是空白处填充物,<是左对齐，20是宽度

>>> print(s)

my name is xiaoming@@@@@@@@@@@@

>>> s = "my name is {:@>20}".format('xiaoming')		# : 是格式，后面@是空白处填充物,>是右对齐，20是宽度

>>> print(s)

my name is @@@@@@@@@@@@xiaoming

>>> s = "my name is {:@^20}".format('xiaoming')		# : 是格式，后面@是空白处填充物,^是居中对齐，20是宽度

>>> print(s)

my name is @@@@@@xiaoming@@@@@@

sign 可选，有无符号数字

　　　　+,正号加正，负号加负

　　　　-，正号不变，负号加负

　　　　空格，正号空格，负号加负

>>> s = "my name is {:+} {:-} {: }".format(1,2,3)

>>> print(s)

my name is +1 2  3

>>> s = "my name is {:+} {:-} {: }".format(-1,-2,-3)

>>> print(s)

my name is -1 -2 -3

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

，可选，为数字添加分隔符，例如：1,000,000

>>> s = "my name is {:,}".format(1000)

>>> print(s)

my name is 1,000

width 可选，格式化位所占宽度
.precision 可选，小数位保留精度

>>> s = "my name is {:.2f}".format(1000.123)

>>> print(s)

my name is 1000.12

type 可选，格式化类型

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

　　　　s，格式化字符串类型数据

　　　　空白，未指定类型，默认是None,同s

　　传入“整数类型”的参数

　　　　b,将10进制整数自动转换成2进制表示然后格式化

　　　　c,将10进制整数自动转换为其对应的unicode字符

　　　　d,10进制整数

　　　　o,将10进制整数自动转换为8进制表示然后格式化

　　　　x,将10进制整数自动转换为16进制表示然后格式化（小写x）

　　　　X,将10进制整数自动转换为16进制表示然后格式化（大写X）

>>> s = "my name is {:b} {:c} {:d} {:o} {:x} {:X}".format(20,20,20,20,20,20)

>>> print(s)

my name is 10100  20 24 14 14

　　传入“浮点型或小数类型”的参数

　　　　e,转换为科学计数法（小写e）表示然后格式化

　　　　E,转换为科学计数法（大写e）表示然后格式化

　　　　f,转换为浮点型（默认小数点后保留6位）表示,然后格式化

　　　　F,转换为浮点型（默认小数点后保留6位）表示，然后格式化；

　　　　g,自动在e和f中切换

　　　　G,自动在E和F中切换

　　　　%,显示百分比（默认显示小数点后6位）

>>> s = "my name is {:%}".format(1.33333334444)

>>> print(s)

my name is 133.333334%

　　必须掌握的常用格式化：

# 通过位置传参数

>>> s = "my name is {}, age {}, alias {}".format("xiaoming",18,"xm")		# 字符串方式 字符串使用双引号

>>> print(s)

my name is xiaoming, age 18, alias xm

>>> s = "my name is {}, age {}, alias {}".format(*["xiaoming",18,"xm"])		# *[] , *args万能参数 []列表 列表中字符串使用双引号

>>> print(s)

my name is xiaoming, age 18, alias xm

>>> s = "my name is {0}, age{1}, alias{0}".format(*["xiaoming",18,"xm"])	# *[] , *args万能参数 []列表 列表中字符串使用双引号

>>> print(s)

my name is xiaoming, age18, aliasxiaoming

>>> s = "my name is {2}, age {1}, alias {2}".format(*["xiaoming",18,"xm"])  # *[] , *args万能参数 []列表 列表中字符串使用双引号

>>> print(s)

my name is xm, age 18, alias xm

# 通过变量传参

>>> s = "my name is {name}, age{age}, alias{alias}".format(name='xiaoming',age=1

8,alias='xm')

>>> print(s)

my name is xiaoming, age18, aliasxm

>>> s = "my name is {name}, age {age}, alias {alias}".format(**{"name":"xiaoming  # **[] , *kwargs万能参数 {}字典 字典中字符串使用双引号

","age":18,"alias":"xm"})

>>> print(s)

my name is xiaoming, age 18, alias xm

# 通过下标传参

>>> s = "my name is {0[0]}, age {0[1]}, alias {0[2]}".format(["lisi",18,"lis"],[

"zhangsan",19,"zs"])

>>> print(s)

my name is lisi, age 18, alias lis

>>> s = "my name is {1[0]}, age {1[1]}, alias {1[2]}".format(["lisi",18,"lis"],[

"zhangsan",19,"zs"])

>>> print(s)

my name is zhangsan, age 19, alias zs

# 通过字符串类型传参

>>> s = "my name is {:s}, age {:d}, number {:f}".format(*["xiaoming",18,1.111223

33])

>>> print(s)

my name is xiaoming, age 18, number 1.111223

>>> s = "my name is {:s}, age {:d}, number {:f}".format("xiaoming",18,1.11122333

)

>>> print(s)

my name is xiaoming, age 18, number 1.111223

>>> s = "my name is {name:s}, age {age:d}, number {number:f}".format(**{"name":"

xiaoming","age":18,"number":1.22233444})

>>> print(s)

my name is xiaoming, age 18, number 1.222334

>>> s = "my name is {name:s}, age {age:d}, number {number:f}".format(name="xiaom

ing",age=18,number=1.22233444)

>>> print(s)

my name is xiaoming, age 18, number 1.222334

生成器

使用函数创造，函数中出现yield就是生成器，通过for循环执行

一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator）；如果函数中包含yield语法，那这个函数就会变成生成器

生成器基本语法

>>> def func():

...     yield 1

...     yield 2

...     yield 3

上面func()函数中出现了yield就是一个生成器，当执行函数func()时会得到一个迭代器

>>> ret = func()

>>> ret.__next__()

1

>>> ret.__next__()

2

>>> ret.__next__()

3

>>> ret.__next__()

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

StopIteration

利用生成器自定义range

>>> def range(arg):

...     start = 0

...     while True:

...             if start > arg:

...                     return

...             yield start

...             start += 1

...

>>> ret = range(3)

>>> for i in ret:

...     print(i)

...

0

1

2

3

迭代器

迭代器不会将内容全部放入内存，而是一行一行迭代，上面生成器例子中使用迭代器的表现

# 使用__next__方法一行一行迭代，需要写多个__next__

r = ret.__next__()

print(r)

# 使用for循环方式迭代，直到越界报错（StopIteration）

for i in ret:

　　print(i)

递归

官方解释

（1）递归就是在过程或函数里调用自身；
（2）在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

递归算法一般用于解决三类问题：

（1）数据的定义是按递归定义的。（比如Fibonacci函数）
（2）问题解法按递归算法实现。（回溯）
（3）数据的结构形式是按递归定义的。（比如树的遍历，图的搜索）　　

递归的缺点

递归算法解题的运行效率较低。在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等

举个列子

>>> def d():

...     return '123'

...

>>> def c():

...     r = d()

...     return r

...

>>> def b():

...     r = c()

...     return r

...

>>> def a():

...     r = b()

...     print(r)

...

>>> a()

123

>>> def func(n):

...     n += 1

...     if n >= 4:

...             return 'end'

...     else:

...             print(n,"start")

...     return func(n)

...

>>> r = func(1)

2 start

3 start

>>> print(r)

end

# 执行过程

   1.调用函数传参数1

   2.执行n+=1，此时n变成2

   3.if判断n<4

   4.执行else 打印n和start

   5.if判断结束

   6.执行函数return返回值，此时又调用了func(n)函数，并传参n=2

   7.知道if判断n>=4

   8.返回end结束

模块

Python模块分为内置模块、自定义模块、第三方模块

使用模块为了将代码分类，方便相互调用
自定义模块存放路径很重要，一定要能调用到
自定义模块的名称也很重要，不要和内置模块或者第三方模块相同，默认会先在当前脚本目录查找模块，如果找到不会继续查找

查看系统模块存放位置

import sys

ret = sys.path

for i in ret:

    print(i)

# Python查找模块的优先级，找到不往下面找

C:\Users\Administrator\PycharmProjects\s13\day5

C:\Users\Administrator\PycharmProjects\s13

C:\Users\Administrator\AppData\Local\Programs\Python\Python35\python35.zip

C:\Users\Administrator\AppData\Local\Programs\Python\Python35\DLLs

C:\Users\Administrator\AppData\Local\Programs\Python\Python35\lib

C:\Users\Administrator\AppData\Local\Programs\Python\Python35

C:\Users\Administrator\AppData\Local\Programs\Python\Python35\lib\site-packages # 一般自定义模块放到这个目录

模块的导入方法的2中方法

# 方法一import导入

import sys

sys.path

import lib.s4

lib.s4login()

#方法二form导入

form s4 import login

login()

form s4 import logout

logout()

form s4 import *

login()

logout()

# 不建议使用form方式，使用import方式，使用什么导入什么例如s4.login s4.logout