# python笔记 **Repository Path**: www.cbj.com/python ## Basic Information - **Project Name**: python笔记 - **Description**: python个人笔记 - **Primary Language**: Python - **License**: Apache-2.0 - **Default Branch**: master - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 0 - **Forks**: 0 - **Created**: 2022-03-18 - **Last Updated**: 2022-03-18 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README ### 简介 Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。 - **Python 是一种解释型语言：** 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。 - **Python 是交互式语言：** 这意味着，您可以在一个 Python 提示符 **>>>** 后直接执行代码。 - **Python 是面向对象语言:** 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。 - **Python 是初学者的语言：**Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。 **特点** 1. 易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。 2. 易于阅读：Python代码定义的更清晰。 3. 易于维护：Python的成功在于它的源代码是相当容易维护的。 4. 一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。 5. 互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。 6. 可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。 7. 可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。 8. 数据库：Python提供所有主要的商业数据库的接口。 9. GUI编程：Python支持GUI可以创建和移植到许多系统调用。 10. 可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。 ### 基础语法 - 编码 默认情况下，Python 3 源码文件以 **`UTF-8`** 编码，所有字符串都是 `unicode` 字符串。 也可以指定编码： `# -*- coding: cp-1252 -*-` - 标识符 - 第一个字符必须是字母表中字母或下划线 **_** 。 - 标识符的其他的部分由字母、数字和下划线组成。 - 标识符对大小写敏感。 - 保留字 ```cmd >>> import keyword >>> keyword.kwlist ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'] ``` - 注释 1. 单行注释 单行注释以 **#** 开头 `# 第一个注释` 2. 多行注释 多行注释可以用多个 **#** 号，还有 **'''** 和 **"""** ```python # 第一个注释 # 第二个注释 ''' 第三注释 第四注释 ''' """ 第五注释 第六注释 """ ``` - 行与缩进 python使用缩进来表示代码块，不需要使用大括号 **{}** ，缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。 ```python if True: print ("True") else: print ("False") ``` - 多行语句 如果语句很长，我们可以使用反斜杠(\)来实现多行语句 ```python total = item_one + \ item_two + \ item_three ``` 在 [], {}, 或 () 中的多行语句，不需要使用反斜杠(\) ```python total = ['item_one', 'item_two', 'item_three', 'item_four', 'item_five'] ``` - 空行 函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。 - Print输出 print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 **end=""**： ```python x="a" y="b" # 换行输出 print( x ) print( y ) print('---------') # 不换行输出 print( x, end=" " ) print( y, end=" " ) ``` - import与from...import 1. 将整个模块(`somemodule`)导入，格式为： **`import somemodule`** 2. 从某个模块中导入某个函数,格式为： **`from somemodule import somefunction`** 3. 从某个模块中导入多个函数,格式为： **`from somemodule import firstfunc, secondfunc, thirdfunc`** 4. 将某个模块中的全部函数导入，格式为： **`from somemodule import *`** ### 数据类型 - Number（数字） 1. 类型 int、float、`bool`、complex（复数） 2. 类型判断 type()不会认为子类是一种父类类型。`isinstance()`会认为子类是一种父类类型。 ```python >>> class A: ... pass ... >>> class B(A): ... pass ... >>> isinstance(A(), A) True >>> type(A()) == A True >>> isinstance(B(), A) True >>> type(B()) == A False ``` 3. 数值运算 ```python >>> 5 + 4 # 加法 9 >>> 4.3 - 2 # 减法 2.3 >>> 3 * 7 # 乘法 21 >>> 2 / 4 # 除法，得到一个浮点数 0.5 >>> 2 // 4 # 除法，得到一个整数 0 >>> 17 % 3 # 取余 2 >>> 2 ** 5 # 乘方 32 ``` - String（字符串） 1. 字符串截取 ```python str = 'Runoob' print (str) # 输出字符串 print (str[0:-1]) # 输出第一个到倒数第二个的所有字符 print (str[0]) # 输出字符串第一个字符 print (str[2:5]) # 输出从第三个开始到第五个的字符 print (str[2:]) # 输出从第三个开始的后的所有字符 print (str * 2) # 输出字符串两次，也可以写成 print (2 * str) print (str + "TEST") # 连接字符串 ``` 2. 转义特殊字符 ```python >>> print('Ru\noob') Ru oob >>> print(r'Ru\noob') Ru\noob >>> ``` - List（列表） 列表是写在方括号 **[ ]** 之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。 ```python list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ] tinylist = [123, 'runoob'] print (list) # 输出完整列表 print (list[0]) # 输出列表第一个元素 print (list[1:3]) # 从第二个开始输出到第三个元素 print (list[2:]) # 输出从第三个元素开始的所有元素 print (tinylist * 2) # 输出两次列表 print (list + tinylist) # 连接列表 ``` - Tuple（元组） 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 **()** 里，元素之间用逗号隔开。 ```python tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 ) tinytuple = (123, 'runoob') print (tuple) # 输出完整元组 print (tuple[0]) # 输出元组的第一个元素 print (tuple[1:3]) # 输出从第二个元素开始到第三个元素 print (tuple[2:]) # 输出从第三个元素开始的所有元素 print (tinytuple * 2) # 输出两次元组 print (tuple + tinytuple) # 连接元组 ``` - Set（集合） 集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素。可以使用大括号 **{ }** 或者 **set()** 函数创建集合。 **注意：**创建一个空集合必须用 **set()** 而不是 **{ }**，因为 **{ }** 是用来创建一个空字典。 ```python sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'} print(sites) # 输出集合，重复的元素被自动去掉 # 成员测试 if 'Runoob' in sites : print('Runoob 在集合中') else : print('Runoob 不在集合中') # set可以进行集合运算 a = set('abracadabra') b = set('alacazam') print(a) print(a - b) # a 和 b 的差集 print(a | b) # a 和 b 的并集 print(a & b) # a 和 b 的交集 print(a ^ b) # a 和 b 中不同时存在的元素 ``` - Dictionary（字典） 列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用 **{ }** 标识，它是一个无序的 **键(key) : 值(value)** 的集合。 ```python dict = {} dict['one'] = "1 - 菜鸟教程" dict[2] = "2 - 菜鸟工具" tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'} print (dict['one']) # 输出键为 'one' 的值 print (dict[2]) # 输出键为 2 的值 print (tinydict) # 输出完整的字典 print (tinydict.keys()) # 输出所有键 print (tinydict.values()) # 输出所有值 ``` - 数据类型转换 | 函数 | 描述 | | :----------------------------------------------------------- | :-------------------------------------------------- | | [int(x [,base\])](https://www.runoob.com/python3/python-func-int.html) | 将x转换为一个整数 | | [float(x)](https://www.runoob.com/python3/python-func-float.html) | 将x转换到一个浮点数 | | [complex(real [,imag\])](https://www.runoob.com/python3/python-func-complex.html) | 创建一个复数 | | [str(x)](https://www.runoob.com/python3/python-func-str.html) | 将对象 x 转换为字符串 | | [repr(x)](https://www.runoob.com/python3/python-func-repr.html) | 将对象 x 转换为表达式字符串 | | [eval(str)](https://www.runoob.com/python3/python-func-eval.html) | 用来计算在字符串中的有效Python表达式,并返回一个对象 | | [tuple(s)](https://www.runoob.com/python3/python3-func-tuple.html) | 将序列 s 转换为一个元组 | | [list(s)](https://www.runoob.com/python3/python3-att-list-list.html) | 将序列 s 转换为一个列表 | | [set(s)](https://www.runoob.com/python3/python-func-set.html) | 转换为可变集合 | | [dict(d)](https://www.runoob.com/python3/python-func-dict.html) | 创建一个字典。d 必须是一个 (key, value)元组序列。 | | [frozenset(s)](https://www.runoob.com/python3/python-func-frozenset.html) | 转换为不可变集合 | | [chr(x)](https://www.runoob.com/python3/python-func-chr.html) | 将一个整数转换为一个字符 | | [ord(x)](https://www.runoob.com/python3/python-func-ord.html) | 将一个字符转换为它的整数值 | | [hex(x)](https://www.runoob.com/python3/python-func-hex.html) | 将一个整数转换为一个十六进制字符串 | | [oct(x)](https://www.runoob.com/python3/python-func-oct.html) | 将一个整数转换为一个八进制字符串 | - 运算符 1. 算术运算符 | 运算符 | 描述 | 实例 | | :----- | :---------------------------------------------- | :------------------------ | | + | 加 - 两个对象相加 | a + b 输出结果 31 | | - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -11 | | * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 210 | | / | 除 - x 除以 y | b / a 输出结果 2.1 | | % | 取模 - 返回除法的余数 | b % a 输出结果 1 | | ** | 幂 - 返回x的y次幂 | a**b 为10的21次方 | | // | 取整除 - 向下取接近商的整数 | `>>> 9//2 4 >>> -9//2 -5` | 2. 关系运算符 以下假设变量a为10，变量b为20： | 运算符 | 描述 | 实例 | | :----- | :----------------------------------------------------------- | :-------------------- | | == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 | | != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 True。 | | > | 大于 - 返回x是否大于y | (a > b) 返回 False。 | | < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 | (a < b) 返回 True。 | | >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 | | <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 True。 | 3. 赋值运算符 假设变量a为10，变量b为20： | 运算符 | 描述 | 实例 | | :----- | :----------------------------------------------------------- | :----------------------------------------------------------- | | = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c | | += | 加法赋值运算符 | c += a 等效于 c = c + a | | -= | 减法赋值运算符 | c -= a 等效于 c = c - a | | *= | 乘法赋值运算符 | c *= a 等效于 c = c * a | | /= | 除法赋值运算符 | c /= a 等效于 c = c / a | | %= | 取模赋值运算符 | c %= a 等效于 c = c % a | | **= | 幂赋值运算符 | c **= a 等效于 c = c ** a | | //= | 取整除赋值运算符 | c //= a 等效于 c = c // a | | := | 海象运算符，可在表达式内部为变量赋值。**Python3.8 版本新增运算符**。 | 在这个示例中，赋值表达式可以避免调用 len() 两次:`if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")` | 4. 逻辑运算符 假设变量 a 为 10, b为 20: | 运算符 | 逻辑表达式 | 描述 | 实例 | | :----- | :--------- | :----------------------------------------------------------- | :---------------------- | | and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 | (a and b) 返回 20。 | | or | x or y | 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 | (a or b) 返回 10。 | | not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False | 5. 位运算符 变量 a 为 60，b 为 13 | 运算符 | 描述 | 实例 | | :----- | :----------------------------------------------------------- | :----------------------------------------------------------- | | & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 | | \| | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a \| b) 输出结果 61 ，二进制解释： 0011 1101 | | ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 | | ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。**~x** 类似于 **-x-1** | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 | | << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 | | >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 | 6. 成员运算符 | 运算符 | 描述 | 实例 | | :----- | :------------------------------------------------------ | :------------------------------------------------ | | in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 | | not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 | 7. 身份运算符 身份运算符用于比较两个对象的存储单元 | 运算符 | 描述 | 实例 | | :----- | :------------------------------------------ | :----------------------------------------------------------- | | is | is 是判断两个标识符是不是引用自一个对象 | **x is y**, 类似 **id(x) == id(y)** , 如果引用的是同一个对象则返回 True，否则返回 False | | is not | is not 是判断两个标识符是不是引用自不同对象 | **x is not y** ， 类似 **id(a) != id(b)**。如果引用的不是同一个对象则返回结果 True，否则返回 False。 | 8. 运算符优先级 从最高到最低优先级的所有运算符： | 运算符 | 描述 | | :----------------------- | :----------------------------------------------------- | | ** | 指数 (最高优先级) | | ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) | | * / % // | 乘，除，求余数和取整除 | | + - | 加法减法 | | >> << | 右移，左移运算符 | | & | 位 'AND' | | ^ \| | 位运算符 | | <= < > >= | 比较运算符 | | == != | 等于运算符 | | = %= /= //= -= += *= **= | 赋值运算符 | | is is not | 身份运算符 | | in not in | 成员运算符 | | not and or | 逻辑运算符 | ### 条件控制 - if语句 ```python if condition_1: statement_block_1 elif condition_2: statement_block_2 else: statement_block_3 ``` - if嵌套 ```python if 表达式1: 语句 if 表达式2: 语句 elif 表达式3: 语句 else: 语句 elif 表达式4: 语句 else: 语句 ``` ### 循环语句 - while循环 ```python while 判断条件(condition)： 执行语句(statements)…… ``` - 无限循环 ```python var = 1 while var == 1 : # 表达式永远为 true num = int(input("输入一个数字 :")) print ("你输入的数字是: ", num) print ("Good bye!") ``` - while循环使用else语句 ```python while : else: ``` - 简单语句 ```python flag = 1 while (flag): print ('欢迎访问菜鸟教程!') ``` - for语句 ```python languages = ["C", "C++", "Perl", "Python"] for x in languages: print (x) ``` - range()函数 遍历数字序列，可以使用内置range()函数。它会生成数列 ```python for i in range(5): print(i) 0 1 2 3 4 ``` - break和continue语句 1. **break** 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。 2. **continue** 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。 - pass语句 pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句 ```python while True: ... pass # 等待键盘中断 (Ctrl+C) ``` ### 迭代器与生成器 - 迭代器 迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。迭代器有两个基本的方法：**iter()** 和 **next()**。字符串，列表或元组对象都可用于创建迭代器。 ```python list=[1,2,3,4] it = iter(list) # 创建迭代器对象 print (next(it)) # 输出迭代器的下一个元素 # 1 print (next(it)) # 2 list=[1,2,3,4] it = iter(list) # 创建迭代器对象 while True: try: print (next(it)) except StopIteration: sys.exit() ``` - 生成器 用了 yield 的函数被称为生成器（generator）。跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。调用一个生成器函数，返回的是一个迭代器对象。 ```python import sys def fibonacci(n): # 生成器函数 - 斐波那契 a, b, counter = 0, 1, 0 while True: if (counter > n): return yield a a, b = b, a + b counter += 1 f = fibonacci(10) # f 是一个迭代器，由生成器返回生成 while True: try: print (next(f), end=" ") except StopIteration: sys.exit() # 0 1 1 2 3 5 8 13 21 34 55 ``` ### 函数 > 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。 - 创建函数 ```python def my_function(): print("Hello from a function") ``` - 调用函数 如需调用函数，请使用函数名称后跟括号： ```python def my_function(): print("Hello from a function") my_function() ``` - 参数值 1. 普通参数 ```python def my_function(fname): print(fname + " Gates") my_function("Rory John") ``` 2. 默认参数 ```python def my_function(country = "China"): print("I am from " + country) ``` 3. 关键字参数 使用 key = value 语法发送参数，参数的顺序无关紧要。 ```python def my_function(child3, child2, child1): print("The youngest child is " + child3) my_function(child1 = "Phoebe", child2 = "Jennifer", child3 = "Rory") ``` 4. 任意参数 如果参数数目未知，请在参数名称前添加 *： ```python def my_function(*kids): print("The youngest child is " + kids[2]) my_function("Phoebe", "Jennifer", "Rory") ``` 5. pass语句 函数定义不能为空，但是如果您出于某种原因写了无内容的函数定义，请使用 pass 语句来避免错误。 ```python def myfunction: pass ``` 6. List传参 函数的参数可以是任何数据类型（字符串、数字、列表、字典等），并且在函数内其将被视为相同数据类型。 ```python def my_function(food): for x in food: print(x) fruits = ["apple", "banana", "cherry"] my_function(fruits) ``` - 返回值 如需使函数返回值，请使用 return 语句： ```python def my_function(x): return 5 * x print(my_function(3)) ``` - 递归 Python 也接受函数递归，这意味着定义的函数能够调用自身。 ```python def tri_recursion(k): if(k>0): result = k+tri_recursion(k-1) print(result) else: result = 0 return result print("\n\nRecursion Example Results") tri_recursion(6) ``` ### Lambda >lambda 函数是一种小的匿名函数。lambda 函数可接受任意数量的参数，但只能有一个表达式。 - 语法 `lambda arguments : expression` - 实例 1. 一个 lambda 函数，它把作为参数传入的数字加 10，然后打印结果： ```python x = lambda a : a + 10 print(x(5)) ``` 2. 一个 lambda 函数，它把参数 a 与参数 b 相乘并打印结果： ```python x = lambda a, b : a * b print(x(5, 6)) ``` 3. 一个 lambda 函数，它把参数 a、b 和 c 相加并打印结果： ```python x = lambda a, b, c : a + b + c print(x(5, 6, 2)) ``` - 使用Lambda函数 把 lambda 用作另一个函数内的匿名函数时，会更好地展现 lambda 的强大能力。 创建一个总是使所发送数字加倍的函数： ```python def myfunc(n): return lambda a : a * n mydoubler = myfunc(2) print(mydoubler(11)) ``` 同一程序中使用相同的函数定义来生成两个函数： ```python def myfunc(n): return lambda a : a * n mydoubler = myfunc(2) mytripler = myfunc(3) print(mydoubler(11)) print(mytripler(11)) ``` ### 类/对象 - 创建类 创建类，请使用 class 关键字： ```python class MyClass: x = 5 ``` - 创建对象 使用名为 `myClass` 的类来创建对象： ```python p1 = MyClass() print(p1.x) ``` - `__init__()`函数 所有类都有一个名为` __init__() `的函数，它始终在启动类时执行。 ```python class Person: def __init__(self, name, age): self.name = name self.age = age p1 = Person("Bill", 63) print(p1.name) print(p1.age) ``` - 对象方法 对象也可以包含方法。对象中的方法是属于该对象的函数。 ```python class Person: def __init__(self, name, age): self.name = name self.age = age def myfunc(self): print("Hello my name is " + self.name) p1 = Person("Bill", 63) p1.myfunc() ``` - self参数 self 参数是对类的当前实例的引用，用于访问属于该类的变量。它不必被命名为 self，您可以随意调用它，但它必须是类中任意函数的*首个参数*： ```python class Person: def __init__(mysillyobject, name, age): mysillyobject.name = name mysillyobject.age = age def myfunc(abc): print("Hello my name is " + abc.name) p1 = Person("Bill", 63) p1.myfunc() ``` - 修改对象属性 `p1.age = 40` - 删除对象属性 `del p1.age` - 删除对象 `del p1` - pass语句 类定义不能为空，但是如果您处于某种原因写了无内容的类定义语句，请使用 pass 语句来避免错误。 ```python class Person: pass ``` ### 继承 - 创建父类 ```python class Person: def __init__(self, fname, lname): self.firstname = fname self.lastname = lname def printname(self): print(self.firstname, self.lastname) # 使用 Person 来创建对象，然后执行 printname 方法： x = Person("Bill", "Gates") x.printname() ``` - 创建子类 要创建从其他类继承功能的类，请在创建子类时将父类作为参数发送： ```python class Student(Person): pass # Student 类拥有与 Person 类相同的属性和方法。 ``` - 添加`__init__()`函数 子的` __init__() `函数会覆盖对父的` __init__() `函数的继承。如需保持父的` __init__() `函数的继承，请添加对父的 `__init__()` 函数的调用： ```python class Student(Person): def __init__(self, fname, lname): Person.__init__(self, fname, lname) ``` - 使用super()函数 super() 函数，它会使子类从其父继承所有方法和属性： ```python class Student(Person): def __init__(self, fname, lname): super().__init__(fname, lname) ``` - 添加属性 把名为 graduationyear 的属性添加到 Student 类： ```python class Student(Person): def __init__(self, fname, lname): super().__init__(fname, lname) self.graduationyear = 2019 ``` - 添加方法 把名为 welcome 的方法添加到 Student 类： ```python class Student(Person): def __init__(self, fname, lname, year): super().__init__(fname, lname) self.graduationyear = year def welcome(self): print("Welcome", self.firstname, self.lastname, "to the class of", self.graduationyear) ``` ### 模块 > 模块是包含一组函数的文件，希望在应用程序中引用。 - 创建模块 如需创建模块，只需将所需代码保存在文件扩展名为 .py 的文件中： 在名为 `mymodule.py` 的文件中保存代码： ```python def greeting(name): print("Hello, " + name) ``` - 使用模块 导入名为 `mymodule` 的模块，并调用 greeting 函数： ```python import mymodule mymodule.greeting("Bill") ``` - 模块中的变量 1. 在文件 `mymodule.py` 中保存代码： ```python person1 = { "name": "Bill", "age": 63, "country": "USA" } ``` 2. 导入名为` mymodule` 的模块，并访问 `person1` 字典： ```python import mymodule a = mymodule.person1["age"] print(a) ``` - 为模块命名 您可以随意对模块文件命名，但是文件扩展名必须是 .py。 - 重命名模块 您可以在导入模块时使用 as 关键字创建别名： `import mymodule as mx` - 内建模块 ```python import platform x = platform.system() print(x) ``` - 使用`dir()`函数 有一个内置函数可以列出模块中的所有函数名（或变量名）。 ```python import platform x = dir(platform) print(x) ``` - 从模块导入 名为 `mymodule` 的模块拥有一个函数和一个字典： ```python def greeting(name): print("Hello, " + name) person1 = { "name": "Bill", "age": 63, "country": "USA" } ``` 仅从模块导入 `person1` 字典： ```python from mymodule import person1 print (person1["age"]) ``` ### 日期 - 当前日期 ```python import datetime x = datetime.datetime.now() print(x) ``` - 日期输出 `2019-08-14 12:52:55.817273` - 日期对象 ```python import datetime x = datetime.datetime(2020, 5, 17) print(x) ``` - `strftime()`方法 把日期对象格式化为可读字符串的方法。 ```python import datetime x = datetime.datetime(2019, 10, 1) print(x.strftime("%B")) ``` - 格式代码 | 指令 | 描述 | 实例 | | :--- | :------------------------------ | :----------------------- | | %a | Weekday，短版本 | Wed | | %A | Weekday，完整版本 | Wednesday | | %w | Weekday，数字 0-6，0 为周日 | 3 | | %d | 日，数字 01-31 | 31 | | %b | 月名称，短版本 | Dec | | %B | 月名称，完整版本 | December | | %m | 月，数字01-12 | 12 | | %y | 年，短版本，无世纪 | 18 | | %Y | 年，完整版本 | 2018 | | %H | 小时，00-23 | 17 | | %I | 小时，00-12 | 05 | | %p | AM/PM | PM | | %M | 分，00-59 | 41 | | %S | 秒，00-59 | 08 | | %f | 微妙，000000-999999 | 548513 | | %z | UTC 偏移 | +0100 | | %Z | 时区 | CST | | %j | 天数，001-366 | 365 | | %U | 周数，每周的第一天是周日，00-53 | 52 | | %W | 周数，每周的第一天是周一，00-53 | 52 | | %c | 日期和时间的本地版本 | Mon Dec 31 17:41:00 2018 | | %x | 日期的本地版本 | 12/31/18 | | %X | 时间的本地版本 | 17:41:00 | | %% | A % character | % | ### JSON - 把`JSON`转换为`python` ```python import json # 一些 JSON: x = '{ "name":"Bill", "age":63, "city":"Seatle"}' # 解析 x: y = json.loads(x) # 结果是 Python 字典： print(y["age"]) ``` - 把`python`转换为`JSON` ```python import json # Python 对象（字典）： x = { "name": "Bill", "age": 63, "city": "Seatle" } # 转换为 JSON： y = json.dumps(x) # 结果是 JSON 字符串： print(y) ``` 可以把以下类型的 Python 对象转换为 `JSON `字符串： dict、list、tuple、string、int、float、True、False、None ```python import json print(json.dumps({"name": "Bill", "age": 63})) print(json.dumps(["apple", "bananas"])) print(json.dumps(("apple", "bananas"))) print(json.dumps("hello")) print(json.dumps(42)) print(json.dumps(31.76)) print(json.dumps(True)) print(json.dumps(False)) print(json.dumps(None)) ``` 当 Python 转换为 JSON 时，Python 对象会被转换为 JSON（JavaScript）等效项： | Python | JSON | | ------ | ------ | | dict | Object | | list | Array | | tuple | Array | | str | String | | int | Number | | float | Number | | True | true | | False | false | | None | null | - 格式化结果 使用 indent 参数定义缩进数： `json.dumps(x, indent=4)` 使用 separators 参数来更改默认分隔符： `json.dumps(x, indent=4, separators=(". ", " = "))` - 对结果排序 `json.dumps()` 方法提供了对结果中的键进行排序的参数： 使用 sort_keys 参数来指定是否应对结果进行排序： `json.dumps(x, indent=4, sort_keys=True)` ### RegEx - 函数 re 模块提供了一组函数，允许我们检索字符串以进行匹配： | 函数 | 描述 | | :------ | :------------------------------------------------ | | findall | 返回包含所有匹配项的列表 | | search | 如果字符串中的任意位置存在匹配，则返回 Match 对象 | | split | 返回在每次匹配时拆分字符串的列表 | | sub | 用字符串替换一个或多个匹配项 | - 元字符 元字符是具有特殊含义的字符： | | | | | :--- | :----------------------------------- | :------------- | | 字符 | 描述 | 示例 | | | [] | 一组字符 | "[a-m]" | | | \ | 示意特殊序列（也可用于转义特殊字符） | "\d" | | | . | 任何字符（换行符除外） | "he..o" | | | ^ | 起始于 | "^hello" | | | $ | 结束于 | "world$" | | | * | 零次或多次出现 | "aix*" | | | + | 一次或多次出现 | "aix+" | | | {} | 确切地指定的出现次数 | "al{2}" | | | \| | 两者任一 | "falls\|stays" | | | () | 捕获和分组 | | | - 特殊序列 特殊序列指的是 \ 后跟下表中的某个字符，拥有特殊含义： | 字符 | 描述 | 示例 | | :--- | :----------------------------------------------------------- | :---------------- | | \A | 如果指定的字符位于字符串的开头，则返回匹配项 | "\AThe" | | | \b | 返回指定字符位于单词的开头或末尾的匹配项 | r"\bain" r"ain\b" | | | \B | 返回指定字符存在的匹配项，但不在单词的开头（或结尾处） | r"\Bain" r"ain\B" | | | \d | 返回字符串包含数字的匹配项（数字 0-9） | "\d" | | | \D | 返回字符串不包含数字的匹配项 | "\D" | | | \s | 返回字符串包含空白字符的匹配项 | "\s" | | | \S | 返回字符串不包含空白字符的匹配项 | "\S" | | | \w | 返回一个匹配项，其中字符串包含任何单词字符 （从 a 到 Z 的字符，从 0 到 9 的数字和下划线 _ 字符） | "\w" | | | \W | 返回一个匹配项，其中字符串不包含任何单词字符 | "\W" | | | \Z | 如果指定的字符位于字符串的末尾，则返回匹配项 | "Spain\Z" | | - 集合 集合（Set）是一对方括号 [] 内的一组字符，具有特殊含义： | 集合 | 描述 | | :----------- | :----------------------------------------------------------- | | [arn] | 返回一个匹配项，其中存在指定字符（a，r 或 n）之一 | | [a-n] | 返回字母顺序 a 和 n 之间的任意小写字符匹配项 | | [^arn] | 返回除 a、r 和 n 之外的任意字符的匹配项 | | [0123] | 返回存在任何指定数字（0、1、2 或 3）的匹配项 | | [0-9] | 返回 0 与 9 之间任意数字的匹配 | | `[0-5][0-9]` | 返回介于 0 到 9 之间的任何数字的匹配项 | | [a-zA-Z] | 返回字母顺序 a 和 z 之间的任何字符的匹配，小写或大写 | | [+] | 在集合中，+、*、.、\|、()、$、{} 没有特殊含义，因此 [+] 表示：返回字符串中任何 + 字符的匹配项 | - `findall()` 函数 `findall()` 函数返回包含所有匹配项的列表。 ```python import re str = "China is a great country" x = re.findall("a", str) print(x) ``` 如果未找到匹配，则返回空列表。 - `search()`函数 search() 函数搜索字符串中的匹配项，如果存在匹配则返回 Match 对象。如果有多个匹配，则仅返回首个匹配项： ```python import re str = "China is a great country" x = re.search("\s", str) print("The first white-space character is located in position:", x.start()) ``` 如果未找到匹配，则返回值 None。 - `split()`函数 split() 函数返回一个列表，其中字符串在每次匹配时被拆分： ```python import re str = "China is a great country" x = re.split("\s", str) print(x) ``` 可以通过指定 `maxsplit `参数来控制出现次数： ```python import re str = "China is a great country" x = re.split("\s", str, 1) print(x) ``` - `sub()`函数 sub() 函数把匹配替换为您选择的文本： ```python import re str = "China is a great country" x = re.sub("\s", "9", str) print(x) ``` 通过指定 count 参数来控制替换次数： ```python import re str = "China is a great country" x = re.sub("\s", "9", str, 2) print(x) ``` - Match对象 Match 对象是包含有关搜索和结果信息的对象。 - span() 返回的元组包含了匹配的开始和结束位置 - .string 返回传入函数的字符串 - group() 返回匹配的字符串部分 **注释：**如果没有匹配，则返回值 **None**，而不是 Match 对象。 执行会返回 Match 对象的搜索： ```python import re str = "China is a great country" x = re.search("a", str) print(x) # 将打印一个对象 ``` 打印首个匹配出现的位置（开始和结束位置）。正则表达式查找以大写 "C" 开头的任何单词： ```python import re str = "China is a great country" x = re.search(r"\bC\w+", str) print(x.span()) ``` 打印传入函数的字符串： ```python import re str = "China is a great country" x = re.search(r"\bC\w+", str) print(x.string) ``` 打印匹配的字符串部分。正则表达式查找以大写 "C" 开头的任何单词： ```python import re str = "China is a great country" x = re.search(r"\bC\w+", str) print(x.group()) ``` 注：如果没有匹配项，则返回值 **None**，而不是 Match 对象。 ### Try Except > try 块允许您测试代码块以查找错误。 > > except 块允许您处理错误。 > > finally 块允许您执行代码，无论 try 和 except 块的结果如何。 - 异常处理 ```python try: print(x) except: print("An exception occurred") ``` - 多个异常 ```python try: print(x) except NameError: print("Variable x is not defined") except: print("Something else went wrong") ``` - Else 如果没有引发错误，那么您可以使用 else 关键字来定义要执行的代码块： ```python try: print("Hello") except: print("Something went wrong") else: print("Nothing went wrong") ``` - Finally 如果指定了 finally 块，则无论 try 块是否引发错误，都会执行 finally 块。 ```python try: print(x) except: print("Something went wrong") finally: print("The 'try except' is finished") ``` - 引发异常 作为 Python 开发者，您可以选择在条件发生时抛出异常。如需抛出（引发）异常，请使用 raise 关键词。 假如 x 小于 0，则引发异常并终止程序： ```python x = -1 if x < 0: raise Exception("Sorry, no numbers below zero") ``` 如果 x 不是整数，则引发 `TypeError`： ```python x = "hello" if not type(x) is int: raise TypeError("Only integers are allowed") ``` ### 文件处理 - 文件打开 在 Python 中使用文件的关键函数是 open() 函数。open() 函数有两个参数：文件名和模式。 - 模式 1. "r" - 读取 - 默认值。打开文件进行读取，如果文件不存在则报错。 2. "a" - 追加 - 打开供追加的文件，如果不存在则创建该文件。 3. "w" - 写入 - 打开文件进行写入，如果文件不存在则创建该文件。 4. "x" - 创建 - 创建指定的文件，如果文件存在则返回错误。 - 文件类型 1. "t" - 文本 - 默认值。文本模式。 2. "b" - 二进制 - 二进制模式（例如图像）。 - 语法实例 因为 "r" (读取)和 "t" (文本)是默认值，所以不需要指定它们。 `f = open("demofile.txt")` `f = open("demofile.txt", "rt")` - 文件读取 - 在服务器上打开文件 `demofile.txt` ```python Hello! Welcome to demofile.txt This file is for testing purposes. Good Luck! ``` 实例 ```python f = open("demofile.txt", "r") print(f.read()) ``` - 只读取文件的一部分 默认情况下，read() 方法返回整个文本，但您也可以指定要返回的字符数： - 返回文件中的前五个字符： ```python f = open("demofile.txt", "r") print(f.read(5)) ``` - 使用 `readline() `方法返回一行： ```python f = open("demofile.txt", "r") print(f.readline()) ``` - 通过两次调用` readline()`，您可以读取前两行： ```python f = open("demofile.txt", "r") print(f.readline()) print(f.readline()) ``` - 通过循环遍历文件中的行，您可以逐行读取整个文件： ```python f = open("demofile.txt", "r") for x in f: print(x) ``` - 关闭文件 ```python f = open("demofile.txt", "r") print(f.readline()) f.close() ``` - 文件写入 - 写入已有文件 - "a" - 追加 - 会追加到文件的末尾 - "w" - 写入 - 会覆盖任何已有的内容 - 打开文件 "demofile2.txt" 并将内容追加到文件中： ```python f = open("demofile2.txt", "a") f.write("Now the file has more content!") f.close() # 追加后，打开并读取该文件： f = open("demofile2.txt", "r") print(f.read()) ``` - 打开文件 "demofile3.txt" 并覆盖内容： ```python f = open("demofile3.txt", "w") f.write("Woops! I have deleted the content!") f.close() # 写入后，打开并读取该文件： f = open("demofile3.txt", "r") print(f.read()) ``` - 创建新文件 - "x" - 创建 - 将创建一个文件，如果文件存在则返回错误 - "a" - 追加 - 如果指定的文件不存在，将创建一个文件 - "w" - 写入 - 如果指定的文件不存在，将创建一个文件 - 创建名为 "myfile.txt" 的文件： `f = open("myfile.txt", "x")` - 如果不存在，则创建新文件： `f = open("myfile.txt", "w")` - 文件删除 - 删除文件 删除文件 "demofile.txt"： ```python import os os.remove("demofile.txt") ``` - 检查文件是否存在 检查文件是否存在，然后删除它： ```python import os if os.path.exists("demofile.txt"): os.remove("demofile.txt") else: print("The file does not exist") ``` - 删除文件 删除文件夹 "myfolder"： ```python import os os.rmdir("myfolder") ``` ### MySQL - Connector 1. 下载驱动 `pip install mysql-connector` 2. 测试驱动 `import mysql.connector` 3. 创建连接 ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword" ) print(mydb) ``` - Create Database 1. 创建数据库 创建名为 "mydatabase" 的数据库： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword" ) mycursor = mydb.cursor() mycursor.execute("CREATE DATABASE mydatabase") ``` 2. 检查数据库是否存在 返回系统中的数据库列表： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword" ) mycursor = mydb.cursor() mycursor.execute("SHOW DATABASES") for x in mycursor: print(x) ``` 3. 尝试连接数据库 "mydatabase"： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) ``` - Create Table 1. 创建表 创建表 "customers"： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() mycursor.execute("CREATE TABLE customers (name VARCHAR(255), address VARCHAR(255))") ``` 2. 检查表是否存在 返回系统中的数据库列表： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() mycursor.execute("SHOW TABLES") for x in mycursor: print(x) ``` 3. 主键 创建表时创建主键： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() mycursor.execute("CREATE TABLE customers (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255), address VARCHAR(255))") ``` 在已有的表上创建主键： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() mycursor.execute("ALTER TABLE customers ADD COLUMN id INT AUTO_INCREMENT PRIMARY KEY") ``` - Insert 1. 插入表 在表 "customers" 中插入记录： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "INSERT INTO customers (name, address) VALUES (%s, %s)" val = ("John", "Highway 21") mycursor.execute(sql, val) mydb.commit() print(mycursor.rowcount, "record inserted.") ``` 2. 插入多行 用数据填充 "customers" 表： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "INSERT INTO customers (name, address) VALUES (%s, %s)" val = [ ('Peter', 'Lowstreet 4'), ('Amy', 'Apple st 652'), ('Hannah', 'Mountain 21'), ('Michael', 'Valley 345'), ('Sandy', 'Ocean blvd 2'), ('Betty', 'Green Grass 1'), ('Richard', 'Sky st 331'), ('Susan', 'One way 98'), ('Vicky', 'Yellow Garden 2'), ('Ben', 'Park Lane 38'), ('William', 'Central st 954'), ('Chuck', 'Main Road 989'), ('Viola', 'Sideway 1633') ] mycursor.executemany(sql, val) mydb.commit() print(mycursor.rowcount, "was inserted.") ``` 3. 获取已插入ID 插入一行，并返回 id： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "INSERT INTO customers (name, address) VALUES (%s, %s)" val = ("Michelle", "Blue Village") mycursor.execute(sql, val) mydb.commit() print("1 record inserted, ID:", mycursor.lastrowid) ``` - Select 1. 从表中选取 从表 "customers" 中选取所有记录，并显示结果： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() mycursor.execute("SELECT * FROM customers") myresult = mycursor.fetchall() for x in myresult: print(x) ``` 2. 选取列 仅选择名称和地址列： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() mycursor.execute("SELECT name, address FROM customers") myresult = mycursor.fetchall() for x in myresult: print(x) ``` 3. 使用`fetchone()`方法 仅获取一行： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() mycursor.execute("SELECT * FROM customers") myresult = mycursor.fetchone() print(myresult) ``` - Where 1. 使用筛选器来选取 选择记录为 "Park Lane 38" 的记录，结果： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "SELECT * FROM customers WHERE address ='Park Lane 38'" mycursor.execute(sql) myresult = mycursor.fetchall() for x in myresult: print(x) ``` 2. 通配符 选择地址中包含单词 "way" 的记录： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "SELECT * FROM customers WHERE address LIKE '%way%'" mycursor.execute(sql) myresult = mycursor.fetchall() for x in myresult: print(x) ``` 3. 防止SQL注入 当用户提供查询值时，您应该转义这些值。使用占位符 ％s 方法来转义查询值： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "SELECT * FROM customers WHERE address = %s" adr = ("Yellow Garden 2", ) mycursor.execute(sql, adr) myresult = mycursor.fetchall() for x in myresult: print(x) ``` - Order By 1. 结果排序 以字符顺序对姓名进行排序，结果： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "SELECT * FROM customers ORDER BY name" mycursor.execute(sql) myresult = mycursor.fetchall() for x in myresult: print(x) ``` 2. 降序排序 使用 `DESC` 关键字按降序对结果进行排序。 按反转字母顺序对姓名的结果进行排序： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "SELECT * FROM customers ORDER BY name DESC" mycursor.execute(sql) myresult = mycursor.fetchall() for x in myresult: print(x) ``` - Delete 1. 删除记录 删除地址为 "Mountain 21" 的任何记录： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "DELETE FROM customers WHERE address = 'Mountain 21'" mycursor.execute(sql) mydb.commit() print(mycursor.rowcount, "record(s) deleted") ``` 2. 防止SQL注入 使用占位符 ％s 方法来转义值： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "DELETE FROM customers WHERE address = %s" adr = ("Yellow Garden 2", ) mycursor.execute(sql, adr) mydb.commit() print(mycursor.rowcount, "record(s) deleted") ``` - Drop Table 1. 删除表 删除 "customers" 表： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "DROP TABLE customers" mycursor.execute(sql) ``` 2. 只在表存在时删除 删除表 "customers" （如果存在）： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "DROP TABLE IF EXISTS customers" mycursor.execute(sql) ``` - Update 1. 更新表 把地址列中的 "Valley 345" 覆盖为 "Canyoun 123"： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "UPDATE customers SET address = 'Canyon 123' WHERE address = 'Valley 345'" mycursor.execute(sql) mydb.commit() print(mycursor.rowcount, "record(s) affected") ``` 2. 防止SQL注入 使用占位符 ％s 方法来转义值： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "UPDATE customers SET address = %s WHERE address = %s" val = ("Valley 345", "Canyon 123") mycursor.execute(sql, val) mydb.commit() print(mycursor.rowcount, "record(s) affected") ``` - Limit 1. 限定结果 选取 "customers" 表中的前五条记录： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() mycursor.execute("SELECT * FROM customers LIMIT 5") myresult = mycursor.fetchall() for x in myresult: print(x) ``` 2. 从另一个位置开始 从位置 3 开始返回 5 条记录： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() mycursor.execute("SELECT * FROM customers LIMIT 5 OFFSET 2") myresult = mycursor.fetchall() for x in myresult: print(x) ``` - Join 1. 组合两张或更多表 **users** ``` { id: 1, name: 'John', fav: 154}, { id: 2, name: 'Peter', fav: 154}, { id: 3, name: 'Amy', fav: 155}, { id: 4, name: 'Hannah', fav:}, { id: 5, name: 'Michael', fav:} ``` **products** ``` { id: 154, name: 'Chocolate Heaven' }, { id: 155, name: 'Tasty Lemons' }, { id: 156, name: 'Vanilla Dreams' } ``` 可以使用 users 的 fav 字段和 products 的 id 字段来组合这两个表。 **实例** 组合用户和产品，查看用户最喜欢的产品名称： ```python import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase" ) mycursor = mydb.cursor() sql = "SELECT \ users.name AS user, \ products.name AS favorite \ FROM users \ INNER JOIN products ON users.fav = products.id" mycursor.execute(sql) myresult = mycursor.fetchall() for x in myresult: print(x) ``` 2. LEFT JOIN 选择所有用户及其喜爱的产品： ```python sql = "SELECT \ users.name AS user, \ products.name AS favorite \ FROM users \ LEFT JOIN products ON users.fav = products.id" ``` 3. RIGHT JOIN 选择所有产品以及喜欢它们的用户： ```python sql = "SELECT \ users.name AS user, \ products.name AS favorite \ FROM users \ RIGHT JOIN products ON users.fav = products.id" ``` ### MongoDB - PyMongo 1. 安装PyMongo `pip install pymongo` 2. 测试PyMongo `import pymongo` - Create Database 1. 创建数据库 创建名为 "mydatabase" 的数据库： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] ``` 2. 检查数据库是否存在 返回系统中的数据库列表： `print(myclient.list_database_names())` 检查 "mydatabase" 是否存在： ```python dblist = myclient.list_database_names() if "mydatabase" in dblist: print("The database exists.") ``` - 创建集合 1. 创建集合 创建名为 "customers" 的集合： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] ``` 2. 检查集合是否存在 返回数据库中所有集合的列表： `print(mydb.list_collection_names())` 检查 "customers" 集合是否存在： ```python collist = mydb.list_collection_names() if "customers" in collist: print("The collection exists.") ``` - Insert 1. 插入集合 在 "customers" 集合中插入记录： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] mydict = { "name": "Bill", "address": "Highway 37" } x = mycol.insert_one(mydict) ``` 2. 返回_id字段 在 "customers" 集合中插入另一条记录，并返回 _id 字段的值： ```python mydict = { "name": "Peter", "address": "Lowstreet 27" } x = mycol.insert_one(mydict) print(x.inserted_id) ``` 3. 插入多个文档 insert_many() 方法的第一个参数是包含字典的列表，其中包含要插入的数据： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] mylist = [ { "name": "Amy", "address": "Apple st 652"}, { "name": "Hannah", "address": "Mountain 21"}, { "name": "Michael", "address": "Valley 345"}, { "name": "Sandy", "address": "Ocean blvd 2"}, { "name": "Betty", "address": "Green Grass 1"}, { "name": "Richard", "address": "Sky st 331"}, { "name": "Susan", "address": "One way 98"}, { "name": "Vicky", "address": "Yellow Garden 2"}, { "name": "Ben", "address": "Park Lane 38"}, { "name": "William", "address": "Central st 954"}, { "name": "Chuck", "address": "Main Road 989"}, { "name": "Viola", "address": "Sideway 1633"} ] x = mycol.insert_many(mylist) # 打印被插入文档的 _id 值列表： print(x.inserted_ids) ``` 4. 插入带有指定ID的多个文档 如果您不希望 MongoDB 为您的文档分配唯一 id，则可以在插入文档时指定 _id 字段。 请记住，值必须是唯一的。两个文件不能有相同的 _id。 ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] mylist = [ { "_id": 1, "name": "John", "address": "Highway 37"}, { "_id": 2, "name": "Peter", "address": "Lowstreet 27"}, { "_id": 3, "name": "Amy", "address": "Apple st 652"}, { "_id": 4, "name": "Hannah", "address": "Mountain 21"}, { "_id": 5, "name": "Michael", "address": "Valley 345"}, { "_id": 6, "name": "Sandy", "address": "Ocean blvd 2"}, { "_id": 7, "name": "Betty", "address": "Green Grass 1"}, { "_id": 8, "name": "Richard", "address": "Sky st 331"}, { "_id": 9, "name": "Susan", "address": "One way 98"}, { "_id": 10, "name": "Vicky", "address": "Yellow Garden 2"}, { "_id": 11, "name": "Ben", "address": "Park Lane 38"}, { "_id": 12, "name": "William", "address": "Central st 954"}, { "_id": 13, "name": "Chuck", "address": "Main Road 989"}, { "_id": 14, "name": "Viola", "address": "Sideway 1633"} ] x = mycol.insert_many(mylist) # 打印被插入文档的 _id 值列表： print(x.inserted_ids) ``` - Find 1. 查找一项 find_one() 方法返回选择中的第一个匹配项。 查找 customers 集合中的首个文档： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] x = mycol.find_one() print(x) ``` 2. 查找全部 返回 "customers" 集合中的所有文档，并打印每个文档： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] for x in mycol.find(): print(x) ``` 3. 只返回某些字段 只返回姓名和地址，而不是 _ids： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] for x in mycol.find({},{ "_id": 0, "name": 1, "address": 1 }): print(x) ``` - Query 1. 筛选结果 查找地址为 "Park Lane 38" 的文档： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] myquery = { "address": "Park Lane 38" } mydoc = mycol.find(myquery) for x in mydoc: print(x) ``` 2. 高级查询 查找地址以字母 "S" 或更高开头的文档： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] myquery = { "address": { "$gt": "S" } } mydoc = mycol.find(myquery) for x in mydoc: print(x) ``` 3. 使用正则表达式来筛选 查找地址以字母 "S" 开头的文档： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] myquery = { "address": { "$regex": "^S" } } mydoc = mycol.find(myquery) for x in mydoc: print(x) ``` - Sort 1. 结果排序 按姓名的字母顺序对结果进行排序： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] mydoc = mycol.find().sort("name") for x in mydoc: print(x) ``` 2. 降序排序 使用值 -1 作为第二个参数进行降序排序。 ```python sort("name", 1) # 升序 sort("name", -1) # 降序 ``` 按名称的逆向字母顺序对结果进行排序： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] mydoc = mycol.find().sort("name", -1) for x in mydoc: print(x) ``` - Delete 1. 删除文档 删除地址为 "Mountain 21" 的文档： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] myquery = { "address": "Mountain 21" } mycol.delete_one(myquery) ``` 2. 删除多个文档 删除地址以字母 S 开头的所有文档： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] myquery = { "address": {"$regex": "^S"} } x = mycol.delete_many(myquery) print(x.deleted_count, " documents deleted.") ``` 3. 删除集合中的所有文档 删除 "customers" 集合中的所有文档： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] x = mycol.delete_many({}) print(x.deleted_count, " documents deleted.") ``` - 删除集合 1. 如果成功删除集合，则 drop() 方法返回 true，如果集合不存在则返回 false。 2. 删除 "customers" 集合： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] mycol.drop() ``` - Update 1. 更新集合 update_one() 方法的第一个参数是 query 对象，用于定义要更新的文档。 把地址 "Valley 345" 改为 "Canyon 123"： ``` import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] myquery = { "address": "Valley 345" } newvalues = { "$set": { "address": "Canyon 123" } } mycol.update_one(myquery, newvalues) #print "customers" after the update: for x in mycol.find(): print(x) ``` 2. 更新多个 如需更新符合查询条件的所有文档，请使用 update_many() 方法。 更新地址以字母 "S" 开头的所有文档： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] myquery = { "address": { "$regex": "^S" } } newvalues = { "$set": { "name": "Minnie" } } x = mycol.update_many(myquery, newvalues) print(x.modified_count, "documents updated.") ``` - Limit 1. 限定结果 **Customers** ```python {'_id': 1, 'name': 'John', 'address': 'Highway37'} {'_id': 2, 'name': 'Peter', 'address': 'Lowstreet 27'} {'_id': 3, 'name': 'Amy', 'address': 'Apple st 652'} {'_id': 4, 'name': 'Hannah', 'address': 'Mountain 21'} {'_id': 5, 'name': 'Michael', 'address': 'Valley 345'} {'_id': 6, 'name': 'Sandy', 'address': 'Ocean blvd 2'} {'_id': 7, 'name': 'Betty', 'address': 'Green Grass 1'} {'_id': 8, 'name': 'Richard', 'address': 'Sky st 331'} {'_id': 9, 'name': 'Susan', 'address': 'One way 98'} {'_id': 10, 'name': 'Vicky', 'address': 'Yellow Garden 2'} {'_id': 11, 'name': 'Ben', 'address': 'Park Lane 38'} {'_id': 12, 'name': 'William', 'address': 'Central st 954'} {'_id': 13, 'name': 'Chuck', 'address': 'Main Road 989'} {'_id': 14, 'name': 'Viola', 'address': 'Sideway 1633'} ``` **实例** 把结果限定为只返回 5 个文档： ```python import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] myresult = mycol.find().limit(5) # 打印结果： for x in myresult: print(x) ```