python---模块、变量、函数、字符串

shutil 模块

基本概念

• shutil 可以简单地理解为 sh + util，shell 工具 的意思
• shutil 模块是对 os 模块的补充，主要针对文件的 拷贝、删除、移动、压缩和解压 操作

shutil 模块的主要方法

复制和移动

shutil.copyfileobj(fsrc, fdst)

• 将类似文件的对象 fsrc 的内容复制到类似文件的对象 fdst

• copy 文件内容到另一个文件，可以 copy 指定大小的内容

• 这个方法是 shutil 模块中其它拷贝方法的基础，其它方法在本质上都是调用这个方法

让我们看一下它的源码：

def copyfileobj(fsrc, fdst, length=16*1024):
    while 1:
        buf = fsrc.read(length)
        if not buf:
            break
        fdst.write(buf)

案例：

import shutil
#文件复制与移动
#1.shutil.copyfileobj(源文件操作对象，目标文件的操作对象)
fr = open("/etc/passwd",mode="r")
fw = open("/opt/passwd123",mode="w")
shutil.copyfileobj(fr,fw) #源文件操作对象=fr ,目标文件操作对象=fw
fr.close()
fw.close()


#2. shutil.copyfile(源文件路径，目标文件路径)
shutil.copyfile("/etc/passwd","/opt/passwd456")

shutil.copyfile(src, dst)

• 将名为 src 的文件的内容（无元数据）复制到名为 dst 的文件，然后返回 dst
• 同样看下它的源码，忽略前面一些检测用的代码，该方法的核心在最后几行，我们可以很清楚地看到 copyfile() 方法对 copyfileobj() 进行了调用。

#2. shutil.copyfile(源文件路径，目标文件路径)
shutil.copyfile("/usr/bin/ls","/opt/mylist")

shutil.copy(src, dst)

将文件 src 复制到文件或目录 dst，包括权限

src 和 dst 应为字符串。如果 dst 指定目录，则文件将使用 src 的基本文件名复制到 dst 中。返回新创建的文件的路径。

#3. shutil.copy(源文件路径，目标文件路径)：复制文件的内容与权限
shutil.copy("/usr/bin/ls","/opt/mylist1")

shutil.move(src, dst)

• 递归地将文件或目录（src）移动到另一个位置（dst），并返回目标

#4. shutil.move(源文件路径，目标文件路径)
shutil.move("/opt/mylist","/opt/mylist2")

shutil.copytree(src, dst)

• 递归地复制以 src 为根的整个目录树，返回目标目录。由 dst 命名的目标目录不能已经存在

#目录操作
#1. shutil.copytree(源目录，目标目录)  只有目标目录不存在时候才能复制成功
shutil.copytree("/etc/security","/opt/security")

shutil.rmtree(path)

• 删除整个目录树； **路径 **必须指向目录（而不是指向目录的符号链接）

#2. shutil.rmtree(目录)：删除目录
shutil.rmtree("/opt/security")

权限管理

shutil.copymode(src, dst)

• 将权限位从 src 复制到 dst
• 文件内容，所有者和组不受影响
• src 和 dst 是以字符串形式给出的路径名称

#权限操作
#shutil.copymode(源文件路径，目标文件路径)：只复制文件权限
shutil.copymode("/usr/bin/ls","/opt/mylist123")

shutil.chown(path, user=None, group=None)

• 更改给定 路径 的所有者 用户 和 组

#shutil.chown(文件路径，user="",group="")
shutil.chown("/opt/mylist123",user="haha",group="haha")

subprocess 模块

基础概念

• subprocess 模块主要用于执行 系统命令

• subprocess 模块允许你产生新的进程，连接到它们的 输入 / 输出 / 错误 管道，并获得它们的返回状态

• 通俗地说就是通过这个模块，你可以在 Python 的代码里执行操作系统级别的命令，比如 "ipconfig" 、"du -sh" 等等

run 方法

• subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, timeout=None, check=False, encoding=None, errors=None)

功能：执行 args 参数所表示的命令，等待命令结束，并返回一个 CompletedProcess 类型对象

import subprocess

#run(列表)： 不能读取环境变量
subprocess.run(['ls'])  # 将命令写到列表中，执行linux命令
subprocess.run(['ls', '/home'])  # 将命令和操作的目录写到列表中，执行linux命令
subprocess.run('ls /home')  # 以字符串形式执行linux命令，无法区分命令和目标文件，错误，会把'ls /home 当做一个整体

通过 shell 执行命令

• subprocess.run(['ls', '/home']) 这种方式不支持环境变量，不支持命令的扩展，不支持 shell解释器 下执行命令，所以使用字符串的方式执行 linux命令

#run(str,shell=True):可以读取环境变量
#shell=True: 以shell的方式理解字符串的内容
subprocess.run('ls /home', shell=True)  # 若想以字符串形式执行，指定shell解释器
subprocess.run("echo $PATH",shell=True)

run 方法返回值

• run 方法查看上一级目录下的内容，使用 shell 执行命令

