Python过程型程序设计快速入门

核心数据类型：

基本数据类型：数字、字符串

数字

整形：整数、布尔数

浮点型

字符型

组合数据类型：

序列：

列表：list

元组：tuple

字符串：string

字典：

可变类型，dict

集合

set

表达式：“某事”

由一个或多个操作数，以及0个或多个以上的运行符组成，可以通过计算得到一个值，对象，方法或名称空间；

表达式的操作符：in, not， in，is，is not

< ,> , == , !=

+，-，*，/，%，**

li[i]

x.method()

x.attr

(…)

[…]

{…}

语句：做“某事”

声明变量、赋值、方法调用、循环访问集合、选择分支；

语句在程序中的执行顺序称为“控制流”，或“执行流”

if , while ,for , try

def, pass, class, return

break, continue

from, import

变量名的命名法则：

只能包含字母、数字和下划线，且不能以数字开头；

区分大小写；禁止使用保留字；

程序结构与控制流：

Python的布尔测试：

(1)任何的非零数字或非空对象都为真”true”

(2)数字零，空对象以及特殊对象None都为“False”

(3)比较和相等测试会递归的应用在数据结构；会返回“True”或“False”

(4)and 和 or，运算符会返回“真”或“假”的操作对象

选择执行

if CONDITION:

suite

if CONDITION:

suite1

else:

suite2

if CONDITION1:

suite1

elif CONDITION2:

suite2

...

else:

suiten

>>> num = 0

>>> if num:

print("Condition is True")

>>> num = 1

>>> if num:

print("Condition is True")

Condition is True

if/else的三元表达式：

expression1 if CONDITION else expression2

循环执行：

while，for

while BOOLEAN_EXPRESSION:

while_suite

while BOOLEAN_EXPRESSION:

while_suite

else:

else_suite

运行到while，即测试其后的条件；为“True”时，则执行一遍循环体，结束之后再运行BOOLEAN_EXPRESSION;

else为可选；

for expression in iterable:

for_suite

else:

else_suite

else也是可选的

控制：

continue

break

前面的都是Windows下的 Python shell

列表解析：Python迭代机制的一种应用，用于实现创建新列表；

[expression for iter_var in iterable_object]

[expression for iter_var in iterable_object if condition]

In [29]: [i ** 2 for i in li if i != 6]

Out[29]: [1, 4, 9, 16, 25, 49, 64]

Python缩进非常重要，4个空白

In [31]: m = 35

文件系统和文件

文件系统是OS用于明确磁盘或分区上的文件的方法和数据结构--即在磁盘上组织文件的方法

计算机文件（或称文件、电脑档案、档案），是存储在某种长期存储设备或临时存储设备中的一段数据流，并且归属于计算机文件系统管理之下

概括来讲

文件是计算机中由OS管理的具有名字的存储区域

在Linux系统上，文件被看做是字节序列

Python内置函数open()用于打开文件和创建文件对象

open(name[,mode[,bufsize]])

open方法可以接收三个参数：文件名、模式和缓冲区参数

open函数返回的是一个文件对象

mode：指定文件的打开模式

bufsize：定义输出缓存

0表示无输出缓存

1表示使用缓冲

负数表示使用系统默认设置

证书表示使用近似指定大小的缓冲

文件的打开模式

简单模式

r：只读

open（”/var/log/message.log”,’r’）

w:写入

a：附加

在模式后使用“+”表示同时支持输入、输出操作

如r+, w+和a+

在模式后附加”b”表示以二进制方式打开

如rb，wb++

文件的方法

Python的函数

函数的基础概念

函数是Python为了代码最大程度地重用和最小代码冗余而提供的基本程序结构

函数是一种设计工具，它能让程序员将复杂的系统分解为可管理的部件

函数用于将相关功能打包并参数化

在Python中可以创建4种函数：

全局函数：定义在模块中

局部函数：嵌套于其他函数中

lambda函数：表达式

方法：与特定数据类型关联的函数，并且只能与数据类型关联一起使用

Python提供了很多内置函数

语法

def functionName(parameters)

suite

一些相关的概念

