내장 모듈 : 시간, 날짜, 무작위, JSON, 피클, 운영 체제, SYS, hashlib, 컬렉션, 재

1.TIME 모듈

import time
time.time() # 时间戳  浮点数
time.sleep() # 睡眠
time.gmtime()/time.localtime() #结构化时间 数据类型是命名元祖
time.strftime('格式化','结构化时间')
time.strptime('字符串','格式化')
time.mktime('结构化时间') #结构化时间转时间戳

# 将时间戳转换成字符串时间
print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime(1564028611.631374)))
# 将字符串时间转换成时间戳
print(time.mktime(time.strptime("2024-3-16 12:30:30","%Y-%m-%d %H:%M:%S")))

2. 날짜

1. 현재 날짜 및 시간 가져 오기

form datetime import datetime
print(datetime.now())
print(datetime(2018,5,20,13,14)) #获取指定日期和时间

2. 날짜와 타임 스탬프 변환

form datetime import datetime
print(datetime.now().timestamp()) # 转时间戳

import time
from datetime import datetime
print(datetime.fromtimestamp(time.time()))

날짜 변환 3. STR

print(datetime.strptime("2019-10-10 22:23:24","%Y-%m-%d %H:%M:%S")) # 将字符串转换成datetime
print(datetime.now().strftime("%Y-%m-%d %H:%M:%S")) # 将datetime转换成字符串
print(str(datetime.now()))

4. 날짜 빼기

from datetime import datetime, timedelta
print(datetime.now() + timedelta(days=1))
print(datetime.now() - timedelta(hours=3))

3. 무작위 임의 모듈

import random
print(random.random()) # 0~1之间的浮点数
print(random.uniform(1,10)) #1~10之间的浮点数
print(random.randint(1,50)) #1~50之间的整数(闭区间)
print(random.randrange(1,5,2)) #(起始,终止,步长)
print(random.choice([1,2,3,4,5,]))#随机选择一个
print(random.choices([1,2,3,4,5,],k=2))#随机选两个,会有重复数字,列表形式
print(random.sample((1,2,3,4,5),k=2))#随机选两个,不会有重复数字,列表形式
lst = [1,2,3,4,5,6,7,8,9,0]
random.shuffle(lst) # 打乱顺序 
print(lst)

무작위 코드를 생성 :

import random
def y_code():
    code = ''
    for i in range(4):
        num = chr(random.randint(48,57))
        # 取数字
        alf = chr(random.randint(97,122))
        # 取小写字母
        alf_upper = chr(random.randint(65,90))
        # 取大写字母
        s = str(random.choice([num,alf,alf_upper]))
        code = ''.join([code,s])
    return code
print(y_code())

제 시퀀싱 모듈

특정한 공정의 순서 (스트링 또는 바이트)로 등 (예컨대 사전, 목록 등)의 데이터 구조를 변환은 직렬화 불린다.

주요 용도 : 읽기 및 데이터 파일, 네트워크 트래픽을 작성합니다.

4.1 JSON 모듈

JSON 모듈 데이터 구조는 특정 문자열의 조건을 충족하도록 변환되고, 또한 다시 복원 직렬화있다.

JSON 직렬화 지원 데이터 구조 파이썬의 일부만 : DICT,리스트, 튜플, STR, INT, 플로트, 참, 거짓, 없음

네트워크 전송의 경우 : 덤프,로드

문서 읽기 쓰는 : 덤프를로드

4.1.1 덤프,로드

1. 문자열 형식 형식으로 변환 사전

import json
dic = {'key1':'1','key2':2}
str_dic = json.dumps(dic)
print(str_dic,type(str_dic))  # 字符串

2. 사전 형식 사전 형식으로 문자열 변환

dic1 = json.loads(str_dic)
print(dic1,type(dic1))

3. 또한 목록의 유형을 지원

import json
lit = [1,2,"3",4]
str_lst = json.dumps(lit)
print(str_lst,type(str_lst))
lst = json.loads(str_lst)
print(lst,type(lst))

4.1.2 덤프,로드

문자열 1에 객체를 변환하는 파일에 기록 말하기

dic = {'key1':1}
with open('a1.txt','a',encoding='utf-8')as f:
    json.dump(dic,f)  

2. 사전의 문자열 형식으로 파일을 변환

with open('a1.txt','r',encoding='utf-8')as f1:
    dic1 = json.load(f1)
print(dic1)