# run 返回值
dc = subprocess.run("ls",shell=True)
print("dc",dc)

# args: 执行的指令 returncode:
dc = subprocess.run("ls /hahahhaha",shell=True)
print("dc:",dc)

dc = subprocess.run("id hahahha",shell=True)
print("dc:",dc)

注意

• subprocess 模块虽然可以支持所有的 linux 命令，但不可乱用，放弃其他的模块
• subprocess 模块编写的代码，不具有跨平台性，不能在 windows，mac 等系统使用

练习 1：调用 ping 命令

#需求

#调用 ping 命令

#编写 ping 函数

#用于测试远程主机的联通性

#ping 通显示：x.x.x.x:up

#ping 不通显示：x.x.x.x:down


import subprocess
def ping(host):

    dc = subprocess.run("ping -c 2 " + host + " &> /dev/null",shell=True)
    #命令的执行结果，成功是0，不成功是非零
    if dc.returncode == 0:
        print(host + ":up")
    else:
        print(host + ":done")
ping("127.0.0.1")

 a.py

#a.py
import b
# a: __main__
print("a:",__name__)

# b:b (模块名)
# a: __main__  main:主

 

 b.py

#b.py
import a
#b: __main__
print("b:",__name__)

# a: a(模块名)
# b: __main__ main:主

---

内置变量，环境不同，值不同

---

c.py

import d
d.dfunc()
# test d

#目标结果:test d
#真实结果
# 这是d模块自己的测试内容
# 不能对外透露
# test d
# test d

d.py

def dfunc():
    print("test d")
#当d是主模块时候，才运行自己的测试代码
print("d:",__name__)
if __name__ == "__main__":
    print("这是d模块自己的测试内容")
    print("不能对外透露")
    dfunc()

 

---

 with打开文件

# #常规打开文件：
# #1.打开文件
# open("/etc/hosts",mode="r")
# #2.文件操作
# print(fr.read())
# #3.关闭资源
# #fr.close()

#打开文件的简写方式 with：
with open("/etc/hosts",mode="r") as fr:  #fr: 变量名
    print(fr.read())
    # fr.close() 可以不写，with会自动关闭文件

python 语法风格和模块布局

变量赋值

1. python支持链式多重赋值

2. python 的多元赋值方法

3. 在python中，完成两个变量值的互换

# 1.多元赋值法
# a = 1
# b = 2
# c = 3
a, b, c, = 1, 2, 3
print(a,b,c)
d, e, f, = ["hello", 100, "world"]
print(d, e, f)
g, h, j, k = "home"
print(g, h, j, k)

# dc1 = 100
# dc2 = 100
# dc3 = 100
# 2.链式赋值
dc1 = dc2 = dc3 =100
print(dc1, dc2, dc3)

# 3.交换俩个变量的值
num01, num02 = 66, 68
num01, num02 = num02, num01
print("num01:",num01)
print("num02:",num02)

4. 给列表使用多重赋值时，两个列表同时指向同一个列表空间，任何一个列表改变，另外一个随着改变

>>> alist = blist = [1, 2]
>>> alist  # 查看列表alist的值
[1, 2]
>>> blist  # 查看列表blist的值
[1, 2]
>>> blist[-1] = 100  # 修改列表blist中的最后一个元素为100
>>> alist  # 当列表blist改变时，alist也会改变
[1, 100]

合法标识符

• Python 标识符，字符串规则和其他大部分用 C 编写的高级语言相似

• 第一个字符必须是 字母或下划线 _

• 剩下的字符可以是字母和数字或下划线

• 大小写敏感

关键字

• 和其他的高级语言一样，python 也拥有一些被称作关键字的保留字符

• 任何语言的关键字应该保持相对的稳定，但是因为 python 是一门不断成长和进化的语言，其关键字偶尔会更新

• 关键字列表和 iskeyword() 函数都放入了 keyword 模块以便查阅

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
>>> "if" in keyword.kwlist     #第一种方法
True
>>> "haha" in keyword.kwlist
False
>>> keyword.iskeyword("and")    # 第二种方法
True
>>> 

练习 2：测试字符串是否为合法标识符

需求

1. 编写用于测试字符串的函数

2. 函数用于确定字符串是否为合法标识符

3. 字符串不能为关键字

# 需求
# 编写用于测试字符串的函数   def check_str(dc)
# 函数用于确定字符串是否为合法标识符
# 字符串不能为关键字
# 第一个字符必须是 字母或者下划线
# 剩下的字符可以是字母和数字或者下划线   dc = "tsest01"
import keyword,string
def check_str(dc):
    first = string.ascii_letters + "_"  #首字符要求
    other = first + string.digits   #其他字符要求
    if dc in keyword.kwlist:  #如果是关键字，那么就不是合法的标识符
        return False
    elif dc[0] not in first:   #如果首字符不满足要求，那么就不是合法的标识符
        return False
    for item in dc[1:]: #对剩余的每一个字符进行条件判断
        if item not in other:
            return False  #如果不满足要求，那么就不是合法的标识符
    return True