def是一个可执行语句

因此可以出现在任何能够使用语句的地方，甚至可以嵌套于其他语句，例如if或while中

def创建一个对象并将其赋值给一个变量名（即函数名）

return用于返回结果对象，其为可选；无return语句的函数自动返回None对象

返回多个值时，彼此间使用逗号分隔，且组合为元组形式返回一个对象

def语句运行之后，可以在程序中通过函数后附加括号进行调用

函数的定义方式：

def functionName(arg1,arg2,...):

function_suite

创建函数对象，并将其赋值给一个变量名（函数名）

return ,None

变量名解析：LEGB原则

变量名引用分三个作用域进行：首先是本地、之后是函数内、接着是全局，最后是内置；

Python模块

可以将代码量较大的程序分隔成多个有组织的、彼此独立但又能互相交互的代码片段，这些自我包含的有组织的代码段就是模块

模块在物理形式上表现为以.py结尾的代码文件

一个文件被看作一个独立的模块，一个模块也可以被看作是一个文件

模块的文件名就是模块的名字加上扩展名.py

每个模块都有自己的名称空间

Python允许“导入”其它模块以实现代码重用，从而实现了将独立的代码文件组织成更大的程序系统

Python中，模块也是对象

在一个模块的顶层定义的所有变量都在被导入时成为了被导入模块的属性

Python程序架构

一个Python程序通常包括一个顶层程序文件和其他的模块文件（0个、1个或多个）

顶层文件：包含了程序的主要控制流程

模块文件: 为顶层文件或其他模块提供各种功能性组件

模块首次导入（或重载）时，Python会立即执行模块文件的顶层程序代码（不在函数内的代码），而位于函数主体内的代码直到函数被调用后才会执行

模块的执行环境

模块是被导入的，但模块也可以导入和使用其他模块，这些模块可以用Python或其他编程语言写成

模块可内含变量、函数以及类来进行其工作，而函数和类可以包含变量和其它元素

模块：

程序文件：mod_name.py

import mod_name

模块中的顶层代码会被执行；模块会引入新的名称空间；

mod_name.

导入模块

在导入模块时只能使用模块名，而不能使用带.py后缀的模块文件名

import语句

导入指定的整个模块，包括生成一个以模块名命名的名称空间

import module1[,module2[,…moduleN]]

建议一个import语句只导入一个模块

import module as module_alias

from import语句

常用于只导入指定模块的部分属性至当前名称空间

from module import name1[,name2[,…nameN]]

import工作机制

import语句导入指定的模块时会执行三个步骤

找到模块文件

在指定的路径下搜索模块文件

编译成字节码

文件导入时就会编译，因此，顶层文件的.pyc字节码文件在内部使用后会被丢弃，只有被导入的文件才会留下.pyc文件

执行模块的代码来创建其所定义的对象

模块文件中的所有语句会一次执行，从头至尾，而此步骤中任何对变量名的赋值运算，都会产生所得到的模块文件的属性

注意：模块只在第一次导入时才会执行如上步骤：

后续的导入操作只不过是提取内存中已加载的模块对象

reload()可用于重新加载模块

模块搜索

Python解释器在import模块时必须先找到对应的模块文件

程序的主目录

PYTHONPATH目录（如果设置了此变量）

标准链接库目录

任何.pth文件的内容（如果存在.pth文件）

这四个组件组合起来即为sys.path所包含的路径，而Python会选择在搜索路径中的第一个符合导入文件的文件

>>> import sys
>>> sys.path
['', '/root/.pyenv/versions/3.4.2/lib/python34.zip', '/root/.pyenv/versions/3.4.2/lib/python3.4', '/root/.pyenv/versions/3.4.2/lib/python3.4/plat-linux', '/root/.pyenv/versions/3.4.2/lib/python3.4/lib-dynload', '/root/.pyenv/versions/3.4.2/lib/python3.4/site-packages', '/root/.pyenv/versions/3.4.2/lib/python3.4/site-packages/IPython/extensions']

Python类与面向对象

面向对象编程（OOP）

面向对象的核心概念

