[Python知识库]第五章 python标准

# Sys模块

定义

Sys模块主要负责与python解释器进行交互

代码

#argv 获取命令行的参数
import sys
#argv第一个参数必须是文件的信息/程序信息
print(sys.argv)
print(sys.argv[3])
"""
?argv 获取命令行的参数
?argv 的第一个参数/下标的是0的参数，一定会是我们运行文件的信息
"""

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

多个参数之间用空格隔开

"""
sys.exit() ?0是正常退出，1是不正常退出，无论是不是1都不会报错
"""
for i in [1,2,3,4,5]:
? ? if i == 2:
? ? ? ? sys.exit(1)
? ? print(i) #1

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

#maxsize ?int数值可以最大是263-1
print(sys.maxsize) #9223372036854775807

#path 获取路径,返回一个list
print(sys.path)

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

#sys.path=[] 删除路径


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

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

#导入模块不一定是内建模块，也有可能是我们自己封装的模块
# 获取内建模块的名字
a = sys.builtin_module_names
print(a)

# Os模块

定义

os是和操作系统（windows）进行交互的，提供了访问操作系统底层的接口

Sys模块主要负责与python解释器进行交互

常用方法

代码

import os 

#os.getcwd() 获取当前目录
#print(os.getcwd()) #D:\axc\Python\PythonTemp
"""
绝对路径/全路径：D:\axc\Python\PythonTemp\test.py
相对路径/半路经：Python\PythonTemp\test.py
想要写半路经，你的当前路径和D:\axc\Python\PythonTemp要一样
"""
#os.mkdir() ?创建一个单级文件夹
#os.mkdir("D:\\axc\\Python\\PythonTemp\\temp")
#os.mkdir("temp")

#os.rmdir() ?删除单级空文件夹
#os.rmdir("D:\\axc\\Python\\PythonTemp\\temp")
#os.rmdir("temp")

#os.makedirs（） 创建多层文件夹
#os.makedirs("D:\\axc\\Python\\PythonTemp\\test\\2002bigdate")
#os.makedirs("test\\2002bigdate")

#os.removedirs（）删除多级空目录
os.removedirs("test\\2002bigdate")


#创建一个文件夹test
#os.mkdir("test")

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

#修改文件名字temp为temp.txt
#os.rename("D:\\axc\\Python\\PythonTemp\\test\\temp.py","test\\temp.txt")

#列出test文件夹里面所有的子文件以及子文件夹
print(os.listdir("test")) #['temp.txt'] ?listdir只列出文件/文件夹名字

#删除test这个文件夹
os.remove("test\\temp.txt")
os.rmdir("test")

#os.path.dirname() 获取路径的父目录（上一级目录）
a = os.path.dirname("D:\\axc\\Python\\PythonTemp\\test.py")
#print(a) #D:\axc\Python\PythonTemp

#os.path.join() 将多个路径进行拼接
b = os.path.join("D:","python","p.py")
#print(b) #D:python\p.py

#os.path.split() 拆分,将文件和文件夹进行拆分.返回一个元组
c = os.path.split("D:\\axc\\Python\\PythonTemp\\test.py")
print(c) #('D:\\axc\\Python\\PythonTemp', 'test.py')

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

#?文件模式匹配：glob模块

import os
import glob

a = os.listdir("D:\\axc\\Python\\PythonTemp")
#print(a) #只显示文件/文件夹的名字
"""
['.pytest_cache', '.vscode', 'cat.py', 'ClearWindow.py', 'count.py', 'eval.py', 'f.txt', 
'foo.txt', 'out.log', 'sudo.py', 'test.py', '__pycache__', '其他文件.py']
"""
for i in glob.glob("D:\\axc\\Python\\PythonTemp\\*.py"):
? ? print(i)

语法

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

优点

1.打印的是全路径

2.可以进行模式匹配

#日期时间相关 Datetime?模块

定义

日期和时间进行操作的内置模块：time模块、datetime模块和calendar模块

Datetime模块常用的三个类?date??time??datetime

一个文件是一个模块，一个模块里面有多个类，一个类有多个方法

## Date

定义

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

常用的方法和属性

import datetime
dt=datetime.datetime
print(dt.today()) #2021-10-11 14:48:40.574201
print(dt.now()) #2021-10-11 14:48:40.574201

## Time

定义

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

常用的方法和属性

## Datetime

定义

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

date和time类的一个结合

常用方法和属性

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

常用方法代码

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

## Timedeltal

定义

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

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

常用的方法

import datetime
dt = datetime.datetime 
a = dt.now()
#三天前
#print(a+datetime.timedelta(-3)) #2021-10-08 15:04:18.884703
#三天后三个小时后三秒后
print(a+datetime.timedelta(days=3,hours=3,seconds=10)) #2021-10-14 18:07:36.521323

# 正则

## 元字符

## 转义字符\

1. 把原本的意义去掉。?“.”任意-----“\.”

