1.3Python快速入門

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