같은 파일에 데이터를 저장하는 복수의 4.1.3 JSON 시퀀스

with open('a1.txt','r',encoding='utf-8')as f1:
    for i in f1:
        lst = json.loads(i)
        print(lst)

4.2 클 모듈

피클 모듈 파이썬 모든 데이터 구조 등와 개체 유형이 바이트 단위로 변환된다 후 감소는 다시 탈 직렬화 될 수있다.

피클 모듈은 파이썬 언어 모듈 인식 시퀀스입니다.

네트워크 전송의 경우 : 덤프,로드

문서 읽기 쓰는 : 덤프를로드

4.2.1 덤프,로드

import json
dic = {'key1':'1','key2':2}
str_dic = pickle.dumps(dic)
print(str_dic,type(str_dic))  # 类似字节
dic1 = pickle.loads(str_dic)
print(dic1,type(dic1))

4.2.2 덤프,로드

with open('a1.txt','ab')as f:
    pickle.dump(dic,f)
with open('a1.txt','rb')as f1:
    dic1 = pickle.load(f1)
print(dic1)

파일에 저장된 복수의 데이터 시퀀스 4.2.3 클

import pickle
dic = {"1":2}
f = open("info","wb")
s = "\n".encode("utf-8")
f.write(pickle.dumps(dic)+ s)
f.write(pickle.dumps(dic)+ s)
f.write(pickle.dumps(dic)+ s)
f.close()

f1 = open("info","rb")
for i in f1:
    print(pickle.loads(i))

5. OS 모듈

os 모듈은 운영 시스템과 상호 작용하는 인터페이스입니다

os 모듈 네 그룹 :

1. 작업 디렉토리

import os
print(os.getcwd()) # 当前工作路径  ***
os.chdir("F:\s24\day06") # 路径切换 ***
print(os.curdir)  # 当前目录
print(os.pardir)  # 当前目录的父级目录

2. 폴더

import os
os.mkdir("ttt") # 创建一个文件夹  ***
os.rmdir("ttt") # 删除一个文件夹,若不为空则无法删除,报错  ***
os.makedirs("ttt/sss/ddd/ee")  # 递归创建文件夹     ***
os.removedirs("ttt/sss/ddd/ee")  # 递归删除文件夹,若为空删除,不为空不删除   ***
print(os.listdir(r"F:\s24\day17"))  # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印***

3. 파일

import os
os.remove()  # 删除一个文件  ***
os.rename("oldname","newname")  # 重命名文件/目录  ***

4. 경로

import os
print(os.path.abspath(r"01 今日内容.py"))  # 通过相对路径获取绝对路径  ***
print(os.path.split(os.path.abspath(r"01 今日内容.py")))  #将路径以最后一个\切割(路径,文件名)
print(os.path.dirname(r"F:\s24\day17\01 今日内容.py"))  # 获取路径 ***
print(os.path.basename(r"F:\s24\day17\01 今日内容.py")) # 获取文件名 ***
print(os.path.exists(r"F:\s24\day17\01 今日内容.py"))  # 判断这个路径是否存在  ***
print(os.path.isdir(r"F:\s24\day17"))     # 判断是不是路径  ***
print(os.path.isfile(r"01 今日内容.py"))  # 判断是不是文件  ***
print(os.path.isabs(r"F:\s24\day17\01 今日内容.py"))     # 判断是不是绝对路径 ***
print(os.path.join("D:\\\\","ttt","bbb"))                # 路径拼接 *****
print(os.path.getatime(r"F:\s24\day17\04 序列化.py"))      # 最后的修改时间
print(os.path.getctime(r"F:\s24\day17\04 序列化.py"))      # 最后的访问时间
print(os.path.getmtime(r"F:\s24\day17\04 序列化.py"))      # 最后的访问时间
print(os.path.getsize(r"F:\s24\day09"))                       # 获取当前文件的大小   ***

6. sys 모듈

SYS 모듈은 파이썬 인터프리터와 상호 작용하는 인터페이스입니다

import sys
if sys.argv[-1] == "alex":
    print("dsb")
else:
    print("cjb")
print(sys.argv[-1])  
# 当前文件运行['F:/s24/day17/06 sys.py'] ***

import sys
print(sys.exit(1))   #退出程序，正常退出时exit(0),错误退出sys.exit(1)
print(sys.version)  # 获取解释器版本
print(sys.path)     # 添加自定义模块查找路径 *****
print(sys.platform)   # *** 区分操作系统然后进行相关逻辑操作