所有编程语言的最终目的都是提供一种抽象方法

在机器模型（“解空间”或“方案空间”）与实际解决的问题模型（“问题空间”）之间，程序员必须建立一种联系

面向过程：程序 = 算法 + 数据结构

面向对象：将问题空间中的元素以及它们在解空间中的表示抽象为对象，并允许通过问题来描述问题而不是方案

可以把实例想象成一种新型变量，它保存着数据，但可以对自身的数据执行操作

类型由状态集合（数据）和转换这些状态的操作集合组成

类抽象

类：定义了被多个同一类型对象共享的结构和行为（数据和代码）

类的数据和代码：即类的成员

数据：成员变量或实例变量

成员方法：简称为方法，是操作数据的代码，用于定义如何使用成员变量；因此一个类的行为和接口是通过方法来定义的

方法和变量：

私有：内部使用

公共：外部可用

面向对象的程序设计

所有东西都是对象

程序是一大堆对象的组合

通过消息传递，各对象知道自己该做什么

消息：即调用请求，它调用的是从属于目标对象的一个方法

每个对象都有自己的存储空间，并可容纳其他对象

通过封装现有对象，可以制作成新型对象

每个对象都属于某一类型

类型，也即类

对象是类的实例

类的一个重要特性为“能发什么样的消息给它”

同一个类的所有对象都能接收相同的消息

对象接口

定义一个类后，可以根据需要实例化出多个对象

如何利用对象完成真正有用的工作？

必须有一种办法能向对象发出请求，令其做一些事情

每个对象仅能接收特定的请求

能向对象发送的请求由其“接口”进行定义

对象的“类型”或“类”则规定了它的接口形式

类间关系

依赖（“uses  a”）

一个类的方法操纵另一个类的对象

聚合（“has  a”）

类A的对象包含类B的对象

继承（“is a”）

描述特殊与一般关系

面向对象编程的原则

面向对象的模型机制有3个原则：封装、继承、多态

封装（encapsulation）

隐藏实现方案细节

将代码及其处理的数据绑定在一起的一种编程机制，用于保证程序和数据不受外部干扰且不会被误用

多态性

允许一个接口被多个通用的类动作使用的特性，具体使用哪个动作与应用场合相关

“一个接口，多个方法”

用于为一组相关的动作设计一个通用的接口，以降低程序复杂性

Python类和实例

类是一种数据结构，可用于创建实例

一般情况下，类封装了数据和可用于改数据的方法

Python类是一个可调用对象，即类对象

Python2.2之后，类是一种自定义类型，而实例则是声明某个自定义类型的变量

实例初始化

通过调用类来创建实例

instance = ClassName（args..）

类在实例化时可以使用__init__的__del__两个特殊方法

Python中创建类

类 ：

class ClassName():

class_suite

例子

class语句内，任何赋值语句都会创建类属性

一般，方法的第一个参数被命名为self，这仅仅是一个约定：对Python而言，名称self绝对没有任何特殊含义。（但是请注意：如果不遵循这个约定，对其他Python程序员而言你的代码可读性就会变差，而且有些类查看器程序也可能是遵循此约定编写的。）

每个实例对象都会继承类的属性并获得自己的名称空间

In [5]: class FirstClass:

name = "tom"

def show(self):

print(self.name)

...:

In [6]: a = FirstClass()

In [7]: a.name

Out[7]: 'tom'

In [8]: a.show()

tom

异常：

运行时错误：

try:

try_suite

except Exception1:

...

except

...

安装库

setup.py

运行 python setup.py install

Python3

help("modules") 查看当前系统安装了哪些模块

import socket

help(socket)

import socketserver

help(socketserver)

安装pip python-pip 是epel源下的rpm包

# pip3 list

decorator (4.0.9)

ipython (4.1.1)

ipython-genutils (0.1.0)

path.py (8.1.2)

pexpect (4.0.1)

pickleshare (0.6)

pip (1.5.6)

ptyprocess (0.5.1)

setuptools (20.2.2)

simplegeneric (0.8.1)

traitlets (4.1.0)

pip是一个安装和管理 Python 包的工具 ,是easy_install的替代品。

