sys是system的缩写，sys模块主要负责与Python解释器进行交互，模块提供了一系列用于控制python运行环境的函数和变量，用来获取操作系统和编译器的一些配置，环境设置以及操作。

sys.argv就是一个从程序外部获取参数的桥梁，argv属性值是一个列表。

argv的参数可以看作一个列表，用[] 下标的方式提取其中的元素。

常用方法

import sys

#如何查看sys里面有哪些方法
#help(sys)

#利用以上的不直观，我们可以dir

print(dir(sys))

代码

#argv 获取命令行的参数

import sys

#argv第一个参数必须是文件的信息/程序信息

print(sys.argv)
print(sys.argv[3])

语法：

argv 获取命令行的参数

 argv 的第一个参数/下标的是0的参数，一定会是我们运行文件的信息

注意：在cmd里面运行python，语法：python 文件名字 参数1 参数2

多个参数之间用空格隔开

语法：

sys.exit()  0是正常退出，1是不正常退出，无论是不是1都不会报错

for i in [1,2,3,4,5]:if i == 2:sys.exit(1)print(i) #1

#sys.version python版本号

print(sys.version) #3.7.6 (tags/v3.7.6:43364a7ae0, Dec 19 2019, 00:42:30) [MSC v.1916 64 bit (AMD64)]

#maxsize  int数值可以最大是263-1

print(sys.maxsize) #9223372036854775807

path列表是由一个目录名构成的列表，返回模块的搜索路径。Python从中查找扩展模块(python源模块，编译模块，二进制扩展)，初始化时使用python环境变量的值。

#path 获取路径,返回一个list

print(sys.path)

#sys.path.insert(index,文件名字) 添加路径

sys.path.insert(0,"temp")
print(sys.path)

# sys.modules  获取我们导入的模块信息,返回一个字典

print(sys.modules)

sys.modules.keys() 只获取导入模块的名字

print(sys.modules.keys())

#导入模块不一定是内建模块，也有可能是我们自己封装的模块

# 获取内建模块的名字

a = sys.builtin_module_names
print(a)

练习题

定义一个函数，传入一个名字，查看是否是内建模块

def is_module(name):if name in a:print("是一个模块")else:print("什么都不是")is_module("time")

os模块

含义：os模块与操作系统交互，提供了访问操作系统底层的接口

sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境

os模块是python标准库中一个用于访问操作系统相关功能的模块，提供了一种可移值使用的操作系统的方法。使用os模块中提供的接口，可以实现跨平台访问，但是，并不是所有的os模块中的接口在全平台都通用的，有一些接口的实现需要特定的平台，如：linux相关文件权限和进程管理。

os模块的主要功能：系统相关、目录相关、目录及文件操作、执行命令和管理进程。

常用方法

代码

import os 

#os.getcwd() 获取当前目录

#print(os.getcwd()) #D:\axc\Python\PythonTem

语法：

绝对路径/全路径：D:\axc\Python\PythonTemp\test.py

相对路径/半路经：Python\PythonTemp\test.py

想要写半路经，你的当前路径和D:\axc\Python\PythonTemp要一样

#os.mkdir()  创建一个单级文件夹

os.mkdir("D:\\axc\\Python\\PythonTemp\\temp")

#os.rmdir()  删除单级空文件夹

os.rmdir("D:\\axc\\Python\\PythonTemp\\temp")

#os.makedirs（） 创建多层文件夹

os.makedirs("D:\\axc\\Python\\PythonTemp\\test\\2002bigdate")

#os.removedirs（）删除多级空目录

os.removedirs("test\\2002bigdate")

#创建一个文件夹test

os.mkdir("test")

#在test里面创建一个文件temp.py（手动创建右键创建）

#修改文件名字temp为temp.txt

os.rename("D:\\axc\\Python\\PythonTemp\\test\\temp.py","test\\temp.txt")

#列出test文件夹里面所有的子文件以及子文件夹

print(os.listdir("test")) #['temp.txt']  listdir只列出文件/文件夹名字

#删除test这个文件夹

os.remove("test\\temp.txt")
os.rmdir("test")

#os.path.dirname() 获取路径的父目录（上一级目录）

a = os.path.dirname("D:\\axc\\Python\\PythonTemp\\test.py")

#print(a) #D:\axc\Python\PythonTemp

#os.path.join() 将多个路径进行拼接

b = os.path.join("D:","python","p.py")

#print(b) #D:python\p.py

#os.path.split() 拆分,将文件和文件夹进行拆分.返回一个元组

c = os.path.split("D:\\axc\\Python\\PythonTemp\\test.py")
print(c) #('D:\\axc\\Python\\PythonTemp', 'test.py')

#os.path.exists() 判断文件/文件夹是否存在

os.path.isabs() #判断是否是绝对路径
os.path.isdir() #判断是否是文件夹
os.path.isfile()  #判断是否是文件

文件模式匹配：glob模块

glob模块根据给定模式生成满足该模式的文件名列表，该模式和正则表达式类似，但是相对更简单。星号（*）匹配0个或更多个字符，问号(?)匹配单个字符，使用方括号来指定字符范围

#glob.glob() 进行模式匹配，返回一个迭代对象

for i in glob.glob("D:\\axc\\Python\\PythonTemp\\*.py"):print(i)

#文件下面所有py为后缀的文件

for file in glob.glob("D:\\axc\\Python\\PythonTemp\\*.py"):print(file)print("-------------------------")
print(os.listdir('D:\\axc\\Python\\PythonTemp'))

注意：这里的glob返回指定的文件完整路径名，这点和os.listdir函数不同，os.listdir只是返回文件名。

优点

1.打印的是全路径

2.可以进行模式匹配

D:\axc\Python\PythonTemp\cat.py

D:\axc\Python\PythonTemp\ClearWindow.py

D:\axc\Python\PythonTemp\count.py

D:\axc\Python\PythonTemp\eval.py