2. 添加意义??????“t”-----“\t”制表符

## 预定义匹配字符

#\d 匹配数字0-9
a= re.findall("\d","red84")
#print(a) #['8', '4']

#\D \d相反，\d不要的，\D要
a= re.findall("\D","red84")
#print(a) #['r', 'e', 'd']

#\w 匹配字母、数字、下划线
b= re.findall("\w","red84\nred79")
#print(b) #['r', 'e', 'd', '8', '4', 'r', 'e', 'd', '7', '9']

#\W \w的相反
b= re.findall("\W","red84\nred79")
#print(b) #['\n']

#\s 匹配空格、换行符、制表符
c = re.findall("\s","red84\nred79")
#print(c) #['\n']

#\S \s相反
c = re.findall("\S","red84\nred79")
print(c) #['r', 'e', 'd', '8', '4', 'r', 'e', 'd', '7', '9']

重复匹配

#{n} 匹配字符出出现n次
a = re.findall("l{2}","yellow")
#print(a) #['ll']

#{m,n} 匹配最少m次，最多n次
b= re.findall("l{2,4}","I like you,yellow,alllow,allll")
#print(b) #['ll', 'lll', 'llll']

#{m,} 至少是m次上不封顶
c= re.findall("l{2,}","yellow,alll,allll,alllll")
#print(c) #['ll', 'lll', 'llll', 'lllll']

#? 匹配0和1次
d = re.findall("l?","like,yellow")
#print(d) #['l', '', '', '', '', '', '', 'l', 'l', '', '', '']

#+ 至少出现1次
e = re.findall("l+","like,yellow")
#print(e) #['l', 'll']

# * 出现0次到任意次
f = re.findall("l*","like,yellow")
print(f) #['l', '', '', '', '', '', '', 'll', '', '', '']

位置匹配

# ?^ 开头
a = re.findall("^1","18539334875")
print(a) #['1']

# ?$ 结尾
b = re.findall("X$","44456789098765432X")
print(b) #['X']

# 贪婪模式/非贪婪模式

“贪婪模式”总是尝试匹配尽可能多的字符；

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

a = re.findall(".","apple,orange,banaba")
print(a) #['a', 'p', 'p', 'l', 'e', ',', 'o', 'r', 'a', 'n', 'g', 'e', ',', 'b', 'a', 'n', 'a', 'b', 'a']

b = re.findall("^a","apple,orange,banaba")
print(b) #['a']

# re模块

定义

Python编译正则的模块

常用方法

# Match对象的方法

import re
"""
匹配两个单词
两个单词用空格隔开
单词的内容可以是字母可以是数字
"""
zz = re.compile(r"(\w+) (\w+)") 
matchOb = re.match(zz,"I LOVE YOU")
#print(matchOb) #<re.Match object; span=(0, 6), match='I LOVE'>
#match.group(index) 
a = ?matchOb.group() #I LOVE ?默认是0，打印所有的单词(字符串)

a = matchOb.group(1) #I ?打印第一个单词(字符串)
a = matchOb.group(2) #LOVE 打印第二个单词(字符串)
# 报错 a = matchOb.group(3)

#给两个参数
a = matchOb.group(1,2) #('I', 'LOVE') ?打印第一个和第二个单词，返回一个元组
print(a)
# match.groups() 获取所有的单词，返回一个元组
a = matchOb.groups() #('I', 'LOVE') #打印所有
a = matchOb.group(1,2) #('I', 'LOVE') #可以规定打印那几个
print(a)
# match.start(index) ?获取起始参数 ?返回int
a = matchOb.start() # 0
a = matchOb.start(2) #2 第二个单词（LOVE）的起始参数是2

# match.end(index) 获取结束参数 返回int
b = matchOb.end() #6
b = matchOb.end(1) #1 第一个单词的结束参数 
print(b)


#match.span(index) 返回一个元组(start,end)
a = matchOb.span() #(0, 6)
a = matchOb.span(1) #(0, 1)
a = matchOb.span(2) #(2, 6)
print(a)

补充

为什么正则前面要带一个r

如果你想要\,只是一个斜杠，没有特殊意义，我们正则前面要加r

# 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

定义

格式化数据结构

补充:日志的讲解

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

#.basicConfig() 使用默认格式化程序创建 StreamHandler 并将其添加到根日志记录器中，从而完成日志系统的基本配置。如果没有为根日志程序定义处理程序，debug()、info()、warning()、error()和 critical() 函数将自动调用 basicConfig()。
logging.basicConfig(
    #级别排序：CRITICAL > ERROR > WARNING > INFO > DEBUG。
    level=logging.DEBUG,
    #为处理程序使用指定的格式字符串。
    #%(levelname) 日志级别  %(message)s已经记录的消息
    format='%(levelname)s %(message)s',
)
#打印
logging.debug('Logging pformatted data')
#对data进行格式化
formatted = pformat(data)
#Python splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
for line in formatted.splitlines():
    #Python rstrip() 删除 string 字符串末尾的指定字符（默认为空格）
    #可写可不写
    logging.debug(line.rstrip())

