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:UsersAdministratorPycharmProjectss13day5
C:UsersAdministratorPycharmProjectss13
C:UsersAdministratorAppDataLocalProgramsPythonPython35python35.zip
C:UsersAdministratorAppDataLocalProgramsPythonPython35DLLs
C:UsersAdministratorAppDataLocalProgramsPythonPython35lib
C:UsersAdministratorAppDataLocalProgramsPythonPython35
C:UsersAdministratorAppDataLocalProgramsPythonPython35libsite-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