D:\axc\Python\PythonTemp\sudo.py

D:\axc\Python\PythonTemp\test.py

D:\axc\Python\PythonTemp\其他文件.py

正则表达式：

正则的含义：普通字符和元字符构成的字符串，描述一类字符串规则

元字符

有特殊含义的字符

import re
a = re.findall("a.c","abcdefg")
print(a) #['abc']

#匹配a或者c

a = re.findall("a|c","abdefgc")
print(a) #['a', 'c']

#匹配列表中的任意任意一个字符

a = re.findall("[acbe]","abdefgc")
print(a) #['a', 'b', 'e', 'c']

#除了a和c其余都要

a = re.findall("[^ac]","adfgcvs")
print(a) #['d', 'f', 'g', 'v', 's']

#a-c 意思是匹配abc三个字符

a = re.findall("[a-c]","adfgcvs")
print(a) #['a', 'c']

#意思是把adf作为一个整体进行输出

a = re.findall("(adf)","adfgcvs")
print(a) #['adf']

#去掉小数点的特殊含义，他就是一个小数点

a = re.findall("\.","adf.gcvs")
print(a) #['.']

转义字符：

一些无法书写或者具有特殊功能的字符，采用在前面加斜杠"\"进行转义的方法

预定义匹配字符集：

正则表达式中的一些表示方法，可以同时匹配某个预定定义字符集中的任意一个字符

#匹配出0-9的数字

a = re.findall("\d","abc1e34r")
print(a) #['1', '3', '4']

# `\d`的反集，也就是非数字的任意一个字符，等同于`[^\d]，除数字以外的

a = re.findall("\D","abc 123")
print(a)  #['a', 'b', 'c', ' ']

# 任意一个字母或数字或下划线，也就是A~Z,a~z,0~9,_ 中的任意一个

a = re.findall("\w","abwc1e34r_")
print(a)  #['a', 'b', 'w', 'c', '1', 'e', '3', '4', 'r', '_']

#`\w`的反集，也就是`[^\w]`  ，除字母以外的

a = re.findall("\W","abwc1 e34r_")
print(a)  #[' ']

#都可以匹配下划线了，那空格怎么匹配

a = re.findall("\s","abc 123")
print(a)  #[' ']

#  `\s`的反集，也就是`[^\s]`,除空格以外

a = re.findall("\S","abc 123")
print(a)  #['a', 'b', 'c', '1', '2', '3']

重复匹配：

前面的表达式，无论是只能匹配一种自符的表达式，还是可以匹配多中字符其中的一个的表达式，都只能匹配一次

import re

#意思是ll要有两个

a = re.findall("l{2}","yesall")
print(a)

#意思是l要有2个到4个

a = re.findall("l{2,4}","alyesallnoalllowallll")
print(a) #['ll', 'lll', 'llll']

#意思是l最少要有两个，上不封顶

a = re.findall("l{2,}","alyesallnoallll")
print(a) #['ll', 'llll']

#意思是l至少有一个

a = re.findall("l+","yellowlow")
print(a) #['ll', 'l']

#意思是l至少有0个

a = re.findall("l*","yellowlow")
print(a) #['', '', 'll', '', '', 'l', '', '', '']

位置匹配：

有时，我们对匹配出现的位置有要求，例如：开头，结尾，单词之间

#1是否在开头

a = re.findall("^1","1364156")
print(a) #['1']

#6是否在末尾

a = re.findall("6$","1364156")
print(a) #['6']

贪婪模式与非贪婪模式

“贪婪模式”总是尝试匹配尽可能多的字符；“非贪婪模式”则相反，总是匹配尽可能少的字符

练习题

1.长度为8-10的用户密码（以字母开头、数字、下划线）

import re#输入一个密码，验证长度为8-10的用户密码（以字母开头、数字、下划线）
s = input("请输入一个密码：")
a= re.findall("^[a-zA-Z]\w{7,9}",s) #从0开始
print(a)

re模块

re模块的用途：

1.测试字符串内的模式---->输入字符串，查看字符串内是否出现电话号码，这称为数据验证

2.替换文本------>使用正则表达式来识别文档中的特定文本，完全删除该文本

3.基于模式匹配从字符串中提取子字符串--->查找文档中或输入域内特定的文本

含义：re模块是python独有的匹配字符串的模块，该模块中提供的很多功能是基于正则表达式实现的

常用方法

查询模块

#compile(pattern)  根据包含正则表达式的字符串创建模式对象    re对象

r = re.compile("[0-9]")
print(r)#返回一个编译正则的re对象

语法：

re.IGNORECASE：忽略大小写，同 re.I。
re.MULTILINE：多行模式，改变^和$的行为，同 re.M。
re.DOTALL：点任意匹配模式，让'.'可以匹配包括'\n'在内的任意字符，同 re.S。
re.LOCALE：使预定字符类\w \W \b \B \s \S 取决于当前区域设定，同 re.L。
re.ASCII：使 \w \W \b \B \s \S 只匹配 ASCII 字符，而不是Unicode 字符，同 re.A。
re.VERBOSE：详细模式。

import re
b = re.compile(r"[a-w]",re.I)
a = b.findall("ADbcG")
print(a) #['A', 'D', 'b', 'c', 'G']a = re.compile(r"""\d + # the integral part\. # the decimal point\d * # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")

#search(pattern, string)    在字符串中查找    第一个匹配到的对象或者None  
#扫描整个字符串，并返回它找到的第一个匹配（Match object）

r = re.compile("[0-9]")
a = r.search("123abc456")
print(a) #<re.Match object; span=(0, 1), match='1'>

#match(pattern, string) 在字符串开头匹配到的对象或者None      返回一个match对象

r = re.compile("[0-9]")
a = r.match("123abc456")
#a = r.match("123abc456")  #开头不是数字，所以输出None
print(a) #<re.Match object; span=(0, 1), match='1'>