# pip3 install PyMySQL 与mysql连接相关的库

Downloading/unpacking PyMySQL

http://pypi.douban.com/simple/PyMySQL/ uses an insecure transport scheme (http). Consider using https if pypi.douban.com has it available

Downloading PyMySQL-0.7.2-py2.py3-none-any.whl (76kB): 76kB downloaded

Installing collected packages: PyMySQL

Successfully installed PyMySQL

Cleaning up...

In [1]: import pymysql

In [2]: pymysql.

pymysql.BINARY pymysql.Error pymysql.ProgrammingError pymysql.apilevel pymysql.get_client_info

pymysql.Binary pymysql.FIELD_TYPE pymysql.ROWID pymysql.charset pymysql.install_as_MySQLdb

pymysql.Connect pymysql.IntegrityError pymysql.STRING pymysql.connect pymysql.optionfile

pymysql.Connection pymysql.InterfaceError pymysql.TIME pymysql.connections pymysql.paramstyle

pymysql.DATE pymysql.InternalError pymysql.TIMESTAMP pymysql.constants pymysql.sys

pymysql.DATETIME pymysql.MySQLError pymysql.Time pymysql.converters pymysql.thread_safe

pymysql.DBAPISet pymysql.NULL pymysql.TimeFromTicks pymysql.cursors pymysql.threadsafety

pymysql.DataError pymysql.NUMBER pymysql.Timestamp pymysql.err pymysql.times

pymysql.DatabaseError pymysql.NotSupportedError pymysql.TimestampFromTicks pymysql.escape_dict pymysql.util

pymysql.Date pymysql.OperationalError pymysql.VERSION pymysql.escape_sequence pymysql.version_info

pymysql.DateFromTicks pymysql.PY2 pymysql.Warning pymysql.escape_string

# pip3 install paramiko 基于ssh实现远程管理的

paramiko是用python语言写的一个模块，遵循SSH2协议，支持以加密和认证的方式，进行远程服务器的连接。
使用paramiko可以很好的解决以下问题：
需要使用windows客户端，
远程连接到Linux服务器，查看上面的日志状态，批量配置远程服务器，文件上传，文件下载等

ipython3

In [1]: import paramiko

In [2]: paramiko.

Display all 100 possibilities? (y or n)

基于socket通信的简单代码

socket:

Server: listen socket

Client: connect socket

起两个回话

一个client，一个server

In [2]: import socket

In [3]: help(socket)

In [4]: dir(socket) 查看可调用方法和可调用属性

Out[4]:

['AF_APPLETALK',

'AF_ASH',

'AF_ATMPVC',

In [6]: help(socket.socket)

In [7]: s = socket.soc

socket.socket socket.socketpair

In [7]: s = socket.socket() 创建一个套接字

In [8]: s.bind(('127.0.0.1',3008)) 绑定在本机的3008端口

In [9]: s.listen(10) 监听

另一个

# ss -tnlp

LISTEN 0 10 127.0.0.1:3008 *:* users:(("ipython",64056,7))

阻塞方式接受客户端连接

sc,client = s.accept() 等待客户端连接并发送数据过来

In [10]: sc,client = s.accept()

另一个

In [1]: import socket

In [2]: c = socket.socke

socket.socket socket.socketpair

In [2]: c = socket.socket()

In [3]: c.co

c.connect c.connect_ex

In [3]: c.connect(('127.0.0.1',3008)) 连接后，server阻塞结束

S

In [11]: print

print

In [11]: print(sc)

<socket.socket fd=8, family=AddressFamily.AF_INET, type=SocketType.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 3008), raddr=('127.0.0.1', 59846)> sc是一个套接字

In [12]: print(client)

('127.0.0.1', 59846) 客户端地址使用随机端口进行连接

再开一个新回话

# ss -tan

ESTAB 0 0 127.0.0.1:3008 127.0.0.1:59846

ESTAB 0 0 127.0.0.1:59846 127.0.0.1:3008

一个来回两个连接

S

基于套接字文件来进行数据接收，将数据保存在data中。使用1024的缓存来接收

