5.1sys模块

定义

sys模块主要负责与Python解释器进行交互

常用方法

import sys#如何查看sys里面有哪些方法
#help(sys)#利用以上的不直观，我们可以dir
print(dir(sys))

属性或方法	描述
sys.argv	获取命令行参数列表，第一个参数是程序本身
sys.exit(n)	退出 Python 程序，exit(0) 表示正常退出。当参数非 0 时,会引发一个 SystemExit 异常，可以在程序中捕获该异常
sys.version	获取 Python 解释程器的版本信息
sys.maxsize	最大的 Int 值，在 64 位操作系统上是 263-1
sys.path	返回模块的搜索路径，初始化时使用 PYTHONPATH 环境变量的值
sys.platform	返回操作系统平台名称
sys.stdin	输入相关
sys.stdout	输出相关
sys.stderr	错误相关
len()	获取长度
sys.path.insert(index,字符)	指定下标插入数据
sys.path = []	删除所有路径
sys.getfilesystemencoding()	获取文件系统使用编码方式，默认是 UTF-8
sys.modules	以字典的形式返回所有当前 Python 环境中已经导入的模块
sys.builtin_module_names	返回一个列表，包含所有已经编译到 Python 解释器里的模块的名字
sys.modules.keys()	返回所有已将导入模块的key
sys.flags	命令行标识状态信息列表
sys.getrefcount(object)	返回对象的引用数量
sys. getrecursionlimit()	返回 Python 最大递归深度，默认为 1000
sys.getsizeof(object[, default])	返回对象的大小
sys.getswitchinterval()	返回线程切换时间间隔，默认为0.005秒
sys.setswitchinterval(interval)	设置线程切换的时间间隔，单位为秒
sys. getwindowsversion()	返回当前 Windows 系统的版本信息
sys.hash_info	返回 Python 默认的哈希方法的参数
sys.implementation	当前正在运行的 Python 解释器的具体实现，如 CPython
sys.thread_info	当前线程信息

代码

此代码在vscode里面写好在cmd窗口去运行
python 文件名字  参数
D:\axc\Python\PythonTemp>python count.py 12 3 4 5import sys
print(sys.argv)

#exit(n)退出 Python 程序，exit(0) 表示正常退出
for i  in range(10):if i==5:exit(0)print(i)

# sys.version | 获取 Python 解释程器的版本信息
import sys
print(sys.version) #3.7.6 (tags/v3.7.6:43364a7ae0, Dec 19 2019, 00:42:30) [MSC v.1916 64 bit (AMD64)]# sys.maxsize | 最大的 Int 值，在 64 位操作系统上是 263-1
print(sys.maxsize)  #9223372036854775807
# sys.path    | 返回模块的搜索路径，初始化时使用 PYTHONPATH 环境变量的值
print(sys.path)

import sys
print('Path 包括：', len(sys.path), '个部分构成')
sys.path.insert(0,"simple") #在路径首位置添加
print(sys.path)a = sys.builtin_module_names
print(a) #所有内建模块的名字

import sys
print(sys.modules)
print("------------------------------------------------")
print(sys.modules.keys())

#sys.getrefcount(object)返回对象的引用数量
import sys
a = [1, 2, 3]
b = a
print(sys.getrefcount(a))    # 3
注意，这个列表被a、b以及getrefcount()三个地方调用，因此输出结果为3。

练习

"""定义一个函数，属于一个名字，查看是否是内建模块
"""def is_module(name):if name in a:print("是一个模块")else:print("什么都不是")is_module("time")

5.2os模块

定义

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

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

常用方法

方法或变量	用途
os.mkdir(‘dirname’)	生成单级目录，相当于shell中mkdir dirname
os.makedirs(‘dirname1/dirname2’)	可生成多层递归目录
os.rmdir(‘dirname’)	删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.removedirs(‘dirname1’)	若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.listdir(‘dirname’)	列出指定目录下的所有文件和子目录，包括隐藏文件并以列表方式打印
os.remove()	删除一个文件
os.rename(“oldname”,“newname”)	重命名文件/目录
os.path.abspath(path)	返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path)	返回path的目录
os.path.exists(path)	如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)	如果path是绝对路径，返回True
os.path.isfile(path)	如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)	如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[,path2[, …]])	将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)	返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)	返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path)	返回path的大小
os.getcwd()	获取当前工作目录，即当前python脚本工作的目录路径
os.chdir(“dirname”)	改变当前脚本工作目录；相当于shell下cd
os.curdir	返回当前目录: (’.’)
os.pardir	获取当前目录的父目录字符串名：(’…’)
os.stat(‘path/filename’)	获取文件/目录信息

代码

import os
#print(os.getcwd())#获取当前目录  D:\axc\Python\PythonTemp#print(os.chdir(r"C:\\Users\\wangyujun\\Desktop"))#切换进入到哪个目录下
#print(os.getcwd()) #print(os.getcwd())#os.rename('本文件.py','test.py')#os.rename(old,new)将old文件重命名为new
#os.remove('test.py')#删除文件
#os.mkdir('dis')#创建单级空文件夹，目录
#os.rmdir('dis')#删除单级空目录
#os.makedirs('dis\\b')#创建多层递归目录
#os.removedirs('dis\\b')#只能删除空的文件夹
#print(os.listdir('dis'))#列出指定目录下的所有文件及文件夹，包括隐藏文件，并返回一个list
#os.system('ipconfig')#可以直接操作系统命令,os.system(command)
"""
res=os.popen('ipconfig').read()#执行操作系统命令
print(res)
"""

import os
#print(os.path.dirname('D:\\axc\\Python\\PythonTemp\\count.py'))#返回path的目录,取父目录
print(os.path.split('D:\\axc\\Python\\PythonTemp\\count.py'))#将path分割成目录和文件名，并返回一个元组
#print(os.path.join('program','python','code','student.py'))#将多个路径拼起来
#print(os.path.exists('D:\\axc\\Python\\PythonTemp\\count.py'))#判断path(文件或文件夹)是否存在
#print(os.path.isfile('D:\\axc\\Python\\PythonTemp\\count.py'))#判断path是否是文件,True
#print(os.path.isdir('D:\\axc\\Python\\PythonTemp\\count.py'))#判断path是否是目录，False