#findall(pattern, string,flags)    列出字符串中模式的所有匹配项    所有匹配到的字符串列表

r = re.compile("[0-9]")
a = r.findall("123abc4567")
print(a) #['1', '2', '3', '4', '5', '6', '7']

#  finditer(pattern, string,flags)    将所有匹配到的项生成一个迭代器   返回一个迭代器

r = re.compile("[0-9]")
a = r.finditer("123abc456")
print(a) #<callable_iterator object at 0x0000020C599BFA88>
print(list(a))

语法：

[<re.Match object; span=(0, 1), match='1'>, 
<re.Match object; span=(1, 2), match='2'>, 
<re.Match object; span=(2, 3), match='3'>, 
<re.Match object; span=(6, 7), match='4'>, 
<re.Match object; span=(7, 8), match='5'>, 
<re.Match object; span=(8, 9), match='6'>]

match object相关的常用方法：

match.group([group1,.....])

match.groups()

match.start.([group])

match.end([group])

match.spen([group])

#match.group(index)将match对象拆分成字符串。不写index默认是0返回match object中的字符串 

语法：

分组编号从1开始，从左往右，每遇到一个左括号，分组编号+1。
组0总是存在的，它就是整个表达式。
没有参数时，group1默认为0，这时返回整个匹配到的字符串。

#空格不要忘了

r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a)  #<re.Match object; span=(0, 6), match='I LOvE'>
print(a.group()) #I LOvE   默认是0
print(a.group(1)) #I
print(a.group(2)) #LOvE
print(a.group(3)) #报错

指定多个参数的时候，就返回一个元组

print(a.group(1,2)) #('I', 'LOvE')r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a.groups()) #('I', 'LOvE')

#match.start(index)没有参数时，返回匹配到的字符串的起始位置。指定参数（整数）时，返回该分组匹配到的字符串的起始位置

r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a.start()) #0
print(a.start(2)) #2  第二个单词的起始位置是2，下标从0开始

#match.end(index)

r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a.end()) #6
print(a.end(2)) #6
print(a.end(1))  #1

模块级的函数

re.match(pattern.string.flags=0)                                                                                                      re.serch(pattern.string.flags=0)

1.分割字符串

splist()函数，在匹配的地方进行字符串分割，并返回一个list值

regex.split(string,maxsplist=0)

拆分

#split(pattern, string)    根据模式的匹配项来分割字符串    分割后的字符串列表 

#意思是匹配到大写的字母就拆分

pattern = re.compile(r"[A-Z]+")
m = pattern.split("abcDefgHijkLmnoPqrs")
print(m) #['abc', 'efg', 'ijk', 'mno', 'qrs']

替换

语法：

sub(repl, string,count=0)   将字符串中所有的pat的匹配项用repl替换 |完成替换后的新字符串           |repl可以是一个字符串，也可以是一个函数。
count用于指定最多替换次数，不指定时全部替换。

#subn(repl, string) | 在替换字符串后，同时报告替换的次数    | 完成替换后的新字符串及替换次数 |
#同sub()，只不过返回值是一个二元tuple，即(sub函数返回值，替换次数)。

r = re.compile(r"like", re.I)

语法：

s1 = r.subn(r"love", "I like you, do you like me?")
print(s1) #('I love you, do you love me?', 2)

s1 = r.subn(r"love", "I like you, do you like me?",count=1)
print(s1) #('I love you, do you like me?', 1)

补充(R)

Python中字符串前面加上 r 表示原生字符串

与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符""，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠

练习题

#匹配身份证

import re
s = input("请输入身份证：")
z= re.compile(r"^(\d{17})(\d|x)$",re.I)
#不能使用findall，他会返回两个字符串
a = re.search(z,s)
print(a.group())

import re#输入一个密码，验证长度为8-10的用户密码（以字母开头、数字、下划线）
s = input("请输入一个密码：")
z = re.compile("^[a-zA-Z]\w{7,9}")
a= re.findall(z,s) #从0开始
print(a)

datetime模块

含义：python中的datetime模块提供了操作日期和时间功能, 该模块提供了一下类对象

两个属性

import datetime
print(datetime.MINYEAR) #1
print(datetime.MAXYEAR) #9999

datetime.date类

含义：class datetime.date(year, month, day)

datetime模块下的日期类(date)，只能处理年月日这种日期时间，不能处理时分秒。

from datetime import date#创建一个日期对象
date01 = date(year=2021, month=12, day=22)
print(date01.year) #2021
print(date01.month) #12
print(date01.day) #22

常用的方法和属性

import time
from datetime import date
​
print(date.max)  # 9999-12-31
print(date.min)  # 0001-01-01
print(date.resolution)  # 1 day, 0:00:00
print(date.today())  # 2020-03-17
print(date.fromtimestamp(time.time()))  # 2020-03-17
d = date.today()
print(d.year)  # 2020
print(d.month)  # 3
print(d.day)  # 17
print(d.replace(2019))  # 2019-03-17
print(d.replace(2019, 5))  # 2019-05-17
print(d.replace(2019, 5, 21))  # 2019-05-21
print(d.timetuple())  # time.struct_time(tm_year=2020, tm_mon=3, tm_mday=17, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=77, tm_isdst=-1)
print(d.toordinal())  # 737501
print(d.weekday())  # 1
print(d.isoweekday())  # 2
print(d.isocalendar())  # (2020, 12, 2)
print(d.isoformat())  # 2020-03-17
print(d.ctime())  # Tue Mar 17 00:00:00 2020
print(d.strftime('%Y/%m/%d'))  # 2020/03/17

datetime.time类

### 定义：

class datetime.time(hour, [minute[, second, [microsecond[, tzinfo]]]])

datetime模块下的时间类，只能处理时分秒。

from datetime import time
a = time(11,59,59)
print(a) #11:59:59

常用方法