In [13]: data = sc.recv(1024) 会处于阻塞状态中

C

发送数据，基于二进制字节编码

In [4]: c.send(b"from client") b是基于二进制编码

Out[4]: 11

数据发送完成后，server阻塞就停止了

S

In [14]: print(data)

b'from client' 可以看到客户端发来的数据了

解码后来显示

In [15]: print(data.decode()) 不会显示其原始格式

from client

可以通过open打开一个文件，把接收的数据都放入到文件中

C

关闭连接

In [5]: c.close()

# ss -tan

LISTEN 0 10 127.0.0.1:3008 *:*

CLOSE-WAIT 1 0 127.0.0.1:3008 127.0.0.1:59846

FIN-WAIT-2 0 0 127.0.0.1:59846 127.0.0.1:3008

S

关闭连接

In [16]: s.close()

# ss -tan

CLOSE-WAIT 1 0 127.0.0.1:3008 127.0.0.1:59846

超时以后，两边都直接断开

安装mysql-server程序

yum install -y mysql-server

# service mysqld start

# mysql -u root

mysql> create database testdb;

Query OK, 1 row affected (0.00 sec)

mysql> grant all on testdb.* to 'testuser'@'127.0.0.1' identified by 'testpass';

Query OK, 0 rows affected (0.01 sec)

mysql> flush privileges;

Query OK, 0 rows affected (0.01 sec)

# mysql -utestuser -h127.0.0.1 -p

Enter password:

Welcome to the MySQL monitor. Commands end with ; or \g.

Your MySQL connection id is 3

Server version: 5.1.73 Source distribution

Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its

affiliates. Other names may be trademarks of their respective

owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

Python连接mysql

In [17]: import pymysql

In [18]: help(pymysql)

CLASSES

builtins.object

Connection

EOFPacketWrapper

LoadLocalFile

LoadLocalPacketWrapper

MySQLResult

MysqlPacket

FieldDescriptorPacket

OKPacketWrapper

RandStruct_323

class Connection(builtins.object)

| Representation of a socket with a mysql server.

|

| The proper way to get an instance of this class is to call

| connect().

|

| Methods defined here:

|

| __del__(self)

|

| __enter__(self)

| Context manager that returns a Cursor

|

| __exit__(self, exc, value, traceback)

| On successful exit, commit. On exception, rollback

|

| __init__(self, host=None, user=None, password='', database=None, port=3306, unix_socket=None, charset='', sql_mode=None, read_default_file=None, c

onv={0: <class 'decimal.Decimal'>, 1: <class 'int'>, 2: <class 'int'>, 3: <class 'int'>, 4: <class 'float'>, 5: <class 'float'>, 7: <function convert_mysq

l_timestamp at 0x7f96a10e07b8>, 8: <class 'int'>, 9: <class 'int'>, 10: <function convert_date at 0x7f96a10e0730>, 11: <function convert_timedelta at 0x7f

96a10e0620>, 12: <function convert_datetime at 0x7f96a10e0598>, 13: <class 'int'>, 15: <function through at 0x7f96a10e08c8>, 16: <function through at 0x7f

96a10e08c8>, 246: <class 'decimal.Decimal'>, 248: <function convert_set at 0x7f96a10e0840>, 249: <function through at 0x7f96a10e08c8>, 250: <function thro

ugh at 0x7f96a10e08c8>, 251: <function through at 0x7f96a10e08c8>, 252: <function through at 0x7f96a10e08c8>, 253: <function through at 0x7f96a10e08c8>, 2

54: <function through at 0x7f96a10e08c8>}, use_unicode=None, client_flag=0, cursorclass=<class 'pymysql.cursors.Cursor'>, init_command=None, connect_timeo

ut=None, ssl=None, read_default_group=None, compress=None, named_pipe=None, no_delay=None, autocommit=False, db=None, passwd=None, local_infile=False, max

_allowed_packet=16777216, defer_connect=False, auth_plugin_map={})

In [22]: conn = pymysql.connect(host = '127.0.0.1',port = 3306,user = 'testuser',password = 'testpass',db = 'testdb')