文件模式匹配：glob模块

import glob
import os#文件下面所有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只是返回文件名。
"""

5.3正则表达式

定义

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

元字符

有特殊含义的字符

表达式	匹配
.	小数点可以匹配除了换行符\n以外的任意一个字符
|	逻辑或操作符 ,或
[]	匹配字符集中的一个字符
[^]	对字符集求反，也就是上面的反操作。尖号必须在方括号里的最前面
-	定义[]里的一个字符区间，例如[a-z]
\	对紧跟其后的一个字符进行转义
()	对表达式进行分组，将圆括号内的内容当做一个整体，并获得匹配的值

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) #['.']

转义字符

表达式	匹配
\r, \n	匹配回车和换行符
\t	匹配制表符
\\	匹配斜杠\
\^	匹配^符号
\$	匹配$符号
\.	匹配小数点.

预定义匹配字符集

表达式	匹配
\d	任意一个数字，0~9中的任意一个
\w	任意一个字母或数字或下划线，也就是AZ,az,0~9,_ 中的任意一个
\s	空格、制表符、换页符等空白字符的其中任意一个
\D	\d的反集，也就是非数字的任意一个字符，等同于[^\d]
\W	\w的反集，也就是[^\w]
\S	\s的反集，也就是[^\s]

#匹配出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']

重复匹配

表达式	匹配
{n}	表达式重复n次，比如\d{2}相当于\d\d,a{3}相当于aaa
{m,n}	表达式至少重复m次，最多重复n次。比如ab{1,3}可以匹配ab或abb或abbb
{m,}	表达式至少重复m次，比如\w\d{2,}可以匹配a12,_1111,M123等等
?	匹配表达式0次或者1次，相当于{0,1}，比如a[cd]?可以匹配a,ac,ad
+	表达式至少出现1次，相当于{1,}，比如a+b可以匹配ab,aab,aaab等等
*	表达式出现0次到任意次，相当于{0,}，比如\^*b可以匹配b,^^^b等等

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', '', '', '']

位置匹配

表达式	匹配
^	在字符串开始的地方匹配，符号本身不匹配任何字符
$	在字符串结束的地方匹配，符号本身不匹配任何字符
\b	匹配一个单词边界，也就是单词和空格之间的位置，符号本身不匹配任何字符
\B	匹配非单词边界，即左右两边都是\w范围或者左右两边都不是\w范围时的字符缝隙

#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)

2.电子邮箱验证

#电子邮箱验证s = input("请输入一个电子邮箱：")a= re.findall("^\w+@\w+[\.]\w+$",s) #从0开始print(a) #newglf@163.com

3.电话号码的验证

s = input("请输入一个电话：")zengze = "^1[3,4,8,]\d{9}$"^1[3-9]\d{9}a= re.findall(zengze,s) #从0开始print(a) #联通电话#130、131、132、145、155、156、166、167、171、175、176、185、186、196s = input("请输入一个电子邮箱：")zengze = "^(13[0,1,2]|14[5]|15[5,6]|16[6,7]|17[1,5,6]|18[5,6]|19[6])\d{8}$"a= re.search(zengze,s)print(a)

5.3re模块

定义

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

常用方法

方法	描述	返回值
compile(pattern)	根据包含正则表达式的字符串创建模式对象	re对象
search(pattern, string)	在字符串中查找 。第一个匹配到的对象或者None	返回一个match对象
match(pattern, string)	在字符串的开始处匹配模式。 在字符串开头匹配到的对象或者None	返回一个match对象
findall(pattern, string,flags)	列出字符串中模式的所有匹配项	所有匹配到的字符串列表
finditer(pattern, string,flags)	将所有匹配到的项生成一个迭代器	所有匹配到的字符串组合成的迭代器
match.group(index)	将match对象拆分成字符串。不写index默认是0	返回match object中的字符串/元组
match.groups()	将match对象转换成元组	返回由所有分组匹配到的字符串组成的tuple。
match.start(index)	没有参数时，返回匹配到的字符串的起始位置。指定参数（整数）时，返回该分组匹配到的字符串的起始位置	返回int类型
match.end(index)	没有参数时，返回匹配到的字符串的结束位置。指定参数（整数）时，返回该分组匹配到的字符串的结束位置。	返回int类型
match.span(index)	返回一个二元tuple表示匹配到的字符串的范围，即(start, end)	返回元组
split(pattern, string)	根据模式的匹配项来分割字符串	分割后的字符串列表
sub(repl, string,count=0)	将字符串中所有的pat的匹配项用repl替换	完成替换后的新字符串
subn(pat,repl, string)	在替换字符串后，同时报告替换的次数	完成替换后的新字符串及替换次数
escape（string）	将字符串中所有特殊正则表达式字符串转义	转义后的字符串
purge(pattern)	清空正则表达式
template(pattern)	编译一个匹配模板	模式对象
fullmatch(pattern, string)	match方法的全字符串匹配版本	类似match的返回值

代码

查询模块

#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")  #开头不是数字，所以输出Noneprint(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相关方法

#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   默认是0print(a.group(1)) #Iprint(a.group(2)) #LOvEprint(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()) #6print(a.end(2)) #6print(a.end(1))  #1

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

拆分

#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用于指定最多替换次数，不指定时全部替换。"""   r = re.compile(r"like", re.I)#s1 = r.sub(r"love", "I like you, do you like me?")  #I love you, do you love me?#最多替换1次，所以把一个like替换了s1 = r.sub(r"love", "I like you, do you like me?",count=1)print(s1) #I love you, do you like me?#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)

补充®

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

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

练习

""" 匹配身份证"""import res = 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)

5.4日期时间相关：datetime模块

定义

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

类名	描述
datetime.date	日期类
datetime.time	时间类
datetime.datetime	日期与时间类
datetime.timedelta	表示两个date、time、datetime实例之间的时间差
datetime.tzinfo	时区相关信息对象的抽象基类。
datetime.timezone	Python3.2中新增的功能，实现tzinfo抽象基类的类，表示与UTC的固定偏移量

两个属性

常量	功能说明	返回值 描述
datetime.MAXYEAR	返回能表示的最大年份	9999
** datetime.MINYEAR**	返回能表示的最小年份	1

import datetimeprint(datetime.MINYEAR) #1print(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) #2021print(date01.month) #12print(date01.day) #22

