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

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=22,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(1)       #设置超时一秒钟
server=socket.socket()           #创建socket模块的对象server
hosts = ['11111:80','2222222:81','3333333:82']       #将多个ip地址与端口的组合放入列表
for i in hosts:
    ip = re.compile('(.*?):(.*)').search(i).group(1)        #re.compile()为匹配正则，得出的结果为字符串格式
    port = re.compile('(.*?):(.*)').search(i).group(2)         #.*?为非贪婪匹配，反之.*为贪婪匹配。search为编译的主体，group为编译的部分
    res=server.connect_ex((ip,int(port)))                   #判断端口是否启用，ip和端口要用元组格式，返回值为0才算启用。
    if res == 0:
        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)                  #1为相对位置
     f.seek(2,1)           #在当前位置的基础上向右移动两位，读取光标右边所有的字符
     print(f.read().decode('utf-8'))      #因为是bytes类型需要解码
     f.seek(7,1)
     print(f.read().decode('utf-8'))      #--->汉字在bytes类型中占3个光标

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

 

装饰器 

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

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

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

可迭代对象与迭代器对象

#为什么要有迭代器？什么是可迭代对象？什么是迭代器对象？
#1、为何要有迭代器？
# 对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，
#： 若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器
l1=['1','2','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))   # 1
print(next(res))   # 2
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()
即名称空间访问顺序为：局部——全局——内置*   加载顺序是：内置——全局——局部   作用域：产生效果的范围，例一个函数体内