In [23]: conn.

conn.DataError conn.character_set_name conn.escape_string conn.password conn.set_charset

conn.DatabaseError conn.charset conn.get_autocommit conn.ping conn.show_warnings

conn.Error conn.client_flag conn.get_host_info conn.port conn.socket

conn.IntegrityError conn.close conn.get_proto_info conn.protocol_version conn.sql_mode

conn.InterfaceError conn.commit conn.get_server_info conn.query conn.ssl

conn.InternalError conn.connect conn.host conn.rollback conn.thread_id

conn.NotSupportedError conn.connect_timeout conn.host_info conn.salt conn.unix_socket

conn.OperationalError conn.cursor conn.init_command conn.select_db conn.use_unicode

conn.ProgrammingError conn.cursorclass conn.insert_id conn.server_capabilities conn.user

conn.Warning conn.db conn.kill conn.server_charset conn.write_packet

conn.affected_rows conn.decoders conn.literal conn.server_language

conn.autocommit conn.encoders conn.max_allowed_packet conn.server_status

conn.autocommit_mode conn.encoding conn.next_result conn.server_thread_id

conn.begin conn.escape conn.open conn.server_version

向mysql中创建和取数据，需要先创建一个游标

In [23]: cur = conn.cursor()

In [24]: cur.

cur.DataError cur.InternalError cur.arraysize cur.execute执行命令 cur.max_stmt_length cur.scroll

cur.DatabaseError cur.NotSupportedError cur.callproc cur.executemany执行大量命令 cur.mogrify cur.setinputsizes

cur.Error cur.OperationalError cur.close cur.fetchall cur.nextset cur.setoutputsizes

cur.IntegrityError cur.ProgrammingError cur.connection cur.fetchmany cur.rowcount

cur.InterfaceError cur.Warning cur.description cur.fetchone cur.rownumber

In [27]: cur.execute("""create table if not exists tb1 (id int auto_increment not null primary key,name varchar(30) not null,email varchar(100) not null)""")

Out[27]: 0

查看表是否创建成功

[root@iptables1 ~]# mysql -utestuser -h127.0.0.1 -p

Enter password:

Welcome to the MySQL monitor. Commands end with ; or \g.

Your MySQL connection id is 5

Server version: 5.1.73 Source distribution

Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its

affiliates. Other names may be trademarks of their respective

owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> use testdb

Reading table information for completion of table and column names

You can turn off this feature to get a quicker startup with -A

Database changed

mysql> show tables;

+------------------+

| Tables_in_testdb |

+------------------+

| tb1 |

+------------------+

1 row in set (0.01 sec)

mysql>

往表中写数据

In [29]: cur.execute("insert into tb1 (name,email) values ("tom","hello@gmail.com")")

File "<ipython-input-29-f77d021f3652>", line 1

cur.execute("insert into tb1 (name,email) values ("tom","hello@gmail.com")") 使用单引号

^

SyntaxError: invalid syntax

In [30]: cur.execute("insert into tb1 (name,email) values ('tom','hello@gmail.com')")

Out[30]: 1

mysql> select * from tb1; 由于这里是myisam引擎，没有事务，创建后，这里马上就可以查看了，如果是innodb存储引擎则，需要在事务提交后，才能查看到的

+----+------+-----------------+

| id | name | email |

+----+------+-----------------+

| 1 | tom | hello@gmail.com |

+----+------+-----------------+

1 row in set (0.00 sec)

In [31]: cur.execute("insert into tb1 (name,email) values ('jerry','jerry@gmail.com')")

Out[31]: 1

mysql> select * from tb1;

+----+-------+-----------------+

| id | name | email |

+----+-------+-----------------+

| 1 | tom | hello@gmail.com |

| 2 | jerry | jerry@gmail.com |

+----+-------+-----------------+

2 rows in set (0.00 sec)

ins_sql = "insert into tb1 (name,email) values (%s,%s)"

values = (("comyn","comyn@gmail.com"),("derek","derek@gmail.com"))

cur.executemany(ins_sql, values)

comn.commit() 提交所有的修改