if __name__ == "__main__":
    jg = check_str("test01")
    if jg == True:
        print("是合法的标识符")
    else:
        print("不是合法的标识符")

字符串

操作符

• 比较操作符：字符串大小按 ASCII 码值大小进行比较
• 切片操作符：[ ]、[ : ]、[ : : ]
• 成员关系操作符：in、not in

格式化详解

• 可以使用格式化符号来表示特定含义

格式化字符	转换方式
%s	优先用str()函数进行字符串转换
%d	转成有符号十进制数
%f	转成浮点数

百分号

关于整数的输出

print("整数：%d,%d,%d" % (1, 22.22, 33))

 结果：

整数：1,22,33

关于浮点数的输出

print("浮点数：%f,%f " % (1, 22.22))
print("浮点数保留两位小数：%.2f  " % 22.222)

结果：

浮点数：1.000000,22.220000 
浮点数保留两位小数：22.22  

关于字符串的输出

print("字符串：%s,%s,%s" % (1, 22.22, [1, 2]))

结果：

字符串：1,22.22,[1, 2]

 字符串拼接：

name, age, height = "huahua", 18, 180.5
#name: huahua, age: 18, height: 180.5
#字符串的格式化   %s：字符串类型的坑   %d: 整数类型的坑  %f：浮点数类型的坑
# %2f: 保留小数点后的俩位小数
str03 = "name:%s,age:%s,height:%s,l:%s"%(name,age,height,[1,2])
str02 = "name: %s, age: %d, height: %.2f"%(name, age, height)
str01 = "name: "+name+", age:" +str(age)+", height:" + str(height)
print(str01)
print(str02)
print(str03)

注意

• 可以传入任意类型的数据，如 整数、浮点数、列表、元组甚至字典，都会自动转成字符串类型

format 格式化输出

• 相对基本格式化输出采用 % 的方法，format() 功能更强大，该函数把字符串当成一个模板，通过传入的参数进行格式化，并且使用大括号 {} 作为特殊字符代替 %

#字符串的格式化 format
str04 = "name:{},age:{},height:{}".format(name,age,height)
print(str04)

  字符串的其他函数：

#字符串的其他函数
str01 = "hello world"
print(str01.startswith("abc"))#判断是否以‘abc’开头的
print(str01.startswith("hel"))
print(str01.endswith("rld")) #是否以‘rld’结尾
print(str01.isalpha())  #是否由全字母组成
str02 = "123456"
str03 = "hello"
str04 = "HELLO"
print(str03.islower())  #判断str03是否全为小写字母
print(str04.isupper())  #是否全为大写字母
print(str02.isdigit())  #是否全为数字

 字符串的切割与拼接：

str06 = "hello.tar.gz"
dc = str06.split(".") #指定字符对原字符串进行切割
print(dc)  #['hello','tar','gz']

dc1 = "_".join(["hello","tar","gz"]) #指定字符对列表中的元素进行字符串连接
print(dc1)  # hello_tar_gz


str05 = "   aa  bb   "
print(str05.lstrip()) #去除字符串左边的空格
print(str05.rstrip()) #去除字符串右边的空格
print(str05.strip())  #去除字符串左右两边的空格

练习 2：创建用户

#  test03.py
# 编写一个程序，实现创建系统用户的功能
# 提示用户输入 用户名   username = input("用户名")
# 随机生成 8位密码 (导入之前的模块文件)
#       import randpass
#       randpass.new_password()
# 创建用户并设置密码  subprocess.run("", shell=True)
# 将用户相关信息 写入指定文件
import subprocess,randpass
def adduser(user,passwd):
    dc = subprocess.run("id %s &> /dev/null"% user, shell=True)
    if dc.returncode == 0: #表示id执行成功，用户存在，不能创建该用户
        print("用户名已存在")
    else: #表示id执行失败，用户不存在，可以创建该用户
        subprocess.run("useradd %s"%user,shell=True) #创建用户
        subprocess.run(  #为用户设置密码
            "echo %s|passwd --stdin %s"%(passwd, user),shell=True
        )
    # 将用户相关信息 写入指定文件
    fw = open("/opt/user.data",mode="a") # mode="a": 追加写
    fw.write("name:%s, passwd:%s\n"%(user,passwd))
    fw.close()
if __name__ == '__main__':  #当前模块是主模块才能执行的逻辑，其他模块导入不能执行的内容，放到main下面
    username = input("用户名:")
    mima = randpass.new_password()
    adduser(username,mima)   #user = username passwd = mima

#  randpass.py
#练习：生成随机密码
#创建 randpass.py 脚本，要求如下：
#编写一个能生成8位随机密码的程序
#使用 random 的 choice 函数随机取出字符
#由用户决定密码长度
import random,string
def new_password():
    n = int(input("密码长度："))
    password = ""
    all = string.ascii_letters + string.digits
    #random.choice(all)
    for i in range(n):
        dc = random.choice(all)
        password += dc
    # print("passwd:",password)
    return password
if __name__ == '__main__':

# 调用函数，才能执行函数内部逻辑
    dc = new_password()
    print("dc:",dc)