python常用模块与MySQL数据库交互（学习笔记）

最新推荐文章于 2024-07-27 12:20:46 发布
最新推荐文章于 2024-07-27 12:20:46 发布
阅读量452 收藏 2
点赞数
文章标签： python 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxwzy1314/article/details/121677420
版权

sys模块

定义

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

常用方法

import sys

#使用help(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 5

sys.argv

import sys
print(sys.argv)#['d:/pythonfile/testCode.py']

exit(n)

退出 Python 程序，exit(0) 表示正常退出

for i  in range(10):
    if i==5:
        exit(0)
    print(i)
'''
0
1
2
3
4
'''

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) #所有内建模块的名字

sys.modules

以字典的形式返回所有当前 Python 环境中已经导入的模块

sys.modules.keys()

返回所有已将导入模块的key

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。

练习

"""
 定义一个函数，属于一个名字，查看是否是内建模块
"""
import sys
def func(hh):
    if hh in sys.builtin_module_names:
      #查找内建模块是否存在
        print("是内建")
    else:
        print("不是内建")
func("path")

os模块

定义

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

常用方法

方法或变量用途
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’)获取文件/目录信息

代码

os.getcwd()

获取当前目录

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

os.chdir

切换进入到哪个目录下

print(os.chdir(r"C:\"))

os.getcwd()

获取当前工作目录，即当前python脚本工作的目录路径

print(os.getcwd())

os.rename(old,new)

将old文件重命名为new

os.rename('本文件.py','test.py')

os.remove

删除文件

os.remove('test.py')

os.mkdi()

创建单级空文件夹，目录

os.mkdir('dis')

os.rmdir()

删除单级空目录

os.rmdir('dis')

os.makedirs

创建多层递归目录

os.makedirs('dis\\b')

os.removedirs

只能删除空的文件夹

os.removedirs('dis\\b')

os.listdir

列出指定目录下的所有文件及文件夹，包括隐藏文件，并返回一个list

print(os.listdir('指定目录'))

os.system(command)

#可以直接操作系统命令

os.system('ipconfig')

res=os.popen('ipconfig').read()
#执行操作系统命令print(res)

os.path.dirname

#返回path的目录,取父目录

import os
print(os.path.dirname('D:\\axc\\Python\\PythonTemp\\count.py'))
#D:\axc\Python\PythonTemp

os.path.split

将path分割成目录和文件名，并返回一个元组

print(os.path.split('D:\\axc\\Python\\PythonTemp\\count.py'))
#('D:\\axc\\Python\\PythonTemp', 'count.py')

os.path.join

将多个路径拼起来

print(os.path.join('program','python','code','student.py'))
#program\python\code\student.py

os.path.exists

判断path(文件或文件夹)是否存在

print(os.path.exists('D:\\axc\\Python\\PythonTemp\\count.py'))
#False

os.path.isfile

判断path是否是文件

print(os.path.isfile('文件路径'))

os.path.isdir

#判断path是否是目录，False

print(os.path.isdir('D:\\axc\\Python\\PythonTemp\\count.py'))

文件模式匹配：glob模块

import globimport 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只是返回文件名。"""

正则表达式

定义

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

元字符

有特殊含义的字符

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

2.电子邮箱验证

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

3.电话号码的验证

num = input("请输入电话号码")
n  = re.findall("^1\[3-9]\d{9}",num) #电话号码11位
print(n)

re模块

定义

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)

根据包含正则表达式的字符串创建模式对象

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

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相关方法

#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

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)

补充 r

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

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

日期时间相关：datetime模块

定义

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

类名描述
datetime.date日期类
datetime.time时间类
datetime.datetime日期与时间类
datetime.timedelta表示两个date、time、datetime实例之间的时间差
datetime.tzinfo时区相关信息对象的抽象基类。
datetime.timezonePython3.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) #2021
print(date01.month) #12
print(date01.day) #22

常用的方法和属性

类方法**/**属性名称描述
date.maxdate对象所能表示的最大日期：9999-12-31
date.mindate对象所能表示的最小日期：00001-01-01
date.resoluationdate对象表示的日期的最小单位：天
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-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 
timea = time(11,59,59)
print(a) #11:59:59

常用方法

类方法**/**属性名称描述
time.maxtime类所能表示的最大时间：time(23, 59, 59, 999999)
time.mintime类所能表示的最小时间：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 time

print(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 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.mintimedelta(-999999999)
timedelta.maxtimedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)
timedelta.resolutiontimedelta(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.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)
"""
[('大数据一班', {'张三': 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())

pickle模块

定义

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 p

list01 = ["小明","翠花","王五","张三"]
#因为只能是二进制的，所以文件要声明成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) #['小明', '翠花', '王五', '张三']

文件的操作

创建/打开文件

语法

"""
 变量名 = 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")

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语言，易于人类的阅读和编写，同时也易于机器解析和生成，是目前应用最广泛的数据交换格式。

#{}是一个对象  []数组
{    "大数据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类型对照表

PythonJSON
dictobject
list,tuplearray
strstring
int,float,Enumsnumber
Truetrue
Falsefalse
Nonenull

JSON类型转换Python类型对照表

JSONPython
objectdict
arraylist
stringstr
number (int)int
number (real)float
trueTrue
falseFalse
nullNone

常用方法

方法功能
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

参数
“”"

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 json

print(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 或者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)

Python与数据库

数据库

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或INTEGER4 Bytes整数
CHAR0-255 bytes定长字符串
VARCHAR0-65535 bytes变长字符串
DATEYYYY-MM-DD日期值
TIMEHH:MM:SS时间值或持续时间
YEARYYYY年份值

约束

主键自增（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

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

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主机的端口，默认是3306
db：连接的数据库名
charset：当读取数据出现中文会乱码的时候，需要我们设置一下编码；python3默认采用的utf8字符集
'''

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

代码
import pymysql

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

3.cursor游标对象

定义

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

开启游标
# 开启mysql的游标功能，创建一个游标对象；
cur = db.cursor()
常用方法
方法功能
execute(query, args)执行单条sql语句，接收的参数为sql语句本身和使用的参数列表，返回值为受影响的行数；
executemany(query, args)执行单条sql语句，但是重复执行参数列表里的参数，返回值为受影响的行数

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

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

cursor用来查询数据的方法

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

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

db=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 pymysql

db=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 pymysql

db=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 pymysql

db=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 pymysql

db=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 pymysql

db=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 pymysql

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

练习

1.创建school数据库，使用数据库（直接使用mysql进行执行）

以下使用python连接mysql进行执行

2.创建学生表（学号主键，姓名，性别，班级，出生年月）

创建教师表（教师编号主键，姓名，性别，出生年月，职称）

创建课程表（课程编号主键，课程名称，教师编号外键）

创建成绩表（学号外键，课程编号外键，成绩）

3.以上四个表格插入数据

4.满足以下需求

4.1查询Student表中的所有记录的Sname、Ssex和Class列。

4.3以班级降序查询学生表的所有记录。

4.4查询Score表中成绩在60到80之间的所有记录

4.5查询每门课的平均成绩

4.6查询课程编号为1的,并且成绩高60 有同学的记录。

4.7查询"男"教师及其所上的课程。

#***************MySQL******************
import pymysql
db = pymysql.connect(
    host="localhost",
    user="root",
    password="wt222",
    port=3306,
    db="school",
    charset="utf8"
)
cur = db.cursor()
'''
sql = """
create table if not exists student(
    s_id int(20) primary key auto_increment,
    s_name varchar(4),
    s_sex varchar(2),
    s_class int,
    birthday datetime
);
"""
#执行sql语句
cur.execute(sql)
#提交数据
db.commit()
'''
'''
#创建游标对象---->负责执行sql语句
sql = """
insert into 
student(s_name,s_sex,s_class,birthday)
values(%s,%s,%s,%s);
"""
list01 = [
    ('赵磊','男','一班',19990224),
    ('钱红','女','二班',20010811),
    ('王强','男','二班',20000920),
    ('李慧','女','四班',20020309),
    ('陈翔','男','三班',19930425),
    ('周久','男','五班',19981102),
    ('张欣','女','九班',20050306)
]
cur.executemany(sql,list01)
db.commit()
'''
#================================================================

'''
sql = """
create table if not exists teacher(
    t_id int(20) primary key auto_increment,
    t_name varchar(4),
    t_sex varchar(2),
    birthday date,
    jobname varchar(10)
);
"""
cur.execute(sql)
db.commit()
'''
'''
sql = """
insert into teacher
(t_name,t_sex,birthday,jobname)
values(%s,%s,%s,%s);
"""
list02 = [
    ('李飞','男','1991-02-24','主任'),
('程伟丽','女','1977-08-11','秘书'),
('赵阳','男','1983-09-20','校长'),
('李慧珍','女','1995-03-09','处长'),
('陈浩','男','1993-04-25','老师'),
('周天宝','男','1999-11-02','组长'),
('张德明','男','2000-03-06','监察长')
]
cur.executemany(sql,list02)
db.commit()
'''
#===============================================
'''
sql = """
create table if not exists course(
    c_id int(20) primary key auto_increment,
    c_name varchar(20),
    t_id int(20),
foreign key(t_id) references teacher(t_id)
);
"""
cur.execute(sql)
db.commit()
'''
'''
sql = """
insert into course
(c_id,c_name,t_id)
values(%s,%s,%s);
"""
list03 = [
    ('01','大学物理','1'),
('02','高分子材料化学','2'),
('03','计算机科学与技术','3'),
('04','通信工程','4'),
('05','生物科学技术','5'),
('06','大数据技术','6')
]
cur.executemany(sql,list03)
db.commit()
'''
#==========================================
'''
sql = """
create table if not exists sourse(
    s_id int(20),
    c_id int(20),
    s_score int(3),
foreign key(s_id) references student(s_id),
foreign key(c_id) references course(c_id)
);
"""
cur.execute(sql)
db.commit()
'''
'''
sql = """
insert into sourse
(s_id,c_id,s_score)
values(%s,%s,%s);
"""
list04 = [
    ('1','01','88'),
('2','02','90'),
('3','03','55'),
('4','04','60'),
('5','05','79'),
('6','06','97')
]
cur.executemany(sql,list04)
db.commit()
'''
#==========================================
"""
sql = "select s_name,s_sex,s_class from student;"
a =cur.execute(sql)
a = cur.fetchall()
print(a)
'''
(('赵磊', '男', '一班'), 
('钱红', '女', '二班'),
 ('王强', '男', '二班'), 
 ('李慧', '女', '四班'), 
 ('陈翔', '男', '三班'), 
 ('周久', '男', '五班'),
  ('张欣', '女', '九班'))
'''
"""

"""
sql = "select * from student order by s_class desc;"
b =cur.execute(sql)
b = cur.fetchall()
print(b)
"""

sql = "select avg(s_score) from sourse;"
c =cur.execute(sql)
c = cur.fetchall()
print(c)

数学：math模块

定义

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

基本函数

函数用法例子
ceil(x)向上取整操作，返回类型：intceil(3.2) 输出：4
floor(x)向下取整操作，返回类型：intfloor(3.2) 输出：3
pow(x,y)计算一个数x的y次方;返回类型：float，该操作相当于**运算但是结果为浮点pow(2,3) 输出：8.0
sqrt(x)开平方，返回类型：floatsqrt(4) 输出：2.0
fabs(x)对一个数值获取其绝对值操作fabs(-1) 输出：1
copysign(x,y)返回一个符号为y值为x的数值，返回类型：floatcopysign(2, -4)输出：-2.0; copysign(2, 4)输出：2.0
factorial(x)返回一个整形数值的阶乘factorial(3)输出：6
fmod(x,y)取模运算，返回类型：floatfmod(4,2)输出：0.0 fmod(4,5)输出：4.0 fmod(4,3)输出：1.0
fsum([])返回迭代器中值的精确浮点和，返回类型：floatfsum([1.1,2.23]) 输出：3.33 fsum([2.4,4.3]) 输出：6.699999999999999
gcd(a, b)返回a、b的最大公约数，返回类型：intgcd(2,4) 输出：2
isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)判断两个数是否接近，返回类型：True/Falseisclose(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取整，返回类型：inttrunc(44.3333)输出：44
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)

定义常数

常数名称使用说明
piπ = 3.141592 …****，可用精度
ee = 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 math

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

random模块（随机数）

常用方法

方法使用说明
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个红包，

rom random import random


def hbsj(num,money):
    list01 = []
    num01 = num #num01 = 4
    for i in range(num):
        num01 -= 1 #3 2 1 0
        if num01 >0: #3 2 1
            m = random.randint(1,money)
        else:
            m = money #最总剩下的钱数都给最后一个人
        money -= m #m是领走的钱，我们的总钱数money要减去领走的钱m
        list01.append(m/100)

面向对象

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

类

定义

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

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

语法

类型要符合大驼峰命名
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 = name
        self.color = color
        self.age = age
    def eat(self,food):
        print("爱吃"+food)
    def jiao(self,jiaosheng):
        print(jiaosheng)
        print(self)
dog = animals("小白")
dog.eat("骨头")

练习

class person():
    def __init__(self,name,sex="男",age=18):
        self.name = name
        self.sex = sex
        self.age = age
    def 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 s

student =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 = name        self.sex = sex        self.age = age    def 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.继承完以后我们可以不可以重写方法

代码

#学生不应该是个对象，是个类的话更加好操作，那把学生定义成类，他要继承人类
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 = hobbit

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

代码

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 = name
        self.sex = sex
        self.age =age
    def 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():
    @staticmethod
    def 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():
    @staticmethod
    def __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 = name
        self.__sex = sex
        self.__age = age
        self.__phone = phone
        self.__idCar = idCar
    def 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 = color

    def 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 = seats
    def showCar(self):
        self.showInfo()
        print(self.__seats)
class Truck(Vehicles):
    def __init__(self,brand,color,load):
        super().__init__(brand,color)
        self.__load = load
    def showTruck(self):
        self.showInfo()
        print(self.__load)

c = Car("7Q","绿色",5)
c.run()
c.showCar()
t = Truck("五菱宏光","蓝色",6.66)
t.run()
t.showTruck()
发量**
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python必学模块之pymysql (操作数据库)
金鞍少年的博客
04-27 3210
Python必学模块之pymysql (操作数据库)
利用python连接数据库(pymysql模块使用)
ammmao的博客
06-25 405
前言 文章目录前言pymysql1.创建connection对象2.connection对象支持的方法:3.curser对象支持的方法:4.增删改查和事务处理示例: pymysql包 包含了一个基于PEP-249的纯python的MySQLclient,大多数公共API与mysqlclient和MyAQLdb兼容。 要求： Python Cpython：2.7版本或者大于3.5版本 PyPy：...
Python连接MySQL数据库
热门推荐
kejiayuan0806的博客
04-22 2万+
Python语言是一种流行的开源编程语言，不仅表达能力强，提供了高效的数据结构，还能简单有效地面向对象编程。我们使用Python进行web开发、网络爬虫、数据挖掘、人工智能等研究时，不可避免的要连接数据库来存储或读取数据。本文主要介绍Python连接MySQL数据库的方法，以及DB
Python与MySQL数据库的交互
不负时光可怜人
09-15 3023
事务（transaction）是作为单个逻辑单元执行的一系列操作。多个操作作为一个整体向系统提交，要么都执行，要么都不执行。通俗讲：在事务中的增删查改等操作,要么都成功，要么都失败。
【原创内容】当Python需要与数据库交互时，这个模块就变得超级好用
weixin_43373042的博客
04-04 169
今天小编和大家来聊一下SQLALchemy这个模块，该模块是Python当中最有名的ORM框架，该框架是建立在数据库API之上，使用关系对象映射进行数据库的操作，简而言之便是：将对象转换成SQL，然后使用数据API执行SQL并获取执行结果。看到这里，相信不少的读者可能会感觉到云里雾里，我们就通过一个简单的案例在说明一下吧。例如我们想要在mysql当中新建一个表格，我们首先...
最通俗易懂的python与mysql数据库交互
数据分析与统计学之美
01-04 7844
1、安装pymysql库 如果你想要使用python操作MySQL数据库，就必须先要安装pymysql库，这个库的安装很简单，直接使用pip install pymysql;进行安装。 假如上面这种方式还是安装不上，就用如下链接找一个合适的安装包进行安装，这个就不细说了，请自行百度。 https://www.lfd.uci.edu/~gohlke/pythonlibs/ 学习本篇文章，最好是先看...
12 Python 与 MySQL 数据库交互（含案例实战2：把金融数据存入数据库中）
Eric005的博客
09-12 1392
Python与数据库进行连接，并实战配套将爬虫出来的金融数据存入数据库当中去。怎么爬怎么处理可以看我之前写的 7案例实战1，因为网页规则大体不变，但会有小的改变，所以你会发现我本次进行的信息处理和之前不一样，不过大体上是一样的，请学习前面文章，后面我会继续更新数据清洗优化
python1903笔记 04-Mysql数据库.zip
03-09
在这一部分的学习中，我们将深入探讨如何使用 Python 与 MySQL 数据库进行交互。MySQL 是一个流行的开源关系型数据库管理系统，它提供了高效、可靠的数据存储解决方案。而 Python 作为一门强大的编程语言，其丰富的...
python学习笔记附带源码及实战
03-10
【Python学习笔记】 Python是一种高级编程语言，以其简洁明了的语法和强大的功能而闻名。这份学习笔记涵盖了从基础到高级的全方位Python知识，旨在帮助初学者快速掌握编程技能并进行实际项目开发。 【源码】 源码是...
Python-jupyterlabsql用于与SQL数据库交互的JupyterLab扩展
08-11
**Python-jupyterlab-sql：SQL数据库交互的JupyterLab扩展** 在数据分析和机器学习领域，Python已经成为首选的编程语言之一。JupyterLab是数据科学家和开发者常用的交互式开发环境，它提供了丰富的代码编辑、运行、...
Python和MySql交互小例子
09-06
Python和MySql交互登录小例子，同时进行封装性，可以通用
Python学习笔记.docx
12-06
Python学习笔记 在Python编程语言的学习过程中，掌握基础语法、数据结构、控制流程以及面向对象编程是至关重要的。下面我们将详细探讨这些方面，以便更好地理解Python的外卖订餐系统实现。 1. **Python基础** ...
2020最新_Python_(MySQL_SQL_Redis)数据库详解【千锋】源码+课件+笔记.zip
07-29
数据库是存储和管理数据的核心工具，而Python提供了与各种数据库交互的能力，包括MySQL、SQL和Redis等。本教程“2020最新_Python_(MySQL_SQL_Redis)数据库详解【千锋】源码+课件+笔记.zip”涵盖了这些关键知识点，...
Python与MySQL交互
happy_wealthy的博客
12-03 1877
pymysql
Python与Mysql交互
m0_64265616的博客
01-31 458
本文使用pycharm，主要介绍了python与mysql数据库交互的一些操作
mysql 字节数组_关于bytes和bytearray
weixin_29890403的博客
02-18 1476
背景平时工作因为有批量线上数据进行更新，通过Python程序连接数据库，利用连接池和gevent的并发性能，处理大量数据。因为数据方提供的数据表结构中带有varbinary类型字段，并非全部，所以在使用Python程序时，导致报错TypeError: Object of type ‘bytes’ is not JSON serializable经过多方查证了解到关于Python中bytes和byt...
mysql模块连接数据库
m0_59023231的博客
03-17 2089
node.js中mysql模块连接数据库、登陆注册连接数据库、art网络模板的设置与使用
快醒醒，别睡了!...讲《数据分析pandas库》了—/—＜4＞
最新发布
qq_64603703的博客
07-27 718
详细解说数据分析pandas库中的常用方法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值