常用的方法和属性

类方法**/**属性名称	描述
date.max	date对象所能表示的最大日期：9999-12-31
date.min	date对象所能表示的最小日期：00001-01-01
date.resoluation	date对象表示的日期的最小单位：天
date.today()	返回一个表示当前本地日期的date对象
date.fromtimestamp(timestamp)	根据给定的时间戳，返回一个date对象
d.year	年
d.month	月
d.day	日
d.replace(year[, month[, day]])	生成并返回一个新的日期对象，原日期对象不变
d.timetuple()	返回日期对应的time.struct_time对象
d.toordinal()	返回日期是是自0001-01-01开始的第多少天
d.weekday()	返回日期是星期几，[0, 6]，0表示星期一
d.isoweekday()	返回日期是星期几，[1, 7], 1表示星期一
d.isocalendar()	返回一个元组，格式为：(year, weekday, isoweekday)
d.isoformat()	返回‘YYYY-MM-DD’格式的日期字符串
d.strftime(format)	返回指定格式的日期字符串，与time模块的strftime(format, struct_time)功能相同

代码

import timefrom datetime import dateprint(date.max)  # 9999-12-31print(date.min)  # 0001-01-01 print(date.resolution)  # 1 day, 0:00:00print(date.today())  # 2020-03-17  print(date.fromtimestamp(time.time()))  # 2020-03-17d = date.today()  print(d.year)  # 2020print(d.month)  # 3print(d.day)  # 17print(d.replace(2019))  # 2019-03-17print(d.replace(2019, 5))  # 2019-05-17print(d.replace(2019, 5, 21))  # 2019-05-21print(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())  # 737501print(d.weekday())  # 1print(d.isoweekday())  # 2print(d.isocalendar())  # (2020, 12, 2)print(d.isoformat())  # 2020-03-17print(d.ctime())  # Tue Mar 17 00:00:00 2020print(d.strftime('%Y/%m/%d'))  # 2020/03/17

datetime.time类

定义：

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

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

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

常用方法

类方法**/**属性名称	描述
time.max	time类所能表示的最大时间：time(23, 59, 59, 999999)
time.min	time类所能表示的最小时间：time(0, 0, 0, 0)
time.resolution	时间的最小单位，即两个不同时间的最小差值：1微秒
t.hour	时
t.minute	分
t.second	秒
t.microsecond	微秒
t.tzinfo	返回传递给time构造方法的tzinfo对象，如果该参数未给出，则返回None
t.replace(hour[, minute[, second[, microsecond[, tzinfo]]]])	生成并返回一个新的时间对象，原时间对象不变
t.isoformat()	返回一个‘HH:MM:SS.%f’格式的时间字符串
t.strftime()	返回指定格式的时间字符串，与time模块的strftime(format, struct_time)功能相同

代码

from datetime import timeprint(time.max)  # 23:59:59.999999print(time.min)  # 00:00:00print(time.resolution)  # 0:00:00.000001t = time(12, 15, 40, 6666)print(t.hour)   # 12print(t.minute)  # 15print(t.second)  # 40print(t.microsecond)  # 6666print(t.replace(21))  # 21:15:40.006666print(t.isoformat())  # 12:15:40.006666print(t.strftime('%H%M%S'))  # 121540print(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 datetimea = datetime(year=2021, month=12, day=3, hour=10, minute=59, second=59)print(a) #2021-12-03 10:59:59

常用方法

类方法**/**属性名称	描述
datetime.today()	返回一个表示当前本期日期时间的datetime对象
datetime.now([tz])	返回指定时区日期时间的datetime对象，如果不指定tz参数则结果同上
datetime.utcnow()	返回当前utc日期时间的datetime对象
datetime.fromtimestamp(timestamp[, tz])	根据指定的时间戳创建一个datetime对象
datetime.utcfromtimestamp(timestamp)	根据指定的时间戳创建一个datetime对象
datetime.combine(date, time)	把指定的date和time对象整合成一个datetime对象
datetime.strptime(date_str, format)	将时间字符串转换为datetime对象
dt.year, dt.month, dt.day	年、月、日
dt.hour, dt.minute, dt.second	时、分、秒
dt.microsecond, dt.tzinfo	微秒、时区信息
dt.date()	获取datetime对象对应的date对象
dt.time()	获取datetime对象对应的time对象，tzinfo为None
dt.timetz()	获取datetime对象对应的time对象，tzinfo与datetime对象的tzinfo相同
dt.replace()	生成并返回一个新的datetime对象，如果所有参数都没有指定，则返回一个与原datetime对象相同的对象
dt.timetuple()	返回datetime对象对应的tuple（不包括tzinfo）
dt.utctimetuple()	返回datetime对象对应的utc时间的tuple（不包括tzinfo）
dt.timestamp()	返回datetime对象对应的时间戳，Python 3.3才新增的
dt.toordinal()	同date对象
dt.weekday()	同date对象
dt.isocalendar()	同date对象
dt.isoformat([sep])	返回一个‘%Y-%m-%d’字符串
dt.ctime()	等价于time模块的time.ctime(time.mktime(d.timetuple()))
dt.strftime(format)	返回指定格式的时间字符串

datetime.timedelta类

定义：

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

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

常用方法

类方法**/**属性名称	描述
timedelta.min	timedelta(-999999999)
timedelta.max	timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)
timedelta.resolution	timedelta(microseconds=1)
td.days	天 [-999999999, 999999999]
td.seconds	秒[0, 86399]
td.microseconds	微秒[0, 999999]
td.total_seconds()	时间差中包含的总秒数，等价于: td / timedelta(seconds=1)

import datetime#一年有多少秒print(datetime.timedelta(365).total_seconds())   #31536000.0#获取现在时间dt = datetime.datetime.now()"""print(dt) #2021-10-04 17:22:31.928545print(dt + datetime.timedelta(3))    # 3天后 2021-10-07 17:23:33.130410print(dt + datetime.timedelta(-3))   # 3天前 2021-10-01 17:23:33.130410print(dt + datetime.timedelta(hours=3))  # 3小时后 2021-10-04 20:24:30.536769print(dt + datetime.timedelta(hours=-3))  # 3小时前 2021-10-04 14:24:30.536769print(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:00td = dt2 - dtprint(td.seconds)  # 36000

