网站菜单分类怎么做,重庆专业网站推广平台,wordpress改字体,做网站需要资质吗本文是对于 现代 Python 开发#xff1a;语法基础与工程实践的总结#xff0c;更多 Python 相关资料参考 Python 学习与实践资料索引#xff1b;本文参考了 Python Crash Course - Cheat Sheets#xff0c;pysheeet 等。本文仅包含笔者在日常工作中经常使用的#xff0c;并…
本文是对于 现代 Python 开发语法基础与工程实践的总结更多 Python 相关资料参考 Python 学习与实践资料索引本文参考了 Python Crash Course - Cheat Sheetspysheeet 等。本文仅包含笔者在日常工作中经常使用的并且认为较为关键的知识点与语法如果想要进一步学习 Python 相关内容或者对于机器学习与数据挖掘方向感兴趣可以参考程序猿的数据科学与机器学习实战手册。
基础语法
Python 是一门高阶、动态类型的多范式编程语言定义 Python 文件的时候我们往往会先声明文件编码方式:
# 指定脚本调用方式
#!/usr/bin/env python
# 配置 utf-8 编码
# -*- coding: utf-8 -*-
# 配置其他编码
# -*- coding: -*-
# Vim 中还可以使用如下方式
# vim:fileencoding
人生苦短请用 Python大量功能强大的语法糖的同时让很多时候 Python 代码看上去有点像伪代码。譬如我们用 Python 实现的简易的快排相较于 Java 会显得很短小精悍:
def quicksort(arr):
if len(arr) 1:
return arr
pivot arr[len(arr) / 2]
left [x for x in arr if x pivot]
middle [x for x in arr if x pivot]
right [x for x in arr if x pivot]
return quicksort(left) middle quicksort(right)
print quicksort([3,6,8,10,1,2,1])
# Prints [1, 1, 2, 3, 6, 8, 10]
控制台交互
可以根据 __name__ 关键字来判断是否是直接使用 python 命令执行某个脚本还是外部引用Google 开源的 fire 也是不错的快速将某个类封装为命令行工具的框架
import fire
class Calculator(object):
A simple calculator class.
def double(self, number):
return 2 * number
if __name__ __main__:
fire.Fire(Calculator)
# python calculator.py double 10 # 20
# python calculator.py double --number15 # 30
Python 2 中 print 是表达式而 Python 3 中 print 是函数如果希望在 Python 2 中将 print 以函数方式使用则需要自定义引入:
from __future__ import print_function
我们也可以使用 pprint 来美化控制台输出内容
import pprint
stuff [spam, eggs, lumberjack, knights, ni]
pprint.pprint(stuff)
# 自定义参数
pp pprint.PrettyPrinter(depth6)
tup (spam, (eggs, (lumberjack, (knights, (ni, (dead,(parrot, (fresh fruit,))))))))
pp.pprint(tup)
模块
Python 中的模块Module即是 Python 源码文件其可以导出类、函数与全局变量当我们从某个模块导入变量时函数名往往就是命名空间Namespace。而 Python 中的包Package则是模块的文件夹往往由 __init__.py 指明某个文件夹为包:
# 文件目录
someDir/
main.py
siblingModule.py
# siblingModule.py
def siblingModuleFun():
print(Hello from siblingModuleFun)
def siblingModuleFunTwo():
print(Hello from siblingModuleFunTwo)
import siblingModule
import siblingModule as sibMod
sibMod.siblingModuleFun()
from siblingModule import siblingModuleFun
siblingModuleFun()
try:
# Import someModuleA that is only available in Windows
import someModuleA
except ImportError:
try:
# Import someModuleB that is only available in Linux
import someModuleB
except ImportError:
Package 可以为某个目录下所有的文件设置统一入口:
someDir/
main.py
subModules/
__init__.py
subA.py
subSubModules/
__init__.py
subSubA.py
# subA.py
def subAFun():
print(Hello from subAFun)
def subAFunTwo():
print(Hello from subAFunTwo)
# subSubA.py
def subSubAFun():
print(Hello from subSubAFun)
def subSubAFunTwo():
print(Hello from subSubAFunTwo)
# __init__.py from subDir
# Adds subAFun() and subAFunTwo() to the subDir namespace
from .subA import *
# The following two import statement do the same thing, they add subSubAFun() and subSubAFunTwo() to the subDir namespace. The first one assumes __init__.py is empty in subSubDir, and the second one, assumes __init__.py in subSubDir contains from .subSubA import *.
# Assumes __init__.py is empty in subSubDir
# Adds subSubAFun() and subSubAFunTwo() to the subDir namespace
from .subSubDir.subSubA import *
# Assumes __init__.py in subSubDir has from .subSubA import *
# Adds subSubAFun() and subSubAFunTwo() to the subDir namespace
from .subSubDir import *
# __init__.py from subSubDir
# Adds subSubAFun() and subSubAFunTwo() to the subSubDir namespace
from .subSubA import *
# main.py
import subDir
subDir.subAFun() # Hello from subAFun
subDir.subAFunTwo() # Hello from subAFunTwo
subDir.subSubAFun() # Hello from subSubAFun
subDir.subSubAFunTwo() # Hello from subSubAFunTwo
表达式与控制流
条件选择
Python 中使用 if、elif、else 来进行基础的条件选择操作
if x 0:
x 0
print(Negative changed to zero)
elif x 0:
print(Zero)
else:
print(More)
Python 同样支持 ternary conditional operator:
a if condition else b
也可以使用 Tuple 来实现类似的效果
# test 需要返回 True 或者 False
(falseValue, trueValue)[test]
# 更安全的做法是进行强制判断
(falseValue, trueValue)[test True]
# 或者使用 bool 类型转换函数
(falseValue, trueValue)[bool()]
循环遍历
for-in 可以用来遍历数组与字典
words [cat, window, defenestrate]
for w in words:
print(w, len(w))
# 使用数组访问操作符能够迅速地生成数组的副本
for w in words[:]:
if len(w) 6:
words.insert(0, w)
# words - [defenestrate, cat, window, defenestrate]
如果我们希望使用数字序列进行遍历可以使用 Python 内置的 range 函数
a [Mary, had, a, little, lamb]
for i in range(len(a)):
print(i, a[i])
基本数据类型
可以使用内建函数进行强制类型转换Casting:
int(str)
float(str)
str(int)
str(float)
Number: 数值类型
x 3
print type(x) # Prints
print x # Prints 3
print x 1 # Addition; prints 4
print x - 1 # Subtraction; prints 2
print x * 2 # Multiplication; prints 6
print x ** 2 # Exponentiation; prints 9
x 1
print x # Prints 4
x * 2
print x # Prints 8
y 2.5
print type(y) # Prints
print y, y 1, y * 2, y ** 2 # Prints 2.5 3.5 5.0 6.25
布尔类型
Python 提供了常见的逻辑操作符不过需要注意的是 Python 中并没有使用 、|| 等而是直接使用了英文单词。
t True
f False
print type(t) # Prints
print t and f # Logical AND; prints False
print t or f # Logical OR; prints True
print not t # Logical NOT; prints False
print t ! f # Logical XOR; prints True
String: 字符串
Python 2 中支持 Ascii 码的 str() 类型独立的 unicode() 类型没有 byte 类型而 Python 3 中默认的字符串为 utf-8 类型并且包含了 byte 与 bytearray 两个字节类型
type(Guido) # string type is str in python2
#
# 使用 __future__ 中提供的模块来降级使用 Unicode
from __future__ import unicode_literals
type(Guido) # string type become unicode
#
Python 字符串支持分片、模板字符串等常见操作:
var1 Hello World!
var2 Python Programming
print var1[0]: , var1[0]
print var2[1:5]: , var2[1:5]
# var1[0]: H
# var2[1:5]: ytho
print My name is %s and weight is %d kg! % (Zara, 21)
# My name is Zara and weight is 21 kg!
str[0:4]
len(str)
string.replace(-, )
,.join(list)
hi {0}.format(j)
str.find(,)
str.index(,) # same, but raises IndexError
str.count(,)
str.split(,)
str.lower()
str.upper()
str.title()
str.lstrip()
str.rstrip()
str.strip()
str.islower()
# 移除所有的特殊字符
re.sub([^A-Za-z0-9], , mystring)
如果需要判断是否包含某个子字符串或者搜索某个字符串的下标:
# in 操作符可以判断字符串
if blah not in somestring:
continue
# find 可以搜索下标
s This be a string
if s.find(is) -1:
print No is here!
else:
print Found is in the string.
Regex: 正则表达式
import re
# 判断是否匹配
re.match(r^[aeiou], str)
# 以第二个参数指定的字符替换原字符串中内容
re.sub(r^[aeiou], ?, str)
re.sub(r(xyz), r\1, str)
# 编译生成独立的正则表达式对象
expr re.compile(r^...$)
expr.match(...)
expr.sub(...)
下面列举了常见的表达式使用场景:
# 检测是否为 HTML 标签
re.search([^/][^]*, )
# 常见的用户名密码
re.match(^[a-zA-Z0-9-_]{3,16}$, Foo) is not None
re.match(^\w|[-_]{3,16}$, Foo) is not None
# Email
re.match(^([a-z0-9_\.-])([\da-z\.-])\.([a-z\.]{2,6})$, hello.worldexample.com)
# Url
exp re.compile(r^(https?:\/\/)? # match http or https
([\da-z\.-]) # match domain
\.([a-z\.]{2,6}) # match domain
([\/\w \.-]*)\/?$ # match api or file
, re.X)
exp.match(www.google.com)
# IP 地址
exp re.compile(r^(?:(?:25[0-5]
|2[0-4][0-9]
|[1]?[0-9][0-9]?)\.){3}
(?:25[0-5]
|2[0-4][0-9]
|[1]?[0-9][0-9]?)$, re.X)
exp.match(192.168.1.1)
集合类型
List: 列表
Operation: 创建增删
list 是基础的序列类型
l []
l list()
# 使用字符串的 split 方法可以将字符串转化为列表
str.split(.)
# 如果需要将数组拼装为字符串则可以使用 join
list1 [1, 2, 3]
str1 .join(list1)
# 如果是数值数组则需要先进行转换
list1 [1, 2, 3]
str1 .join(str(e) for e in list1)
可以使用 append 与 extend 向数组中插入元素或者进行数组连接
x [1, 2, 3]
x.append([4, 5]) # [1, 2, 3, [4, 5]]
x.extend([4, 5]) # [1, 2, 3, 4, 5]注意 extend 返回值为 None
可以使用 pop、slices、del、remove 等移除列表中元素
myList [10,20,30,40,50]
# 弹出第二个元素
myList.pop(1) # 20
# myList: myList.pop(1)
# 如果不加任何参数则默认弹出最后一个元素
myList.pop()
# 使用 slices 来删除某个元素
a [ 1, 2, 3, 4, 5, 6 ]
index 3 # Only Positive index
a a[:index] a[index1 :]
# 根据下标删除元素
myList [10,20,30,40,50]
rmovIndxNo 3
del myList[rmovIndxNo] # myList: [10, 20, 30, 50]
# 使用 remove 方法直接根据元素删除
letters [a, b, c, d, e]
numbers.remove(numbers[1])
print(*letters) # used a * to make it unpack you dont have to
Iteration: 索引遍历
你可以使用基本的 for 循环来遍历数组中的元素就像下面介个样纸:
animals [cat, dog, monkey]
for animal in animals:
print animal
# Prints cat, dog, monkey, each on its own line.
如果你在循环的同时也希望能够获取到当前元素下标可以使用 enumerate 函数:
animals [cat, dog, monkey]
for idx, animal in enumerate(animals):
print #%d: %s % (idx 1, animal)
# Prints #1: cat, #2: dog, #3: monkey, each on its own line
Python 也支持切片Slices:
nums range(5) # range is a built-in function that creates a list of integers
print nums # Prints [0, 1, 2, 3, 4]
print nums[2:4] # Get a slice from index 2 to 4 (exclusive); prints [2, 3]
print nums[2:] # Get a slice from index 2 to the end; prints [2, 3, 4]
print nums[:2] # Get a slice from the start to index 2 (exclusive); prints [0, 1]
print nums[:] # Get a slice of the whole list; prints [0, 1, 2, 3, 4]
print nums[:-1] # Slice indices can be negative; prints [0, 1, 2, 3]
nums[2:4] [8, 9] # Assign a new sublist to a slice
print nums # Prints [0, 1, 8, 9, 4]
Comprehensions: 变换
Python 中同样可以使用 map、reduce、filtermap 用于变换数组:
# 使用 map 对数组中的每个元素计算平方
items [1, 2, 3, 4, 5]
squared list(map(lambda x: x**2, items))
# map 支持函数以数组方式连接使用
def multiply(x):
return (x*x)
def add(x):
return (xx)
funcs [multiply, add]
for i in range(5):
value list(map(lambda x: x(i), funcs))
print(value)
reduce 用于进行归纳计算:
# reduce 将数组中的值进行归纳
from functools import reduce
product reduce((lambda x, y: x * y), [1, 2, 3, 4])
# Output: 24
filter 则可以对数组进行过滤:
number_list range(-5, 5)
less_than_zero list(filter(lambda x: x 0, number_list))
print(less_than_zero)
# Output: [-5, -4, -3, -2, -1]
字典类型
创建增删
d {cat: cute, dog: furry} # 创建新的字典
print d[cat] # 字典不支持点Dot运算符取值
如果需要合并两个或者多个字典类型
# python 3.5
z {**x, **y}
# python 2.7
def merge_dicts(*dict_args):Given any number of dicts, shallow copy and merge into a new dict,
precedence goes to key value pairs in latter dicts.result {}
for dictionary in dict_args:
result.update(dictionary)
return result
索引遍历
可以根据键来直接进行元素访问:
# Python 中对于访问不存在的键会抛出 KeyError 异常需要先行判断或者使用 get
print cat in d # Check if a dictionary has a given key; prints True
# 如果直接使用 [] 来取值需要先确定键的存在否则会抛出异常
print d[monkey] # KeyError: monkey not a key of d
# 使用 get 函数则可以设置默认值
print d.get(monkey, N/A) # Get an element with a default; prints N/A
print d.get(fish, N/A) # Get an element with a default; prints wet
d.keys() # 使用 keys 方法可以获取所有的键
可以使用 for-in 来遍历数组:
# 遍历键
for key in d:
# 比前一种方式慢
for k in dict.keys(): ...
# 直接遍历值
for value in dict.itervalues(): ...
# Python 2.x 中遍历键值
for key, value in d.iteritems():
# Python 3.x 中遍历键值
for key, value in d.items():
其他序列类型
集合
# Same as {a, b,c}
normal_set set([a, b,c])
# Adding an element to normal set is fine
normal_set.add(d)
print(Normal Set)
print(normal_set)
# A frozen set
frozen_set frozenset([e, f, g])
print(Frozen Set)
print(frozen_set)
# Uncommenting below line would cause error as
# we are trying to add element to a frozen set
# frozen_set.add(h)
函数
函数定义
Python 中的函数使用 def 关键字进行定义譬如:
def sign(x):
if x 0:
return positive
elif x 0:
return negative
else:
return zero
for x in [-1, 0, 1]:
print sign(x)
# Prints negative, zero, positive
Python 支持运行时创建动态函数也即是所谓的 lambda 函数
def f(x): return x**2
# 等价于
g lambda x: x**2
参数
Option Arguments: 不定参数
def example(a, bNone, *args, **kwargs):
print a, b
print args
print kwargs
example(1, var, 2, 3, wordhello)
# 1 var
# (2, 3)
# {word: hello}
a_tuple (1, 2, 3, 4, 5)
a_dict {1:1, 2:2, 3:3}
example(1, var, *a_tuple, **a_dict)
# 1 var
# (1, 2, 3, 4, 5)
# {1: 1, 2: 2, 3: 3}
生成器
def simple_generator_function():
yield 1
yield 2
yield 3
for value in simple_generator_function():
print(value)
# 输出结果
# 1
# 2
# 3
our_generator simple_generator_function()
next(our_generator)
# 1
next(our_generator)
# 2
next(our_generator)
#3
# 生成器典型的使用场景譬如无限数组的迭代
def get_primes(number):
while True:
if is_prime(number):
yield number
number 1
装饰器
装饰器是非常有用的设计模式:
# 简单装饰器
from functools import wraps
def decorator(func):
wraps(func)
def wrapper(*args, **kwargs):
print(wrap function)
return func(*args, **kwargs)
return wrapper
decorator
def example(*a, **kw):
pass
example.__name__ # attr of function preserve
# example
# Decorator
# 带输入值的装饰器
from functools import wraps
def decorator_with_argument(val):
def decorator(func):
wraps(func)
def wrapper(*args, **kwargs):
print Val is {0}.format(val)
return func(*args, **kwargs)
return wrapper
return decorator
decorator_with_argument(10)
def example():
print This is example function.
example()
# Val is 10
# This is example function.
# 等价于
def example():
print This is example function.
example decorator_with_argument(10)(example)
example()
# Val is 10
# This is example function.
类与对象
类定义
Python 中对于类的定义也很直接:
class Greeter(object):
# Constructor
def __init__(self, name):
self.name name # Create an instance variable
# Instance method
def greet(self, loudFalse):
if loud:
print HELLO, %s! % self.name.upper()
else:
print Hello, %s % self.name
g Greeter(Fred) # Construct an instance of the Greeter class
g.greet() # Call an instance method; prints Hello, Fred
g.greet(loudTrue) # Call an instance method; prints HELLO, FRED!
# isinstance 方法用于判断某个对象是否源自某个类
ex 10
isinstance(ex,int)
Managed Attributes: 受控属性
# property、setter、deleter 可以用于复写点方法
class Example(object):
def __init__(self, value):
self._val value
property
def val(self):
return self._val
val.setter
def val(self, value):
if not isintance(value, int):
raise TypeError(Expected int)
self._val value
val.deleter
def val(self):
del self._val
property
def square3(self):
return 2**3
ex Example(123)
ex.val str
# Traceback (most recent call last):
# File , line 1, in
# File test.py, line 12, in val
# raise TypeError(Expected int)
# TypeError: Expected int
类方法与静态方法
class example(object):
classmethod
def clsmethod(cls):
print I am classmethod
staticmethod
def stmethod():
print I am staticmethod
def instmethod(self):
print I am instancemethod
ex example()
ex.clsmethod()
# I am classmethod
ex.stmethod()
# I am staticmethod
ex.instmethod()
# I am instancemethod
example.clsmethod()
# I am classmethod
example.stmethod()
# I am staticmethod
example.instmethod()
# Traceback (most recent call last):
# File , line 1, in
# TypeError: unbound method instmethod() ...
对象
实例化
属性操作
Python 中对象的属性不同于字典键可以使用点运算符取值直接使用 in 判断会存在问题:
class A(object):
property
def prop(self):
return 3
a A()
print prop in a.__dict__ , prop in a.__dict__
print hasattr(a, prop) , hasattr(a, prop)
print a.prop , a.prop
# prop in a.__dict__ False
# hasattr(a, prop) True
# a.prop 3
建议使用 hasattr、getattr、setattr 这种方式对于对象属性进行操作:
class Example(object):
def __init__(self):
self.name ex
def printex(self):
print This is an example
# Check object has attributes
# hasattr(obj, attr)
ex Example()
hasattr(ex,name)
# True
hasattr(ex,printex)
# True
hasattr(ex,print)
# False
# Get object attribute
# getattr(obj, attr)
getattr(ex,name)
# ex
# Set object attribute
# setattr(obj, attr, value)
setattr(ex,name,example)
ex.name
# example
异常与测试
异常处理
Context Manager - with
with 常用于打开或者关闭某些资源:
host localhost
port 5566
with Socket(host, port) as s:
while True:
conn, addr s.accept()
msg conn.recv(1024)
print msg
conn.send(msg)
conn.close()
单元测试
from __future__ import print_function
import unittest
def fib(n):
return 1 if n2 else fib(n-1)fib(n-2)
def setUpModule():
print(setup module)
def tearDownModule():
print(teardown module)
class TestFib(unittest.TestCase):
def setUp(self):
print(setUp)
self.n 10
def tearDown(self):
print(tearDown)
del self.n
classmethod
def setUpClass(cls):
print(setUpClass)
classmethod
def tearDownClass(cls):
print(tearDownClass)
def test_fib_assert_equal(self):
self.assertEqual(fib(self.n), 55)
def test_fib_assert_true(self):
self.assertTrue(fib(self.n) 55)
if __name__ __main__:
unittest.main()
存储
文件读写
路径处理
Python 内置的 __file__ 关键字会指向当前文件的相对路径可以根据它来构造绝对路径或者索引其他文件:
# 获取当前文件的相对目录
dir os.path.dirname(__file__) # src\app
## once youre at the directory level you want, with the desired directory as the final path node:
dirname1 os.path.basename(dir)
dirname2 os.path.split(dir)[1] ## if you look at the documentation, this is exactly what os.path.basename does.
# 获取当前代码文件的绝对路径abspath 会自动根据相对路径与当前工作空间进行路径补全
os.path.abspath(os.path.dirname(__file__)) # D:\WorkSpace\OWS\tool\ui-tool-svn\python\src\app
# 获取当前文件的真实路径
os.path.dirname(os.path.realpath(__file__)) # D:\WorkSpace\OWS\tool\ui-tool-svn\python\src\app
# 获取当前执行路径
os.getcwd()
可以使用 listdir、walk、glob 模块来进行文件枚举与检索
# 仅列举所有的文件
from os import listdir
from os.path import isfile, join
onlyfiles [f for f in listdir(mypath) if isfile(join(mypath, f))]
# 使用 walk 递归搜索
from os import walk
f []
for (dirpath, dirnames, filenames) in walk(mypath):
f.extend(filenames)
break
# 使用 glob 进行复杂模式匹配
import glob
print(glob.glob(/home/adam/*.txt))
# [/home/adam/file1.txt, /home/adam/file2.txt, .... ]
简单文件读写
# 可以根据文件是否存在选择写入模式
mode a if os.path.exists(writepath) else w
# 使用 with 方法能够自动处理异常
with open(file.dat,mode) as f:
f.write(...)
...
# 操作完毕之后记得关闭文件
f.close()
# 读取文件内容
message f.read()
复杂格式文件
JSON
import json
# Writing JSON data
with open(data.json, w) as f:
json.dump(data, f)
# Reading data back
with open(data.json, r) as f:
data json.load(f)
XML
我们可以使用 lxml 来解析与处理 XML 文件本部分即对其常用操作进行介绍。lxml 支持从字符串或者文件中创建 Element 对象
from lxml import etree
# 可以从字符串开始构造
xml
root etree.fromstring(xml)
etree.tostring(root)
# b
# 也可以从某个文件开始构造
tree etree.parse(doc/test.xml)
# 或者指定某个 baseURL
root etree.fromstring(xml, base_urlhttp://where.it/is/from.xml)
其提供了迭代器以对所有元素进行遍历
# 遍历所有的节点
for tag in tree.iter():
if not len(tag):
print tag.keys() # 获取所有自定义属性
print (tag.tag, tag.text) # text 即文本子元素值
# 获取 XPath
for e in root.iter():
print tree.getpath(e)
lxml 支持以 XPath 查找元素不过需要注意的是XPath 查找的结果是数组并且在包含命名空间的情况下需要指定命名空间
root.xpath(//page/text/text(),ns{prefix:url})
# 可以使用 getparent 递归查找父元素
el.getparent()
lxml 提供了 insert、append 等方法进行元素操作
# append 方法默认追加到尾部
st etree.Element(state, nameNew Mexico)
co etree.Element(county, nameSocorro)
st.append(co)
# insert 方法可以指定位置
node.insert(0, newKid)
Excel
可以使用 [xlrd]() 来读取 Excel 文件使用 xlsxwriter 来写入与操作 Excel 文件。
# 读取某个 Cell 的原始值
sh.cell(rx, col).value
# 创建新的文件
workbook xlsxwriter.Workbook(outputFile)
worksheet workbook.add_worksheet()
# 设置从第 0 行开始写入
row 0
# 遍历二维数组并且将其写入到 Excel 中
for rowData in array:
for col, data in enumerate(rowData):
worksheet.write(row, col, data)
row row 1
workbook.close()
文件系统
对于高级的文件操作我们可以使用 Python 内置的 shutil
# 递归删除 appName 下面的所有的文件夹
shutil.rmtree(appName)
网络交互
Requests
Requests 是优雅而易用的 Python 网络请求库:
import requests
r requests.get(https://api.github.com/events)
r requests.get(https://api.github.com/user, auth(user, pass))
r.status_code
# 200
r.headers[content-type]
# application/json; charsetutf8
r.encoding
# utf-8
r.text
# u{type:User...
r.json()
# {uprivate_gists: 419, utotal_private_repos: 77, ...}
r requests.put(http://httpbin.org/put, data {key:value})
r requests.delete(http://httpbin.org/delete)
r requests.head(http://httpbin.org/get)
r requests.options(http://httpbin.org/get)
数据存储
MySQL
import pymysql.cursors
# Connect to the database
connection pymysql.connect(hostlocalhost,
useruser,
passwordpasswd,
dbdb,
charsetutf8mb4,
cursorclasspymysql.cursors.DictCursor)
try:
with connection.cursor() as cursor:
# Create a new record
sql INSERT INTO users (email, password) VALUES (%s, %s)
cursor.execute(sql, (webmasterpython.org, very-secret))
# connection is not autocommit by default. So you must commit to save
# your changes.
connection.commit()
with connection.cursor() as cursor:
# Read a single record
sql SELECT id, password FROM users WHERE email%s
cursor.execute(sql, (webmasterpython.org,))
result cursor.fetchone()
print(result)
finally:
connection.close()
