python函数与模块（装饰器，文件处理，迭代器等）

paramiko:模仿ssh连接linux运行命令以及上传下载

import paramiko ---》先下载模块加载
ssh =paramiko.SSHClient()         ----》创建ssh对象
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())  ---》此设置作用为忽略not found known hosts文件的报错
ssh.connect(hostname='192.168.253.135',port=,username='root',password='369369nx')    ---》将主机名，端口号，用户名，密码输入
while True:
    stdin,stdout,stderr = ssh.exec_command(input('--->:').strip())     ----》自定义输入命令
    res = stdout.read().decode('utf-8') + stderr.read().decode('utf-8')   ---》将标准输出与错误输出结合
    print(res)

hostname = '192.168.253.135'   --->linux的ip地址 1
port = 22         ----》ssh端口号 2
username = 'root'         ---》用户名 3
password = '369369ynx'     ---》密码 4
t=paramiko.Transport((hostname,port))     ---》主机名和端口，注意要以元组的格式输入。
t.connect(username=username,password=password)      ---》这里不需要更改，固定格式，如果更改可省略1 2 3 4步骤
sftp = paramiko.SFTPClient.from_transport(t)
sftp.put(r'‪C:\Users\zzz\Desktop\a.txt','/root/b.txt')     ---》文件的绝对路径上传到linux目录下指定文件名，文件名可以修改
sftp.get('/root/b.txt',r'‪C:\Users\zzz\Desktop\a.txt')     ---->将lilnux目录下的文件下载到指定地方并重命名
sftp.close() 

os模块：

利用python调用系统命令

 os.system('命令')  利用python调用系统命令,命令可以是以列表或者元组内的元素形式*  res
 import os
 res=os.system('ipconfig')
 print(res)       # ----> ...0 如果返回0,则证明执行结果成功，其他值失败。可以此来验证命令是否执行成功。*
 cmd=['ipconfig','systemctl restart network','setenforce 0']
 for i in cmd:
     res = os.system(i)
     print(res)        ----> 0 1 1 即ipconfig成功，其他两个失败

 res=os.path.exists(r'D:\charm日常\a.txt')   #----》查看文件的绝对路径，如果是同级目录直接写文件名。 res
 if res:                           #----》判断此文件是否存在
     print('文件存在')
 else:
      os.system('dir')   #--->如果不存在列出目录
 print(res)  #--->false 布尔，可用此来判断文件是否存在

 os.remove('a.txt')  --->a.txt文件被删除

 os.path.join:拼接路径 res
 HOME = 'etc/yum.repo.d/'
 res=os.path.join(HOME,'a.txt')   --->变量不需要引号
 print(res)     ---->etc/yum.repo.d/a.txt 成功拼接成一个路径

 os.rename:重命名
 os.rename('250.txt','250.py')  #--->250.txt改名为250.py,不同后缀也可重命名

configparser模块：

读取配置文件

 import configparser
 config = configparser.ConfigParser()
 config.read(r'D:\charm日常\mariadb.repo',encoding='utf-8')       #绝对路径（相对路径） / utf-8，其他操作的的前提
 注意如果读文件时没有r不会报错，但是会影响读取结果
 config.add_section('zzz')                                       #-->添加小模块

 config.set('zzz','baseurl','http://1929393')        #------》设置模块，变量名，变量值，都用引号，注意模块必须存在才能设置，如果
　　变量存在，则会刷新变量值

 config.write(open('mariadb.repo','w'))         #设置完要写入，才算保存了。 格式为.write（open('文件名',‘w'))

 res=config.has_section('zzz')
 print(res)                 #--->true   布尔

 config.remove_option('zzz','baseurl')     #---->删除zzz模块的baseurl这个变量，删除玩写入保存才生效
 config.write(open('mariadb.repo','w'))

 config.remove_section('hhh')             # ----->将hhh这个模块的所有内容都删除
 config.write(open('mariadb.repo','w'))

 res=config.sections()           #--->['zzz', 'hhh'] 将变量以列表格式输出
 print(res)

 res=config.get('zzz','baseurl')       #---->查看zzz模块的变量的 变量值
 print(res)

sock模块：

基于端口号和ip地址实现监控通信等

import socket         #加载socket模块
import re             #加载re模块
socket.setdefaulttimeout()       #设置超时一秒钟
server=socket.socket()           #创建socket模块的对象server
hosts = ['11111:80','2222222:81','3333333:82']       #将多个ip地址与端口的组合放入列表
for i in hosts:
    ip = re.compile('(.*?):(.*)').search(i).group()        #re.compile()为匹配正则，得出的结果为字符串格式
    port = re.compile('(.*?):(.*)').search(i).group()         #.*?为非贪婪匹配，反之.*为贪婪匹配。search为编译的主体，group为编译的部分
    res=server.connect_ex((ip,int(port)))                   #判断端口是否启用，ip和端口要用元组格式，返回值为0才算启用。
    if res == :
        print('端口启用')
    else:
        print('端口没启用')
