Python
anaconda的环境设置命令
anaconda 包含了conda和pip两个包管理工具。
conda -V / conda --version 查看conda的版本。
conda update anaconda 升级anaconda的版本。
conda update conda 升级conda包管理器的版本
conda update pip 升级pip包管理器的版本。
conda env list 查看系统中虚拟环境。
(base) leo@leo-Surface-Pro:~$ conda env list
# conda environments:
base * /home/leo/anaconda3
conda activate env_name 切换虚拟环境
conda deactivate 退出当前虚拟环境,进入base。
conda create -n env_name 创建虚拟环境。
conda create -n env_name -c 源env_name 从其他环境复制一份新的虚拟环境。
conda remove -n env_name --all 删除虚拟环境
conda(pip) install -n env_name module_name 安装模块
conda install -n demo selenium
conda install python=3.9.4
conda remove -n 环境名 模块名 删除conda安装的模块
pip3 uninstall -n 环境名 模块名 删除pip删除的模块模块
conda list -n 环境名 显示指定环境下安装的模块。
配置Pycharm使用Anaconda的环境
创建新的项目,使用已经配置的虚拟环境。
赋值
x, y, z = 1,[1,2,3], 'Fidelio'
x = 'micros' , 'Fidelio' ==> ('micros' , 'Fidelio')
a, b = b, a 值互换
m = n = 'Fidelio' 链式赋值
id(对象) 显示对象的内存地址。
a is b 判断a 和 b 是不是一个对象。
基本数据类型
Python的每个对象在内存中都有自己的地址,使用 id(对象) 可以获得内存地址。
type(对象) 可以查看对象的类型。
a = 'www.163.com'
id(a)
4592242544
type(a)
<class 'str'>
对象有类型,变量无类型。 变量只是一个标签,贴到不同的对象上。
整型和浮点型
整型 int表示, 浮点型 float表示。
浮点数与整型运算,得到的是浮点型。
Python解决了整型溢出的问题。
浮点数可以使用科学记数法表示,2e3表示2000.0, 浮点数。
浮点数会溢出。
// 取得两个数的整数商,不是四舍五入,而是直接去整。
误差问题
100.0 / 3 得到的结果是33.333333333333336。
要获得准确的结算结果,需要使用decimal模块的Decimal类型。
使用内置的round(数值,保留小数位)来进行四舍五入计算。
#decimal.Decimal演示
import decimal
a = decimal.Decimal(100)
b = decimal.Decimal(3)
a / b
Decimal('33.33333333333333333333333333')
#round()的演示
round(a/b,2)
Decimal('33.33')
字符串
字符串可以使用单引号或者双引号,结果都是一样的。
转义
\ 是转义字符。
- \n换行
- \b 退格
- \000 空白,其后面的内容不现实。
- \f 换页
r'字符串' 代表字符串中的字符就是原始字符,不包含特殊含义。
print('Micros\nFidelio')
Micros
Fidelio
print(r'Micros\nFidelio')
Micros\nFidelio
字符串切片
字符串是一个序列,可以使用序列的方法进行操作。
- 通过索引可以访问字符串的字符。
- 切片 str[开始索引:结束索引] 包头不包尾。
- len(str) 获得字符串长度。
- + 连接两个序列。
- * 重复序列的元素,生成新序列。
- in 判断元素是否在序列中
- max(str) , min(str) 虽然最大值元素和最小值元素。
str[0:3]
'abc'
str[:3]
'abc'
str[3:]
'de'
str[-3:-1]
'cd'
str[::2]
'ace'
max(str)
'e'
min(str)
'a'
'a' in str
True
str * 3
'abcdeabcdeabcde'
字符与编码转换
ord(字符) 获得字符对应的数字编码。 chr(数字) 获得数字对应的字符。
字符串的格式化
- "{0:15}".format(str) 使用str替换占位符,15个字符长度,靠左对齐。
- "{0:>15}".format(str) 使用str替换占位符,15个字符长度,靠右对齐。
- "{0:^15}".format(str) 使用str替换占位符,15个字符长度,居中对齐。
- "{0:>15.2}".format(str) 使用str的前两个字符替换占位符,15个字符长度,靠右对齐。
- "{0:^10d}".format(int) 使用int替换占位符,10个长度,居中对齐。
- "{0:010d}".format(int) 使用int替换占位符,10个长度,靠右对齐,不足补0。
- "{0:010.2f}".format(float) 使用float替换占位符,10个长度,四舍五入保留两位小数,不足补0。
- "{Key1} and {Key2}".format(Key1 = value, Key2=value)
- f"{变量名} 其他内容 {变量名}"
'I love {0:^10}'.format('fidelio')
>>'I love fidelio '
'I love {0:^10.2}'.format('fidelio')
>>'I love fi '
'My weight is {0:^10.2f} kg'.format(87.567)
>>'My weight is 87.57 kg'
'My height is {0:^10d} cm'.format(180)
>>'My height is 180 cm'
'My height is {0:010d} cm'.format(180)
>>'My height is 0000000180 cm'
'I like {lang} and {name}'.format(lang = 'Python', name = 'Leo')
>>'I like Python and Leo'
字符串检查方法
- str.isalnum(): 是否只包含字母和数字。
- str.isdigit():是否只包含数字。
- str.isspace(): 是否只有空白, \n\t都会是True。
- str.istitle():是否每个单词都是第一个字母大写。
- str.islower():是否都是小写。
- str.isupper(): 是否都是大写。
- str.startswith(str1):字符串是否是str1开头
- str.endswith(str1):字符串是否是str1结尾
字符串修改
- str.split(str1): 使用str1分割字符串,返回一个字符串列表。默认参数是空格。
- str.lstrip():去掉字符串左边的空白。
- str.rstrip(): 去掉字符串右边的空白。
- str.strip():去掉字符串两边的空白。
- str.upper():全部转为大写
- str.lower():全部转为小写
- str.capitalize(): 首字母大写
- str.title():每个单词的第一个字母大写
- str.join(序列):返回 序列元素1+'str'+序列元素2+'str'. split的逆操作。
布尔值
True / False
直接得到真值: 数字1, 任何非空的东西,例如:非空字符串,非空序列。
直接得到假值:数字0, 任何空的东西,例如:空字符串,空序列,None。
逻辑运算符
and
or
not
分支与循环语句
if条件语句
if 条件:
语句块
elif 条件 :
语句块
else :
语句块
三目运算符:
A = X if 条件 else Y 条件为真,A=X,否则A=Y。
pass 站位语句,什么也不做。if语句后如果什么也不写会抛出异常,可以使用pass占位。
for循环语句
- for i in range(10):
语句块 i = 0 ~9
-
for element in 集合 :
语句块
-
for 条件:
语句块
else:
语句块
for 运行完以后,else语句块执行。
for被break以后,else语句块不会执行。
- 列表推导式 list = [ i for i in range(10) ]
while语句
while 条件 :
语句块
else :
语句块(当while条件不在成立时)
while条件为True时, else语句块不会执行。当While条件为False时,else语句块执行。
break 跳出循环体
continue 从continue所在位置调到循环语句块的最后一行(不执行最后一行)
序列
序列相关的内置函数
len(序列) 序列元素的个数,或者字符串的字符个数。
max(序列) 序列的最大元素。
min(序列) 序列的最小元素。
列表
list = [元素,元素]
list = list(元组) 将元组转为列表
list = list[: :-1]反转元素。
list.count(元素) 元素出现的次数。
list.index(元素) 元素出现的位置。找不到返回ValueError异常。
list.remove(元素) 从列表中删除元素,找不到元素返回ValueError异常。
list.pop(i) 删除索引为i的元素,并返回元素。不加参数默认删除最后一个元素。
del 列表[索引] 删除列表指定索引的元素。
list.reverse() 反转列表中的元素。
list.sort() 将列表的元素进行升序排序。list.sort(reverse = True) 进行降序。list.sort(key=len) 以元素的长度排序。
list.append(元素) 将元素添加到list。
list.insert(位置, 元素) 将元素插入到位置。
reversed(列表) 返回一个反向排序的元组。
str.join(列表) 返回一个str连接列表元素的字符串。
列表支持加法和乘法。
元组
tuple = (元素, 元素), 只有一个元素是,使用 tuple = (元素, )
来创建元组。
tuple = tuple(list) 将列表转为元组
tuple.count(元素) 元素出现的次数。
tuple.index(元素)
封包和解包(元组,列表)
封包: 将多个值赋值给一个变量,会产生一个元组。
解包:将一个元组或者列表的元素赋值给多个变量。
#封包
>>> names = 'leo', 'kevin', 'winston'
>>> names -> ('leo', 'kevin', 'winston')
#解包
>>> name1, name2, name3 = names
>>> print(name1, name2, name3, sep='\n')
leo
kevin
winston
字典
字典的key一定是不可改变的类型,比如字符串常量,数值常量,布尔类型,元组。
dict() 转换元组或者列表为字典。
a= (['name', 'leo'], ['age', 18], ['gender', 'male'])
b = dict(a)
b
{'name': 'leo', 'age': 18, 'gender': 'male'}
dict.copy() 产生另外一个字典对象。
如果dict中的元素有引用型,需要使用copy模块的deepcopy命令来产生一个完全不同的字典。
import copy
a = {'name': ['leo','kevin']}
b = copy.deepcopy(a)
dict[键] 或者dict.get(键) 区别是get方法找不到key的时候也不返回异常。
dict.get(key , [ default ] ) 找到key,返回value,找不到,返回default(可选参数,默认为None)。
dict[key] = value 来设置键值对,缺点是如果存在键值对,会被覆盖掉。
dict.setdefault(key, [default] ) ,如果能找到key, 则返回value。 找不到key,就设置一个dict[key] = default , 并返回default。
dict.update(dict) 融合两个字典的键值对。如果作为参数的字典的key在当前字典存在,则更新value。
del dict[key] 删除键值对,找不到返回KeyError 异常。
dict.pop(key , [default]) 删除一个键值对,返回value,找不到默认返回异常。如果设置了default,返回default。
dict.popitem() 随机删除一个键值对,并用元组的形式返回删除的键值对。
dict.clear() 清除字典的所有键值对。被清空的字典为{ } , 仍然存在内存中。 del(dict) 就把字典从内存中销毁。
dict = {'name':'leo', 'age':18, 'gender':'male'}
dict.keys() 得到所有的key,以列表返回。['name', 'age', 'gender']
dict.values() 得到所有的value,以列表返回。['leo', 18, 'male']
dict.items() 得到所有的键值对,每个键值对放在一个元组中,所有的元组放在一个列表中。
[('name', 'leo'), ('age', 18), ('gender', 'male')]
集合
使用set(序列)可以创建可变集合。
set1 = set(['Leo' , 'Fidelio'])
{'Fidelio', 'Leo'}
list1 = list(set1) #将集合转为列表 或者用tuple转元组。
集合没有索引,也没有顺序,不属于序列。
集合中不能有重复的数据,重复数据会自动删除。
集合中不能添加可变类型的数据,例如列表不能添加到集合中。
set.add(元素) 向集合中添加元素。
set.update(set1) 将set1的元素添加到集合中。
set.pop() 随机删除集合的元素,不能有参数指定。空集合删除元素返回异常。
set.remove(元素) 删除指定的元素。删除不存在的元素会返回异常。
set.discard(元素) 删除指定的元素。元素不存在也不会返回异常。
set.clear() 清除集合的所有元素。
可以用集合set() 方法消除重复项。
list1 = [1,2,3,4,5,1,1,2,3,1,4]
list1 = list(set(list1))
print(list1) -> [1, 2, 3, 4, 5]
元素 in 集合 判断元素是否存在于集合。
集合1 == 集合2 判断两个集合的元素是否相同。
集合1 < 集合2 判断集合1是不是集合2的子集。a.issubset(b)
集合1 > 集合2 判断集合1是不是集合2的超集。a.issuperset(b)
集合1 | 集合2 返回两个集合的并集。 a = a.union(b)
集合1 & 集合2 返回两个集合的交集。a = a.intersection(b) intersection_update 直接更新a
集合1 - 集合2 返回集合1相对于集合2的差集。a.difference(b) difference_update会直接更新a。
集合1 ^ 集合2 返回集合1和集合2的对称差集。a.symmetric_difference(b)
使用frozenset() 创建不可变集合。
dir(frozenset) 查看可用的命令。
模块和包
使用模块的优点:
- 提供代码可重用性。
- 提供独立的命名空间。
导入模块
import 模块名
import 模块名, 模块名, 模块名
from 模块名 import 函数名 导入模块下的某个函数。
from 模块名 import 函数名 as 别名 导入模块下的某个函数,并给一个别名。
from 模块名 import * 导入模块下的所有函数,不推荐。
使用主入口__main__的意义
当import的时候,会立即运行一遍导入的模块的代码。
如果模块有主入口的main函数语句,只有当前py文件被当成程序执行的时候才执行。作为模块被导入时,不会执行main函数的语句。
当模块没有包含在sys.path中,是无法导入的。
两个方法:
-
将模块创建在这个目录: '/Users/leo/opt/anaconda3/lib/python3.9/site-packages'
-
将需要使用的目录添加到sys.path 环境变量。
import sys
new_path = '/home/leo/PycharmProjects/leo1/venv/fid/fid'
sys.path.append(new_path)
import my_first_module
my_first_module.say_hello()
导入包
使用. 进入包的目录,找到对应的模块。
import 包路径
import 包路径.包路径
from 包路径 import 模块名
from asyncio.events(包.模块) import Handle(类)
__init__.py的作用
导入包的时候,就会读取包目录下的__init__.py文件。
__init__.py的作用是:
- 编写一些让导入者可以看到的信息。
- 提供可以调用的信息,比如: 类、方法、函数、变量等。
- 把下级成员的模块导入到顶层模块,然后通过顶层模块直接调用。
Fidelio包的__init__.py中定义了函数.
def intro():
print('Hello, I will facilitate the opera manipulation....')
导入Fidelio包的时候,init.py自动运行,函数可以使用.
import Fidelio
Fidelio.intro() -> Hello, I will facilitate the opera manipulation....
Fidelio包中的init.py,将其包含的模块的方法导入Fidelio包的环境。
from Fidelio.mod1 import fun1
from Fidelio.mod2 import fun2
from Fidelio.Opera.mod3 import fun3
写程序的时候,导入Fidelio包就可以通过Fidelio.fun1()去调用了。
Fidelio.fun1()
脚本运行
脚本开头的两句话,第一句指明python的位置,第二句指明使用utf8编码,避免中文乱码。
#!/usr/bin/env python
#coding:utf-8
python运行的时候,会将py文件编译为pyc文件。如果没有修改py文件,那么执行这个程序的时候,会直接运行之前生成的pyc文件,这样可以提升执行速度。
帮助系统
-
单行注释 #
-
多行注释
```
多行注释
\```
查看函数的功能,可以使用 help(函数) 来查看。
help(id)
输出如下:
Help on built-in function id in module builtins:
id(obj, /)
Return the identity of an object.
This is guaranteed to be unique among simultaneously existing objects.
(CPython uses the object's memory address.)
可以使用函数或者对象的__doc__属性来查看帮助文档。
print(print.__doc__)
output:
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
为函数编写帮助
使用三引号将帮助信息包含在函数定义的下一行。
def calc_score(*scores):
"""
本函数用来计算总成绩。
:param scores: 可以填写多个成绩。
:return: 返回总成绩
"""
total = 0
for i in scores:
total += i
return total
函数
函数可以封装代码,达到代码复用的目的; 创建一个新的命名空间。
主函数
main函数时程序的主入口。作为模块被调用的时候,主函数中的语句避免了脚本运行。
#pycharm中输入main()即可
#main函数的上面定义函数和类。
if __name__ == '__main__':
代码...
函数的定义
def 函数名(参数...):
语句...
语句...
顺序参数与关键字参数
顺序参数按照型参定义的顺序传递参数,顺序不能乱,参数不能少。
使用函数名 = 值的形式传递的参数。顺序可以乱,参数不能少。
def func(var1, var2):
print(var1, var2)
func(var2 = 'Zhang' , var1 = 'Leo')
变量的作用域
作用域定义了变量能在多大的范围内被访问。
- 全局变量:直接在内存中定义的单独变量。全局变量可以在任何地方访问。
- 局部变量: 在函数中定义的变量叫做局部变量。局部变量只能在定义的函数中,或者函数的函数中被访问。
def demo():
var = 20 #局部变量
#函数中使用global var可以访问全局变量。不实用global,则会创建一个新的局部变量。
if __name__ == '__main__':
var = 10 #全局变量
形参和实参
定义函数的参数列表叫做形参。
调用函数传入的参数列表叫做实参。
def demo(var): #定义函数的规定的参数是形参
pass
demo(123) #调用函数时实际传入的参数是实参。
默认参数
指定默认值的参数的值,调用的时候可以不传递这个参数。
默认值参数应该放在型参列表的最后。
为默认值参数传递值,新值会覆盖默认值。
def func(var1, var2='Zhang')
print(var1, var2)
func('Leo')
参数收集
当时用的参数数量不确定的时候,可以使用参数收集的方式传递多个参数,传递的实参以元组形式存放。
这种参数名前加 * 表示。
应当注意:
- 型参中只能由一种这样的参数。
- 尽量将这种参数放在型参列表的尾部。
- 出现在这种参数之后的参数,只能使用关键字调用(想想print函数)。
def func(*args):
print(f'number of args: {len(args)}')
print(args)
func('Leo', 'Zhang')
output:
number of args: 2
('Leo', 'Zhang')
关键字参数收集
当有不确定数量的关键字参数时,可以使用关键字参数收集,将收集到的关键字实参封装为字典存放。
这种参数名前加 ** 表示。
应当注意:
- 型参中只能由一种这样的参数。
- 必须将这种参数放在型参列表的尾部。
def func(**kargs):
print(kargs)
func(name = 'Leo', age = '41')
output:
{'name': 'Leo', 'age': '41'}
逆向参数收集
将序列对象传递给函数,按照一定规则将序列对象的元素分配给型参。
应当注意:
实参为元组或者列表时,元素的数量应当与型参相同。
实参为字典时,元素的key必须与型参名字相同。
def func(var1 , var2):
print(var1, var2)
arg1 = ['Leo', 'Zhang']
arg2 = {'var1': 'Leo' , 'var2':'Zhang'}
func(*arg1)
func(**arg2)
参数传递机制
不可变类型作为参数传递给函数后,按值传递的机制会复制一份传递,对于实参的任何操作都不会影响实参的值。
def func(name):
name = 'IT: ' + name #修改传递的参数
print(name) #IT: Leo
if __name__ == '__main__':
my_name = 'Leo'
func(my_name)
print(my_name) #Leo
可变类型作为参数传递给函数后,因为传递的是可变类型的地址,对于参数的任何操作都会影响实参的值。
def func(name_list,name):
name_list.append(name) #name_list作为可变参数被添加了新值。
if __name__ == '__main__':
names = []
func(names, 'Leo')
print(names) #['Leo']
return返回值
函数执行到return,会立即返回。return后面的语句不会执行。
return可以多个值,自动封包为元组。
不定义return的时候,函数返回一个None。
def demo():
return 1,2,3
if __name__ == '__main__':
result = demo()
print(result) # -> (1, 2, 3)
Lambda表达式
Lambda匿名函数,使用lambda关键自定义。 func = lambda 逗号分割的参数列表: 表达式主体
Lambda表达式主体只能放一个语句。Lambda自带return语句。
Lambda表达式支持的参数形式和正常函数一致。
func = lambda x, y: x + y
args = (1,2)
print(func(*args)) #3
异常处理
所有的异常都派生于BaseException类,不同的类记录了不同的异常信息。
异常处理的结构
try:
可能发生异常的语句
except 异常类型 [as 别名]:
异常处理语句
except Exception [as 别名]:
异常处理语句
[else:
没有异常发生所处理的语句]
[finally:
有无异常一定处理的语句]
如果有多个except,处理异常的时候会去找最准确的异常类型,如果找不到在看有没有父类的异常类型,所以exception会在没有匹配上的时候在执行这个异常处理的分支。
finally分支用来进行资源的回收,无论try分支是否有异常,都会执行finally分支。
资源的回收包括: 打开文件、建立的网络套接字、数据库连接、多线程多进程。
触发异常
raise关键字主动抛出异常raise Exception
。
raise Exception('异常信息说明')
raise TypeError('This s a user-defined exception message....')
output:
Traceback (most recent call last):
File "/home/leo/PycharmProjects/Fidelio/main.py", line 1, in <module>
raise TypeError('This s a user-defined exception message....')
TypeError: This s a user-defined exception message....
内置电池函数
基本函数
round(数值, 小数位) : 四舍五入
bool(对象) 判断对象是否为空。当变量为数字0,None,空字符串或者空序列的时候,得到的结果为False。
reverved(列表) 将列表反转,返回列表。
sorted(列表) 将列表排序,返回列表。
range(开始值,结束值,步长) 返回从开始到结束值-1 的 range对象。
zip(集合1 , 集合2) 返回zip对象,集合1与集合2 索引相同的值作为zip对象的元素。
a = (1, 2, 3)
b = ('a' ,'b', 'c')
print(list(zip(a,b))) ==> [(1, 'a'), (2, 'b'), (3, 'c')]
enumerate(集合) 将每个集合的值的索引与值形成一个数组。
a = (1,2,3)
list(enumerate(a)) ==> [(0, 1), (1, 2), (2, 3)]
for i,d in enumerate(a):
print(i,d)
0 1
1 2
2 3
文件
file = open(文件路径 , 'r') 打开文件
file = open(文件路径 , 'w') 清空写入文件
file = open(文件路径 , 'a') 追加写入文件
for line in file : 针对文件每行进行扫描,遇到\n 结束本行。
file.read(size) 返回文本文件的所有内容 或者 size个字符的内容。
file.readline() 读取一行的内容。
file.readlines() 将文件的内容读到一个列表中,每行是列表的一个元素。
file.seek(行号) 移动文件读取的指针。
file.tell() 显示当前指针的位置。
file.write(内容) 写入一行数据
file.writelines(字符串列表) 将列表的每个元素作为一行写入文件。
file.close() 关闭文件
面向对象
创建类和实例
class 类名:
类的语句
class 类名(父类) :
类的语句
类名的首字母需要大写。
类名() 创建了一个实例。
面向对象编程
面向对象的三大特征:
- 封装
- 继承
- 多态
封装
将类的属性和方法包含到类中。
构造方法 __init__ 将属性绑定到类的对象。
self代表将被创建出来的类的对象。
class User:
def __init__(self,name, age, major):
self.name = name
self.age = age
self.major = major
def __str__(self):
print(f'{self.name}\'s age is {self.age} and major is {self.major}',end='')
return ''
user1 = User('Leo', 30, 'History')
user2 = User('Kevin',34, 'Math')
print(user1) -> Leo's age is 30 and major is History
print(user2) -> Kevin's age is 34 and major is Math
#self 参数用来指明创建出来的属性绑定到哪个对象。
类的方法中也可以添加类的属性,所添加的属性在类中可以全局调用。
class User:
def __init__(self, name):
self.name = name
def set_age(self, age):
self.age = age
def get_age(self):
print(self.age)
user1 = User('leo')
user1.set_age(30) -> 这里产生了一个属性age
user1.get_age() -> 查询类属性age
实例方法、类方法、静态方法
实例方法:首个参数是self,绑定给类的实例调用的,类本身不能调用。
类方法:首个参数是cls,并以classmethod修饰的方法,类可以直接调用,类的实例也能直接调用。类的属性在类方法中是无法使用的。
静态方法:无首个参数,使用修饰器staticmethod修饰的方法,类可以直接调用,类的实例也能直接调用。类的属性在类方法中是无法使用的。
class User:
def __init__(self, name):
self.name = name
@classmethod
def cls_method(cls, name):
print(name)
@staticmethod
def sta_method(name):
print(name)
User.cls_method('Leo') #-> Leo
User.sta_method('Winston') #-> Winston
动态的添加属性和方法
动态添加属性
为类添加的属性影响所有类的实例。为对象添加属性只影响单个对象。
class User:
def __init__(self, name):
self.name = name
if __name__ == '__main__':
user1 = User('Leo')
User.age = 30 ->为类添加动态属性
print(user1.age) -> 30
#虽然先创建的实例,添加类属性后,前面创建的对象也获得了这个属性。
动态添加方法
实例方法:只能单独为对象添加,不能为类添加。需要使用types模块来协助。只有在添加方法的对象可以调用,其他对象无法调用。
import types
class Person:
def __init__(self,name):
self.name = name
def say_hello(self): 定义需要添加到对象的方法
print('Hello World')
if __name__ == '__main__':
user = Person('Leo')
user.say_hello = types.MethodType(say_hello, Person) 添加方法到对象。
user.say_hello()
类方法:使用@classmethod装饰器定一个类方法,然后复制给类。类和对象都可以调用。
class Person:
def __init__(self,name):
self.name = name
@classmethod
def say_hello(cls):
print('Hi, I am newly added class method...')
if __name__ == '__main__':
Person.say_hello = say_hello
Person.say_hello() -> Hi, I am newly added class method...
user = Person('Leo')
user.say_hello() -> Hi, I am newly added class method...
静态方法:使用@staticmethod装饰器定一个类方法,然后复制给类。类和对象都可以调用。
class Person:
def __init__(self,name):
self.name = name
@staticmethod
def get_rid_from_china():
print('No way...')
if __name__ == '__main__':
Person.get_rid = get_rid_from_china
Person.get_rid()
user = Person('Leo')
user.get_rid()
继承
子类继承父类后,可以直接使用父类的属性和方法。
子类定义了和父类同名同参的方法,则会覆盖父类的方法。
class 类名(父类名):
类定义代码
class User:
def __init__(self, name):
self.name = name
def show_message(self):
print('Show message in user view')
def add_message(self):
print('Add a new message')
class Admin(User):
def show_message(self):
print('Show message in admin view')
if __name__ == '__main__':
admin1 = Admin('Leo') 调用了父类的__init__(self, name)方法
admin1.show_message() 调用了子类覆盖父类的show_message
admin1.add_message() 调用从父类继承的show_message
super()函数调用的方法
可以在子类中调用父类的任何方法。
如果父类的方法要传参,子类调用的时候同样要传递参数。
子类调用父类的方法时,方法定义的self指向的是子类而不是父类。
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def see(self):
print('I can see you')
class Teacher(Person):
def __init__(self,name, age, school):
super().__init__(name, age) #调用父类构造函数
self.school = school
def see_student(self):
super().see() #调用父类的方法
if __name__ == '__main__':
leo = Teacher('Leo', 30, 'Collins')
leo.see_student() #I can see you
print(leo.name, leo.school) #Leo Collins
对于属性的继承
全部保留属性:子类不重写父类的__init__函数,就会全部保留父类的属性。
全部替换属性:子类重写父类的__init__函数,父类的__init__函数因为不调用,所以父类的属性都不存在。
class Vehicle:
def __init__(self, brand, wheel):
self.wheel = wheel
self.brand = brand
class Car(Vehicle):
def __init__(self, manufacturer):
self.manufacturer = manufacturer
if __name__ == '__main__':
my_car = Car('Japan')
部分保留,无新增:子类的__init__函数使用super()调用父类的__init__函数,用不到的参数传递None。
class Vehicle:
def __init__(self, brand, wheel):
self.wheel = wheel
self.brand = brand
class Car(Vehicle):
def __init__(self, brand): -> 只使用brand参数创建car对象
super().__init__(brand, wheel=None) ->使用None去掉不需要的属性
self.model = model
部分保留,有新增:子类的__init__函数使用super()调用父类的__init__函数,用不到的参数传递None。也新加子类专用的属性。
class Vehicle:
def __init__(self, brand, wheel):
self.wheel = wheel
self.brand = brand
class Car(Vehicle):
def __init__(self, brand, model): ->新增一个model属性,使用brand,model参数创建新对象
super().__init__(brand, wheel=None) ->使用None去掉不需要的属性
self.model = model
类变量
在类中定义的变量,不是类的属性。
使用类来访问和修改类变量。实例只能访问但无法修改类变量。
类对变量的访问顺序:
实例的属性(动态添加) -> 类的属性 -> 类变量 -> 父类的属性 -> 父类的类变量 -> 再继续往父类找....
class User:
var = 10
def __init__(self,name):
self.name = name
if __name__ == '__main__':
print(User.var)
a = User('a') #10
print(a.var) #10
User.var = 100
print(a.var) #10
a.var = 50 #实例改变不了类变量,只是给自己动态增加了一个属性。
print(a.var) #50
print(User.var) #100
类方法和静态方法可以访问和修改类变量
class User:
var = 10
@classmethod
def change_var(cls, new_var):
User.var = new_var
@staticmethod
def modify_var(new_var):
User.var = new_var
def __init__(self,name):
self.name = name
if __name__ == '__main__':
User.change_var(200)
print(User.var)
User.modify_var(250)
print(User.var)
常用模块
re模块
用来创建正则表达式,用来验证和查找符合规则的文本。广泛用于搜索引擎和账号密码的验证。
正则表达式预定义字符
\d : 匹配十进制数字。
\D : 匹配所有的非数字。
\s : 匹配所有空白字符, 空格,tab。
\S :匹配所有非空字符和下划线。
\w : 匹配所有字母、汉字、数字。a-z, A-Z, 0-9.
\W : 匹配所有字母、汉字、数字和下划线。
import re
str1 = '[我是你爷爷abcd] 1234'
finded = re.search('\d\d\d', str1) #从字符串匹配三个连续数字,从后往后找。
print(finded.group()) # 第一个匹配的是123
正则表达式特殊字符
^ : 文本的开头
$ : 文本的结尾
* : 前面的字符出现0次或者多次。
+ : 前面的字符出现1次或者多次。
? : 前面的字符出现0次或者多次,但变变贪婪模式为勉强模式匹配。
贪婪模式匹配出的字符串尽量的长,勉强模式匹配的字符串尽量的短。
. : 匹配除了\n以外的任何单个字符。
| : 使用竖线左右的正则表达式进行匹配。
import re
str1 = '[我你是你爷爷爷爷abcd] 你爷爷, 你爷1234'
finded_star = re.findall('你爷*', str1) #从字符串匹配你[爷0-无限次]
finded_plus= re.findall('你爷+', str1) #从字符串匹配你[爷1-无限次]
finded_question = re.findall('你爷?', str1) #勉强模式从字符串匹配。
finded_dot = re.findall('.*', str1)
finded_or = re.findall('你爷+|\d', str1)
print(finded_star) # ['你', '你爷爷爷爷', '你爷爷', '你爷']
print(finded_plus) #['你爷爷爷爷', '你爷爷', '你爷']
print(finded_question) #['你', '你爷', '你爷', '你爷']
print(finded_dot) #['[我你是你爷爷爷爷abcd] 你爷爷, 你爷1234', '']
print(finded_or) #['你爷爷爷爷', '你爷爷', '你爷', '1', '2', '3', '4']
[ ] : 代表一个集合。
- [abc] -- 匹配指定的单个字符。
- [a-zA-Z0-9 ] -- 匹配范围内的单个字符,可取反。 [^表达式] 取反。
- [0-5][0-9] -- 可以组合匹配。
import re
str1 = '我的名字是zhangsan,我的电话是18660236631'
str1 = '86, 71, 99, 97,00'
find1 = re.findall('[5-9][5-9]|0', str2)
print(find1) #['86', '99', '97', '0', '0']
find3 = re.findall('[^a-zA-Z0-9,]+',str1) #取反
print(find3) #['我的名字是', ',我的电话是']
{ } : 标记前面字符出现的频率。
- {m, n} -- 前面字符最少m次,最多n次。
- {m, } -- 前面字符最少m次,上不封顶。
- { , n} -- 前面字符最多出现m次,最少一次都可以不出现。
- { n } -- 前面字符最少出现n次。
正则表达式合理字符
\t : 制表符
\n : 换行符
\r : 回车符
\f : 换页符
\a : 报警符
\e : Escape符
匹配方法 match, search
re.match将目标文本与正则表达式进行匹配。
如果匹配成功,将返回一个匹配对象,对象中包含匹配到的第一个子串。
如果匹配不成功,将返回None。
-
match 在目标文本的开头进行匹配。
import re str1 = 'https://www.baidu.com' not_find = re.match('www', str1) do_find = re.match('ht+p\w+', str1) print(not_find) # -> None print(do_find) # -> <re.Match object; span=(0, 5), match='https'>
-
search 在整个目标文本中进行匹配。
import re while True: email_addr = input('Please input email: ') match_result = re.search('\w+\.\w+@\w+\.\w+', email_addr) print(match_result)
查找方法 findall, finditer, fullmatch
-
findall 扫描整个字符串,将与规则相匹配的子串拿出来组成列表。 没有匹配的字符串,返回空的列表。
import re str1 = 'https://mail.163.com/email/webmail' finded = re.findall('\w{,3}mail',str1) print(finded) # -> ['mail', 'email', 'webmail']
-
findall 扫描整个字符串,将与规则相匹配的子串组成一个迭代器。 没有匹配的字符串,返回空的迭代器。
import re str1 = 'https://mail.163.com/email/webmail' finded = re.finditer('\w{,3}mail',str1) for i in finded: print(i) output: <re.Match object; span=(8, 12), match='mail'> <re.Match object; span=(21, 26), match='email'> <re.Match object; span=(27, 34), match='webmail'>
-
fullmatch 要求整个字符串完全符合规则,否则返回None。
import re str1 = 'https://mail.163.com' finded = re.fullmatch('\w*.//\w*\.\w*\.\w*',str1) #正则必须完全匹配文本 print(finded) # -> <re.Match object; span=(0, 20), match='https://mail.163.com'>
替换方法
-
sub : 将匹配到的子串替换为其他文本。
re.sub(正则,替换的文本,字符串,count替换的次数)
count默认为0,代表匹配上的子串全部替换。
import re
str1 = '某个党人说自己是全心全意为人民服务的'
str1 = re.sub('^..','共产',str1, count=1)
print(str1)
- split : 用规则匹配的子串来切割文本放入列表,没有符合的子串则将目标文本放入列表。
re.split(正则, 字符串,maxsplit最大切割次数)
import re
str1 = '2022年11月20日'
arr_found = re.split('[年月日]',str1)
print(arr_found) # -> ['2022', '11', '20', '']
分组字符()
使用re.search的时候,在正则表达式中用 ( ) 括起来想要获取的数据。
搜索后,可以使用 search对象的group方法 取得其值。
search对象.group() 默认的参数是0, 返回正则匹配到的所有数据。
search对象.group(1) 代表正则中第一个分组数据的值。以此类推。
import re
str1 = "<p>我们可以通过这里<a href='aaa.jpg'>连接</a>了解更多信息。</p>"
result = re.search("href='(.+)'>(\w+)",str1)
print(result.group()) # -> href='aaa.jpg'>连接
print(result.group(1)) # -> aaa.jpg
print(result.group(2)) # -> 连接
search对象.groups() 将分组数据作为元组返回。
import re
str1 = "<p>我们可以通过这里<a href='aaa.jpg'>连接</a>了解更多信息。</p>"
result = re.search("href='(.+)'>(\w+)",str1)
print(result.groups()) # -> ('aaa.jpg', '连接')
search对象.groupdict() 将分组对象作为字典返回。需要为分组命名作为key,分组的内容作为value。
分组中用 ?P<key名称>
来命名
import re
str1 = "<p>我们可以通过这里<a href='aaa.jpg'>连接</a>了解更多信息。</p>"
result = re.search("href='(?P<link_addr>.+)'>(?P<link_text>\w+)",str1)
print(result.groupdict()) # -> {'link_addr': 'aaa.jpg', 'link_text': '连接'}
位置函数
search对象的start()方法可以返回匹配到的子串的开始索引。
search对象的end()方法可以返回匹配到的子串的结束索引。
search对象的span()方法可以返回元组形式的开始索引和结束索引。
import re
str1 = "<p>我们可以通过这里<a href='aaa.jpg'>连接</a>了解更多信息。</p>"
result = re.search("href",str1)
print(result.start()) # 14
print(result.end()) # 18
print(result.span()) # (14, 18)
print(result) #<<re.Match object; span=(14, 18), match='href'>
json模块
提供对JSON的支持。JSON是一种轻量级的数据交换格式。
JSON的数据结构:
-
键值对组成的JSON对象。
-
有序集合(数组 )。
[value1, value2, value3 ......]
dump与load方法
-
dump : 将python对象保存为JSON,例如:列表,字典等。
dump(python对象, file对象 [ , ensure_ascii=False] , [indent=None])
import json student = {'姓名':'张三', 'age':18} f = open('/Users/leo/Desktop/stud.json', 'w') json.dump(student,f) #写入:{{"\u59d3\u540d": "\u5f20\u4e09", "age": 18}} #默认ensure_ascii=True,如果改为false,JSON的中文正常显示。 json.dump(student,f,ensure_ascii=False) #{"姓名": "张三", "age": 18} #使用indent参数来缩进显示 json.dump(student,f,ensure_ascii=False, indent= 2) { "姓名": "张三", "age": 18 }
-
load: 将JSON转换为python对象。
load(file对象) -> python对象
import json f = open('/Users/leo/Desktop/stud.json', 'r') student = json.load(f) print(student) #{'姓名': '张三', 'age': 18} f.close()
dumps和loads方法
-
dumps : 将python对象转为字符串。
dumps(python对象, ensure_ascii = True, indent = None)
-
loads : 将字符串转为python对象。
loads(字符串) -> python对象
import json
student = {'姓名':'张三', 'age':18}
str= json.dumps(student, ensure_ascii=False, indent=3)
print(str)
output:
{
"姓名": "张三",
"age": 18
}
new_student = json.loads(str)
print(new_student, type(new_student))
output:
{'姓名': '张三', 'age': 18} <class 'dict'>
logging模块
logging模块用来在程序中生成日志。
日志等级
loggin模块提供了五种日志等级:
- DEBUG : 反映细节信息,仅当诊断的时候使用。
- INFO : 用来确认程序按照预期执行。
- WARNING:日志默认等级,Warning表示程序或者即将发生意外,做警告,不过程序依然可以按照预期执行。
- ERROR :由于严重问题,程序已经不能按预期正常执行。
- CRITICAL : 严重错误,程序已经无法继续执行。
basicConfig设置日志
logging.basicConfig : 对日志进行设置
- filename:字符串,指定日志输出的文件。
- filemode:记录日志的模式,默认是a(追加模式)。如果使用'w',每次清空日志写入。
- level : 更改记录日志的等级,logging.DEBUG / INFO / WARNING / ERROR / CRITICAL。
- datefmt : 定义记录日期字符串的格式。定义%(asctime)s 的样式。
import logging
logging.basicConfig(filename='aaa.log', filemode='w', level=logging.INFO)
logging.warning('Hello, world...')
logging.info('Fidelio')
output:
WARNING:root:Hello, world...
INFO:root:Fidelio
-
format : 使用格式字符来定义日志的格式。
属性名称 字符格式 描述 asctime %(asctime)s 记录时间,精确到毫秒 name %(name)s 使用的记录其名称,默认是root filename %(filename)s 日志输出的模块名称 module %(module)s 日志输出的模块名称(无扩展名) pathname %(pathname)s 日志输出模块的完整路径 funcName %(funcName)s 日志输出的函数名称 levelname %(levelname)s 日志等级 message %(message)s 日志消息 lineno %(lineno)d 日志所在的行号 levelno %(levelno)s 日志等级的数字表示,10 - 50 process %(process)s 进程id processName %(processName)s 进程名称 thread %(thread)s 线程ID import logging format1 = '%(asctime)s:%(lineno)d:%(levelname)s:%(message)s' logging.basicConfig(filename='/Users/leo/aaa.log', filemode='a', level=logging.DEBUG, format=format1) logging.info('demo message') # 2022-05-26 22:30:05,122:5:INFO:demo message
生成日志
调用 logging.日志等级
可以产生日志。低于Warning默认日志等级的日志,系统不会理会,默认等级之下的python不输出。
import logging
#output:WARNING:root:system encounters some error.
logging.warning('system encounters some error.')
日志流
将日志发送的不同的位置,比如记录在文件,发送邮件,记录在web站点。
发送到不同位置的日志使用不同的格式。
日志流依赖于logging模块的四大组件:
组件名称 | 对应类名 | 功能描述 |
---|---|---|
记录器 | Logger | 提供应用程序可一直使用的接口。 |
处理程序 | Handler | 将Logger创建的日志发送到合适的目的地。 |
过滤器 | Filter | 使用更加细粒度的控制工具来决定要输出的日志。 |
格式化程序 | Formatter | 决定日志输出的格式。 |
Logger 记录器
- getLogger() : 创建记录器。
- setLevel(logging.等级名称) : 设置记录器的默认日志等级。
- addHandler(Handler): 记录器中添加处理程序。
- removeHandler(Handler) : 从记录器中删除处理程序。
import logging
logger = logging.getLogger()
#设置默认等级
logger.setLevel(logging.DEBUG)
#设置一个控制台Handler
stream_handler = logging.StreamHandler()
logger.addHandler(stream_handler)
#记录日志事件
logger.warning('this is a demo')
Handler 处理程序
- StreamHandler() : 控制台处理程序
- FileHandler(filename, mode='a', encoding=None) : 创建一个日志输出到文件的处理程序
- setLevel(logging.等级名称 ) : 设置处理程序的默认日志等级。Handler等级覆盖Logger等级。
- setFormatter : 向处理程序中添加格式化程序。
import logging
logger = logging.getLogger()
#设置一个控制台Handler
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.DEBUG)
logger.addHandler(stream_handler)
#设置一个文件Handler
file_handler = logging.FileHandler(filename='/Users/leo/Desktop/fh.log', mode='w', encoding='utf-8')
file_handler.setLevel(logging.INFO)
logger.addHandler(file_handler)
#记录日志事件,StreamHandler和FileHandler都会收到。
logger.warning('this is a demo')
Formatter格式化程序
- logging.formatter(fmt=格式字符串, datefmt=时间格式) : 返回一个格式字符串规定的formatter对象。
- formatter对象与Handler对象进行绑定, Handler.setFormatter(formatter对象)
import logging
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
fmt = logging.Formatter(fmt = '%(asctime)s:%(lineno)s:%(module)s:%(message)s',\
datefmt='%y%m%d%H%M%S')
sh = logging.StreamHandler()
sh.setLevel(logging.INFO)
sh.setFormatter(fmt)
logger.addHandler(sh)
fh = logging.FileHandler(filename='aa.log', mode='w', encoding='utf-8')
fh.setLevel(logging.WARNING)
fh.setFormatter(fmt)
logger.addHandler(fh)
logger.warning('Fdelio')
time模块
time模块与时间戳关系密切的模块。
-
time() : 返回当前的时间戳。两个时间戳的差可以用来计算耗时。
-
sleep(sec) : 指定程序暂停的时间。
-
localtime(时间戳) -> 结构化时间 : 以结构化时间返回时间。
-
mktime(结构化时间) -> 时间戳 : 将结构化时间转换为时间戳。
-
strftime(格式字符串, 结构化时间) : 格式化字符传唤为字符串。
-
strptime(时间字符串,格式字符串): 字符串转为格式化时间。
时间符号 | 说明 |
---|---|
%y | 两位数年份 |
%Y | 四位数年份 |
%m | 月份(0-12) |
%d | 日期(1-31) |
%H | 24小时的小时数(0-23) |
%I | 12小时的小时数(0-11) |
%M | 分钟(0-59) |
%S | 秒(0-25) |
%a | 简化的day of week |
%A | 完整的的day of week |
%b | 简化的月份名称 |
%B | 完整的月份名称 |
%j | 一年的第几天(1-366) |
%p | am / pm |
%U | 一年中的星期数(0-53) |
%x | 日期 |
%X | 时间 |
%Z | 时区 |
print(time.strftime('%Y-%m-%d %I:%M:%S %p %Z %a,%B'))
#输出: 2022-05-27 10:51:04 PM CST Fri,May
print(time.strptime('2022-7-1', '%Y-%m-%d'))
#输出:
#time.struct_time(tm_year=2022, tm_mon=7, tm_mday=1, tm_hour=0,
# tm_min=0, tm_sec=0, tm_wday=4, tm_yday=182, tm_isdst=-1)
datetime模块
不涉及时间戳,处理日期和时间。
类名 | 功能 |
---|---|
date | 日期对象,属性:year,month,day |
time | 时间对象 |
datetime | 日期时间对象 |
timedelta | 时间间隔对象,两个时间点之间的长度 |
tzinfo | 时区信息对象 |
使用datetime一般这样导入: from datetime import date, time as dtime, datetime, detedelta
如果和time模块一起用,那么给time模块起一个别名来避免冲突。
datetime.date类
-
datetime.date(y,m,d) : 实例化date对象。
-
datetime.date.today() : 返回当前日期的date对象。
-
datetime.date对象.isocalendar() : 返回元组(年份,周数,星期几)的IsoCalendarDate对象。
import datetime to_date = datetime.date.today() # datetime.date(2022, 5, 27) print(to_date.isocalendar()) # datetime.IsoCalendarDate(year=2022, week=21, weekday=5)
-
datetime.date对象.isoformat() : 返回日期字符串。
today = datetime.date.today()
print(today.isoformat())
output: 2022-05-29
-
datetime.date对象.replace(year=value, month=value, day=value) :替换日期对象的属性值。
today.replace(year=9999) output: datetime.date(9999, 5, 29)
-
datetime.date. fromisoformat(字符串) : 通过标准字符串返回一个datetime.date对象。
new_date = datetime.date.fromisoformat('2099-12-31') new_date datetime.date(2099, 12, 31)
-
datetime.date.fromisocalendar(year=?, week=?, weekday=?) : 通过年份,周数,星期几返回date对象。
new_date = datetime.date.fromisocalendar(2099,52,1) new_date datetime.date(2099, 12, 21)
-
datetime.date对象.timetuple() : 返回一个structure_time对象。
new_date.timetuple() output: time.struct_time(tm_year=2099, tm_mon=12, tm_mday=21, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=355, tm_isdst=-1) time.mktime(new_date.timetuple()) output: 4101465600.0
-
datetime.date.fromtimestamp(时间戳) : 从时间戳返回一个datetime对象。
datetime.date.fromtimestamp(4101465600.0) datetime.date(2099, 12, 21)
datetime.time类
用于创建时间对象,有四个属性,hour, minute, second, microsecond。
-
datetime.time(hour=0, minute=0, second=0, microsecond=0) : 关键字参数创建time对象。
-
datetime.time对象.isoformat() : 返回标准的时间字符串。
datetime.time(hour=13).isoformat() '13:00:00'
-
datetime.time.fromisoformat(时间字符串) : 通过时间字符串返回时间对象。
time1 = datetime.time.fromisoformat('12:00:00.123456') Output: datetime.time(12, 0, 0, 123456)
-
datetime.time对象.replace(属性=新值): 返回更改了属性值的time对象。
datetime.datetime类
用于创建时间日期对象,具有date对象和time对象的属性。
-
datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0) : 创建datetime对象。
print(datetime.datetime(year=2022, month=5, day=30, hour=22)) 2022-05-30 22:00:00
-
datetime.datetime对象.timestamp() : 返回时间戳。
-
datetime.datetime.fromtimestamp(时间戳): 通过时间戳返回datetime对象。
datetime.datetime.fromtimestamp(time.time()) datetime.datetime(2022, 5, 30, 22, 14, 22, 906529)
-
datetime.datetime.utcfromtimestamp(时间戳) : 通过时间戳返回一个格林威治时间的datetime对象。
datetime.datetime.utcfromtimestamp(time.time()) datetime.datetime(2022, 5, 30, 14, 15, 54, 357506)
-
datetime.datetime.today() :
-
datetime.datetime.now() : 获得当前时间的datetime对象。
-
datetime.datetiem.utcnow() : 获得当前的格林威治时间。
datetime.datetime.now() output: datetime.datetime(2022, 5, 30, 22, 17, 42, 99342) datetime.datetime.utcnow() output: datetime.datetime(2022, 5, 30, 14, 17, 48, 388774)
-
datetime.datetime.combine(date对象, time对象) : 合并date对象和time对象,返回一个datetime对象。
date1 = datetime.date(2019,4,24) time1 = datetime.time(20) datetime1 = datetime.datetime.combine(date1, time1) output: datetime.datetime(2019, 4, 24, 20, 0)
-
datetime.datetime对象.isoformat() : 返回字符串表示的datetime对象。
date1 = datetime.datetime.now() date1.isoformat() Output: '2022-05-31T21:52:36.697098'
-
datetime.datetime.fromisoformat(‘dayTtime字符串’) : 通过标准字符串返回datetime对象。
datetime1 = datetime.datetime.fromisoformat('2022-12-01T23:59:59') output: datetime.datetime(2022, 12, 1, 23, 59, 59)
-
datetime.datetime对象.isocalendar() : 返回元组(年, 周数, 星期几)
-
datetime.datetime.fromisocalendar(year, week, weekday) : 返回datetime对象。
today = datetime.datetime.now() today.isocalendar() output: datetime.IsoCalendarDate(year=2022, week=22, weekday=1) datetime.datetime.fromisocalendar(2022,22,7) output: datetime.datetime(2022, 6, 5, 0, 0)
-
datetime.datetime对象.timetuple() : 返回structure_time对象。
datetime.datetime.now().timetuple() output: time.struct_time(tm_year=2022, tm_mon=5, tm_mday=30, tm_hour=22, tm_min=28, tm_sec=40, tm_wday=0, tm_yday=150, tm_isdst=-1)
-
datetime.datetime对象.utctimetuple() : 返回格林威治时区的structure_time对象。
-
datetime.datetime对象.date() :返回date对象。
-
datetime.datetime对象.time() : 返回time对象。
-
datetime.datetime对象.weekday() : 返回星期几,周一从0开始。
-
datetime.datetime对象.isoweekday() : 返回星期几,周一从1开始。
-
datetime.datetime对象.replace(属性值) : 更改属性值,返回新的对象。
-
datetime.datetime对象.strftime(格式字符串) : 将datetime,date, time对象转为字符串。
datetime_today = datetime.datetime.now() datetime_today.strftime('%m-%d %H:%M') '05-31 21:41'
-
datetime.datetime.strptime(字符串, 格式串) : 将字符串转为datetime对象。
datetime.datetime.strptime('2022-09-8T13:26', '%Y-%m-%dT%H:%M') Output: datetime.datetime(2022, 9, 8, 13, 26)
datetime.timedelta类
创建时间间隔对象,用于事件相关的计算。
-
datetime.timedelta(days, seconds, microseconds, milliseconds, minutes, hours, weeks)
td1 = datetime.timedelta(days=1, weeks = 3, hours=12, milliseconds=1122311) output: datetime.timedelta(days=22, seconds=44322, microseconds=311000)
-
两个时间直接相减,得到的就是datetime.timedelta对象。
datetime1 = datetime.datetime(2022,12,31, 23,59,59) datetime2 = datetime.datetime.now() datetime1 - datetime2 datetime.timedelta(days=215, seconds=2871, microseconds=215016)
-
datetime对象与timedelta对象进行加减操作。
current = datetime.datetime.now() td = datetime.timedelta(hours = 14, days=10) future = current + td #datetime.datetime(2022, 6, 10, 13, 17, 15, 807876) past = current - td #datetime.datetime(2022, 5, 20, 9, 17, 15, 807876)
文件IO
os.path模块
实现对文件路径的操作。
-
_file_ : 获取当前文件的绝对路径。
-
os.path.abspath(文件名) : 获得文件的绝对路径。
os.path.abspath('asd.py') output: '/Users/leo/Documents/asd.py'
-
os.path.basename(路径) : 返回路径的最后一部分。
-
os.path.dirname(路径) : 返回路径除了最后一部分的其他部分。
-
os.path.exists(路径) : 判断路径是否存在.
os.path.abspath('asd.py') '/Users/leo/Documents/asd.py' os.path.basename('/Users/leo/Documents/asd.py') 'asd.py' os.path.dirname('/Users/leo/Documents/asd.py') '/Users/leo/Documents' os.path.exists('/Users/leo/Documents/asd.py') True
-
os.path.isdir(路径) : 判断目录是否存在。
-
os.path.isfile(路径) : 判断文件是否存在。
os.path.isdir('/etc') True os.path.isfile('/etc') False
-
os.path.split(路径) : 将路径分割为dirname和basename组成的元组。
os.path.split('/Users/leo/Documents/asd.py') output: ('/Users/leo/Documents', 'asd.py')
-
os.path.splitext(路径) : 将路径分为路径和扩展名组成的元组。
os.path.splitext('/Users/leo/Documents/asd.py') output: ('/Users/leo/Documents/asd', '.py')
-
os.path.join(路径的多个组成部分) : 将路径的多个组成部分组合成一个路径。
os.path.join('/Users', 'leo','Documents') output: '/Users/leo/Documents'
工程目录
将不同的代码分开,不同功能的代码放在不同的目录中。
每个子目录设置为不同的模块包,方便调用。
主流的子目录:
- bin目录,放置主逻辑,main.py。
- log目录,放置日志文件。
- db目录,存放数据库目录。
- data目录,存放普通数据文件,txt,json等。
一定要有readme文件,readme包含:
-
那个目录做什么用的
-
包含的方法,函数,类的说明。
posted on 2022-05-23 23:19 LeoZhangJing 阅读(58) 评论(0) 编辑 收藏 举报