什么是Python
一、介绍
python是一种面向对象的、解释型、多用途设计语言，拥有丰富强大的库，语法简洁，强制空格作为缩进，能快速完成项目开发，相比传统语言效率更高
Python官方文档：https://www.python.org/doc
二、应用场景
系统运维、网站开发、科学计算、爬虫、人工智能与大数据等
常用web框架：Django、Flask、Tornado（异步）
三、安装
LInux安装较为简单使用yum即可一键安装：
yum install python36 -y
Windows安装https://www.python.org/downloads/windows/
基本数据类型
整数（int）
浮点数（float）
字符串（str）
布尔值（bool） True or Flase
使用type()内建函数可以查看对象类型如：
print(type(True))
<class 'bool'>
算数运算符
变量
一、概念
编程语言中能存储结果或表示值的抽象概念
二、用途
给一段数据赋予一个简短，易于记忆的名字，方便重用
1 变量赋值例如：
name = 'zhangsan'
print(f'my name is {name}')2 多重赋值
name1,name2 = 'zhangsan','lisi'
#格式化字符串：
name = 'zhangsan'
print(“hello %s”%name)
#保留2位小数点：
calc = 100 / 88
print('计算结果：%.2f' %calc)赋值操作符
转义字符串
#示例
name,age = 'zhangsan','18'
print("姓名: %s, \"年龄：%d" %(name, age))获取用户输入
#input()内建函数：用于与用户交互，接收一个参数，即要向用户显示的提示或者说明，让用户知道该怎么做。
#示例：
name = input(“请输入你的姓名：”)
print(name
)字符串操作
字符串格式化输出
name = 'zhangsan'
age = 28
#方法一
print("my name is %s, %s years old." %(name,age))
#方法二
print(f"my name is {name}, {age} years old.")
#方法三
print("my name is {}, {} years old.".format(name,age))字符串拼接
a = 'Hello'
b = 'World'
print(a +' '+ b)len()获取字符串长度
str = "Hello World"
print(len(str))字符串切片
语法格式： string[start:end:step]
string 要切片的字符串
start 切片字符串第一个字符的索引（包括该字符串），默认为0
end 切片字符串最后一个字符索引（不包括该字符），默认为字符串长度
step 表示切片步长，默认为1
s = 'hello world!'
print(s[4]) #截取第5个字符串
print(s[0:5]) #截取第一个到第5个字符串，不包含第5个
print(s[-1]) #截取最后一个字符串
print(s[0::2]) 截取步长为2的字符串字符串处理方法
a = 'abcdefg'
print("首字母大写: %s" % a.capitalize())
print("字符l出现次数: %s" % a.count('l'))
print("感叹号是否结尾: %s" % a.endswith('!'))
print("w字符是否是开头: %s" % a.startswith('w'))
print("w字符索引位置: %s" % a.find('w')) # a.index('W')
print("格式化字符串: Hello{0} world!".format(','))
print("是否都是小写: %s" % a.islower())
print("是否都是大写: %s" % a.isupper())
print("所有字母转为小写: %s" % a.lower())
print("所有字母转为大写: %s" % a.upper())
print("感叹号替换为句号: %s" % a.replace('!','.'))
print("以空格分隔切分成列表: %s" % a.split(' '))
print("切分为一个列表: %s" % a.splitlines())
print("去除两边空格: %s" % a.strip())
print("大小写互换: %s" % a.swapcase())
print("以指定的字符连接: %s" % '.'.join(a))运行结果
首字母大写: Abcdefg
字符l出现次数: 0
感叹号是否结尾: False
w字符是否是开头: False
w字符索引位置: -1
格式化字符串: Hello, world!
是否都是小写: True
是否都是大写: False
所有字母转为小写: abcdefg
所有字母转为大写: ABCDEFG
感叹号替换为句号: abcdefg
以空格分隔切分成列表: ['abcdefg']
切分为一个列表: ['abcdefg']
去除两边空格: abcdefg
大小写互换: ABCDEFG
以指定的字符连接: a.b.c.d.e.f.g数据类型
列表(list)
1 列表概念
也称为数组，是一个序列的数据结构。
序列是指成员都是有序排列，并且可以通过索引访问一个或多个成员
2 定义列表
computer = ["host","display","mouse","keyboard"]
3 列表基本操作
computer = ["host","display","mouse","keyboard"]
print(computer.index("host")) #host索引位置
print(computer.count("host")) #host 出现次数
computer.reverse()
computer.sort()
computer.append("GPU")
computer.insert(3,"memory")
computer[3] = "mem"
print(computer)4 列表切片
列表切片方式与字符串一样，语法格式如下：
list[start:end:step]
computer = ["host","display","mouse","keyboard"]
print(computer[0]) #第一个元素
print(computer[0:5]) #第一个到第五个字符
print(computer[0:-1]) #第一个到倒数第二个元素
print(computer[-1]) #截取至最后一个元素5 清空列表
computer = []
del computer元组(tuple)
1 元组（Tuple）：与列表类似，也是一个序列数据结构。主要区别在于元组中的元素不能修改。
2 定义元组
computer = ("host","display","mouse","keyboard")
集合(set)
1 集合（Set）：是一个无序、不重复元素的序列，主要用于元素去重和关系测试
2 关系测试支持有联合、交集、差集、对称差集
set1 = set(["显示器", "主机", "鼠标", "显示器", "显示器", "CPU"])
set2 = set(["显示器", "主机", "鼠标", "键盘", "显示器", "显示器", "内存"])
print(set2 - set1) # 差集，获取set2中有，而set1中没有元素
print(set1- set2) # 差集，获取set1中有，而set2中没有元素
print(set1 & set2) # 交集，获取set1中有的，在set2里面也存在的元素
print(set1 | set2) # 合集，获取set1与set2合并去重后的元素
print(set1 != set2) # True
print(set1 == set2) # False3 定义集合 想要创建空集合，必须使用set()而不是{}。后者用于创建空字典
# 定义一个空集合
setx = set()字典(dict)
1 是一个对映射关系为key:value的数据结，通过key来访问value，因此字典中的key不允许重复
2 字典操作
#定义字典
computer = {"主机":5000,"显示器":1000,"鼠标":60,"键盘":150}
computer2 = {"内存":150}
# 查询字典,获取字典中key对应的值
print(computer.get("主机"))
print(computer["主机"])
# 获取所有的key
print(computer.keys())
#获取所有的value
print(computer.values())
# 获取所有键值对
print(computer.items())
# 增加元素
computer["CPU"] = 2000
print(computer)
computer.update(computer2)
# 删除字典中的key
print(computer.pop("CPU")) # 抛出的是key对应的value
print(computer)常用数据类型转换
a = '1'
b = 2
c = int(a) + b
print("=======================字符串转为bool类型===========================")
# 字符串可以转为bool类型
str1 = "hello"
# print(int(str1)) # 字符串中如果存在字母或特殊符号，则不能转为int，float等数值类型
print(bool(str1)) # True，字符串可以转为bool值
str2 = ""
print(bool(str2)) # Flase, 变量只要存在值，就为True，空字符串为False，空字符串不能转为数值类型
print("=======================数值类型转bool类型===========================")
# 数值类型转为bool类型
# 非数字0都为True，数字0为False
num1 = 1
print(bool(num1))
num2 = 0
print(bool(num2))
print("=======================数值和bool类型转字符串类型===========================")
# 几乎所有类型都可以转为字符串类型
# 字符串类型是编程语言最基础的类型
num1 = 1
print(str(num1))
print("=======================布尔类型转数值类型===========================")
bl1 = True
bl2 = False
print(int(bl1)) # 1
print(int(bl2))操作符
比较操作符
逻辑操作符and, or, not
成员操作符in,not in
身份操作符 is ,is not
流程控制
条件判断if else
#单分支条件判断
age = int(input("input you age，please"))
if age > 18:
print("you are adult，congratulations ")
else:
print("you are minor,sorry")
#三目表达式
"you are adult，congratulations" if age >18 else "you are minor,sorry"
#多条件判断
age = int(input("input you age，please"))
if age < 7:
print("children")
elif age >=7 and age <17:
print("teenagers")
elif age >=18 and age <60:
print("adult")
else:
print("old")循环语句 for , while
#遍历字符串
s="123456"
for i in s:
print(i)
#遍历列表
computer = ["host","display","mouse","keyboard"]
for s in computer:
print(s,len(i))
#遍历字典
computer = {"host":5000,"display":1000,"mouse":80,"keyboard":200}
for y in computer.items():
print(y)
print("name:%s\tcost:%s"%(y[0],y[1]))
#循环嵌套
s1 = "123456"
s2 = "456789"
for j in s1:
for k in s2:
if j == k:
print(j)
###############################################################
#当条件满足时停止循环
count=0
while count <5:
print(count)
count +=1
#死循环
count = 0
while True:
print(count)
count += 1pass语句continue ,break
# continue与break只在for和while循环语句中生效
# continue 当满足条件时，跳出本次循环
for i in range(1,6):
if i ==3:
continue
else:
print(i)
# break 当满足条件时，跳出所有循环
for i in range(1,6):
if i ==3:
break
else:
print(i)
# 登录用户三次错误机会
count = 0
while 1:
if count < 3:
name = input("请输入你的用户名: ").strip() # .strip()去除首尾空格
if len(name) == 0:
print("输入不能为空!")
count += 1
continue
elif name == "zhansan":
print("登录成功.")
break
else:
print("用户名错误，请重新输入!")
count += 1
else:
print("超出错误次数, 退出!")
break文件操作
open()函数
语法：open(file,mode='r',encoding=None)
file: 打开文件的路径
mode(可选): 打开文件的模式
r: 只读(默认)
w: 写
a: 在文件末尾追加
w+: 读写
b: 以二进制字节读取文件
文件对象操作
with语句
open()每次打开文件后都需要close(),那么为了方便可以使用with语句，因为不管在处理文件过程中是否发生异常，都能保证 with 语句 执行完毕后已经关闭了打开的文件句柄。
with open("test.txt",encoding="utf8") as f:
data = f.read()
print(data)类
什么是面向对象编程
编程大致分为以下两种方式：
面向过程编程是一种以过程为中心的编程思想，是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，优点是性能比面向对象高，但维护性较差，不宜与修改.
面向对象编程对象为中心的编程思想，对现实世界理解和抽象的方法 ，具有封装性，继承性和多态性，优点是易维护，易复用，易扩展.
类的定义
类是对现实生活中一类具有相同特征事物的抽象描述。如人类、动物类
对象是类的实体，实际存在的事物，如人的手、头、腿都是实际存在可触摸到的
类与对象的关系是由对象来决定的，这个过程叫做抽象化。用类创建对象，这个过程称为实例化
类的特点
封装：把相同对象的功能(函数)、属性(变量)组合在一起
方法：对象的实际功能，如人的手能作画、写字，实际上在类里面就是函数，称为成员函数，也可以称为方法
属性：对象的特征
实例化：用类创建对象，这个对象具体是什么东西，例如我这个人
类的书写规范
一般采用大驼峰命名，如MyClass
类注释，用于说明该类的用途，提高阅读性
只存在量两种数据：属性(变量)和方法(函数)
声明属性时必须赋值
声明方法的第一个参数必须是self，其他与普通函数一致
一般会使用__init__方法给类指定初始状态属性
使用class关键字定义类：
class Computer(): #定义电脑类
def __init__(self): #定义初始属性
self.host = "4C8G"
self.displayer = "27寸"
self.keyboard = "机械键盘"
self.mouse = "无线鼠标"
def office(self): #定义方法
return "办公"
def internet(self):
return "上网"
类的实例化
实例化：用类创建对象的过程
类实列：用类创建对象
实例属性：对象的属性
示例方法：对象调用的方法
pc = Computer() #类实例化，pc是类实例
print(pc.host) #访问类属性，查看电脑配置
print(pc.office()) #访问类方法，让电脑做事类的继承
子类可以继承父类的所有属性及方法
父类有的属性和方法，子类都会有，除非覆盖
子类有的属性和方法父类不一定有
实例化后的类中修改的父类属性，不影响其他实例使用
实例化后，类中可以零时定义属性，类销毁时，属性也会销毁
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Parent: # 定义父类
parentAttr = 100
def __init__(self): # 定义初始属性
print "调用父类构造函数"
def parentMethod(self): #定义类方法
print '调用父类方法'
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print "父类属性 :", Parent.parentAttr
class Child(Parent): # 定义子类
def __init__(self):
print "调用子类构造方法"
def childMethod(self):
print '调用子类方法'
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法 - 设置属性值
c.getAttr() # 再次调用父类的方法 - 获取属性值
p = Parent() #实例化父类
p.childMethod() # 父类不能调用子类方法函数
Python函数是组织好的，可重复使用，用来实现单一，或相关关联功能的代码块，提高了代码的重复利用率
定义一个函数
函数代码块以def关键字开头，后接函数标识符()
任何函数传入的参数和变量必须放在圆括号中间
函数第一行语句可以选择性地使用文档字符串，用于函数说明
函数内容以冒号起始，并且缩进
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None
#定义一个无参函数
def func():
'''
函数说明
'''
return "Hello World"
#定义有参函数
def func(str):
print(str)
func(hello)
#参数默认值 当函数不是必须要调用方传入数值或字符串的，可以设置默认值
# 当必须要调用方传入参数的，则不配置默认值
def sub(a=0, b=0):
print(f'a={a}, b={b}')
print(a + b)
sub()函数作用域
函数作用域即使限制一个变量或一段段代买的可用范围，不在这个范围就不能使用。提高程序逻辑的局部性，减少变量名冲突
作用域有四种，分别是:
L (Local): 局部变量，包含在 def 关键字定义的语句块中，即函数中中定义的变量
E(Enclosing): ：嵌套作用域，包含了非局部(non-local)也非全局(non-global)的变量。比如两 个嵌套函数，一个函数（或类） A 里面又包含了一个函数 B ，那么对于 B 中的名称来说 A 中 的作用域就为 nonlocal
G ( Global): 全局作用域，当前脚本的最外层，比如当前模块的全局变量
B (Built-in): 内置作用域，包含了内建的变量/关键字等。最后被搜索
全局和局部作用域
# 定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域
a = 2 #函数外的变量作用域是整个代码中有效，因此称为全局变量
def func():
b = 3 #函数内的变量作用域只在函数内有效，因此称为局部变量，全局变量即使与局部变量名字一样也不冲突
print(a)
print(b)
# 如果函数内变量也能在全局引用，则需要使用global声明:
a = 2
def func():
global b
b = 3
print(a)
func() # 需要调用函数再引用变量
print(b)
内置作用域
内置作用域是通过一个名为 builtin 的标准模块来实现的，但是这个变量名自身并没有放入内置作 用域内，所以必须导入这个文件才能够使用它。在 Python3.0 中，可以使用以下的代码来查看到底 预定义了哪些变量:
#注：Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，
#其它的代码块（如 if/elif/else/、try/except、for/while 等）是不会引入新的作用域的，也就
#是说这些语句内定义的变量，外部也可以访问。
import builtins
dir(builtins)嵌套作用域
#嵌套作用域是指在一个函数里定义再定义函数，即嵌套函数，内部函数的可以访问外部函数作用域
def outer():
x = 1
def inner():
print(x) #1
return inner() #2
outer()
#1 位置引用变量，会先查找局部作用域（inner）,如果没有 会从外层作用域（outer）查找，即获取到x=1，所以这里inner函数可以访问外层作用域
#2 位置返回inner函数执行结果闭包
闭包可以简单粗暴理解为是一个定义在函数内部的函数，闭包使得变量即使脱离了该函数的作用域范围也依然能被访问到，嵌套函数也是闭包的一种形式
def outer():
x = 1
def inner():
print(x) # 1
return inner # 不加括号，表示返回函数体
sf = outer()
sf() # 调用，等同于 outer()()
#在一个外部函数内定义了一个函数，内部函数引用外部函数的变量，并且外部函数的返回值是内部函数的引用，这样就构成了一个闭包，并且满足了闭包的三个条件：
#1两层以上的嵌套关系
#2 内部函数调用外部函数定义的变量
#3 外部函数返回内部函数体对象，而不是函数体结果
函数装饰器
装饰器本生是一个函数，用于包装一个函数或类，它可以让其他函数不需要在改动代码的情况下动态增加功能，这样有助于我们的代码更加简短
无参函数装饰器
def hello():
print("我是原函数")
def decorator(func):
def f():
print("原函数开始执行了")
func()
print("原函数执行结束了")
return f
dec = decorator(hello)
dec()
#在实际应用中，我们每一个需要调用decorator装饰器的地方都需要这么写，较为麻烦。Python提供了一个简洁的写法就是语法糖"@"
@decorator
def hello():
print("我是原函数")
hello()带参函数装饰器
#固定传参
def decorator(func):
def f(msg):
print("原函数执行前")
func(msg)
print("原函数执行后")
return f
@decorator
def hello(msg):
print(msg)
hello("我是原函数")
# 接受不固定传参
def decorator(func):
def f(*args,**kwargs):
print("函数执行前")
func(*args,**kwargs)
print("函数执行后")
return f
@decorator
def hello(*args,**kwargs):
print(args,kwargs)
hello("我是原函数",你好='hello')匿名函数
#匿名函数lambda 是一次性函数，用完后在内存中就被删除，一般零时使用，比较省内存
#lambda 与普通函数相比，省去了定义函数的过程和函数名称，让代码更加精简，其他并没有太多作
#用。如果用 lambda 函数不能使你的代码变得更清晰时，这时你就要考虑使用常规的方式来定义函数。
sub = lambda a, b: a + b
等同于
def sub(a,b):
return a + b异常处理
异常捕捉语法
try:
expression
except [Except Type]:
expression常见异常类型
#打印一个没有定义的变量
try:
print(name)
except NameError:
print("发生错误时，执行的代码")
#当不确定异常类型时，可以使用通用异常 Exception
try:
print(name)
except Exception
print("发生错误时，执行的代码")自定义模块
模块时一系列常用功能的集合体，一个py文件就是一个模块。这样做的目的时为了将重复使用的代码有组织的存放在一起，方便管理，谁用谁拿，拿的这个过程称为导入(import)
# 定义一个模块calc.py
"""
说明：
这是一个自定义的模块，做的是计算器的加减乘除
说明文档需要使用三引号引起来
"""
class Calc:
"""自定义的模块"""
def __init__(self, num1, num2):
self.num1 = num1
self.num2 = num2
def jia(self):
return self.num1 + self.num2
def jian(self):
return self.num1 - self.num2
def cheng(cls):
return cls.num1 * cls.num2
def chu(self):
return self.num1 / self.num2
if __name__ == '__main__': #作用当该py文件作为一个模块时，声明以下代码为测试调用代码，将不会在导入时执行
# 测试代码
calc = Calc(2, 2)
print(calc.jian())
#调用该模块
from calc import Calc #导入一个类
常用标准库
os库
import os #导入os库
print(os.name) #操作系统类型
print(os.getcwd()) #当前路径
try:
print(os.remove('')) # 删除文件
except FileNotFoundError:
pass
print(os.chmod('异常处理.py', mode=777))# 修改文件权限sys库
import sys
# print(sys.argv)
print(sys.argv[1])
print(sys.argv[2])
# print(sys.argv[3])
name = sys.argv[1]
age = sys.argv[2]
print(f"{name} 今年 {age} 岁")platform 库
glob库
glob库用于文件查找，支持通配符（*、？、[]）
示例1：查找目录中所有以.sh为后缀的文件:
>>> glob.glob('/home/user/*.sh')
['/home/user/b.sh', '/home/user/a.sh', '/home/user/sum.sh']
示例2：查找目录中出现单个字符并以.sh为后缀的文件:
>>> glob.glob('/home/user/?.sh')
['/home/user/b.sh', '/home/user/a.sh']
示例3：查找目录中出现a.sh或b.sh的文件:
>>> glob.glob('/home/user/[a|b].sh')
['/home/user/b.sh', '/home/user/a.sh'random库
subprocess库
subprocess库用于执行Shell命令，工作时会fork一个子进程去执行任务，连接到子进程的标准输入、输出、错误，并获得 它们的返回代码。
语法：subprocess.run(args, *, stdin=None, stdout=None, stderr=None, shell=False, cwd=None, timeout=None, check=False, encoding=None)
import subprocess
cmd = "pwd"
result = subprocess.run(cmd, shell=True, timeout=3, stderr=subprocess.PIPE,
stdout=subprocess.PIPE)
print(result)
run方法返回CompletedProcess实例，可以直接从这个实例中获取命令运行结果：
print(result.returncode) # 获取命令执行返回状态码
print(result.stdout) # 命令执行标准输出
print(result.stderr) # 命令执行错误输出pickle库
pickle模块实现了对一个Python对象结构的二进制序列化和反序列化。
# 序列化将对象保存到文件
import pickle
computer = {"主机":5000,"显示器":1000,"鼠标":60,"键盘":150}
with open("data.pkl", "wb") as f:
pickle.dump(computer, f)
# 反序列化 使用load()函数从文件中读取
import pickle
with open("data.pkl", "rb") as f:
print(pickle.load(f))json库
JSON是一种轻量级数据交换格式，一般API返回的数据大多是 JSON、XML，如果返回JSON的话，需将获取的数据转换成字典， 方面在程序中处理。 json与pickle有相似的接口，主要提供两种方法
dumps() 对数据进行编码
loads() 对数据进行解码
# 将字典类型转换为JSON对象
import json
computer = {"主机":5000,"显示器":1000,"鼠标":60,"键盘":150}
json_obj = json.dumps(computer)
print(type(json_obj))
print(json_obj)
# 将JSON对象转换为字典
import json
data = json.loads(json_obj)
print(type(data))time库
示例1：将当前时间转换为指定格式
import time
time.strftime("%Y-%m-%d %H:%M:%S")
示例2：将时间戳转换指定格式
now = time.time()
struct_time = time.localtime(now)
time.strftime('%Y-%m-%d %H:%M:%S',struct_time)datetime库
from datetime import date, datetime
# 将当前系统时间转换指定格式
date.strftime(datetime.now(), '%Y-%m-%d %H:%M:%S')
# 获取当前系统时间
date.isoformat(date.today())
# 将时间戳转换指定格式
date_array = datetime.fromtimestamp(time.time())
date_array.strftime("%Y-%m-%d %H:%M:%S")
# 获取昨天日期
from datetime import date, timedelta
yesterday = date.today() - timedelta(days=1)
yesterday = date.isoformat(yesterday)
print(yesterday)
# 获取明天日期
tomorrow = date.today() + timedelta(days=1)
# 将时间对象格式化
tomorrow = date.isoformat(tomorrow)
print(tomorrow)urllib库
包含以下类：
urllib.request 打开和读取 URL
urllib.error包含 urllib.request 抛出的异常
urllib.parse 用于解析 URL
urllib.robotparser 用于解析 robots.txt 文件
#自定义用户代理
from urllib import request
url = "https://docs.python.org/zh-cn/3.8/library/index.html"
user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:106.0) Gecko/20100101 Firefox/106.0"
header = {"User-Agent": user_agent}
req = request.Request(url, headers=header)
res = request.urlopen(req)
print(res.getcode())
#向接口提交数据
from urllib import request, parse
url = "http://www.aliangedu.cn/login"
post_data = {"username":"user1","password":"123456"}
#将字典转为URL查询字符串格式，并转为bytes类型
post_data = parse.urlencode(post_data).encode("utf8")
req = request.Request(url, data=post_data, headers=header)
res = request.urlopen(req)
print(res.read())
pymysql 库
pymysql是第三方模块，需要单独安装，首选通过pip安装PyMySQL: # pip3 install pymysql
先创建一个test库，再创建一张user表：
create database test;
use test;
create table user(
id int primary key not null auto_increment,
username varchar(50) not null,
password varchar(50) not null
);
########################################################################
import pymysql
connect = pymysql.connect(host="127.0.0.1", port=3306, user="root", password="admin123456", database="test", cursorclass=pymysql.cursors.DictCursor)
try:
with connect.cursor() as cursor: # 使用with创建数据库游标，在执行完成后会自动关闭，sql语句需要通过数据库游标来执行
# 创建一条记录
sql = "insert into user(username, password) values('zhangsan', '123456');"
cursor.execute(sql)
# 写入到数据库
connect.commit()
with connect.cursor() as cursor:
# 读取一条记录
sql = "select id,username,password from user;"
cursor.execute(sql)
result = cursor.fetchone()
print(result)
finally: # 无论try中的代码块是否执行成功，最后一定会执行finally中的代码
connect.close()
正则表达式
正则表达式是对字符串操作的一种逻辑方式，就是用实现定义好的一些特定字符及这些特定字符的组 合，组成一个规则字符串，这个规则字符串就是表达对字符串的逻辑，给定一个正则表达式和另一个 字符串，通过正则表达式从字符串我们想要的部分
2623
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