# pickle模块

定义

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

序列化方法

## dumps()与loads()

"""
dumps(数据类型) 将python转换成二进制
loads(二进制) 将二进制转换成python
"""
import pickle as p 

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

b = p.loads(a)
print(b) #I love you

## dump()与load()

"""
dump(数据类型,文件对象) 把python转成二进制写入文件
load(文件对象) 把文件中的数据读取成二进制转成python
"""
import pickle as 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(文件名，打开模式)

## 打开模式

代码

#在路径下面创建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()
#必须关闭文件，因为每次操作都是保存在内存中，并没有真正保存到文件中

## 读文件

常用方法

代码

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

文件--->首选项--->设置--->搜索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)

## 写文件

常用方法

代码

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

## 删除文件

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

## with语句

语法? ：with open(文件名) as 别名

代码

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

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

# json模块

定义

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

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

}

## JSON类型转换Python类型对照表

常用方法

## dumps()与loads()

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

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

"""
dumps(python数据) 把python数据转换成json数据
loads(json) 把json数据转换成python数据
"""
import 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 或者2
separators 是（ ‘元素之间用逗号隔开’ ， ‘key和内容之间’ 用冒号隔开）
这里是 ‘逗号’ ， ‘冒号’ 中间的逗号不带引号
"""
a = json.dumps([1, 2, 3, {'4': 5, '6': 7}], separators=(',', ':')) # 输出结果：[1,2,3,{"4":5,"6":7}]
print (json.loads(a))

#\b就有特殊的意义，单词边界，本身没有什么意思
b = json.dumps("\"foo\bar")
print (json.loads(b)) #"foar  

## dump()与load()

"""
dump(python,文件对象) 把python转换成json格式并保存到文件中
load(文件对象) 把json格式的文件读取转换成python
"""
import json

data = {
    "大数据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) #没有返回值，但是数据已经写进去了r

with open("f.txt","r") as f:
    a = json.load(f)
    print(a)

# Python与数据库

创建?

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

## 创建数据表

语法：?CREATE TABLE IF NOT EXISTS table_name (column_namecolumn_type);

数据类型

## 约束

主键自增（int） ：primary key auto_increment

## 外键

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

## 唯一约束

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

## 非空约束

not null

## 默认约束

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

## 切换数据库

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

# 增(添加数据)

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

# 删

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

# 改

更新数据

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

alter?
alter table 旧表名 rename ?to 新表名; #修改表名字
alter table 表名字 modify 列名 (新)数据类型; #修改数据类型 id char(10)---->id int
alter table 表名字 change 旧列名字 新列名字 新数据类型；#修改列名名字?
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条数据

# 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的游标功能，创建一个游标对象； ? ? ? ? ? ? ?
cursor = db.cursor()

常用方法

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

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

cursor用来查询数据的方法

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

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

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

# 数学：math模块

定义

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

基本函数

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)

## 定义常数

## 对数和三角函数

代码

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模块（随机数）

常用方法

## 针对浮点数

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)

# 面向对象

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

## 类

定义

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

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

语法

类型要符合大驼峰命名
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("骨头")   
        

## 继承

继承：继承就是子类继承父类的特征和行为，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 s


class student(person):
    def huaqian(self):
        print("花钱神兽")

#同样我们可以调用人类中的方法和属性
#继承person类以后，初始化方法也继承过来了，所以一定不要忘了给参数
s = student("小明")
print(s.show())

重点

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

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

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

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

1.继承完以后我们可以不可以重写方法
#学生不应该是个对象，是个类的话更加好操作，那把学生定义成类，他要继承人类
class student(person):
    def huaqian(self):
        print("花钱神兽")
    def qita(self):
        print("学生的任务是：好好学习天天向上")

#继承person类以后，初始化方法也继承过来了
s = student("小明")
print(s.show())
#我们调用其他会发现，调用的是子类的其他，并不是父类的其他
"""
所以我们python也支持重写
1.不同的两个类    2.继承关系      3.方法名，参数相同
"""
s.qita()


2.能不能保留父类的一些方法里面的代码
class student(person):
    def huaqian(self):
        print("花钱神兽")
    def qita(self):
        #调用父类的方法
        super().qita()
        print("学生的任务是：好好学习天天向上")

#继承person类以后，初始化方法也继承过来了
s = student("小明")
"""
可不可以保留这样的一句话，
不同的人有不同的任务，学生的任务是：好好学习天天向上
意思是在父类的基础上重新添加代码
"""
s.qita()

3.字类可以初始化，可以理解为，字类可以有构造方法吗
class student(person):
    def __init__(self, name,hobbit,sex="男", age=18,):
       self.hobbit = 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()