from datetime import timeprint(time.max)  # 23:59:59.999999
print(time.min)  # 00:00:00
print(time.resolution)  # 0:00:00.000001
t = time(12, 15, 40, 6666)
print(t.hour)   # 12
print(t.minute)  # 15
print(t.second)  # 40
print(t.microsecond)  # 6666
print(t.replace(21))  # 21:15:40.006666
print(t.isoformat())  # 12:15:40.006666
print(t.strftime('%H%M%S'))  # 121540
print(t.strftime('%H%M%S.%f'))  # 121540.006666

datetime.datetime类

### 定义：

class datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None)

一定要注意这是datetime模块下的datetime类，千万不要搞混了！datetime模块下的日期时间类，你可以理解为datetime.time和datetime.date的组合类

from datetime import datetime
a = datetime(year=2021, month=12, day=3, hour=10, minute=59, second=59)
print(a) #2021-12-03 10:59:59

常用方法

datetime.timedelta类

定义：

class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, hours=0, weeks=0)

timedelta对象表示两个不同时间之间的差值。可以对datetime.date, datetime.time和datetime.datetime对象做算术运算

常用方法

import datetime
#一年有多少秒
print(datetime.timedelta(365).total_seconds())   #31536000.0
#获取现在时间
dt = datetime.datetime.now()

语法：

print(dt) #2021-10-04 17:22:31.928545
print(dt + datetime.timedelta(3))    # 3天后 2021-10-07 17:23:33.130410
print(dt + datetime.timedelta(-3))   # 3天前 2021-10-01 17:23:33.130410
print(dt + datetime.timedelta(hours=3))  # 3小时后 2021-10-04 20:24:30.536769
print(dt + datetime.timedelta(hours=-3))  # 3小时前 2021-10-04 14:24:30.536769
print(dt + datetime.timedelta(hours=3, seconds=30))  # 3小时30秒后 2021-10-04 20:25:55.309684

dt2 = dt + datetime.timedelta(hours=10)
print(dt2 - dt)  # 10:00:00
td = dt2 - dt
print(td.seconds)  # 36000

pprint模块

## 定义

pprint模块包含一个“美观打印器(PrettyPrinter)”，用于产生美观的数据结构视图。格式化程序生成可以由解释器正确解析的数据结构，并且容易使人阅读

## Printing

使用 pprint 模块的最简单方法是调用 pprint() 方法：

### 定义

pprint模块包含一个“美观打印器(PrettyPrinter)”，用于产生美观的数据结构视图。格式化程序生成可以由解释器正确解析的数据结构，并且容易使人阅读

语法：

`pprint.pprint`(*object*,*stream=None*,*indent=1*, *width=80*, *depth=None*)

indent --- 缩进，width --- 一行最大宽度，
depth --- 打印的深度，这个主要是针对一些可递归的对象，如果超出指定depth，其余的用"..."代替。

             eg: a=[1,2,[3,4,],5]  a的深度就是2; b=[1,2,[3,4,[5,6]],7,8] b的深度就是3

stream ---指输出流对象，如果stream=None，那么输出流对象默认是sys.stdout

from pprint import pprint
data = [("大数据一班",{"张三":18,"李四":20}),
("大数据二班",{"张三":18,"李四":20}),
("大数据三班",{"张三":18,"李四":20}),
("大数据四班",{"张三":18,"李四":20})]

#这种是打印一行

print(data)
pprint(data)

Formatting

定义

格式化数据结构

补充:日志的讲解

https://blog.csdn.net/colinlee19860724/article/details/90965100

import logging
from pprint import pformat
data = [("大数据一班",{"张三":18,"李四":20}),
("大数据二班",{"张三":18,"李四":20}),
("大数据三班",{"张三":18,"李四":20}),
("大数据四班",{"张三":18,"李四":20})]

#.basicConfig() 使用默认格式化程序创建 StreamHandler 并将其添加到根日志记录器中，从而完成日志系统的基本配置。如果没有为根日志程序定义处理程序，debug()、info()、warning()、error()和 critical() 函数将自动调用 basicConfig()。

logging.basicConfig(#级别排序：CRITICAL > ERROR > WARNING > INFO > DEBUG。level=logging.DEBUG,#为处理程序使用指定的格式字符串。#%(levelname) 日志级别  %(message)s已经记录的消息format='%(levelname)s %(message)s',
)
#打印
logging.debug('Logging pformatted data')
#对data进行格式化
formatted = pformat(data)
#Python splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
for line in formatted.splitlines():#Python rstrip() 删除 string 字符串末尾的指定字符（默认为空格）#可写可不写logging.debug(line.rstrip())

pickle模块

定义

pickle模块只能在python中使用，python中几乎所有的数据类型（列表，字典，集合，类等）都可以用pickle来序列化。

序列化方法

dumps()与loads()

语法：

dumps(数据类型) 将python转换成二进制
loads(二进制) 将二进制转换成python

import pickle as p String01 = "I love you"
a = p.dumps(String01)
print(a) #b'\x80\x03X\n\x00\x00\x00I love youq\x00.'b = p.loads(a)
print(b) #I love you

dump()与load()

语法：

dump(数据类型,文件对象) 把python转成二进制写入文件
load(文件对象) 把文件中的数据读取成二进制转成python

import pickle as plist01 = ["小明","翠花","王五","张三"]
#因为只能是二进制的，所以文件要声明成b 。要写进去所以是w
#open("f.txt","x") #创建一个文件
f1 = open("f.txt","wb")
p.dump(list01,f1) #文件是个二进制文件，打不开f1 = open("f.txt","rb")#r代表的是读
a = p.load(f1)
print(a) #['小明', '翠花', '王五', '张三']

文件的操作

创建/打开文件

Python内置了一个open()方法，用于对文件进行读写操作。使用open()方法操作文件，可分为三个步骤：1.打开文件、操作(读取/写入)文件、关闭文件

open()方法的返回值是一个file对象，基本语法如下：