5.5pprint模块

定义

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的深度就是3stream ---指输出流对象，如果stream=None，那么输出流对象默认是sys.stdout
"""

代码

from pprint import pprint
data = [("大数据一班",{"张三":18,"李四":20}),
("大数据二班",{"张三":18,"李四":20}),
("大数据三班",{"张三":18,"李四":20}),
("大数据四班",{"张三":18,"李四":20})]#这种是打印一行
print(data)
pprint(data)
"""
[('大数据一班', {'张三': 18, '李四': 20}),('大数据二班', {'张三': 18, '李四': 20}),('大数据三班', {'张三': 18, '李四': 20}),('大数据四班', {'张三': 18, '李四': 20})]
"""

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())"""
DEBUG Logging pformatted data
DEBUG [('大数据一班', {'张三': 18, '李四': 20}),
DEBUG  ('大数据二班', {'张三': 18, '李四': 20}),
DEBUG  ('大数据三班', {'张三': 18, '李四': 20}),
DEBUG  ('大数据四班', {'张三': 18, '李四': 20})
"""

练习

import logging
from pprint import pformat
"""把下面的报错加上error
"""
data = ["FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. MetaException(message:org.apache.hadoop.hbase.client.RetriesExhaustedException: Can't get the locations","at org.apache.hadoop.hbase.client.RpcRetryingCallerWithReadReplicas.getRegionLocations(RpcRetryingCallerWithReadReplicas.java:312)","at org.apache.hadoop.hbase.client.ScannerCallableWithReplicas.call(ScannerCallableWithReplicas.java:153)","at org.apache.hadoop.hbase.client.ScannerCallableWithReplicas.call(ScannerCallableWithReplicas.java:61)","at org.apache.hadoop.hbase.client.RpcRetryingCaller.callWithoutRetries(RpcRetryingCaller.java:200)","at org.apache.hadoop.hbase.client.ClientScanner.call(ClientScanner.java:320)","at org.apache.hadoop.hbase.client.ClientScanner.nextScanner(ClientScanner.java:295)","at org.apache.hadoop.hbase.client.ClientScanner.initializeScannerInConstruction(ClientScanner.java:160)","at org.apache.hadoop.hbase.client.ClientScanner.<init>(ClientScanner.java:155)","at org.apache.hadoop.hbase.client.HTable.getScanner(HTable.java:811)","at org.apache.hadoop.hbase.MetaTableAccessor.fullScan(MetaTableAccessor.java:602)","at org.apache.hadoop.hbase.MetaTableAccessor.tableExists(MetaTableAccessor.java:366)","at org.apache.hadoop.hbase.client.HBaseAdmin.tableExists(HBaseAdmin.java:303)","at org.apache.hadoop.hbase.client.HBaseAdmin.tableExists(HBaseAdmin.java:313)"]#.basicConfig()
logging.basicConfig(#级别排序：CRITICAL > ERROR > WARNING > INFO > DEBUG。level=logging.ERROR,#为处理程序使用指定的格式字符串。#%(levelname) 日志级别  %(message)s已经记录的消息format='%(levelname)s %(message)s',
)
#打印
logging.error('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.error(line.rstrip())

5.6pickle模块

定义

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

序列化方法

方法	功能
pickle.dump(obj, file)	将Python数据转换并保存到pickle格式的文件内
pickle.dumps(obj)	将Python数据转换为pickle格式的bytes字串
pickle.load(file)	从pickle格式的文件中读取数据并转换为python的类型
pickle.loads(bytes_object)	将pickle格式的bytes字串转换为python的类型

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) #['小明', '翠花', '王五', '张三']

5.7文件的操作

创建/打开文件

语法

"""变量名 = open(文件名，打开模式)
"""

打开模式

文件的打开模式	描述
‘r’	只读模式，默认值，如果文件不存在，返回FileNotFoundError
‘w’	覆盖写模式，文件不存在则创建，存在则完全覆盖
‘x’	创建写模式，文件不存在则创建，存在则返回FileExistsError
‘a’	追加写模式，文件不存在则创建，存在则在文件最后追加内容
‘b’	二进制文件模式
‘t’	文本文件模式，默认值
‘+’	与r/w/x/a一同使用，在原功能基础上增加同时读写功能

代码

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

关闭文件

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

读文件

常用方法

操作方法	描述
.read()	读入全部内容
.readline(size=-1)	读入一行内容，如果给出参数，读入该行前size长度
.readlines(hint=-1)	读入文件所有行，以每行为元素形成列表 如果给出参数，读入前hint行

代码

注意：如果文件是中文，打开之后报错。就按照一下步骤修改

文件—>首选项—>设置—>搜索encoding---->simplified chiese (GBK)

#首先我们要打开一个文件，需要有一个文件的对象f = open("test.txt","r")# <f>.read()      | 读入全部内容#r1=f.read()#print(r1)# <f>.readline(size)  | 读入一行内容，如果给出参数，读入该行前size长度  r2 = f.readline()   print(r2)  #伟大的中国r3 = f.readline(2)   print(r3)  #伟大   # <f>.readlines(hint=-1) | 读入文件所有行，以每行为元素形成列表 如果给出参数，读入前hint行 r4 = f.readlines()print(r4) #['伟大的中国\n', '伟大的人民\n']#第四种for i in f.readlines():    print(i)

写文件

常用方法

操作方法	描述
.write(s)	向文件写入一个字符串或字节流
.writelines(lines)	将一个元素全为字符串的列表写入文件
.seek(offset)	改变当前文件操作指针的位置，offset含义如下： 0 – 文件开头； 1 – 当前位置； 2 – 文件结尾

代码

#首先我们要打开一个文件，需要有一个文件的对象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 osos.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)

5.8json模块

定义

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

#{}是一个对象  []数组{    "大数据1班":[{"张三":15,"李四":18,"赵六":20}],    "大数据2班":[{"张三":15,"李四":18,"赵六":20}],    "大数据3班":[{"张三":15,"李四":18,"赵六":20}],    "大数据4班":[{"张三":15,"李四":18,"赵六":20}],    "大数据5班":[{"张三":15,"李四":18,"赵六":20}],    "大数据6班":[{"张三":15,"李四":18,"赵六":20}],    "大数据7班":[{"张三":15,"李四":18,"赵六":20}],    "大数据8班":[{"张三":15,"李四":18,"赵六":20}],    "大数据9班":[{"张三":15,"李四":18,"赵六":20}],    "大数据10班":[{"张三":15,"李四":18,"赵六":20}],}

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

Python	JSON
dict	object
list,tuple	array
str	string
int,float,Enums	number
True	true
False	false
None	null

JSON类型转换Python类型对照表

JSON	Python
object	dict
array	list
string	str
number (int)	int
number (real)	float
true	True
false	False
null	None

常用方法

方法	功能
json.dump(obj,fp)	将python数据类型转换并保存到json格式的文件内
json.dumps(obj)	将python数据类型转换为json格式的字符串
json.load(fp)	从json格式的文件中读取数据并转换为python的类型
json.loads(s)	将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和4separators:是分隔符的意思，参数意思分别为不同dict项之间的分隔符和dict项内key和value之间的分隔符，skipkeys：默认值是False，如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时，就会报TypeError的错误。此时设置成True，则会跳过这类keyensure_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 或者2separators 是（ ‘元素之间用逗号隔开’ ， ‘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 或者2separators 是（ ‘元素之间用逗号隔开’ ， ‘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

dump()与load()

"""dump(python,文件对象) 把python转换成json格式并保存到文件中load(文件对象) 把json格式的文件读取转换成python"""import jsondata = {    "大数据1班":[{"张三":15,"李四":18,"赵六":20}],    "大数据2班":[{"张三":15,"李四":18,"赵六":20}],    "大数据3班":[{"张三":15,"李四":18,"赵六":20}],    "大数据4班":[{"张三":15,"李四":18,"赵六":20}],    "大数据5班":[{"张三":15,"李四":18,"赵六":20}],    "大数据6班":[{"张三":15,"李四":18,"赵六":20}],    "大数据7班":[{"张三":15,"李四":18,"赵六":20}],    "大数据8班":[{"张三":15,"李四":18,"赵六":20}],    "大数据9班":[{"张三":15,"李四":18,"赵六":20}],    "大数据10班":[{"张三":15,"李四":18,"赵六":20}],}with open("f.txt","w") as f:    a = json.dump(data,f)    #print(a) #没有返回值，但是数据已经写进去了rwith open("f.txt","r") as f:    a = json.load(f)    print(a)

5.9Python与数据库

数据库

windows安装数据库

https://blog.csdn.net/weixin_45955039/article/details/120687285?spm=1001.2014.3001.5501

创建

updata------------>dml (数据操作语言)
insert------------>dml (数据操作语言)
delete------------>dml (数据操作语言)
select------------>dql (数据查询语言)

创建数据库

CREATE DATABASE 数据库名;

创建数据表

语法

CREATE TABLE IF NOT EXISTS table_name (column_name column_type);

数据类型

类型	大小	用途
INT或INTEGER	4 Bytes	整数
CHAR	0-255 bytes	定长字符串
VARCHAR	0-65535 bytes	变长字符串
DATE	YYYY-MM-DD	日期值
TIME	HH:MM:SS	时间值或持续时间
YEAR	YYYY	年份值

约束

主键自增（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 intalter table 表名字 change 旧列名字 新列名字 新数据类型；#修改列名字  studentname-->namealter table 表名 drop 列名;#删除某一列alter table 表名 add 新列名 （新列名）数据类型;#添加一个列alter table 表名 modify 列名1 数据类型 after 列名字2;#把列1插入到列2后面

查

select 要查询的列名1，列名2 from 表名1,表2 where 表达式1 and/not/or 表达式2order 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

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

2.连接mysql

连接方法

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

首先打开服务----->启动mysql

代码

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

3.cursor游标对象

定义

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

开启游标

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

常用方法

方法	功能
execute(query, args)	执行单条sql语句，接收的参数为sql语句本身和使用的参数列表，返回值为受影响的行数；
executemany(query, args)	执行单条sql语句，但是重复执行参数列表里的参数，返回值为受影响的行数

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

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

cursor用来查询数据的方法

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

方法	功能
fetchone()	返回一条结果行
fetchmany(size)	接收size条返回结果行。如果size的值大于返回的结果行的数量，则会返回cursor.arraysize条数据
fetchall()	接收全部的返回结果行

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()

游标类型（了解）

类型	意义
Cursor	默认，元组类型
DictCursor	字典类型
DictCursorMixin	支持自定义的游标类型，需先自定义才可使用
SSCursor	无缓冲元组类型
SSDictCursor	无缓冲字典类型

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

4.操作数据库

创建表

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()提交事务。

5.10 数学：math模块

定义

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

基本函数

函数	用法	例子
ceil(x)	向上取整操作，返回类型：int	ceil(3.2) 输出：4
floor(x)	向下取整操作，返回类型：int	floor(3.2) 输出：3
pow(x,y)	计算一个数x的y次方;返回类型：float，该操作相当于**运算但是结果为浮点	pow(2,3) 输出：8.0
sqrt(x)	开平方，返回类型：float	sqrt(4) 输出：2.0
fabs(x)	对一个数值获取其绝对值操作	fabs(-1) 输出：1
copysign(x,y)	返回一个符号为y值为x的数值，返回类型：float	copysign(2, -4)输出：-2.0; copysign(2, 4)输出：2.0
factorial(x)	返回一个整形数值的阶乘	factorial(3)输出：6
fmod(x,y)	取模运算，返回类型：float	fmod(4,2)输出：0.0 fmod(4,5)输出：4.0 fmod(4,3)输出：1.0
fsum([])	返回迭代器中值的精确浮点和，返回类型：float	fsum([1.1,2.23]) 输出：3.33 fsum([2.4,4.3]) 输出：6.699999999999999
gcd(a, b)	返回a、b的最大公约数，返回类型：int	gcd(2,4) 输出：2
isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)	判断两个数是否接近，返回类型：True/False	isclose(0.99,1,rel_tol=0.2) 输出：True isclose(0.9999999999,0.999999999991) 输出：True math.isclose(0.99,0) 输出：False
modf(x)	返回x的小数部分和整数部分。两个结果都带有x的符号，并且都是浮点数	modf(2.4) 输出：(0.3999999999999999, 2.0)
trunc	取整，返回类型：int	trunc(44.3333)输出：44

import matha = 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)

定义常数

常数名称	使用说明
pi	π = 3.141592 …****，可用精度
e	e = 2.718281 …，达到可用的精度
tau	τ = 6.283185 …，可达到精度
inf	无穷大
nan	非数字

对数和三角函数

函数	用法	例子
log(n)	e****为底数	log(5) 输出结果： 1.6094379124341003
log(n, basic)	其他数为底数	log(2, 5)输出结果： 0.43067655807339306
log2(n)	2为底数	log2(5)输出结果： 2.321928094887362
log10(n)	10为底数	log10(2) 输出结果 0.3010299956639812
sin(x)	正弦函数	sin(5) 输出结果： -0.9589242746631385
cos(x)	余弦函数	cos(5) 输出结果： 0.28366218546322625
tan(x)	正切函数	tan(5) 输出结果： -3.380515006246586

在数学里面，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)

5.11random模块（随机数）

常用方法

方法	使用说明
random.random()	随机生成一个0-1之间的浮点数
random.randint(start,stop)	随机生成一个start,stop之间的整数
random.randrange(start,stop,step)	随机生成一个start,stop之间的整数
random.choice(sequence)	从一个序列中随机选择一个元素
random.shuffle(sequence)	随机打乱列表的顺序,原列表发生变化
random.sample(population,k)	从集合中随机抽取K个不重复的元素形成新的序列，返回的是一个新的序列，不会破坏原有序列。

针对浮点数

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)

针对序列类型

import random as ra
"""
random.choice(sequence)  从一个序列中随机选择一个元素
1.只能从字符串、元组、列表中随机获取
"""
#
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#random.shuffle(sequence)  随机打乱列表的顺序,原列表发生变化
#自能是列表类型
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
#random.sample(population,k) 从序列中随机抽取k个元素，返回一个新元素
#字典不可以
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之间的整数，若其中有两个值相等，则提示中奖，否则提示谢谢参与

#随机生成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.红包随机。

比如30元随机4个红包，

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)

面向对象

类和对象是面向对象的两大核心

类

定义

类是对一群具有相同特征和行为的事物的统称，是抽象的

特征被称为属性，行为被称为方法

语法

类型要符合大驼峰命名
class 类名(object):def 方法名(self,参数)：代码块def 方法名(self,参数)：代码块

对象

定义

对象是由类创建的具体存在，在程序中现有类才有对象

比如制作飞机，要先有图纸再有飞机这个实体

语法

创建对象的语法
对象名 = 类名()

代码

class animals:color = "yellow"def sellp(self):print("睡觉")def eat(self,food):print("吃"+food)dog = animals()
print(dog.color)
dog.eat("骨头")

补充

1.类需不需要参数，比如类名（object）

可以写也可以不写，python3.x中的所有类都继承了object，即使你不写也会默认继承object

2.方法为什么要用self

self是类的实例，并不是一个类

self和java中的this一样，你可以使用this，但是在python中约定俗成的就是self

class animals(object):color = "yellow"def duixiang(self):print(self)def sellp(self):print("睡觉")def eat(self,food):print("吃"+food)class dog(animals):def duixiang(self):print(self)
"""
self是类的对象，是本类的对象，即使是继承关系，他也是子类的对象，并不是父类的对象
"""
d = dog()
d.duixiang()
an = animals()
an.duixiang()

自定义类

#pass是空语句，不做任何事情，只是为了保持结构的完整性
#初始化就相当于我们的构造函数，给参数一个默认值，或者是定义某些参数
class animals():def __init__(self,name,color="白色",age=5):self.name = nameself.color = colorself.age = agedef eat(self,food):print("爱吃"+food)def jiao(self,jiaosheng):print(jiaosheng)print(self)
dog = animals("小白")
dog.eat("骨头")   

练习

"""
定义一个人类，
初始化以下属性  名字，性别默认男，年龄默认18
方法：睡觉，吃饭，任务(比如学生要学习，教师要教学)
打印方法，打印人的名字，性别和年龄打印学生对象的信息，比如学生对象的名字是小明，学生的任务是学习
"""
class person():def __init__(self,name,sex="男",age=18):self.name = nameself.sex = sexself.age = agedef sleep(self):print("睡觉")def eat(self):print("一天三顿饭")def qita(self,zhiye):print(zhiye)#相当于我们tostring方法，把所有的信息展示出来def show(self):s = '姓名：%s,性别：%s,年龄：%d' %(self.name,self.sex,self.age)return sstudent =person("小明")
print(student.show())
student.qita("学习")

继承

继承：继承就是子类继承父类的特征和行为，python支持多继承，多继承在以后不常用，最多会出现三个继承，因为他很复杂，我们那单继承举例

语法

class 类1(object):pass
class 类2(object)：pass
class 类3(类1，类2)：pass

代码

"""
定义一个人类
学生类继承人类，同时定义一个花钱的方法
"""
class person():def __init__(self,name,sex="男",age=18):self.name = nameself.sex = sexself.age = agedef sleep(self):print("睡觉")def eat(self):print("一天三顿饭")def qita(self):print("不同的人有不同的任务")def show(self):s = '姓名：%s,性别：%s,年龄：%d'%(self.name,self.sex,self.age)return sclass student(person):def huaqian(self):print("花钱神兽")#同样我们可以调用人类中的方法和属性
#继承person类以后，初始化方法也继承过来了，所以一定不要忘了给参数
s = student("小明")
print(s.show())

class aminal():def eat(self):print("都需要吃饭")
class person():def gongzuo(self):print("赚钱养女朋友")class teacher(aminal,person):def hauqian(self):print("花钱消费任性")t = teacher()
t.eat()
t.gongzuo()
t.hauqian()

重点（一定要会）

1.继承完以后我们可以不可以重写方法

2.能不能保留父类的一些方法里面的代码

3.字类可以初始化，可以理解为，字类可以有构造方法吗

4.那么初始化的时候，能不能保留父类的初始化呢

1.继承完以后我们可以不可以重写方法
#学生不应该是个对象，是个类的话更加好操作，那把学生定义成类，他要继承人类
class student(person):def huaqian(self):print("花钱神兽")def qita(self):print("学生的任务是：好好学习天天向上")#继承person类以后，初始化方法也继承过来了
s = student("小明")
print(s.show())
#我们调用其他会发现，调用的是子类的其他，并不是父类的其他
"""
所以我们python也支持重写
1.不同的两个类    2.继承关系      3.方法名，参数相同
"""
s.qita()2.能不能保留父类的一些方法里面的代码
class student(person):def huaqian(self):print("花钱神兽")def qita(self):#调用父类的方法super().qita()print("学生的任务是：好好学习天天向上")#继承person类以后，初始化方法也继承过来了
s = student("小明")
"""
可不可以保留这样的一句话，
不同的人有不同的任务，学生的任务是：好好学习天天向上
意思是在父类的基础上重新添加代码
"""
s.qita()3.字类可以初始化，可以理解为，字类可以有构造方法吗
class student(person):def __init__(self, name,hobbit,sex="男", age=18,):self.hobbit = hobbit4.那么初始化的时候，能不能保留父类的初始化呢
class student(person):def __init__(self, name, hobbit,sex="男", age=18):#引用父类的初始化super().__init__(name, sex=sex, age=age)self.hobbit = hobbit
s = student("小明","打游戏")
print(s.name)
print(s.age)

公有 私有

静态属性：直接写在类里面的是静态属性

动态属性：写在初始化里面的是动态属性，因为它可以改变

静态方法：staticmethod

普通方法：

公有：公共的

私有：不允许外部访问的，私有的

组合起来有：公有静态属性、公有动态属性、公有静态方法、公有普通方法

​ 私有静态属性、私有动态属性、私有静态方法、私有普通方法

公有静态属性

class person():food = "馒头，公有静态属性" #比如所有的人喜欢吃馒头def eat(self): #类内部访问print("所有的人喜欢吃"+self.food) class student(person):def studentEat(self):#派生类访问print("学生喜欢吃"+self.food)#类访问。就是类自己可以访问
print(person.food)#类内部访问
p = person()
p.eat()#派生类访问
s =  student()
s.studentEat()

私有静态属性

class person():__gongju = "手机，私有静态属性"def wan(self):#类内部访问print(self.__gongju)class student(person):def chagang(self):#派生类访问print(self.__gongju,"这是能随便查的吗")#类访问----->报错
#print(person.__gongju )  #类内部访问
p = person()
p.wan()#派生类访问--->报错
s= student()
s.chagang()

公有动态属性

"""
通过对象访问
类内部可以访问:类的内部的某个方法
派生类可以访问: 类1继承类2，类1是派生类
"""
class person():def __init__(self,name,sex,age):#以下这些属于公有字段/成员变量self.name = nameself.sex = sexself.age =agedef perShow(self):#类内部访问print(self.name)print(self.sex)print(self.age)class student(person):def show(self):#派生类的使用print(self.name)print(self.sex)print(self.age)#通过对象访问
p = person("张三","男",18)
print(p.name)#类内部可以访问
p.perShow()#派生类可以访问
s = student("小明","男",70)
s.show()

私有动态字段

class person():def __init__(self,name,phone,idCar):self.name = name #公有字段self.__phone = phone #私有字段self.__idCar = idCar #私有字段def perShow(self):#类内部访问print(self.name)print(self.__phone)print(self.__idCar)class student(person):def show(self):#派生类的使用print(self.name)print(self.__phone)print(self.__idCar)#通过对象访问-----失败报错
p = person("张三","11111111111","223456789098865432")
#print(p.name)
#print(p.__idCar)
#print(p.__phone)#类内部可以访问----成功
p.perShow()#派生类可以访问----失败报错
s = student("xiaoming","11111111111","223456789098865432")
s.show()"""
总结：私有的普通字段只能在类的内部访问
"""

公有普通方法

class person():def drink(self):print("所有人都得喝水,公有的普通方法")def he(self):#类内部self.drink()class student(person):pass#类对象访问
p = person()
p.drink()#类内部
p.he()#派生类访问
s = student()
s.drink()

私有普通方法

class person():def __wc(self):print("厕所，私有普通方法")def Wcc(self):#类内部访问self.__wc()
class student(person):pass#对象访问----->报错
p = person()
#p.__wc()#类内部访问---->成功
p.Wcc()#派生类访问---->报错
s = student()
s.__wc()

公有静态方法

"""
静态方法的关键字:staticmethod  [ˈmeθəd]方法
语法：@staticmethod
"""
class person():@staticmethoddef jiaoliu():print("所有的人都有朋友,公有的静态方法")def aihao(self):#类内部访问self.jiaoliu()class student(person):pass#对象访问
p = person()
p.jiaoliu()#类内部访问
p.aihao()#派生类访问
s = student()
s.jiaoliu()
#类直接访问
person.jiaoliu()

私有静态方法

class person():@staticmethoddef __jiaoliu():print("所有的人都有朋友,公有的静态方法")def aihao(self):#类内部访问self.__jiaoliu()class student(person):pass#对象访问 ---->报错
p = person()
#p.jiaoliu()#类内部访问
p.aihao()#派生类访问---->报错
s = student()
#s.jiaoliu()
#类直接访问
#person.jiaoliu()

总结

"""
公有静态属性：1.类访问 2.类内部访问 3.派生类访问
私有静态属性：只能类内部访问
------------------------------------------------
公有动态属性：1.类对象 2.类内部访问 3.派生类访问
私有动态属性：只能类内部访问
------------------------------------------------
公有普通方法：1.类对象 2.类内部访问 3.派生类访问
私有普通方法：只能类内部访问
----------------------------------------------
公有静态方法：1.类对象 2.类内部访问 3.派生类访问 4.类直接访问
私有静态方法：只能类内部访问
"""

封装

class person():#初始化def __init__(self,name,sex,age,phone,idCar):self.__name = nameself.__sex = sexself.__age = ageself.__phone = phoneself.__idCar = idCardef eat(self):print("吃饭")def sleep(self):print("睡觉")def __wc(self):print("wc")def show(self):print(self.__name )print(self.__sex) print(self.__age)print(self.__phone)print(self.__idCar)

多态

一个对象多种形态

举例，比如动物类，所有的动物都要吃饭，但是狗类吃的骨头，猫类吃的鱼

那怎么让一个动物类的吃有多种形式呢，在狗和猫这两个子类中重写eat方法

class animal():def __init__(self,name):self.name = name def eat(self):print("吃饭")class dog(animal):def eat(self):print("吃骨头")class cat(animal):def eat(self):print("吃鱼")d = dog("哈士奇")
print(d.name)
d.eat()c = cat("白猫")
print(c.name)
c.eat()

练习

"""
定义一个名为Vehicles（交通工具）的基类，私有属性brand（商标）和color（颜色），成员方法run（行驶）和showInfo（显示信息，在控制台显示商标和颜色），并编写构造方法初始化其成员属性。
编写Car（小汽车）类继承于Vehicles类，增加int型成员属性seats（座位），增加成员方法showCar（在控制台显示小汽车的信息），并编写构造方法。
编写Truck（卡车）类继承于Vehicles类，增加float型成员属性load（载重），增加成员方法showTruck（在控制台显示卡车的信息），并编写构造方法。
"""
class Vehicles():def __init__(self,brand,color):self.__brand = brand         self.__color = colordef run(self):print("我已经开动了")def showInfo(self):print(self.__brand,self.__color)class Car(Vehicles):def __init__(self,brand,color,seats):super().__init__(brand,color)self.__seats = seatsdef showCar(self):self.showInfo()print(self.__seats)
class Truck(Vehicles):def __init__(self,brand,color,load):super().__init__(brand,color)self.__load = loaddef showTruck(self):self.showInfo()print(self.__load)c = Car("7Q","绿色",5)
c.run()
c.showCar()
t = Truck("五菱宏光","蓝色",6.66)
t.run()
t.showTruck()

python第五章模块总结相关推荐

1. 【python第五章——函数】

   python第五章--函数 第五章--函数 5.1函数概述 5.2 函数进阶 下面部分之后再写 5.3函数习题(一些小例子) 第五章--函数 5.1函数概述 快速入门: #定义函数 def func( ...

2. python 第五章 字典

   python 第五章 # # !/usr/bin/python # # -*- coding: utf-8 -*- # # @File : 总结.py # # @time : 2019-07-1010 ...

3. python第五章课后题答案_python程序设计基础（嵩天）第五章课后习题部分答案

   原博文 2019-10-13 13:50 − 第五章p1515.2:实现isodd()函数,参数为整数,如果参数为奇数,返回true,否则返回false.def isodd(s): x=eval(s) ...

4. python第五章总结

   第5章组合数据类型 5.1认识组合数据类型 (1)常用的序列类型有字符串.列表和元组. (2)序列支持双向索引:正向递增索引和反向递减索引正向递增索引从左向右依次递增,第一个元素的索引为0,第二个元素 ...

5. Python牛刀小试(五)--logging模块

   由于想给自己的Python程序添加日志功能,学习下Python的日志模块. 一个简单的例子: 点击(此处)折叠或打开 import logging ##第一个简单的例子 logging.warning ...

6. python第五章课后作业_python 入门到实践第五章课后练习

   原博文 2020-06-19 11:05 − users = ['admin','alex','eric','crystol','joji']#创建一个列表for i in users:#遍历整个列表 ...

7. Python第五章序列，集合，字典

   一.切片 介绍 1.函数float函数和eval函数的区别: 2. 利用下标"[]"可以从字符串(列表,元组)中截取一个子串 二.浅拷贝和深拷贝 1.浅拷贝 2.深拷贝 3.哈希 ...

8. python第五章课后编程题答案_Python核心编程-第五章课后习题

   5-1 整形 讲讲 Python 普通整型和长整型的区别 答:在2.7版本基本淡化了区别.真要区分的话,普通整型是32位或者64位,而长整型只与PC内存有关,很大就是了 5-2 运算符 (a) 写一个 ...

9. 给普通人的Python——第五章（上）

   文章目录 5. 代码重复使用的艺术:函数 5.1 一个例子引入 5.2 定义函数 5.3 使用函数重构代码 请关注公众号:编程之路从0到1 5. 代码重复使用的艺术:函数 编程中的函数和我们数学中的函 ...

10. Python 第五章 因子分析

    #相关系数矩阵 import pandas as pd Data=pd.read_excel('农村居民人均可支配收入来源2016.xlsx') X=Data.iloc[:,1:] R=X.corr( ...

最新文章

1. STM32堆栈大小及位置
2. freemarker程序开发
3. 机器学习知识点(九)BP神经网络Java实现
4. js 设备条形码字体_蚌埠食品袋激光打码机设备-青岛博泰格睿特
5. 每个大数据工程师都应该知道的OLAP 核心知识点
6. 刚刚，三位科学家获得2019年诺贝尔物理学奖！
7. 数据分析 数据科学_数据科学中的数据分析
8. 一个既能做CV任务，也能做NLP任务的Transformer模型！谷歌UCLA提出统一的基础模型...
9. 落户北京经开区 小米汽车首车预计2024年下线并量产 网友：开始存钱！
10. Spark Streaming ReceiverTracker架构设计
11. viper4android还用酷狗,听HiFi专业的App，VIPER独占USB源码输出发烧友用过都上瘾
12. Ember学习（1）：Ember核心概念
13. 推荐测温软件SpeedFan 4.32
14. 利用java中的Calendar类完成当前月份日历Calendar类小练习
15. elementUI的Upload的手动上传及限制数量后隐藏上传样式
16. VScode常用的快捷键
17. 敏捷个人2012.2月份线下活动报道：活出我的最好生活
18. python实现删除空行
19. 鲁大师5月新机性能/流畅榜：中兴Axon 40 Ultra性能夺冠，特供版新机扎堆了！
20. 人群密度检测-CSRnet

热门文章

1. mysql数据库有dbo吗_拒绝了对对象 '表名' (数据库 '数据库名'，架构 'dbo')的 SELECT 权限...
2. 如何快速撰写/总结国内外研究现状？
3. Oracle中除数为0的解决办法
4. Sloth演示程序及源代码发布
5. python读取excel合并单元_python读取excel合并方法
6. 如何快速注册一个谷歌gmail邮箱(2021）
7. visio至word图片失真
8. 抖音小程序是什么_如何开发抖音小程序
9. STM32内部ADC基准电压计算方法
10. 挖金矿 Java实现