제 hashlib 모듈

암호화 및 체크섬

MD5는 SHA1은 sha256이, SHA512
만큼 같은 일반 텍스트 암호문으로 1. 동일
만큼 평문이 같은 암호문이 아닌 2. 동일하지 않습니다
3.이없는 재귀 역 (해독 할 수 없습니다) 수 - MD5 중국인 휴식

암호화 :
1. 암호화 된 내용
의 콘텐츠를 암호화 2. 바이트로 변환 할

import hashlib
md5 = hashlib.md5()  # 加密初始化
md5.update("alex123".encode("utf-8"))
print(md5.hexdigest())

염 (고체 / 동적)

import hashlib
md5 = hashlib.md5("alex".encode("utf-8"))  
md5.update("alex123".encode("utf-8"))
print(md5.hexdigest())

제 컬렉션 모듈

1.namedtuple 세대는 요소 튜플의 콘텐츠에 액세스하기 위해 이름을 사용할 수 있습니다

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p)
# Point(x=1, y=2)

2.deque : 양단 큐, 다른 측면에서 신속하고 추가 개체 출시 될 수 있습니다

from collections import deque
q = deque(['a', 'b', 'c'])
q.append('x')
q.appendleft('y')
print(q)
# deque(['y', 'a', 'b', 'c', 'x'])

큐 : FIFO

스택 : 밖으로 지속

3.OrderedDict : 주문 사전

od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od)
# OrderedDict([('a', 1), ('b', 2), ('c', 3)])

4.defaultdict : 기본값 사전

from collections import defaultdict
values = [11, 22, 33,44,55,66,77,88,99,90]
my_dict = defaultdict(list)
for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

5.Counter : 주를 카운트하는 카운터

from collections import Counter
c = Counter('abcdeabc')
print(c)
# Counter({'a': 2, 'b': 2, 'c': 2, 'd': 1})

제 re 모듈 (정규식)

# \w 匹配字母（包含中文）或数字或下划线 
import re
name = "宝元-meet_123 "
print(re.findall("\w",name))
# ['宝', '元', 'm', 'e', 'e', 't', '_', '1', '2', '3']
# \W 匹配非字母（包含中文）或数字或下划线 
# \s 匹配任意的空白符 
# \S 匹配任意非空白符 
# \d 匹配数字 
# \D 匹配非数字 
# \A 从字符串开头匹配 
# \Z 匹配字符串的结束，如果是换行，只匹配到换行前的结果 
# \n 匹配一个换行符 
# \t 匹配一个制表符 
# ^ 匹配字符串的开始 
# $ 匹配字符串的结尾 
# . 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。 
import re
name = "宝元-meet_123\t \n"
print(re.findall(".",name))
# ['宝', '元', '-', 'm', 'e', 'e', 't', '_', '1', '2', '3', '\t', ' ']
print(re.findall(".",name,re.DOTALL))
# ['宝', '元', '-', 'm', 'e', 'e', 't', '_', '1', '2', '3', '\t', '\n']
# [...] 匹配字符组中的字符 
print(re.findall("[a-z]",s))
# [^...] 匹配除了字符组中的字符的所有字符 
# * 匹配0个或者多个左边的字符。 
# + 匹配一个或者多个左边的字符。 
# ？ 匹配0个或者1个左边的字符，非贪婪方式。 
# {n} 精准匹配n个前面的表达式。 
# {n,m} 匹配n到m次由前面的正则表达式定义的片段，贪婪方式 
# a|b 匹配a或者b 
# () 匹配括号内的表达式，也表示一个组 
import re
print(re.findall('(.*?)_sb', 'alex_sb wusir_sb 日天_sb'))
# ['alex', ' wusir', ' 日天']
print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>')
# ['http://www.baidu.com']

발견 된 모든 1.findall, 목록을 반환

객체를 반환, 경기가 중단 찾을 문자열 어디서나 2.search. 일치하는 내용의 인수했다) (.group 사용되어야합니다

오직 문자열 일치의 시작 부분에 3.match

4.split 파티션은 분리로 분리 될 수있다

5.sub 교체

6.compile 정의 일치 규칙

obj = re.compile("\w")
print(obj.findall("meet_宝元_常鑫垃圾"))

7.finditer는 반복자를 돌려줍니다

import re
g = re.finditer('al',"alex_alsb,al22,aladf")
print(next(g).group())
print([i.group() for i in g])
# al
# ['al','al','al']