语法：

 变量名 = open(文件名，打开模式)   f = open (filename,mode)

filename:1一个包含要访问的文件名称的字符串值，通常是一个文件路径

mode:打开文件的模式，默认是只读方式r

打开模式

#在路径下面创建text.py文件
#f =  open("text.txt","x")#在桌面上创建test。windows下面\有转义的意思
#f =  open("C:\\Users\\wangyujun\\Desktop\\text.txt","x")#想要打开的文件进行什么操作，就使用是什么模式
f =  open("text.txt","r")

#想要打开的文件进行什么操作，就使用是什么模式
f =  open("text.txt","r")

关闭文件

f.close()
#必须关闭文件，因为每次操作都是保存在内存中，并没有真正保存到文件中

读文件

常用方法

#首先我们要打开一个文件，需要有一个文件的对象
f = open("test.txt","w")#  <f>.write(s)      向文件写入一个字符串或字节流
s = "少年强则国强"
f.write(s)# <f>.writelines(lines)    将一个元素全为字符串的列表写入文件
l = ["馒头","大米","红烧肉"]
f.writelines(l)#  <f>.seek(offset)    改变当前文件操作指针的位置，offset含义如下：  0  – 文件开头；  1  – 当前位置；  2  – 文件结尾
f.seek(2)
f.write("zuguo")

#读文件也可以这样操作，但是这里的文本必须是英文，编码格式必须是UTF-8
#首先我们要打开一个文件，需要有一个文件的对象
f = open("test.txt","r+")#这里的指针是指第一行的从几到几
#下标是从0开始的
f.seek(4)
r1 = f.readline()
print(r1)

import os
os.remove("test.txt")
#大家先知道怎么使用，我们下一节课就讲解os模块

with语句

语法

with open(文件名) as 别名

f =  open("f.txt","rb")
a = f.readline()
print(a)
#打开一个文件，每一次都需要关闭文件
f.close()

#和上面是一样的，只是不需要去关闭流
with open("f.txt","rb") as f:a = f.readline()print(a)

json模块

定义

Json是一种轻量级的数据交换格式。Json源自JavaScript语言，易于人类的阅读和编写，同时也易于机器解析和生成，是目前应用最广泛的数据交换格式。

Json是跨语言，跨平台的，只能对python的基本数据类型的操作，对python的类型就无能为力。

{}是一个对象  []数组

Python内置类型转换JSON类型对照表

JSON类型转换Python类型对照表

常用方法

dumps()与loads()

语法：

json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, encoding="utf-8", default=None, sort_keys=False, **kw)
sort_keys =True:是告诉编码器按照字典排序(a到z)输出。如果是字典类型的python对象，就把关键字按照字典排序。
indent:参数根据数据格式缩进显示，读起来更加清晰。一般写2和4
separators:是分隔符的意思，参数意思分别为不同dict项之间的分隔符和dict项内key和value之间的分隔符，
skipkeys：默认值是False，如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时，就会报TypeError的错误。此时设置成True，则会跳过这类key
ensure_ascii=True：默认输出ASCLL码，如果把这个该成False,就可以输出中文。

check_circular：如果check_circular为false，则跳过对容器类型的循环引用检查，循环引用将导致溢出错误(或更糟的情况)。
allow_nan：如果allow_nan为假，则ValueError将序列化超出范围的浮点值(nan、inf、-inf)，严格遵守JSON规范，而不是使用JavaScript等价值(nan、Infinity、-Infinity)。
default：default(obj)是一个函数，它应该返回一个可序列化的obj版本或引发类型错误。默认值只会引发类型错误。

dumps(python数据) 把python数据转换成json数据
loads(json) 把json数据转换成python数据

import jsonprint(json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])) # 输出结果：["foo", {"bar": ["baz", null, 1.0, 2]}]
print(json.dumps("\"foo\bar")) # 输出结果："\"foo\bar" 里面相当于是一个整体
print(json.dumps('\u1234')) # 输出结果："\u1234"
print(json.dumps('\\'))  # 输出结果："\\"#如果sort_keys是False，则随机打印结果，如果sortkeys为true，则按顺序打印
print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)) # 输出结果：{"a": 0, "b": 0, "c": 0}

这里indent是缩进的意思一般写为4 或者2
separators 是（ ‘元素之间用逗号隔开’ ， ‘key和内容之间’ 用冒号隔开）
这里是 ‘逗号’ ， ‘冒号’ 中间的逗号不带引号

print(json.dumps([1, 2, 3, {'4': 5, '6': 7}], separators=(',', ':')))
# 输出结果：[1,2,3,{"4":5,"6":7}]
print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4))

这里indent是缩进的意思一般写为4 或者2
separators 是（ ‘元素之间用逗号隔开’ ， ‘key和内容之间’ 用冒号隔开）
这里是 ‘逗号’ ， ‘冒号’ 中间的逗号不带引号

a = json.dumps([1, 2, 3, {'4': 5, '6': 7}], separators=(',', ':')) # 输出结果：[1,2,3,{"4":5,"6":7}]
print (json.loads(a))#\b就有特殊的意义，单词边界，本身没有什么意思
b = json.dumps("\"foo\bar")
print (json.loads(b)) #"foar 

b = json.dumps("\"foo\bar")
print (json.loads(b)) #"foar 

数据库

windows安装数据库

windows10安装mysql_wyju的博客-CSDN博客

创建

updata------------>dml (数据操作语言)

insert------------>dml (数据操作语言)

delete------------>dml (数据操作语言)

select------------>dql (数据查询语言)

创建数据库

CREATE DATABASE 数据库名;

创建数据表

语法:

CREATE TABLE IF NOT EXISTS table_name (column_name column_type);

数据类型

约束

主键自增（int）

primary key auto_increment

外键

CONSTRAINT <约束名>
FOREIGN KEY <外键名>(字段名1，字段名2...)
REFERENCES <主表名>(主键字段名)

唯一约束

