Python基础语法

1. python技术连接
2. Python编程基础
   1. Python简介

      Python语言由Guido van Rossum于1989年底开始设计，并于1991年公开发行。

      Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言。

      Python目前有两个版本，Python2和Python3，最新版分别为2.7和3.6，现阶段大部分公司用的是Python2。

      Life is shot, you need Python. 人生苦短，我用Python。

      Python特点

      简单/易学

      免费、开源

      跨平台/可移植性

      面向对象

      可扩展性

      丰富的库

      Python的应用

      人工智能/科学计算

      云计算/自动化运维

      Web应用开发/数据挖掘

      桌面软件/游戏

   2. Python安装

      安装python3.6可能使用的依赖

      yum -y install openssl-devel bzip2-devel expat-devel gdbm-devel readline-devel sqlite-devel

      导入python3.6

      ./configure --prefix=/usr/local/

      make

      make altinstall

       

      python3.6程序的执行文件：/usr/local/bin/python3.6

      python3.6应用程序目录：/usr/local/lib/python3.6

      pip3的执行文件：/usr/local/bin/pip3.6

      pyenv3的执行文件：/usr/local/bin/pyenv-3.6

       

      --------------------------------------------------------------

       

      替换python2为python3.6

      更改/usr/bin/python链接（尽量不用，容易出问题）

      # cd/usr/bin

      # mv python python.backup

      # ln -s /usr/local/bin/python3.6 /usr/bin/python

      # ln -s /usr/local/bin/python3.6 /usr/bin/python3

      #rm -rf /usr/bin/python2

      #ln -s /usr/bin/python2.6 /usr/bin/python2

      更改yum脚本的python依赖

      # cd /usr/bin

      # ls yum*

      yum yum-config-manager yum-debug-restore yum-groups-manager

      yum-builddep yum-debug-dump yumdownloader

      更改以上文件头为

      #!/usr/bin/python 改为 #!/usr/bin/python2

      Linux系统自带python，注意版本，安装python3。

      开发工具：vim Sublime

   3. Python编程入门

      第一个python程序

      vim hello.py

      #!/usr/bin/python

      print("Hello World")

      运行方式：./hello.py或python hello.py

      注释

          单行注释：#

          多行注释：'''注释内容'''    或    """注释内容"""

      中文支持

          #coding=utf-8

          标准写法：# -*- coding:utf-8 -*-

      变量

      num1 = 10

      num2 = 20

      result = num1 + num2

      type(变量)            #变量的类型确定

      变量的类型

      Numbers（数字）

              分为 int(整数)、float（浮点）、bool（布尔）、complex（复数x+2y）

      String（字符串）

      List（列表）

      Tuple（元组）

      Sets（集合）

      Dictionary（字典）

      Number可以具体

      布尔类型

      在python2中当时是没有布尔类型的 使用 0 或者1表示

      在python3中新增了True和False的关键字，但是依然使用数字存储

      布尔类型只有2个值：True和False

      命名规则

      驼峰式命名规则

      单驼峰式命名法：例如：myName、logFile

      双驼峰式命名法：例如：LogFile、AccessLog

      关键字

      python已经使用的，所以不允许开发者自己定义和关键字相同的名字的标示符

      查看关键字:

      and     as     assert     break     class continue     def     del

      elif     else     except     exec     finally     for     from global

      if     in     import     is     lambda not     or     pass

      print     raise     return     try     while     with     yield

      >>> keyword.kwlist        #查看关键字

      输出

      print('hello world')            #输出变量hello world

      vim print.py

      name = "lamp"

      age = 11

      print("我的姓名是%s,年龄是%d"%(name,age))    

      #格式化输出%s字符串，%d整数，必须空4格

      输入

      pw = raw_input("please input password:")

      print "password:%s"%pw

      raw_input()的小括号中放入的是，提示信息，用来在获取数据之前给用户的一个提示

      raw_input()在从键盘获取数据以后，会存放到等号左边的变量中

      raw_input()会把用户输入的任何值都作为字符串来对待

      pw = input("please input password:")

      print ("password:%s"%pw)

      Python3没有raw_input()函数，只有input()

      print函数 python2 中可以没有（） python3中需要添加（）

   4. 运算符

      算术运算符

      

      赋值运算符

      

      复合赋值运算符

      

    

   数据类型转换

   函数     说明

   a = '100' # 此时a的类型是一个字符串，里面存放了100这3个字符

   b = int(a) # 此时b的类型是整型，里面存放的是数字100

           #适合用于脚本运算

   比较/关系运算符

   

   逻辑运算符

   

    

    

    

   1. 判断语句和循环语句

      if-else

      实例if1.py

      fileLog = 1

      if fileLog == 1:        #如果字符串判断，需要加""号

      print("存在，可以写入")

      else:

      print("不存在，不能写入记录，请建立文件")

      elif

      实例if2.py

      score = 85

      if score>=90 and score<=100:

      print('本次考试，等级为A')

      elif score>=80 and score<90:

      print('本次考试，等级为B')

      elif score>=70 and score<80:

      print('本次考试，等级为C')

      elif score>=60 and score<70:

      print('本次考试，等级为D')

      while循环

      实例while1.py：        #while必须要有条件变量

      i = 0

      while i<5:

      print("当前是第%d次执行循环"%(i+1))

      print("i=%d"%i)

      i+=1

      for循环

      实例for1.py

      name = 'lampBrother'

      for x in name:

      print(x)

      ------------------

      name = 'lampBrother'

      for x in name:

      print(x)

      else:

      print("没有数据")

      break

      例1：

      name = 'lampBrother'

      for x in name:

      print('----')

      if x == 'm':

      break

      print(x)

      例2：

      i = 0

      while i<10:

      i = i+1

      print('----')

      if i==5:

      break

      print(i)

      continue

              例1：

      name = 'lampBrother'

      for x in name:

      print('----')

      if x == 'm':

      continue

      print(x)

              例2：

      i = 0

      while i<10:

      i = i+1

      print('----')

      if i==5:

      continue

      print(i)

       

   2. 字符串（string）

      双引号或者单引号中的数据，就是字符串

      注意：input获取的数据，都以字符串的方式进行保存，即使输入的是数字

      下标

      所谓"下标"，就是编号

      列表与元组支持下标索引，字符串实际上就是字符的数组，所以也支持下标索引

      切片

      切片是指对操作的对象截取其中一部分的操作

      切片的语法：[起始:结束:步长]

      注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)。

      如果取出一部分，则可以在中括号[]中，使用:

      name = 'abcdef'

      print(name[0:3])         #取下标0~2 的字符

      name = 'abc'

      print(name[3:5])             #取下标为3、4 的字符

      name = 'de'

      print(name[2:])             #取下标为2开始到最后的字符

      name = 'cdef'

              str = "abcdef"

                  str[::2]                    #步长2，2个元素为一组，输出每组第一个字符

              'ace'

              str[1:5:2]

              'bd'

              str[::-2]                #2个一组，倒序输出

              'fdb'

      字符串常见函数

      <1>find

      检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1

      mystr.find(str)

      mystr.find(str, start=0, end=len(mystr))

      <2>index

      跟find()方法一样，只不过如果str不在 mystr中会报一个异常

      mystr.index(str)

      mystr.index(str, start=0, end=len(mystr))

      <3>count

      返回 str在start和end之间 在 mystr里面出现的次数

      mystr.count (str)

      mystr.count(str, start=0, end=len(mystr))

      <4>replace

      把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次

   mystr.replace(str1, str2)

   mystr.replace(str1, str2, mystr.count(str1))

   <5>split

   以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串

   mystr.split(str=" ", 2)

   <6>capitalize

   把字符串的第一个字符大写

   mystr.capitalize()

   <7>title

   把字符串的每个单词首字母大写

   >>> a = "hello lamp"

   >>> a.title()

   'Hello Lamp'

   <8>startswith

   检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False

   mystr.startswith(obj)

   <9>endswith

   检查字符串是否以obj结束，如果是返回True,否则返回 False.

   mystr.endswith(obj)

   <10>lower

   转换 mystr 中所有大写字符为小写

   mystr.lower()

   <11>upper

   转换 mystr 中的小写字母为大写

   mystr.upper()

   <12>ljust

   返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

   mystr.ljust(width)

   <13>rjust

   返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

   mystr.rjust(width)

   <14>center

   返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

   mystr.center(width)

   <15>lstrip

   删除 mystr 左边的空白字符

   mystr.lstrip()

   <16>rstrip

   删除 mystr 字符串末尾的空白字符

   mystr.rstrip()

   <17>strip

   删除mystr字符串两端的空白字符

   >>> a = "\n\t lamp \t\n"

   >>> a.strip()

   'lamp'

   <18>rfind

   类似于 find()函数，不过是从右边开始查找.

   mystr.rfind(str, start=0,end=len(mystr) )

   <19>rindex

   类似于 index()，不过是从右边开始.

   mystr.rindex( str, start=0,end=len(mystr))

   <20>partition

   把mystr以str分割成三部分,str前，str和str后

   mystr.partition(str)

   <21>rpartition

   类似于 partition()函数,不过是从右边开始.

   mystr.rpartition(str)

   <22>splitlines

   按照行分隔，返回一个包含各行作为元素的列表

   mystr.splitlines()

   <23>isalpha

   如果 mystr 所有字符都是字母 则返回 True,否则返回 False

   mystr.isalpha()

   <24>isdigit

   如果 mystr 只包含数字则返回 True 否则返回 False.

   mystr.isdigit()

   <25>isalnum

   如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False

   mystr.isalnum()

   <26>isspace

   如果 mystr 中只包含空格，则返回 True，否则返回 False.

   mystr.isspace()

   <27>join

   mystr 中每个字符后面插入str,构造出一个新的字符串

   mystr.join(str)

   1. 列表list

      列表的格式

      namesList = ['xiaoZhang','xiaoLi','xiaoWang']

      print(namesList[0])

      print(namesList[1])

      print(namesList[2])

      列表的循环遍历输出

      例1：

      namesList = ['xiaoZhang','xiaoLi,'xiaoWang']

      for name in namesList:

      print(name)

      例2：

      namesList = ['xiaoZhang','xiaoLi,'xiaoWang']

      length = len(namesList)

      i = 0

      while i

      print(namesList[i])

      i+=1

      添加元素("增"append, extend, insert)

      append

      实例

      A = ['xiaoWang','xiaoZhang','xiaoHua']

      temp = input('请输入要添加的学生姓名:')

      A.append(temp)

      for tempName in A:

      print(tempName)

      extend

      通过extend可以将另一个集合中的元素逐一添加到列表中

      >>> a = [1, 2]

      >>> b = [3, 4]

      >>> a.append(b)

      >>> a

      [1, 2, [3, 4]]

      >>> a.extend(b)

      >>> a

      [1, 2, [3, 4], 3, 4]

      insert

      insert(index, object) 在指定位置index前插入元素object

      >>> a = [0, 1, 2]

      >>> a.insert(1, 3)

      >>> a

      [0, 3, 1, 2]

      修改元素("改")

      修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改

      A = ['xiaoWang','xiaoZhang','xiaoHua']

      A[1] = 'xiaoxiao'            #修改元素

      查找元素("查"in, not in, index, count)

      in（存在）,如果存在那么结果为true，否则为false

      not in（不存在），如果不存在那么结果为true，否则false

      实例:

      nameList = ['xiaoWang','xiaoZhang','xiaoHua']

      findName = input('请输入要查找的姓名:')

      if findName in nameList:

      print('在字典中找到了相同的名字')

      else:

      print('没有找到')

      删除元素("删"del, pop, remove)

      del：根据下标进行删除

      pop：删除最后一个元素

      remove：根据元素的值进行删除

      实例 (del)

      movieName = ['战狼1','战狼2','速8','孙悟空','星球大战','异星觉醒']

      del movieName[2]

      print('------删除之后------')

      for tempName in movieName:

      print(tempName)

      实例(pop)

      movieName = ['战狼1','战狼2','速8','孙悟空','星球大战','异星觉醒']

          movieName.pop()

          print('------删除之后------')

          for tempName in movieName:

      print(tempName)

      实例:(remove)

      movieName = ['战狼1','战狼2','速8','孙悟空','星球大战','异星觉醒']

      movieName.remove('星球大战')

      print('------删除之后------')

      for tempName in movieName:

      print(tempName)

      排序(sort, reverse)

      sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序

      reverse方法是将list逆置。

      >>> a = [1, 4, 2, 3]

      >>> a

      [1, 4, 2, 3]

      >>> a.reverse()

      >>> a

      [3, 2, 4, 1]

      >>> a.sort()

      >>> a

      [1, 2, 3, 4]

      >>> a.sort(reverse=True)

      >>> a

      [4, 3, 2, 1]

    

   1. 元组tuple

      Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

      >>> Tuple = ('xiaoming',177,79)

      >>> Tuple

      ('xiaoming',177,79)

      <1>访问元组

      Tuple[1]

      <2>修改元组 （不允许）

      注意： python中不允许修改元组的数据，包括不能删除其中的元素。

   2. 字典dict

      info = {'name':'超哥', 'id':100, 'sex':'f', 'address':'回龙观'}

      注意：

      字典和列表一样，也能够存储多个数据

      列表中找某个元素时，是根据下标进行的

      字典中找某个元素时，是根据'名字'（就是冒号:前面的那个值，例如上面代码中的'name'、'id'、'sex'）

      字典的每个元素由2部分组成，键:值。例如 'name':'超哥' ,'name'为键，'超哥'为值

      根据键访问值

      info = {'name':'超哥', 'id':100, 'sex':'f', 'address':'回龙观'}

          print(info['name'])

      print(info['address'])

      结果:

      超哥

      回龙观

      修改元素

      字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

      实例

      info = {'name':'超哥', 'id':100, 'sex':'f', 'address':'回龙观'}

      newId = input('请输入新的学号')

      info['id'] = int(newId)

      print('修改之后的id为%d:'%info['id'])

      添加元素

      如果在使用 变量名['键'] = 数据 时，这个"键"在字典中，不存在，那么就会新增这个元素

      实例

      info = {'name':'超哥', 'sex':'f', 'address':'回龙观'}

      newId = input('请输入新的学号:')

      info['id'] = int(newId)

      print('添加之后的id为:%d'%info['id'])

      删除元素(del, clear())

               del

       info = {'name':'超哥', 'sex':'f', 'address':'回龙观'}

       print('删除前,%s'%info['name'])

       del info['name']

       print('删除后,%s'%info['name'])

   实例del1.py:del删除整个字典 报错！！！

       info = {'name':'monitor', 'sex':'f', 'address':'China'}

       print('删除前,%s'%info)

       del info

       print('删除后,%s'%info)

   clear

       info = {'name':'monitor', 'sex':'f', 'address':'China'}

       print('清空前,%s'%info)

       info.clear()

       print('清空后,%s'%info)

   字典常用操作

   info = {'name':'超哥', 'id':100, 'sex':'f', 'address':'回龙观'}

   <1>len()

   测量字典中，键值对的个数

   >>>len(info)

   <2>keys

   返回一个包含字典所有KEY的列表

   >>> info.keys()

   <3>values

   返回一个包含字典所有value的列表

   >>> info.values()

   <4>items

   返回一个包含所有（键，值）元祖的列表

   >>> info.items()

   1. 函数

      函数格式

      def 函数名():

      代码

      # 定义一个函数，能够完成打印信息的功能

      def printInfo():

      print '------------------------------------'

      print ' Hello Python'

      print '------------------------------------'

      调用函数

      调用函数很简单的，通过 函数名() 即可完成调用

      printInfo()

      函数参数

              形参：定义时小括号中的参数，用来接收参数用的，称为 "形参"

          实参：调用时小括号中的参数，用来传递给函数用的，称为 "实参"

      例1：

      def add2num():

      a = 11

      b = 22

      c = a+b

      print (c)

      add2num()

               例2：

   def add2num(a, b):

   c = a+b

   print (c)

   调用带有参数的函数 注意程序执行过程

   add2num(22,33)

   a=input("输入数字:")

   a1=int(a)

   b=input("输入数字:")

   b1=int(b)

   add2num(a1,b1)

   函数返回值

   return返回值，就是程序中函数完成一件事情后，最后给调用者的结果

   例1：

   def add2num(a, b):

   c = a+b

   return c

           例2：

   def add2num(a, b):

   return a+b

   result = add2num(10,20)

   print result

   函数的分类

   函数根据有没有参数，有没有返回值，可以相互组合，一共有4种

   无参数，无返回值

   无参数，有返回值

   有参数，无返回值

   有参数，有返回值

   无参数，无返回值的函数

   此类函数，不能接收参数，也没有返回值，打印提示等类似的功能，使用这类的函数

           例：

   def printMenu():

   print('--------------------------')

   print(' 请输入大写字母')

   print('')

   print(' 1. INSTALL')

   print(' 2. REMOVE')

   print(' 3. 完成请退出')

   print('--------------------------')

   无参数，有返回值的函数

   不能接收参数，但是可以返回某个数据，一般情况下，采集数据，用此类函数

   def getTemperature():

   #获取温度的一些处理过程

   #模拟返回一个数据

   return 37

   temperature = getTemperature()

   print('当前的温度为:%d'%temperature)

    

   有参数，无返回值的函数

   能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数

   有参数，有返回值的函数

   能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数

   def calculateNum(num):            #计算1~num的累积和

   result = 0

   i = 1

   while i<=num:

   result = result + i

   i+=1

   return result

   result = calculateNum(100)

   print('1~100的累积和为:%d'%result)

   函数的嵌套调用

           例1：

   def testB():

   print('---- testB start----')

   print('这里是testB函数执行的代码...(省略)...')

   print('---- testB end----')

   def testA():

   print('---- testA start----')

   testB()

   print('---- testA end----')

   testA()

           例2：

   def sum3Number(a,b,c):            #求3个数的和

   return a+b+c # return 的后面可以是数值，也可是一个表达式

   def average3Number(a,b,c):        #完成对3个数求平均值

   # 因为sum3Number函数已经完成了3个数的就和，所以只需调用即可

   # 即把接收到的3个数，当做实参传递即可

   sumResult = sum3Number(a,b,c)

   aveResult = sumResult/3

   return aveResult

   result = average3Number(30,20,100)        #调用函数，完成对3个数求平均值

   print("average is %d"%result)

   变量在函数中的分类

   局部变量

   局部变量，就是在函数内部定义的变量

   不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响

   作用：为临时保存数据，需要在函数中定义变量，进行存储

   全局变量

   如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量

   在函数外边定义的变量叫做全局变量

   全局变量能够在所有的函数中进行访问

   如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错

   如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量(作用域)

   递归函数

   自我调用的函数。

   一个函数可以调用其他函数。

   如果一个函数在内部不调用其它的函数，而是调用自己本身，这个函数就是递归函数。

   例：

   def getNums(num):

   if num>1:

   return num * getNums(num-1)        #不断调用函数，直到num小于1

   else:

   return num

   result = getNums(10)

   print(result)

   匿名函数

   用lambda关键词能创建小型匿名函数。

   省略用def声明函数的标准步骤。

   Lambda函数能接收任何数量的参数但只能返回一个表达式的值

   匿名函数不能直接调用print，因为lambda需要一个表达式

           例：

   sum = lambda arg1, arg2: arg1 + arg2

   #调用sum函数

   print ("Value of total : ", sum( 10, 20 ))

   print ("Value of total : ", sum( 20, 20 ))

   匿名函数的应用

   例1：

   >>> def fun(a, b, opt):

   ... print ("a =", a)

   ... print ("b =", b)

   ... print ("result =", opt(a, b))

   ...

   >>> fun(1, 2, lambda x,y:x+y)            #函数作为参数传递

   a = 1

   b = 2    

   result = 3

           例2：

   作为内置函数的参数

   stus = [

   {"name":"zhangsan", "age":18},

   {"name":"lisi", "age":19},

   {"name":"wangwu", "age":17}

   ]

   按name排序：

   >>> stus.sort(key = lambda x:x['name'])

   >>> stus

   [{'name': 'lisi', 'age': 19}, {'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}]

   按age排序：

   >>> stus.sort(key = lambda x:x['age'])

   >>> stus

   [{'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}, {'name': 'lisi', 'age': 19}]

   1. 文件操作

      打开文件

      使用open函数，打开一个已经存在的文件，或者创建一个新文件

      open(文件名，访问模式)

      f = open('test.txt', 'w')

      

      关闭文件

      close( )

      # 新建一个文件，文件名为:test.txt

      f = open('test.txt', 'w')

      # 关闭这个文件

      f.close()

      文件的读写操作

      使用write()可以完成向文件写入数据，如果文件不存在那么创建，如果存在那么就先清空，然后写入数据

      f = open('test.txt', 'w')

      f.write('hello python, very good!')

      f.close()

      读数据(read)

      使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据

      如果使用读了多次，那么后面读取的数据是从上次读完后的位置开始的

      例：

      f = open('test.txt')

      content = f.read(5)

      print(content)

      print("-"*20)

      content = f.read()

      print(content)

      f.close()

      读数据（readlines）

      readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素

      例：

      f = open('test.txt', 'r')

      content = f.readlines()

      print(type(content))

      i=1

      for temp in content:

      print("%d:%s"%(i, temp))

      i+=1

      f.close()

      读数据（readline）

      读取1行，光标停在第二行

      例：

      f = open('test.txt', 'r')

      content = f.readline()

      print("1:%s"%content)

      content = f.readline()

      print("2:%s"%content)

      content = f.readline()

      print("3:%s"%content)

      f.close()

      文件操作应用

      制作文件的备份

      要求：输入文件的名字，然后程序自动完成对文件进行备份

      #coding=utf-8

      oldFileName = input("请输入要拷贝的文件名字:")

      oldFile = open(oldFileName,'r')

      #如果打开文件

      if oldFile:

      #提取文件的后缀

      fileFlagNum = oldFileName.rfind('.')

      if fileFlagNum > 0:

      fileFlag = oldFileName[fileFlagNum:]

      #组织新的文件名字

      newFileName = oldFileName[:fileFlagNum] + '[bak]' + fileFlag

      #创建新文件

      newFile = open(newFileName, 'w')

      #把旧文件中的数据，一行一行的进行复制到新文件中

      for lineContent in oldFile.readlines():

      newFile.write(lineContent)

      oldFile.close()

      newFile.close()

      文件定位读写

      获取当前读写的位置

      在读写文件的过程中，如果想知道当前的位置，可以使用tell()来获取

      f = open("test.txt", "r")

      str = f.read(3)

      print ("读取的数据是 : ", str)

      # 查找当前位置

      position = f.tell()

      print ("当前文件位置 : ", position)

      str = f.read(3)

      print ("读取的数据是 : ", str)

      # 查找当前位置

      position = f.tell()

      print ("当前文件位置 : ", position)

      f.close()

      定位到某个位置

      如果在读写文件的过程中，需要从另外一个位置进行操作的话，可以使用seek()

      seek(offset, from)有2个参数

      offset:偏移量

      from:方向

      0:表示文件开头

      1:表示当前位置

      2:表示文件末尾

      #把位置设置为：从文件开头，偏移5个字节

      # 打开一个已经存在的文件

      f = open("test.txt", "r")

      str = f.read(30)

      print ("读取的数据是 : ", str)

      # 查找当前位置

      position = f.tell()

      print ("当前文件位置 : ", position)

      # 重新设置位置

      f.seek(5,0)

      # 查找当前位置

      position = f.tell()

      print ("当前文件位置 : ", position)

      f.close()

      文件重命名

      在对文件进行重命名、删除等操作，通过python的os模块实现

      rename(需要修改的文件名, 新的文件名)

      import os

      #os.rename("test.txt", "b.txt")

      os.remove("b.txt")

      删除文件

      os模块中的remove()可以完成对文件的删除操作

      remove(待删除的文件名)

      创建文件夹

      如果要操作文件夹，同样需要os模块

      import os

      os.mkdir("ttt")

      a = os.getcwd()

      print (a)

      os.chdir("../")

      os.mkdir("aaaaaaaaa")            #创建文件夹

      os.mkdir("张三")

      os.getcwd()                            #获取当前目录

      os.chdir("../")                            #改变默认目录

      os.listdir("./")                            #获取目录列表

      删除文件夹

      import os

      os.rmdir("张三")

      批量修改文件名

      # 批量在文件名前加前缀

      import os

      funFlag = 2 # 1表示添加标志 2表示删除标志

      folderName = './renameDir/'

      # 获取指定路径的所有文件名字

      dirList = os.listdir(folderName)

      # 遍历输出所有文件名字

      for name in dirList:

      print (name)

      if funFlag == 1:

      newName = '[python]-' + name

      elif funFlag == 2:

      num = len('[python]-')

      newName = name[num:]

      print (newName)

      os.rename(folderName+name, folderName+newName)

   2. 面向对象编程

      类

      具有相同属性和行为事物的统称。

      类是抽象的,在使用的时候通常会找到这个类的一个具体的存在,使用这个具体的存在。一个类可以找到多个对象。

      对象

      某一个具体事物的存在 ,在现实世界中可以是看得见摸得着的；可以是直接使用的。

      区分类和对象

      硬盘 类

      固态硬盘 类

      张三的硬盘 对象

      文件 类

      Shell文件 类

      李四写的shell文件 对象

      汽车 类

      宝马汽车 类

      王五的宝马汽车 对象

      类的构成

      类(Class) 由3个部分构成

      类的名称:类名

      类的属性:一组数据

      类的方法:允许对象进行操作的方法 (行为)

      定义类，格式：

      class Car()

      def getCarInfo(self):

      print('车轮子个数:%d, 颜色%s'%(self.wheelNum, self.color))

      def move(self):

      print("车正在移动...")

      定义类时有2种：

      新式类和经典类，上面的Car为经典类，如果是Car(object)则为新式类

      类名的命名规则按照"双驼峰"

      创建对象

      class Car:

      def move(self):

      print('奔跑...')

      def toot(self):

      print("鸣笛...")

      BMW = Car()     #创建一个对象，并用变量BMW来保存它的引用

      BMW.move()

      BMW.toot()

      总结：

      BMW = Car()，这样就产生了一个Car的实例对象，此时也可以通过实例对象BMW来访问属性或者方法

      第一次使用BMW.color = '黑色'表示给BMW这个对象添加属性，如果后面再次出现BMW.color = xxx表示对属性进行修改

      BMW是一个对象，它拥有属性（数据）和方法（函数）

      当创建一个对象时，就是用一个模板，来制造一个实物

   3. 模块

      模块引入

      在Python中用关键字import来引入某个模块.

      >>>import os            #引入一个模块

      >>>os.__file__

      import module1,mudule2...

      from 模块名 import 函数名1,函数名2....            #引入模块中的一个应用

      模块安装

      一.

      1.找到模块的压缩包（官网下载）

      2.解压

      3.进入文件夹

      4.执行命令python setup.py install

      （缺点 依赖关系复杂）

      二.

      网络安装：pip install 模块名

      Python实现服务器监控

      /proc 文件系统

      系统信息：从/proc/stat 中获得，其中包括 CPU 占用情况、磁盘空间、内存对换等。

      CPU信息：利用/proc/cpuinfo 文件可以获得cpu的信息。

      负载信息：/proc/loadavg 文件包含系统负载信息。

      系统内存信息：/proc/meminfo 文件包含系统内存的详细信息，其中显示物理内存的数量、可用交换空间的数量，以及空闲内存的数量等。

      /proc 目录中的主要文件的说明

      文件或目录名称     描 述

      cpuinfo         中央处理器信息

      loadavg         系统平均负载均衡

      meminfo     存储器使用信息，包括物理内存和交换内存

      net             网络协议状态信息

      CPU监测获取信息

      实例：

      from __future__ import print_function

      from collections import OrderedDict

      import pprint

      def cpuinfo():

      cpuinfo=OrderedDict()

      procinfo=OrderedDict()

      nprocs = 0

      with open('/proc/cpuinfo') as f:

      for line in f:

      if not line.strip():

      cpuinfo['proc%s' % nprocs] = procinfo

      nprocs=nprocs+1

      procinfo=OrderedDict()

      else:

      if len(line.split(':')) == 2:

      procinfo[line.split(':')[0].strip()] = line.split(':')[1].strip()

      else:

      procinfo[line.split(':')[0].strip()] = ''

      return cpuinfo

      if __name__=='__main__':

      cpuinfo = cpuinfo()

      for processor in cpuinfo.keys():

      print(cpuinfo[processor]['model name'])

      监测系统负载

      实例：

      import os

      def load_stat():

      loadavg = {}

      f = open("/proc/loadavg")

      con = f.read().split()

      f.close()

      loadavg['lavg_1']=con[0]

      loadavg['lavg_5']=con[1]

      loadavg['lavg_15']=con[2]

      loadavg['nr']=con[3]

      loadavg['last_pid']=con[4]

      return loadavg

      print ("loadavg",load_stat()['lavg_15'])

      print ("loadavg",load_stat()['lavg_1'])

      print ("loadavg",load_stat()['lavg_5'])

      获取内存使用信息

      实例：

      from __future__ import print_function

      from collections import OrderedDict

      def meminfo():

      ''' /proc/meminfo '''

      meminfo=OrderedDict()

      with open('/proc/meminfo') as f:

      for line in f:

      meminfo[line.split(':')[0]] = line.split(':')[1].strip()

      return meminfo

      if __name__=='__main__':

      print(meminfo())

      meminfo = meminfo()

      print('Total memory: {0}'.format(meminfo['MemTotal']))

      print('Free memory: {0}'.format(meminfo['MemFree']))

      网络接口监测（流量监控）

      实例：

      import time

      import sys

      if len(sys.argv) > 1:

          INTERFACE = sys.argv[1]

      else:

          INTERFACE = 'eth0'

      STATS = []

      print ('Interface:',INTERFACE)

      def    rx():

          ifstat = open('/proc/net/dev').readlines()

          for interface in ifstat:

              if INTERFACE in interface:

                  stat = float(interface.split()[1])

                  STATS[0:] = [stat]

      def    tx():

          ifstat = open('/proc/net/dev').readlines()

          for interface in ifstat:

              if INTERFACE in interface:

                  stat = float(interface.split()[9])

                  STATS[1:] = [stat]

      print    ('In            Out')

      rx()

      tx()

      while    True:

          time.sleep(1)

          rxstat_o = list(STATS)

          rx()

          tx()

          RX = float(STATS[0])

          RX_O = rxstat_o[0]

          TX = float(STATS[1])

          TX_O = rxstat_o[1]

          RX_RATE = round((RX - RX_O)/1024/1024,3)

          TX_RATE = round((TX - TX_O)/1024/1024,3)

          print (RX_RATE ,'MB        ',TX_RATE ,'MB')

      常用模块说明

      OrderedDict，实现了对字典对象中元素的排序。模块collections，里面自带一个子类。

      pprint模块 提供打印出任何python数据结构类和方法。

      __future__模块，把下一个新版本的特性导入到当前版本，可以在当前版本中测试一些新版本的特性

      strip() 方法用于移除字符串头尾指定的字符（默认为空格）

      split() 通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串

      python 中__name__ = '__main__' 的作用：

      让你写的脚本模块既可以导入到别的模块中用，另外该模块自己也可执行。

      sys.argv中[]是用来获取命令行参数的，sys.argv中[0]表示代码本身文件路径，所以参数从1开始

      os：该模块提供了使用操作系统相关功能的便携式方法,提供了一种方便的使用操作系统函数的方法。

      sys：该模块提供对解释器使用或维护的一些变量以及与解释器强烈交互的函数的访问,这个模块可供访问由解释器使用或维护的变量和与解释器进行交互的函数。

      os常用方法

      os.remove（）删除文件

      os.rename（）重命名文件

      os.walk（）生成目录树下的所有文件名

      os.chdir（）改变目录

      os.mkdir / makedirs创建目录/多层目录

      os.rmdir / removedirs删除目录/多层目录

      os.listdir（）列出指定目录的文件

      os.getcwd（）取得当前工作目录

      os.chmod（）改变目录权限

      os.path.basename（）去掉目录路径，返回文件名

      os.path.dirname（）去掉文件名，返回目录路径

      os.path.join（）将分离的各部分组合成一个路径名

      os.path.split（）返回（dirname（），basename（））元组

      os.path.splitext（）返回（filename，extension）元组

      os.path.getatime \ ctime \ mtime分别返回最近访问，创建，修改时间

      os.path.getsize（）返回文件大小

      os.path.exists（）是否存在

      os.path.isabs（）是否为绝对路径

      os.path.isdir（）是否为目录

      os.path.isfile（）是否为文件

      sys常用方法

      sys.argv命令行参数列表，第一个元素是程序本身路径

      sys.modules.keys（）返回所有已经导入的模块列表

      sys.exc_info（）获取当前正在处理的异常类，exc_type，exc_value，exc_traceback当前处理的异常详细信息

      sys.exit（n）退出程序，正常退出时exit（0）

      sys.hexversion获取Python解释程序的版本值，16进制格式如：0x020403F0

      sys.version获取Python解释程序的版本信息

      sys.maxint最大的Int值

      sys.maxunicode最大的Unicode值

      sys.modules返回系统导入的模块字段，key是模块名，value是模块

      sys.path返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

      sys.platform返回操作系统平台名称

      sys.stdout标准输出

      sys.stdin标准输入

      sys.stderr错误输出

      sys.exc_clear（）用来清除当前线程所出现的当前的或最近的错误信息

      sys.exec_prefix返回平台独立的python文件安装的位置

      sys.byteorder本地字节规则的指示器，big-endian平台的值是"big"，little-endian平台的值是"little"

      sys.copyright记录python版权相关的东西

      sys.api_version解释器的C的API版本

      OS模块负责程序与操作系统的交互，提供了访问操作系统底层的接口; SYS模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。

      time模块中常用函数：

      1）time.localtime([secs])：将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。

      >>> time.localtime()

      2）time.gmtime([secs])：和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。

      >>>time.gmtime()

      3）time.time()：返回当前时间的时间戳。

      >>> time.time()

      4）time.mktime(t)：将一个struct_time转化为时间戳。

      >>> time.mktime(time.localtime())

      5）time.sleep(secs)：线程推迟指定的时间运行。单位为秒。

      6）time.clock()：这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是"进程时间"，它是用秒表示的浮点数（时间戳）。而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。（实际上是以WIN32上QueryPerformanceCounter()为基础，它比毫秒表示更为精确）

      7）time.asctime([t])：把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。如果没有参数，将会将time.localtime()作为参数传入。

      >>> time.asctime()

      8）time.ctime([secs])：把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。

      9）time.strftime(format[, t])：把一个代表时间的元组或者struct_time（如由time.localtime()和time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个元素越界，ValueError的错误将会被抛出。

   4. Ansible自动化运维

      发展阶段

      传统运维

      命令行 批量脚本

      特点：资源少机器少 几台机器 规模 数据量少 运维工作简单

      缺点：效率低 重复工作 无法跨平台 资源分散 无标准

      自动化运维（把运维日常需要登录机器的操作，完全web化）

      一组将静态的设备结构转化为智能的根据IT服务需求动态弹性响应的策略，目的就是实现IT运维的质量，提高效率，降低成本。

      优点： 高效率 重复的工作由机器做

      平台化 任务自动执行 监控 日志管理

      标准化

      流程化 业务流程 部署流程 代码上线

      自动化运维思想

      管理体系化 管理机器 代码 业务

      工作流程化 标准

      人员专业化 懂运维 懂编程 懂业务

      任务自动化 环境定义自动化 部署自动化 监控自动化

      现阶段自动化运维缺点

      数据无法共享：A公司和B公司 无法共享

      无法主动式发现(预测)问题

      部署成本高

      标准不统一

      DevOps

      DevOps（Development和Operations）一组过程、方法与系统的统称，用于促进开发（应用程序/软件工程）、技术运营和质量保障（QA）部门之间的沟通、协作与整合。它的出现是由于软件行业日益清晰地认识到：为了按时交付软件产品和服务，开发和运营工作必须紧密合作。

      DevOps是开发（软件工程）、技术运营和质量保障（QA）三者的组合。

      自动化运维工具：

      

      Ansible

      Ansible自动化运维工具，基于Python开发，集合了众多运维工具的优点，实现了批量系统配置、批量程序部署、批量运行命令等功能。ansible是基于模块工作的，本身没有批量部署的能力。真正具有批量部署的是ansible所运行的模块，ansible只是提供一种框架。

      特点

      (1) no agents：不需要在被管控主机上安装任何客户端；

      (2) no server：无服务器端，使用时直接运行命令即可；

      (3) modules in any languages：基于模块工作，可使用任意语言开发模块；

      (4) yaml，not code：使用yaml语言定制剧本playbook；

      (5) ssh by default：基于SSH工作；

      (6) strong multi-tier solution：可实现多级管理。

      优势

      (1) 轻量级，无需在客户端安装agent，更新时，只需在操作机上进行一次更新即可；

      (2) 批量任务执行可以写成脚本，而且不用分发到远程就可以执行；

      (3) 使用python编写，维护更简单；

      (4) 支持sudo。

      工作原理

      

      CMDB(开发)

      CMDB（Configuration Management Database），配置管理数据库，是IT管理信息的重要工具和手段。开发CMDB主要采集硬件数据,API和页面管理。

      系统：硬件 软件 服务管理 人员 业务 ......

      收费CMDB

      开源CMDB github 开源社区

      资源

      www.google.com
      www.w3cschool.cn

      www.github.com

      https://docs.ansible.com/

      http://www.ansible.cn/

      Ansible安装配置与应用

      安装方式：1）pip 自动安装 2）yum 自动安装

      1. pip 方式 （参考）

      安装python-pip 和 python-devel 程序包

      yum -y install python-pip python-devel

      安装Ansible服务

      yum -y install gcc glibc-devel zlib-devel rpm-build openssl-devel

      pip install --upgrade pip

      pip install ansible --upgrade

      测试 ansible --version

      2.yum 方式（网络）（重点）

      先安装EPEL源后可找到并安装Ansible

      rpm -Uvh https://dl.fedoraproject.org/pub/epel/epel-release-latest-6.noarch.rpm

      yum -y install ansible

      测试 ansible --version

      Ansible配置

      1.配置文件目录

      /etc/ansible/

      两个核心文件：ansible.cfg和hosts文件,默认都存放在/etc/ansible目录下。

      ansible.cfg：主要设置ansible初始化信息，比如：日志存放路径、模块、插件等配置信息。

      hosts：机器清单（被控主机文件），进行分组管理

      命令文件

      /usr/bin/ansiable*

      配置文件 /etc/ansible/ansible.cfg

      [defaults] 通用默认配置

      inventory = /etc/ansible/hosts 这个是默认库文件位置,脚本,或者存放可通信主机的目录

      #library = /usr/share/my_modules/ Ansible默认搜寻模块的位置

      remote_tmp = $HOME/.ansible/tmp Ansible 通过远程传输模块到远程主机,然后远程执行,执行后在清理现场.在有些场景下,你也许想使用默认路径希望像更换补丁一样使用

      pattern = * 如果没有提供"hosts"节点,这是playbook要通信的默认主机组.默认值是对所有主机通信

      forks = 5 在与主机通信时的默认并行进程数 ，默认是5

      poll_interval = 15 当具体的poll interval 没有定义时,多少时间回查一下这些任务的状态, 默认值是5秒

      sudo_user = root sudo使用的默认用户 ，默认是root

      ask_sudo_pass = True 用来控制Ansible playbook 在执行sudo之前是否询问sudo密码.默认为no

      ask_pass = True 控制Ansible playbook 是否会自动默认弹出密码

      transport = smart 通信机制.默认 值为'smart'。如果本地系统支持 ControlPersist技术的话,将会使用(基于OpenSSH)'ssh',如果不支持讲使用'paramiko'.其他传输选项包括'local', 'chroot','jail'等等

      remote_port = 22 远程SSH端口。 默认是22

      module_lang = C 模块和系统之间通信的计算机语言，默认是C语言

      被控主机信息配置文件，进行分组管理

      hosts

   5. 安装Ansible 并且配置应用

      1）准备工作

      两台被控主机：192.168.31.168 192.168.31.178

      一台主控管理主机：192.168.31.188

      安装要求：

      被控主机：需要安装 Python2.6/2.7

      主控主机：需要安装 Python2.4 以上版本，关闭selinux

      2）配置主机清单

      vim /etc/ansible/hosts

      192.168.31.168

      192.168.31.178

      3）配置控制主机SSH密钥

      在控制主机中生成ssh密钥对

      #ssh-keygen -t rsa

      4）将公钥拷贝到管理主机中.ssh/authorized_keys文件中，实现免密码登录远程管理主机

      ssh-copy-id -i ~/.ssh/id_rsa.pub [email protected]

      ssh-copy-id -i ~/.ssh/id_rsa.pub [email protected]

      （ssh-copy-id命令会自动将id_rsa.pub文件的内容追加到远程主机root用户下.ssh/authorized_keys文件中）

      5)    ansible配置

      vim /etc/ansible/ansible.cfg

      1 禁用每次执行ansbile命令检查ssh key host

      host_key_checking = False

      6）开启日志记录

      log_path = /var/log/ansible.log

      测试：

      #ansible all -m ping

      三、Ansible应用

      1.常用模块使用

      1）setup

      查看远程主机基本信息

      # ansible [HostGroup or IP] -m setup

      2）ping

      测试远程主机运行状态

      # ansible [HostGroup or IP] -m ping

      3）file

      设置文件属性

      相关选项：

      group：定义文件/目录的属组

      mode：定义文件/目录的权限

      owner：定义文件/目录的属主

      path：必选项，定义文件/目录的路径

      recurse：递归设置文件的属性，只对目录有效

      src：被链接的源文件路径，只应用于state=link的情况

      dest：被链接到的路径，只应用于state=link的情况

      force：需要在两种情况下强制创建软链接，一种是源文件不存在，但之后会建立的情况下；另一种是目标软链接已存在，需要先取消之前的软链，然后创建新的软链，有两个选项：yes|no

      state：

      directory：如果目录不存在，就创建目录

      file：即使文件不存在，也不会被创建

      link：创建软链接

      hard：创建硬链接

      touch：如果文件不存在，则会创建一个新文件，如果文件或目录已存在，则更新其最后修改时间

      absent：删除目录、文件或者取消链接文件

   6. ansible实例：

      远程文件链接创建

      # ansible [HostGroup or IP] -m file -a "src=/etc/resolv.conf dest=/tmp/resolv.conf state=link"

      远程文件链接删除

      # ansible [HostGroup or IP] -m file -a "path=/tmp/resolv.conf state=absent"

      copy复制文件到远程主机

      相关选项：

      backup：在覆盖之前，将源文件备份，备份文件包含时间信息。有两个选项：yes|no

      content：用于替代"src"，可以直接设定指定文件的值

      dest：必选项。要将源文件复制到的远程主机的绝对路径，如果源文件是一个目录，那么该路径也必须是个目录

      directory_mode：递归设定目录的权限，默认为系统默认权限

      force：如果目标主机包含该文件，但内容不同，如果设置为yes，则强制覆盖，如果为no，则只有当目标主机的目标位置不存在该文件时，才复制。默认为yes

      others：所有的file模块里的选项都可以在这里使用

      src：被复制到远程主机的本地文件，可以是绝对路径，也可以是相对路径。如果路径是一个目录，它将递归复制。在这种情况下，如果路径使用"/"来结尾，则只复制目录里的内容，如果没有使用"/"来结尾，则包含目录在内的整个内容全部复制，类似于rsync。

      实例：

      将本地文件"/etc/ansible/ansible.cfg"复制到远程服务器

      #ansible [HostGroup or IP] -m copy -a "src=/etc/ansible/ansible.cfg dest=/tmp/ansible.cfg owner=root group=root mode=0644"

      command在远程主机上执行命令

      相关选项如下：

      creates：一个文件名，当该文件存在，则该命令不执行

      free_form：要执行的linux指令

      chdir：在执行指令之前，先切换到该目录

      removes：一个文件名，当该文件不存在，则该选项不执行

      executable：切换shell来执行指令，该执行路径必须是一个绝对路径

      实例：

      # ansible [HostGroup or IP] -m command -a "uptime"

      远程文件信息查看

      # ansible [HostGroup or IP] -m command -a "ls –al /tmp/resolv.conf"

      切换到shell执行指定的指令，参数与command相同。

      与command不同的是，此模块可以支持命令管道，同时还有另一个模块也具备此功能：raw

      实例：

      先在本地创建一个SHELL脚本

      # vim /tmp/test.sh

      #!/bin/sh

      date +%F_%H:%M:%S

      #chmod +x /tmp/test.sh

      将创建的脚本文件分发到远程

      # ansible [HostGroup or IP] -m copy -a "src=/tmp/test.sh dest=/tmp/test.sh owner=root group=root mode=0755"

      远程执行

      # ansible [HostGroup or IP] -m shell -a "/tmp/test.sh"

      cron创建和删除计划任务

      #ansible [HostGroup or IP] -m cron -a "name='....' job='.....' $time"

      -m 跟模块，使用的是 cron 模块

      name= 指定计划任务的名字，方便日后管理

      job= 指定具体的任务

      $time 指定具体的执行时间，minute分钟，hour小时，day 天，month 月份。weekday 0 或者 7 代表周末。

      state= 选项用来指定 name 并删除

      增加计划任务

      # ansible [HostGroup or IP] -m cron -a "name='test cron' job='/bin/bash /tmp/test.sh' weekday=6"

      #ansible [HostGroup or IP] -m cron -a "name='test n' job='/bin/bash /tmp/test.sh' weekday=6 minute=30 hour='*/8'"

      #ansible [HostGroup or IP] -m cron -a "name='test cron' job='/bin/bash /tmp/test.sh' minute=30 hour='*/8' day='1,10,20' weekday=6"

      删除计划任务

      # ansible [HostGroup or IP] -m cron -a "name='test n' state=absent"

      # ansible [HostGroup or IP] -m cron -a "name='test cron' state=absent"

      安装 rpm 包

      -m 使用 yum 模块

      state= installed removed ，不加state选项默认是 installed

      # ansible [HostGroup or IP] -m yum -a "name=tree"

      # ansible [HostGroup or IP] -m yum -a "name=wget"

      # ansible [HostGroup or IP] -m yum -a "name=wget state=removed"

      管理服务

      -m service 模块

      name= 系统服务，可以用 chkconfig --list 查看

      enabled= 是否开机启动，yes| no。

      # ansible [HostGroup or IP] -m service -a "name=httpd state=started enabled=no"

      # ansible [HostGroup or IP] -m service -a "name=httpd state=stopped enabled=yes"

      Ansible 文档使用

      列出所有模块

      # ansible-doc -l

      查看具体的模块使用方法

      # ansible-doc service

      # ansible-doc cron

      # ansible-doc shell

      为Ansible定义节点的清单

      文件 /etc/ansible/hosts 维护着Ansible中服务器的清单。

      [root@artemis ~]# vi /etc/ansible/hosts

      [dbservers]

      192.168.56.212

      192.168.56.213

      尝试在Ansible服务端运行命令

      [root@artemis ~]# ansible -m ping 'dbservers'

      执行shell命令

      例子1：检查Ansible节点的运行时间（uptime):

      [root@artemis ~]# ansible -m command -a "uptime" 'dbservers'

      例子2：检查节点的内核版本

      [root@artemis ~]# ansible -m command -a "uname -r" 'dbservers'

      例子3：给节点增加用户

      [root@artemis ~]# ansible -m command -a "useradd david" 'dbservers'

      [root@artemis ~]# ansible -m command -a "grep david /etc/passwd" 'dbservers'

      例子4：重定向输出到文件中

      ansible -m command -a "df -Th" 'dbservers' > /tmp/command-output.txt

      cat /tmp/command-output.txt

转载于:https://www.cnblogs.com/hxqxiaoqi/p/9720147.html