In [33]: ins_sql = "insert into tb1 (name,email) values (%s,%s)"

In [34]: values = (("comyn","comyn@gmail.com"),("derek","derek@gmail.com"))

In [35]: cur.executemany(ins)

%install_default_config %install_ext %install_profiles ins_sql install.log install.log.syslog

In [35]: cur.executemany(ins_sql,values)

Out[35]: 2

mysql> select * from tb1;

+----+-------+-----------------+

| id | name | email |

+----+-------+-----------------+

| 1 | tom | hello@gmail.com |

| 2 | jerry | jerry@gmail.com |

| 3 | jerry | jerry@gmail.com |

| 4 | comyn | comyn@gmail.com |

| 5 | derek | derek@gmail.com |

+----+-------+-----------------+

5 rows in set (0.00 sec)

In [36]: conn.commit()

In [37]: cur.execute("select * from tb1") 显示有5行数据返回

Out[37]: 5

所有数据取出放在data中

In [38]: data = cur.fetchall()

In [39]: data

Out[39]:

((1, 'tom', 'hello@gmail.com'),

(2, 'jerry', 'jerry@gmail.com'),

(3, 'jerry', 'jerry@gmail.com'),

(4, 'comyn', 'comyn@gmail.com'),

(5, 'derek', 'derek@gmail.com'))

In [40]: print(data)

((1, 'tom', 'hello@gmail.com'), (2, 'jerry', 'jerry@gmail.com'), (3, 'jerry', 'jerry@gmail.com'), (4, 'comyn', 'comyn@gmail.com'), (5, 'derek', 'derek@gmail.com'))

In [41]: if data:

....: for record in data:

....: print(record)

....:

(1, 'tom', 'hello@gmail.com')

(2, 'jerry', 'jerry@gmail.com')

(3, 'jerry', 'jerry@gmail.com')

(4, 'comyn', 'comyn@gmail.com')

(5, 'derek', 'derek@gmail.com')

paramiko

import paramiko

help(paramiko.SSHClient)

In [42]: import paramiko

In [43]: ssh = paramiko.SSHClient()

In [44]: ssh.

ssh.close ssh.get_host_keys ssh.load_host_keys ssh.save_host_keys

ssh.connect ssh.get_transport ssh.load_system_host_keys ssh.set_log_channel

ssh.exec_command ssh.invoke_shell ssh.open_sftp ssh.set_missing_host_key_policy

In [45]: help(ssh.set)

ssh.set_log_channel ssh.set_missing_host_key_policy

In [45]: help(ssh.set_missing_host_key_policy)

Help on method set_missing_host_key_policy in module paramiko.client:

set_missing_host_key_policy(policy) method of paramiko.client.SSHClient instance

Set the policy to use when connecting to a server that doesn't have a

host key in either the system or local `.HostKeys` objects. The

default policy is to reject all unknown servers (using `.RejectPolicy`).

You may substitute `.AutoAddPolicy` or write your own policy class.

:param .MissingHostKeyPolicy policy:

the policy to use when receiving a host key from a

previously-unknown server

In [46]: ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

In [47]: ssh.connect("192.168.16.36",username="root",password="123456")

In [48]: 已经连接上了

可以在远程主机上运行命令了

In [48]: ssh.exec_command("whoami")

Out[48]:

(<paramiko.ChannelFile from <paramiko.Channel 0 (open) window=2097152 -> <paramiko.Transport at 0xa0bb9be0 (cipher aes128-ctr, 128 bits) (active; 1 open channel(s))>>>,

<paramiko.ChannelFile from <paramiko.Channel 0 (open) window=2097152 -> <paramiko.Transport at 0xa0bb9be0 (cipher aes128-ctr, 128 bits) (active; 1 open channel(s))>>>,

<paramiko.ChannelFile from <paramiko.Channel 0 (open) window=2097152 -> <paramiko.Transport at 0xa0bb9be0 (cipher aes128-ctr, 128 bits) (active; 1 open channel(s))>>>)

返回的结果都保存在了一个对象上，有三个 标准输入、标准输出、标准错误

