我的python笔记

预科班

www.python.org 3.6.7 3.6.8

www.virtualbox.org#虚拟机

www.vmware.com#虚拟机

常用单词

embeddable     可嵌入的
executable      安装包
public          ['p ʌblik] 公共的,公用的
private         ['praivit]  私有的,私人的
static          ['stæ tik] 静的;静态的;静止的
void            [vɔid] 空的,没有返回值的
demo            [ 'deməu ]     演示，例子
define          [dɪˈfaɪn] 定义
syntax          [ˈsɪnˌtæks] 语法
invalid         [ɪnˈvælɪd] 无效的
indentation     [ˌɪndenˈteɪʃn] 缩进
unexpected      [ˌʌnɪkˈspektɪd] 不期望的
usage           [ˈju:sɪdʒ] 使用
version         [ˈvɜ:ʃn] 版本
author          [ˈɔ:θə(r)] 作者
string          [striŋ] 字符串类型
encode          [ɪnˈkəʊd] 编码
decode          [ˌdi:ˈkəʊd] 解码
integrated      [ˈɪntɪgreɪtɪd] 集成
development     [dɪˈveləpmənt] 开发
environment     [ɪnˈvaɪrənmənt] 环境
salary          [ 'sæləri ] 薪水
switch          [switʃ]   判断语句
case            [keis]    实例,情况
default         [di'fɔ:lt] 默认的
interpreter     [ɪnˈtɜ:prɪtə(r)] 解释器
configured      [kən'fɪɡəd] 配置
variables       ['veərɪəblz] 变量
unreachable     ['ʌn'ri:tʃəbl] 不能达到的
colum           [ˈkɔləm] 列
row             [rəʊ] 行
index           [ˈɪndeks] 索引
function        [ 'fʌŋ k ʃən ] 功能,函数
method          [ 'meθə d] 方法
compare         [ kəm' pεə ] 比较
exception       [ ik 'sep ʃən] 异常
index           ['indeks] 角标,索引,指针
out of          [ a:ut ɔf] 在...之外
change          [ tʃeindʒ ] 改变，交换
swap            [ swɔp ] 交换
half            [ hɑ:f  ] 一半的,半个的
search          [ sə: tʃ] 搜索,查找
mid             [ mid] 中间的
number          [ 'nʌmbə ] 数字,号码
transition      [ træn'ziʃən]
class member   [ 'membə ] 类成员
class method   [ 'meθəd] 类方法
package         [ 'pækidʒ] 包
multiply        [ˈmʌltɪplaɪ] 乘
division        [dɪˈvɪʒn] 除法
iterable        ['itəreibl] 可迭代的
attribute       [əˈtrɪbju:t] 属性
private         ['praivit ] 私有的,私人的
sleep           [sli:p ] 睡, 睡觉, 睡眠 1秒=1000毫秒
single          ['siŋgl] 单一的,单独的,单身的,单程的
instance        ['instəns ] 实例,情况
data            ['deitə]   资料
develop         [di'veləp ] 开发
extends         [ ik'stends] 继承,延伸,推广
location        [ ləu'keiʃən]  位置(文件在电脑中的位置)
encoding        [in'kəudiŋ] 编码
super            ['sju: pə]  父类的,超级的,,超类的
final           ['fai nl] 最终的
finally          [ˈfaɪnəli] 最后
interface       [ 'intəfeis ] 接口
implements      ['impliments] 实现
mouse           [maus ] 鼠标, 老鼠
bonus           [ 'bəunəs ] 奖金
inner           [ 'inə ] 内部的
protect         [prəu'tekt] 保护，受保护的， 防卫
file         [ 'fail]  文件
folder          ['fəʊldə] 文件夹
view            [ vju: ] 视图, 视线,看
equals          ['i:kwəls]判断两个字符串是否相等
memory          ['meməri] 记忆，内存，存储器
heap            [hi:p] 堆
throw           [θrəu] 抛出,投掷
finally          ['fainəli] 最后,最终
message         ['mesidʒ] 消息,信息,通知
catch           [kætʃ] 捕获,捕捉,抓住
edit            ['edit]  编辑
project         [prədʒekt] 项目,工程,计
directory       [ di'rektəri ]  目录
runtime         [run'taim] 运行时间
current         ['kʌrənt] 当前的,现在的
preference      ['prefə rəns] 个人喜好
rename          [,ri:'neim] 重命名
template        ['templit] 模板
method          [ˈmeθəd] 方法
static          [ˈstætɪk] 静态
runnable        [ 'rʌnəbl] 可捕捉的
interrupted             [,intə'rʌptid]  中断的,被阻止的
ticket                  ['tikit] 票
bank                    [bæŋk]  银行
tank                    [tæŋk] 坦克
flag                    [flæɡ] 标记, 旗帜
dead                    [ded] 死亡的,无生命的
lock                    [ lɔk] 锁
unlock                  [ˌʌnˈlɒk] 解锁
console                 [kən'səul] 控制台
font                    [fɔnt] 字体
resource                [ ri'sɔ:s] 资源
notify                  ['nəutifai ] 唤醒, 告知
bounded                 ['baundid] 有界限的
buffer                   ['bʌfə]  缓冲区
signal                  ['siɡ nəl]  信号,标志
condition               [kən'diʃən]   条件
producer                [prə'du:sə] 生产者
consumer                [ kən'sju:mə ] 消费者
substring               [ 'sʌb striŋ] 子字符串
append                  [ə'pend]  添加
replace                 [ri'pleis]  代替,取代,更换
update                  [ ʌp'deit] 更新
create                  [ kri'eit ] 创造,创作
builder                 ['bildə] 构建器
character               ['kærəktə] 字符
reverse                 [ ri'və:s ] 反转,翻转
collection              [kə'lekʃən] 集合,聚集,采集
remove                  [ri'mu:v]  移除,删除
clear                   [kliə]  清空,清除,清楚的.
iterator                [itə'rei tə] 迭代器

02基本数据类型

01数值类型

±*/ // **

int整形 float浮点型 complex复数 (real image) bool布尔型 (a=’’ a=() 空即False)

import math
import decimala = decimal.Decimal('0.2')b = a * ac = math.ceil(a)

02序列类型

str字符串

list列表 b = [ ]

tuple元组 //内容一次定义后不可更改

a =（100,）

03序列类型的通用操作

>>> a="345678"
>>> b=list(a)
>>> b
['3', '4', '5', '6', '7', '8']
>>> c=tuple(a)
>>>
>>> c
('3', '4', '5', '6', '7', '8')
>>> c[1]='AAA'

切片[ 开始 : 结束 : 步长]

步长可以为负，空即无穷

拆包

a,*b=[1,2,3,4]

一些函数

type( )求变量类型

id( )求变量地址

[外链图片转存失败(img-eVexi7xR-1562205374737)(C:\Users\25327\AppData\Local\Temp\1554986187095.png)]

列表（list）

增

append

insert

extend

删

pop

del

remove

clear

改

a[0] =

查

index

count

20190415

集合(set)

定义方式

a = {1,2,3,4}

字典(dict)

定义方式

a = {‘name’ : ‘laowwang’}

dict(name = ‘laowang’)

访问

a[‘name’]

a.get(‘name’)

a.values()

a.keys()

a.items()

修改

a[‘name’] = ‘laozhang’

添加

a[‘sex’] = ‘man’

b = a.copy()

a.setdefault(‘sex’,‘man’) # 有则查无则增

删除

a.clear()清空

a.pop(‘name’)删除键值

a.popitem()随机删除

20190416

三木运算

   if  a > 5:print(True)else :print(False)print(True) if a>5 else print(False)print(True if a>5 else False)

循环

while i<= 10

print(i)

i += 1;

while i< len(mylist)

print(mylist[i])

i=i+1;

关键词 break

迭代循环

for i in list

for i in range(5) 0…4

for i in range(1,10,1) 开始结束步长

随机数

import random

a = random.randint(1,100)

20190419

b = int (input(‘输入1表示石头，2表示剪刀，3表示石头’))

range break continue

函数

id() help() set() list()

str() tuple() dict() int()

reserved() float() input()

list = [‘a’,‘b’,‘c’]

enumerate(list,100)返回可枚举对象

[(100,‘a’),(101,‘b’),(102,‘c’)]

for i,j in list : print (i,j)

0 a

1 b

2 c

eval()提取字符串中有效内容

exec()执行字符串中有效表达式

filter（）过滤器

map(函数，列表)对象注意配对

zip(列表，列表)逐一配对

定义

def hello():

print(‘hello’)

pass # 暂时不知道怎么写，就写pass

def func (x) #必备参数

def func ( a,b = 6) #默认参数，定义了就用，没定义就默认

def func (*args)#不定长参数，组包成一个元组

func(1,2,3,4,[1,2])

(1,2,3,4,[1,2])

def func(**k)#键值对，关键字

func(a=1,b=2,c=3)

{‘a’:1,‘b’:2,‘c’:3}

def func(*)

20190420

函数

sorted（a，reverse）默认reverse为false

sorted(a,reverse=True)实现了反向排序

func(*list , default=‘haha’)

默认>必备>位置参数>关键字(后两种为不定长参数)

a,b = b,a+b

for i in range(5)

a.append(i)

return a

13函数作用域和匿名函数20190222

匿名函数

没有名字的函数

def func(a):return a**3
#我想没有名字如何做到

#lambda 参数：表达式
g = lambda a: a**3 print(g)#相当于前面的func，输出一个地址
print(g(2))#有括弧就是调用函数
#相当于想用函数又不想起名字(lambda a: a**3)(2)#连g都不用

list( filter(lambda x: True if x% 2 == 0 else: False, range(101)) )

list( filter(lambda x: x>5, [1,2,3,4,5,6,7,8,9,10]))

变量作用域

内部能访问外部

内部不能修改外部

但是

x = 123

def fun():

global x全局变量

x++

nonlocal y外层变量

闭包

闭包就是函数嵌套，内部函数调用外部函数的变量，外函数返回内函数的引用

def fun(i)

def fun1()

i…

…

return fun1

a = []
for i in range(4):def fun(i):def fun1():return ireturn fun1a.append(fun(i))print (a)
////////////////////
li = []
for i in range(4)def func()return ili.append(func)print(li)

高阶函数函数当参数传到另一个函数中

24种设计模式

20190423

def func(*args, **kwargs)：fun(1,2,3,4,a=11,b=22,c=33)

类定义

dir(sss) 查看方法

class A:pass

类的三要素类名属性方法

面向对象（外卖）

面向过程（自己做）

class Person#类名name = '奥利奥'#属性（变量）print(Person.name)#就能访问了Person.sex='男'#添加属性cat = Person() #类的实例化print(cat.name) #cat是Person创造出来的cat.age = 18 #实例属性

类属性，类实例都能访问

实例属性，类不能访问实例才能访问

私有属性类独有的，一般不会拿到外面去用

class Person:_aaa = 'hello'#下划线私有属性__bb = 'world'#私有属性qiye = Person()qiye._aaa#能访问，最好别访问qiye.__bb#不能访问  _Person__bb

方法

class Person:name = '小明'def fun(self):#self实例对象 约定俗成print('正在跑’)qiye = Person()
qiye.run()#没有self就实例方法用不了

类方法（无self）类可以调用

实例方法实例可用类调用需传实例

class Personname = 'xiaoming'def run(self)#self就是实例本身print('%s正在跑'%self.name)laowang = person()
laowang.name = '老王'
laowang.run()

初始化，析构

初始化

class Persondef __init__(self):#自己调用自己 这里self是自己print('hello')qiye = Person()class Persondef __init__(self, name , age, sex):#自己调用自己 这里self是自己self.name = nameself.age = ageself.sex = sexdef run(self):print('%s %d岁 性别%s 正在跑'%(self.name,self.age,self.sex))qiye=Person('郑天尧',22，'男')

析构(删除)

def __del__(self):print()

qiye = Person(男，两个大眼睛，两只长耳朵)

muzi=Person（女，两只小眼睛，两只短耳朵）

20190424

继承

class Rectangle:def __init__(self,length,width)self.length = lengthself.width = widthdef getarea(self):area = self。length*self.widthreturn areaclass Square:def __init__(self,length,width)self.length = lengthself.width = widthdef getarea(self):area = self。length*self.widthreturn areaclass Square(Rectangle):#继承passclass rectangle(object)#基类class Square(Rectangle):def __init__(self,length,width):if length==widthRectangle.__init__(self,length,width)elseprint("你骗我")Square.__base__#查看继承的谁class Dog:def __init__(self):print("wangwang")def run(self)print('haha')class God_Dog(Dog)def __init__(self)#重写Dog.__init__(self)#调用父类initprint('雷神托尔')#自己独有属性def run(self):Dog.run(self)print('heihei')tuoer = God_Dog()class A:def play(self):class B:def play(self):class C(A,B)def play(self):B.play()#一种方法super().play()#另一种方法print()C.mro()#追本溯源

基于多继承的Mix-in设计模式

魔法方法

__init__
__del__
__add__#字符串相加
class Rectangle:def __init__(self,length,width)self.length = lengthself.width = widthdef getarea(self):area = self。length*self.widthreturn areadef __add__(self,other)add_length = self.length + other.lengthadd_width = self.width + other.widthreturn add_length,add_widtha = Rectangle(2,4)
b = Rectangle(3,5)
print(a+b)#就是执行了a.__add__(b)def __repr__(self,other)
def __str__(self,other)def __call__(self)
把实例变函数class C:def __call__(self,*args,**kwargs):print('haha')a = C()
a()
a

20190425

class C(A,B)def __init__(self,a,b,c)super().__init__(a,c,b)#同等与如下写法,C的父类里的initsuper(C,self).__init__()#如下就是在B的父类里找super(B,self).__init__()

类名.方法名（实例本身）

20190426

class A:def __init__(self, name):def Type()type('hello')def Isinstance('helli',str)class rectangle(object):def __init__(self,width,length):self.width = widthself.length = lengthdef getarea(self):return self.width * self.lengthclass square(rectangle):def __init__(self,width,length):if width==length:super().__init__(width,length)def __call__(self, *args, **kwargs):print('正方形的边长是%d'%self.width)# a = square(10,10)
# a()
# print(a.getarea())class A:def __init__(self,name):self.name = namedef __new__(cls, *args, **kwargs):#开辟空间cls就是类本身print(cls)#打印类本身Areturn object.__new__(cls)#一定得有参数def run(self):print(self.name)a = A('小张')#a.run()#__init__实例化的时候调用
#__new__创建的的时候被调用
#__new__先被调用#创建很多实例，只占用一个内存地址   单例模式
class B:_instance = Nonedef __new__(cls, *args, **kwargs):if cls._instance == None:cls._instance = object.__new__(cls)return cls._instanceelse :return cls._instance#instance可以替换，就是一个私有属性def __init__(self,name):self.name = name
#应对那些只能开启一次的
xiaozhang = B('left')
xiaoming = B('right')
print(id(xiaozhang))
print(id(xiaoming))
print(xiaozhang.name)
print(xiaoming.name)class Person:def __init__(self,name):self.name = namedef __getattr__(self, item):return '没属性'xiaoming = Person('xiaoming')#查询实例小明里有没有name属性？True/False
print(hasattr(xiaoming,'name'))#访问实例小明里的name属性
print(getattr(xiaoming,'name'))#修改实例小明的name属性，有则改无则增
setattr(xiaoming,'name','laowang')#增加实例的属性
setattr(xiaoming,'age',19)
print(xiaoming.age)# 删除实例的属性
delattr(xiaoming,'name')
#print(xiaoming,name)#删除实例
#del(xiaoming)xiaoming = Person('xiaoming')
print(xiaoming.name)
print(xiaoming.age)#未传参到达getattr，实现报错

装饰器

#高阶函数
def func():print('haha')def func2(a):a()print('func2')func2(func)#闭包
def func(x):def func2():return xreturn func2a = func(10)
print(a())def modify(func):def wrapper():result = func()return result + '三里桃花不及卿'return wrapper
#g = modify(girl)#函数调用函数
#print(g())@modify#只会影响一行girl放入modity传递出来
def girl():return '春风十里不如你'h = girl()
print(h)class Person:  #龟叔@propertydef run(self):print('人在跑')
a = Person()
a.run()
a.run#可以把方法当属性一样使用class Person:  #龟叔@staticmethod#静态方法 去掉self 变成普通函数 实例解绑def run(self):print('人在跑')
Person.run()class Person:  #龟叔name = 'xiaowang'@classmethod# 类装饰器 以前的self换成clsdef run(cls):print(cls.run)print(cls.name)class Myclass:def __init__(self,func):self.func = funcdef __call__(self, *args, **kwargs):#call实例直接调用print('开始验证')###以后可改return self.func()@myclass
def func():print('正在登陆')

20190429

文件

open('test.txt',encoding=utf8)
open('test.txt')
open('test.txt','r')只读r+没有则报错open('test.txt','w')只写w+有则覆盖没有则创建open('test.txt','a')追加
print(f.read())(r'c:\users\qiye\text','r')取消转义字符
print(f.write('hello')with open('test.txt','r',encoding='utf8') as f1:with open('test2.txt', 'w',encoding='utf8') as f2:a = f1.read()print(a)f2.write(a)#文件内容复制到test2

20190506

L = (i for i in range(5))
L = [i for i in range(5)]

20190507正则表达式

正则是，匹配或者提取(过滤)符串

单字符匹配findall

import re
#######
ret = 'hello WORLD 123'
元字符 .(\n匹配不到的，只有ret处添加,re.S能匹配\n)
a = re.findall(r'.'.ret)这个.任意匹配任何字符
['h', 'e', 'l', 'l', 'o', ' ', 'W', 'O', 'R', 'L', 'D', ' ', '1', '2', '3']元字符 []
a = re.findall(r'[a-z]',ret)
a = re.findall(r'[0-9]',ret)#匹配数字['1', '2', '3']
元字符\d
a = re.findall(r'\d',ret)#匹配数字
a = re.findall(r'\D',ret)#匹配非数字元字符\D
a = re.findall(r'\s',ret)#匹配空格
a = re.findall(r'\S',ret)#匹配非空格元字符\w
a = re.findall(r'\w',ret)#匹配单词字符a-z,A-Z,0-9,_
a = re.findall(r'\W',ret)#匹配非单词字符

数量元字符

数量元字符*有或无
a = re.findall(r'[dnf]*',ret)#
数量元字符+一次或无数次
a = re.findall(r'[dnf]',ret)#
数量元字符{}
a = re.findall(r'h{2}',ret)#出现两次
a = re.findall(r'h{2,}',ret)#至少出现两次
a = re.findall(r'h{2,4}',ret)#两次到四次出现
a = re.findall(r'h{2,4}？',ret)#优先少匹配

单词边界的原字符

a = re.findall(r'^hello',ret)#以hello开头
a = re.findall(r'hello$',ret) #以hello结尾
a = re.findall(r'\b',ret)#匹配一个单词的边界
a = re.findall(r'\B',ret)#匹配一个非单词的边界
a = re.findall(r'h？',ret)#匹配0次或者没有

re.findall(r'\w+',ret)#拿下整个单词
re.findall(r'he|wo',ret)#or
re.findall(r'我(爱你)')#分组
re.findall(r'.*',ret)#整个拿下
re.findall(r'.*?',ret)#所有单字符
re.findall(r'.+？',ret)#所有单字符去空‘’a = '<html>0000</html><td>bbbb</td>'
re.findall(r'<.*>',a)#贪婪模式
re.findall(r'<.*?>',a)#非贪婪模式

match/search

str = 'pythonddddddddddd'
b = re.match(r'python',str)#开头开始匹配
print(b.group())c = re.search(r'python',str)#内容匹配
print(c.group())

json

轻量级前后端交互

python              json
字典                对象
列表/元组            数组
字符串               字符串
int/float           数字
True/False          true/false
None                null

import json
#dumps,dump,loads,load这四个方法
my_dict = {'a':1,'b':[1,2,3],'c':True,'d':None,'e':(1,2,3),'f':'hansha','g':'郑天'}#python转换成json
res = json.dumps(my_dict,ensure_ascii=False)
print(res,type(res))#json转换成python
res2 = json.loads(res)
print(res2)#写入txt文件，转换为json保存文件
with open ('json_txt.txt','w+') as f:json.dump(my_dict,fp = f,ensure_ascii= False)f.seek(0)#光标回到0位置print(f.read())#读取txt文件，读取json转换为python
with open ('json_txt.txt','r+') as f:result = json.load(fp = f)print(result)

hashlib单向加密

对称加密：加密解密用相同密钥

非对称加密：加密解密用不同密钥，公钥加密，私钥解密

单项加密：只能加密数据不能解密数据

hashlib就是单项加密，任意长度变成固定长度

特点

不可逆  定长输出    抗修改性 强碰撞性

代码

import hashlib#print(hashlib.algorithms_available)res = hashlib.new('md5','1hansha'.encode())
res = hashlib.md5(b'123456')
res = hashlib.md5('寒沙'.encode())
print(res.digest()) #转换二进制
print(res.hexdigest())  #转换为十六进制res1 = hashlib.md5('寒'.encode())
res1.update('沙'.encode())#末尾添加 沙
print(res1.hexdigest())#加盐
salt = '寒沙真帅'.encode()
password = b'123456'
paw = password + salt
res = hashlib.md5(paw)

base64对称加密

import base64
# [A-Z,a-z,0-9,'+','/']#编码
s = '寒沙'.encode()#对寒沙进行编码
res = base64.b64encode(s)#对s进行加密
print(res)res_1 = base64.b64decode(res)#对res进行解密
print(res_1)
print(res_1.decode())#解码才能得到

datetime

import datetime#date类（年月日）
my_date1 = datetime.date(2019,6,22)
print(my_date1)#time类（时分秒）
my_date2 = datetime.time(21,3,1)
print(my_date2)#datetime 时间日期类（年月日时分秒）
mydatetime = datetime.datetime(2019,6,22,21,6,1)
print(mydatetime)#now()获取当前时间
mydate = datetime.datetime.now()
print(mydate)#时间转换为时间戳
mydate3 = mydate.timestamp()
print(mydate3)#时间戳转换为时间对象
mydate4 = datetime.datetime.fromtimestamp(mydate3)
print(mydate4)#时间转换为字符串
mydate5 = mydate4.strftime('%y-%m-%d %H:%M:%S')#y取到19  Y取到2019 %H是24小时制 换成%I是12小时制
print(mydate5,type(mydate5))#字符串转换成时间格式
mydate6 = datetime.datetime.strptime(mydate5,'%y-%m-%d %H:%M:%S')
print(mydate6,type(mydate6))#当前时间 - 上课所花时间 = 上课开始时间
present = datetime.datetime.now()
last = datetime.timedelta(minutes = 45)
start = present - last
print(start)

logging

几种级别，由轻到重

日志等级     描述
DEBUG           调试信息
INFO            普通信息
WARNING         警告信息
ERROR           错误信息
CRITICAL        危险信息

Formatter格式

%(asctime)s      日志事件发生的时间
%(levelname)s   该日志的级别
%(message)s     日志记录的文本内容
%(name)s        所使用的日志器名称
%(pathname)s    调用日志记录函数的文件的全路径
%(filename)s    调用日志记录函数的文件
%(funcName)s    调用日志记录函数的函数名
%(lineno)d      调用日志记录函数的代码所在的行号

res进行解密
print(res_1)
print(res_1.decode())#解码才能得到


### datetime```python
import datetime#date类（年月日）
my_date1 = datetime.date(2019,6,22)
print(my_date1)#time类（时分秒）
my_date2 = datetime.time(21,3,1)
print(my_date2)#datetime 时间日期类（年月日时分秒）
mydatetime = datetime.datetime(2019,6,22,21,6,1)
print(mydatetime)#now()获取当前时间
mydate = datetime.datetime.now()
print(mydate)#时间转换为时间戳
mydate3 = mydate.timestamp()
print(mydate3)#时间戳转换为时间对象
mydate4 = datetime.datetime.fromtimestamp(mydate3)
print(mydate4)#时间转换为字符串
mydate5 = mydate4.strftime('%y-%m-%d %H:%M:%S')#y取到19  Y取到2019 %H是24小时制 换成%I是12小时制
print(mydate5,type(mydate5))#字符串转换成时间格式
mydate6 = datetime.datetime.strptime(mydate5,'%y-%m-%d %H:%M:%S')
print(mydate6,type(mydate6))#当前时间 - 上课所花时间 = 上课开始时间
present = datetime.datetime.now()
last = datetime.timedelta(minutes = 45)
start = present - last
print(start)

logging

几种级别，由轻到重

日志等级     描述
DEBUG           调试信息
INFO            普通信息
WARNING         警告信息
ERROR           错误信息
CRITICAL        危险信息

Formatter格式

%(asctime)s      日志事件发生的时间
%(levelname)s   该日志的级别
%(message)s     日志记录的文本内容
%(name)s        所使用的日志器名称
%(pathname)s    调用日志记录函数的文件的全路径
%(filename)s    调用日志记录函数的文件
%(funcName)s    调用日志记录函数的函数名
%(lineno)d      调用日志记录函数的代码所在的行号