<字段名> <数据类型> UNIQUE

非空约束

not null

默认约束

<字段名> <数据类型> DEFAULT <默认值>

切换数据库

#使用/切换这个数据库： use 数据库名字；

增(添加数据)

insert into 表名（列名1，列名2） values（值1，值2）

删

delete from 表名 where 表达式  #删除单个语句
drop database 库名字； #输出数据库
drop table 表名字;#输出数据表

改

更新数据

update 表名 set 列名=值 [where 表达式]

alter

alter table 旧表名 rename  to 新表名; #修改表名字
alter table 表名字 modify 列名 (新)数据类型; #修改数据类型 id char(10)---->id int
alter table 表名字 change 旧列名字 新列名字 新数据类型；#修改列名字  studentname-->name
alter table 表名 drop 列名;#删除某一列
alter table 表名 add 新列名 （新列名）数据类型;#添加一个列
alter table 表名 modify 列名1 数据类型 after 列名字2;#把列1插入到列2后面

查

select 要查询的列名1，列名2 from 表名1,表2 
where 表达式1 and/not/or 表达式2
order by 列名字 desc/asc #order by 排序 desc降序 asc升序
limit 数字 #限制查询的条数 limit（2, 5）第2条数据到第5条数据

练习题

创建学生信息表。字段有：学生id（主键自增），学生姓名，性别，生日，电话（不为空），身份证号（唯一）
创建科目表：字段有：科目id（主键自增），科目名字
成绩表：成绩id（主键自增，成绩，科目id（外键），学生id（外键））
分别插入十条数据

#学生信息表
create TABLE studentInfo(
studentId int auto_increment primary key,
StudentName varchar(20),
#性别
Gender varchar(2),
Birthday date,
Age int(4),
BeginYear year,
Phone  varchar(11) not null,
idcard varchar(20) not null unique
);#科目表
create TABLE subject(
subjectId int auto_increment primary key,
subjectname varchar(20)
);#成绩表
create TABLE exam(
examId int auto_increment primary key,
exam float(4),
subjectid int,
constraint fk_subjectr_id foreign key(subjectid) references subject(subjectId),
studentid int,
constraint fk_student_id foreign key(studentid) references studentInfo(studentId)
);

python与数据库

1.安装pymsql

PyMySQL是一个纯python实现的mysql客户端操作库，支持事务，存储过程\批量执行

步骤：

pip install pymysql

列出软件包清单
    pip list
查看软件包信息
    pip show django

2.连接mysql

连接方法

使用python连接mysql数据库

1.6个常用的连接参数

pymysql.connect(host,user, password,port,db,charset)
host：MySQL服务器所在的主机的ip；
user：用户名
password：密码
port：连接的MySQL主机的端口，默认是3306
db：连接的数据库名
charset：当读取数据出现中文会乱码的时候，需要我们设置一下编码；python3默认采用的utf8字符集

注意：首先打开服务----->启动mysql

2.python连接MySOL的语法：

import pymysql

import pymysqldb=pymysql.connect(host='localhost',user='root',password='123456',port=3306,db='temp',charset='utf8')
#运行不报错就是可以了

3.cursor游标对象

定义

它负责执行我们熟悉的SQL语句

开启游标

# 开启mysql的游标功能，创建一个游标对象

cursor = db.cursor()

常用方法

注意：区别是：批量添加的时候executemany比较快

# 要执行的SQL语句，确保数据表中有相应的数据
sql = "select * from exam;"
# 使用游标对象执行SQL语句；
cursor.execute(sql)

cursor用来查询数据的方法

我们执行完sql语句怎么查询返回的受影响的函数呢，有以下及格方法

import pymysqldb=pymysql.connect(host='localhost',user='root',password='123456',port=3306,db='temp',charset='utf8')
#运行不报错就是可以了# 开启mysql的游标功能，创建一个游标对象；
cursor = db.cursor()# 要执行的SQL语句，确保数据表中有相应的数据
sql = "select * from exam;"
# 使用游标对象执行SQL语句；
cursor.execute(sql)
# 使用fetchone()方法，获取返回的结果，但是需要用变量保存返回结果；
#data = cursor.fetchone() #(1, '张三', 60)  单条数据
#多条数据
#data = cursor.fetchall() #((1, '张三', 60), (2, '李四', 60), (3, '王五', 80))
#两条数据
data = cursor.fetchmany(2) #((1, '张三', 60), (2, '李四', 60))
print(data)
# 断开数据库的连接，释放资源；
db.close()

游标类型（了解）

# 开启mysql的游标功能，创建一个游标对象；
cursor = db.cursor(cursor=DictCursor)

操作数据库

创建表

import pymysqldb=pymysql.connect(host='localhost',user='root',password='123456',port=3306,db='temp',charset='utf8')
#运行不报错就是可以了# 开启mysql的游标功能，创建一个游标对象；
cursor = db.cursor()#创建表，字段是id，姓名，年龄，性别
sql = """
CREATE TABLE ceshi(id int,name varchar(10),age int,sex char(10)
) """
# 使用游标对象执行SQL语句；
cursor.execute(sql)
# 断开数据库的连接，释放资源；
db.close()

插入数据

插入单调

import pymysqldb=pymysql.connect(host='localhost',user='root',password='123456',port=3306,db='temp',charset='utf8')
#运行不报错就是可以了# 开启mysql的游标功能，创建一个游标对象；
cursor = db.cursor()#插入数据
sql = """
insert into ceshi(id, name, age, sex)
values(%s,%s,%s,%s)
"""
try:# 使用游标对象执行SQL语句；cursor.execute(sql,(2,"翠花",19,"男"))db.commit()
except Exception as ex:print('插入语句错误' + str(ex))db.rollback()
finally:db.close()

插入多条数据