# 非贪婪匹配：在限制字符前尽可能少的匹配;
# 贪婪匹配：极可能多的匹配

文件处理知识点

 with open (r'C:\Users\zzz\Desktop\1.txt.txt','w',encoding='utf-8') as f:
     res=f.readlines()      --->['邻家有女初长成']将文件内容按列表格式读出
     print(res)
     res=f.read(3)     #---->邻家有， 读取光标从左到右三个字符，而不是第三个字符
     print(res)
     print(f.read(2))    #----》光标在’有‘后面再往右读取两个字符

     f.write('吧，baba')    #---->f.wirte没有返回值，效果直接体现在文件中
     f.writelines(['吧，爸爸'])   #--->括号内可以是字符，元组或者列表，写进文件后都是以字符形式出现

     print(f.readable())    ---->false 不可读。因为上面权限是w

 with open (r'C:\Users\zzz\Desktop\1.txt.txt','rb') as f:
     print(f.read())        #asdf爸爸---->b'asdf\xe7\x88\xb8\xe7\x88\xb8'  前面 b 表示bytes类型，英文可以直接用b读取，但是汉字会读取为二进制类型。
     print(f.read().decode('utf-8'))      --->asdf爸爸 ,因为f里面的类型为rb，已经转码过，所以这里直接decode解码就行。#只能转码成二进制，解码成utf-8.

 with open(r'C:\Users\zzz\Desktop\1.txt.txt', 'r') as f:
     data=f.read().encode()  ---->将文件内容转为二进制类型，如果内容里面没有汉字，可直接在上方类型中加个b。b相当于.encode,但是如果有汉字则必须用encode
     # print(data)
     res=data.decode('utf-8') ----》二进制转码后需要decode解码
     print(res)

 with open(r'D:\charm日常\mariadb','rb') as f:     #光标的移动只能在bytes类型下，除了0为光标置顶格，在两种类型下都可以
      f.read()                  #1为相对位置
      f.seek(,)           #在当前位置的基础上向右移动两位，读取光标右边所有的字符
      print(f.read().decode('utf-8'))      #因为是bytes类型需要解码
      f.seek(,)
      print(f.read().decode('utf-8'))      #--->汉字在bytes类型中占3个光标

      f.seek(,)    #(,)代表把光标移动到末尾
      data =f.read()
      print(data)    #--->b''  光标在末尾所以无法读取任何内容
      f.seek(-,)
      data=f.read()
      print(data)      #--->b'f'  光标在末尾，再往走移动一个光标

装饰器

在不改变源代码和调用方式的基础之上给函数增加新的功能

1 def deco(lala):  # --->定义形参为lala
     def wrapper():
         lala()          #这里的作用是调用test(),所以要设置形参lala=test
         print('')
     return wrapper    #--->这个是deco（）的调用结果，注意位置，如果再缩进就成了wrapper（）的调用结果

 @deco          #---》test = deco(test)  意思为test这个内存地址为deco（）的调用结果也就是test = wrapper; 然后形参为test=lala.
 def test():
     print('')
10test()

可迭代对象与迭代器对象

 #为什么要有迭代器？什么是可迭代对象？什么是迭代器对象？
 #1、为何要有迭代器？
 # 对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，
 #： 若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器
 l1=['','','a']
 t1=(1,2,3)
 str=('13daf')
 d1={'a':'g',"aa":1}
 set={1,2,'a'}
 res=iter(l1.__iter__())    # 也可以写成res=iter(l1)
 print(next(res))   #
 print(next(res))   #
 print(next(res))   # a     打印一次返回一个值，而不同for循坏一样会自动循坏所有值
 print(next(res))   # StopIteration 停止迭代

名称与作用域

def f1():
    def f2():
        def f3():
            print(x)
        f3()          #---->嵌套的函数f3被调用后，函数体才生效报错，因为在f3局部空间内还是在全局都找不到变量的值。
    f2()
f1()

def f1():
    def f2():
        x=1
        def f3():
            print(x)--->在f2中找到了x的赋值，但是这建立在f2被调用的前提下*/变量的赋值先是在本局部空间中寻找，然后是其他局部，然后才是全局和内置。
        f3()
    f2()
f1()
即名称空间访问顺序为：局部——全局——内置*   加载顺序是：内置——全局——局部   作用域：产生效果的范围，例一个函数体内