In [49]: stdin,stdout,stderr=ssh.exec_command("whoami")

In [50]: stdout.

stdout.FLAG_APPEND stdout.FLAG_WRITE stdout.closed stdout.seek

stdout.FLAG_BINARY stdout.SEEK_CUR stdout.flush stdout.tell

stdout.FLAG_BUFFERED stdout.SEEK_END stdout.newlines stdout.write

stdout.FLAG_LINE_BUFFERED stdout.SEEK_SET stdout.read stdout.writelines

stdout.FLAG_READ stdout.channel stdout.readline stdout.xreadlines

stdout.FLAG_UNIVERSAL_NEWLINE stdout.close stdout.readlines

In [50]: stdout.readline

Out[50]: <bound method ChannelFile.readline of <paramiko.ChannelFile from <paramiko.Channel 1 (closed) -> <paramiko.Transport at 0xa0bb9be0 (cipher aes128-ctr, 128 bits) (active; 0 open channel(s))>>>>

In [51]: stdout.readline()

Out[51]: 'root\n'

In [53]: stdin,stdout,stderr=ssh.exec_command("whoami")

In [54]: stdout.readli

stdout.readline stdout.readlines

In [54]: stdout.readlines()

Out[54]: ['root\n']

In [55]: stdin,stdout,stderr=ssh.exec_command("whoami")

In [56]: stdout.read()

Out[56]: b'root\n'

In [57]: stdin,stdout,stderr=ssh.exec_command("whoami")

In [58]: stdout.read().decode()

Out[58]: 'root\n'

远程服务器获取文件到本地

In [59]: ssh.

ssh.close ssh.get_host_keys ssh.load_host_keys ssh.save_host_keys

ssh.connect ssh.get_transport ssh.load_system_host_keys ssh.set_log_channel

ssh.exec_command ssh.invoke_shell ssh.open_sftp ssh.set_missing_host_key_policy

In [59]: ftp = ssh.open_sftp() 生成ftp连接对象，需要先安装一下ftp工具

In [60]: ftp.

ftp.chdir ftp.from_transport ftp.listdir ftp.mkdir ftp.readlink ftp.sock ftp.unlink

ftp.chmod ftp.get ftp.listdir_attr ftp.normalize ftp.remove ftp.stat ftp.utime

ftp.chown ftp.get_channel ftp.listdir_iter ftp.open ftp.rename ftp.symlink

ftp.close ftp.getcwd ftp.logger ftp.put ftp.request_number ftp.truncate

ftp.file ftp.getfo ftp.lstat ftp.putfo ftp.rmdir ftp.ultra_debug

获取帮助

In [60]: help(ftp.get)

get(remotepath, localpath, callback=None) method of paramiko.sftp_client.SFTPClient instance

Copy a remote file (``remotepath``) from the SFTP server to the local

host as ``localpath``. Any exception raised by operations will be

passed through. This method is primarily provided as a convenience.

:param str remotepath: the remote file to copy

:param str localpath: the destination path on the local host

:param callable callback:

optional callback function (form: ``func(int, int)``) that accepts

the bytes transferred so far and the total bytes to be transferred

.. versionadded:: 1.4

.. versionchanged:: 1.7.4

Added the ``callback`` param

In [6]: ftp.get('/etc/rsyncd.conf','/tmp/rsyncd.conf.paramiko')

# ls /tmp/ rsyncd.conf.paramiko

上传一个文件到远程的服务器上

In [7]: ftp.put('/etc/hosts','/tmp/hosts.paramiko')

Out[7]: <SFTPAttributes: [ size=158 uid=0 gid=0 mode=0o100644 atime=1460449355 mtime=1460449355 ]>

# ls /tmp/

hosts.paramiko 上传成功了

# rm /tmp/hosts.paramiko

rm: remove regular file `/tmp/hosts.paramiko'? y

In [8]: res = ftp.put('/etc/hosts','/tmp/hosts.paramiko')

In [9]: if res:

...: print("successful")

...:

successful

# ls /tmp/

hosts.paramiko

ftp连接结束后，可以关闭

In [10]: ftp.close()

In [11]: ssh.close()