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.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) #2021
print(date01.month) #12
print(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-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.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 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.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.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类型对照表
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
参数
“”"
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或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
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) | 向上取整操作,返回类型: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 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 …****,可用精度 |
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 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()