import pymysqldb=pymysql.connect(host='localhost',user='root',password='123456',port=3306,db='temp',charset='utf8')
#运行不报错就是可以了# 开启mysql的游标功能，创建一个游标对象；
cursor = db.cursor()#插入数据
sql = """
insert into ceshi(id, name, age, sex)
values(%s,%s,%s,%s)
"""
data = [(3,"王五",19,"男"),(4,"李四",19,"男"),(5,"赵六",19,"男")
]try:# 使用游标对象执行SQL语句；cursor.executemany(sql,data)db.commit()
except Exception as ex:print('插入语句错误' + str(ex))db.rollback()
finally:db.close()

查询数据

import pymysqldb=pymysql.connect(host='localhost',user='root',password='123456',port=3306,db='temp',charset='utf8')# 开启mysql的游标功能，创建一个游标对象；
cursor = db.cursor()
# 要执行的SQL语句，确保数据表中有相应的数据
sql = "select * from ceshi;"
# 使用游标对象执行SQL语句；
cursor.execute(sql)
#多条数据
data = cursor.fetchall()
print(data)
# 断开数据库的连接，释放资源；
db.close()

更新数据

import pymysqldb=pymysql.connect(host='localhost',user='root',password='123456',port=3306,db='temp',charset='utf8')# 开启mysql的游标功能，创建一个游标对象；
cursor = db.cursor()
# 要执行的SQL语句，确保数据表中有相应的数据
sql = "update ceshi set age=%s, sex=%s where id=%s;"
try:# 使用游标对象执行SQL语句；cursor.execute(sql,(50,"女",3)) db.commit()
except Exception as ex:print('插入语句错误' + str(ex))db.rollback()
finally:db.close()

删除数据

import pymysqldb=pymysql.connect(host='localhost',user='root',password='123456',port=3306,db='temp',charset='utf8')# 开启mysql的游标功能，创建一个游标对象；
cursor = db.cursor()
# 要执行的SQL语句，确保数据表中有相应的数据
sql = 'delete from ceshi where id=%s'
try:cursor.execute(sql, 3)  db.commit()
except Exception as ex:print('插入语句错误' + str(ex))db.rollback()
finally:db.close()

总结：执行事务

事务机制可以确保数据一致性。

事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。

· 原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的各种操作要么都做，要么都不做。

· 一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。

· 隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

· 持久性（durability）。持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

在pymysql模块是默认开启MySQL的事务功能的，MySQL不会自动提交所执行的相关SQL语句。因此，进行"增"、"删"、"改"的时候，一定要使用db.commit()提交事务，否则就看不见所插入的数据。

同时，进行"增"、"删"、"改"的时候，一定要使用try…except…语句，因为SQL语句一旦没有执行成功，我们可以使用db.rollback()回滚到操作之前的状态；当语句执行成功，我们就db.commit()提交事务。

math模块

定义：

math模块是基础的python中的数学函数模块，进行一些数学计算功能

math中的函数不可以用于太过于复杂的数的运算

基本函数

import math
​
a = math.ceil(3.2) #向上取整
a = math.floor(3.2) #向下取整
a = math.pow(3,2) #3的2次方
a = math.sqrt(4) #开平方
a = math.fabs(-1) #绝对值
a = math.copysign(4, -2) #符号是符号，值是数值
a = math.factorial(4) #阶乘  4*3*2*1
a = math.fmod(4,2) #取余
a = math.fsum([2,3])   #迭代器的和
print(a)

定义常数

对数和三角函数

在数学里面，log用于表示一般的对数，可以用任意一个数作为底数。. 【举例，2的2次方等于4，那么，log2 (4)就等于2。. 】. 而lg在数学里面称为常用对数，常用对数就是以10为底数的对数。. 【举例，10的2次方等于100，那么lg (100)就等于2。. 】.

import matha = math.log(5)
a = math.log(2,5)
a = math.log2(5)
a = math.log10(2)
a = math.sin(5)
print(a)

random模块（随机数）

random模块用于生成伪随机数，

常用方法

针对浮点数

import random as ra
#random.random() 随机生成一个浮点数
print(ra.random()) #0.7025318415790162

针对整数

注意：在使用后面的方法时，一定要小心区间的开闭

import random as ra
"""
random.randint(start,stop) 随机生成一个start,stop之间的整数
随机产生start-stop之间的整数，包括start和stop。
"""
for i in range(10):a = ra.randint(0,10)print(a)

语法：

random.randrange(start,stop,step)  随机生成一个start,stop之间的整数 
1.random.randrange(stop)  不写start，默认是0
2.左开右闭
3.step 步长,间隔

#a = ra.randrange(10) #0-9之间的数据，不包含10
#a = ra.randrange(1,10) #1-10,不包含10
a = ra.randrange(1,10,2) #步长2，相当于奇数
print(a)

针对序列类型

语法：

random.choice(sequence)  从一个序列中随机选择一个元素 
1.只能从字符串、元组、列表中随机获取

random.shuffle(sequence)  随机打乱列表的顺序,原列表发生变化 

random.sample(population,k) 从序列中随机抽取k个元素，返回一个新元素

import random as ra
String01 = "I love you"
list01 = ["张三","李四","王五","赵六"]
tuple01 = (1,2,3)
# 报错 dict01 = {"张三":14,"王五":20,"李四":40}
# 报错 set01 = {1,2,3,4}
a = ra.choice(String01)
print(a)

import random as ra#自能是列表类型
String01 = "I love you" #报错 字符串是字母有序的组合
list01 = ["张三","李四","王五","赵六"]
tuple01 = (1,2,3)  #报错
dict01 = {"张三":14,"王五":20,"李四":40} #报错
set01 = {1,2,3,4} #报错
ra.shuffle(list01)
print(list01)

import random as ra
#字典不可以
String01 = "I love you"
list01 = ["张三","李四","王五","赵六"]
tuple01 = (1,2,3)
dict01 = {"张三":14,"王五":20,"李四":40} #报错
set01 = {1,2,3,4}
a= ra.sample(set01,3)
print(a)

