预科班
www.python.org 3.6.7 3.6.8
常用单词
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 decimal
a = decimal.Decimal('0.2')
b = a * a
c = 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 i
return fun1
a.append(fun(i))
print (a)
////////////////////
li = []
for i in range(4)
def func()
return i
li.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 Person
name = 'xiaoming'
def run(self)#self就是实例本身
print('%s正在跑'%self.name)
laowang = person()
laowang.name = '老王'
laowang.run()
初始化，析构
初始化
class Person
def __init__(self):#自己调用自己 这里self是自己
print('hello')
qiye = Person()
class Person
def __init__(self, name , age, sex):
#自己调用自己 这里self是自己
self.name = name
self.age = age
self.sex = sex
def 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 = length
self.width = width
def getarea(self):
area = self。length*self.width
return area
class Square:
def __init__(self,length,width)
self.length = length
self.width = width
def getarea(self):
area = self。length*self.width
return area
class Square(Rectangle):#继承
pass
class rectangle(object)#基类
class Square(Rectangle):
def __init__(self,length,width):
if length==width
Rectangle.__init__(self,length,width)
else
print("你骗我")
Square.__base__#查看继承的谁
class Dog:
def __init__(self):
print("wangwang")
def run(self)
print('haha')
class God_Dog(Dog)
def __init__(self)#重写
Dog.__init__(self)#调用父类init
print('雷神托尔')#自己独有属性
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 = length
self.width = width
def getarea(self):
area = self。length*self.width
return area
def __add__(self,other)
add_length = self.length + other.length
add_width = self.width + other.width
return add_length,add_width
a = 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的父类里的init
super(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 = width
self.length = length
def getarea(self):
return self.width * self.length
class 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 = name
def __new__(cls, *args, **kwargs):#开辟空间cls就是类本身
print(cls)#打印类本身A
return object.__new__(cls)#一定得有参数
def run(self):
print(self.name)
a = A('小张')
#a.run()
#__init__实例化的时候调用
#__new__创建的的时候被调用
#__new__先被调用
#创建很多实例，只占用一个内存地址 单例模式
class B:
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance == None:
cls._instance = object.__new__(cls)
return cls._instance
else :
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 = name
def __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 x
return func2
a = 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: #龟叔
@property
def 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换成cls
def run(cls):
print(cls.run)
print(cls.name)
class Myclass:
def __init__(self,func):
self.func = func
def __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 调用日志记录函数的代码所在的行号
扫一扫
1989
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