练习题

1.随机生成3个0-9之间的整数，若其中有两个值相等，则提示中奖，否则提示谢谢参与

import random
a1 = int(random.random()*10)
a2 = int(random.random()*10)
a3 = int(random.random()*10)
print(a1,a2,a3)
if a1==a2 or a2==a3 or a1==a3:print("中奖")
else:print("谢谢参与")

2.红包随机。

import random
#分配红包函数---fphb
#红包的总个数--zNumber
#红包的钱数，以分为单位---money
def fphb(zNumber, money):result = []number = zNumber#依据红包总个数遍历，有四个红包，就遍历四次for i in range(zNumber):#红包总个数不断的在减一number -= 1#红包个数大于0证明还有人没领红包if number > 0:#随机分钱，范围在1-m = random.randint(1, money)else:#最后一个人拿到剩下的钱m = money#把分出去的钱减去money -= m#结果从分换算成了元result.append(m / 100.0)return resultn = int(input('红包个数:'))
#为什么money要乘100，我们的单位是分
m = eval(input('总金额:') * 100)
list01= fphb(n, m)
print(list01)

第五章 PYTHON标准库相关推荐

1. 第 9 章 Python 标准库概览

   整理的文章内容主要来源为高教版<计算机等级考试二级 Python>教程视频讲义,并且更正了原讲义中的错误的地方. 专栏文章索引如下: 考试大纲 第 1 章 程序设计基本方法 第 2 章 P ...

2. python语言程序设计 梁勇_计算机二级教程 Python语言程序设计，第9章Python标准库概览...

   第九章学习知识导图 考点主要是: 1) 标准库: turtle库(必选) 2) 标准库: random库(必选).time库(可选) 3) 作者归纳:这章考大题和选择题的读程序题,本章结束,pytho ...

3. A Byte of Python 笔记（12）python 标准库：sys、os，更多内容

   第14章 python 标准库 Python标准库是随Python附带安装的,它包含大量极其有用的模块. sys 模块 sys 模块包含系统对应的功能.如 sys.argv 列表包含命令行参数. # ...

4. 第 11 章 Python 第三方库纵览

   整理的文章内容主要来源为高教版<计算机等级考试二级 Python>教程视频讲义,并且更正了原讲义中的错误的地方. 专栏文章索引如下: 考试大纲 第 1 章 程序设计基本方法 第 2 章 P ...

5. 第十五章 Python和Web

   第十五章 Python和Web 本章讨论Python Web编程的一些方面. 三个重要的主题:屏幕抓取.CGI和mod_python. 屏幕抓取 屏幕抓取是通过程序下载网页并从中提取信息的过程. 下载 ...

6. python标准库不需要导入即可使用其中的所有对象和方法_Python程序设计-中国大学mooc-题库零氪...

   <Python程序设计基础>课程导学 单元测验 1.下面属于Python应用领域的有? A.数据分析 B.云计算 C.开发操作系统 D.网络安全 E.树莓派 F.数据可视化 2.在Wind ...

7. python标准库不需要导入即可使用其中的所有对象和方法_Python编程及应用-中国大学mooc-题库零氪...

   <Python程序设计基础>课程导学 单元测验 1.下面属于Python应用领域的有? A.数据分析 B.云计算 C.开发操作系统 D.网络安全 E.树莓派 F.数据可视化 2.在Wind ...

8. 汤老师的Python标准库

   Python常用标准库 汤小洋 关注 0人评论 701人阅读 2018-08-26 18:05:12 (转自汤老师的博客http://blog.51cto.com/12402007/2164567) ...

9. Python 标准库之 xml.etree.ElementTree xml解析

   Python 标准库之 xml.etree.ElementTree Python中有多种xml处理API,常用的有xml.dom.*模块.xml.sax.*模块.xml.parser.expat模块和 ...

10. Python标准库04 文件管理 (部分os包，shutil包)

    摘要:Python标准库 os包: rmdir, mkdir, listdir, remove, rename, chmod, chown, stat, symlink shutil包: copy, ...

最新文章

1. Bootstrap表单验证插件bootstrapValidator使用方法整理
2. MM32F3277 MicroPython移植过程中对应的接口文件
3. 感知算法论文（七）：DFANet: Deep Feature Aggregation for Real-Time Semantic Segmentation（2019）
4. 有的日期输入框，可直接调用javascripts
5. python until怎么用_python基础之从认识python到python的使用
6. 华为P30系列高清渲染图曝光：后置三摄拍照要上天
7. js递归遍历json树_2020-08-26：裸写算法：树的非递归先序遍历
8. 一文搞定移动端适配！
9. 根据一览，自动生成Sheet页
10. python全景图像拼接_超详讲解图像拼接/全景图原理和应用 | 附源码
11. objenesis的基本使用方法
12. 通达信 python_python 适用通达信
13. 银行业务头条体系推广
14. android自定义区域生成截图,一文看懂MIUI区域截屏 使用教程 （钉子户米6也能用）...
15. meanshift跟踪算法
16. python画名侦探柯南_基于flask的可视化动漫分析网站【python入门必学】
17. Rancher Cluster is being upgraded
18. 什么叫做云计算？学习云计算先要理解
19. vue+element自动计算天数
20. 跳棋最少移动次数 java,跳棋

热门文章

1. matlab 读取mp3文件,MATLAB音频文件读取
2. ios visio流程图_微软visio绘图查看器ios版下载|Microsoft Visio Viewer iphone/ipad版下载 v1.17 - 跑跑车苹果网...
3. 基于NFC的Android读写软件,NFC读写（android代码）
4. python安装包下载及安装（超详细）
5. 数学建模c语言知识,数学建模方法总结
6. MATLAB通信系统建模与仿真
7. Java自学视频整理
8. 安全测试|SQL注入技术
9. 世界顶级图表-华尔街日报配色方案详解
10. Vensim学习之Random Normal函数的使用