Python-基础学习-第二轮

数据类型

Python 默认拥有以下内置数据类型：

在 Python 中，当您为变量赋值时，会设置数据类型：

如果希望指定数据类型，则您可以使用以下构造函数：

文件

open函数的参数

要读写文件，首先要通过内置函数open 打开文件，获得文件对象。

函数open的参数如下

open(
    file, 
    mode='r', 
    buffering=-1, 
    encoding=None, 
    errors=None, 
    newline=None, 
    closefd=True, 
    opener=None
    ) 

其中下面这3个参数是我们常用的。

• 参数 file

  file参数指定了要打开文件的路径。

  可以是相对路径，比如 ‘log.txt’， 就是指当前工作目录下面的log.txt 文件， 
  也可以是绝对路径，比如 ’d:\project\log\log.txt'，
  

• 参数 mode

  mode参数指定了文件打开的 模式 ，打开文件的模式，决定了可以怎样操作文件。

  常用的打开模式有

  • r 只读文本模式打开，这是最常用的一种模式
  • w 只写文本模式打开
  • a 追加文本模式打开

  如果我们要 读取文本文件内容到字符串对象中 ， 就应该使用 r 模式。

  我们可以发现mode参数的缺省值 就是 ‘r’ 。

  就是说，调用open函数时，如果没有指定参数mode的值，那么该参数就使用缺省值 ‘r’，表示只读打开。

  如果我们要 创建一个新文件写入内容，或者清空某个文本文件重新写入内容， 就应该使用 ‘w’ 模式。

  如果我们要 从某个文件末尾添加内容， 就应该使用 ‘a’ 模式。

• 参数 encoding

  encoding 参数指定了读写文本文件时，使用的 字符编解码 方式。

  调用open函数时，如果传入了encoding参数值：

    后面调用write写入字符串到文件中，open函数会使用指定encoding编码为字节串；
      
    后面调用read从文件中读取内容，open函数会使用指定encoding解码为字符串对象
  

  如果调用的时候没有传入encoding参数值，open函数会使用系统缺省字符编码方式。 比如在中文的Windows系统上，就是使用cp936（就是gbk编码）。

  建议大家编写代码 读写文本文件时，都指定该参数的值。

if __name__ == '__main__':
    # 指定编码方式为 utf8
    f = open('D:/Code2022/Python/pythonProjectStudy/table_contents/tmp.txt', 'w', encoding='utf8')
 
    # write方法会将字符串编码为utf8字节串写入文件
    f.write('李嘉图：祝大家学有所成！')
 
    # 文件操作完毕后， 使用close 方法关闭该文件对象
    f.close()
    # 指定编码方式为utf8
    f = open('D:/Code2022/Python/pythonProjectStudy/table_contents/tmp.txt', 'r', encoding='utf8')
 
    # read 方法会在读取文件中的原始字节串后， 根据上面指定的gbk解码为字符串对象返回
    content = f.read()
 
    # 文件操作完毕后， 使用close 方法关闭该文件对象
    f.close()
 
    # 通过字符串的split方法获取其中用户名部分
    name = content.split('：')[0]
 
    print(name)

with

if __name__ == '__main__':
    f = open('D:/Code2022/Python/pythonProjectStudy/table_contents/tmp.txt', 'w', encoding='utf8')
    f.write('李嘉图：祝大家学有所成！')
    f.close()
 
    with open('D:/Code2022/Python/pythonProjectStudy/table_contents/tmp.txt', 'r', encoding='utf8') as f:
        linelist = f.readlines()
        for line in linelist:
            print(line)
 

附加：文件和目录

文件和目录操作 | 白月黑羽

自调用其他程序

Python中调用外部程序主要是通过两个方法实现的， 一个是os库的 system 函数，另外一个是 subprocess 库。

os.system函数

使用os库的 system 函数 调用其它程序 是非常方便的。就把命令行内容 作为 system 函数的参数 即可

import os
 
if __name__ == '__main__':
    os.system('cd D:/test && mkdir test.txt')

os.system 函数调用外部程序的时候， 必须要等被调用程序执行结束， 才会接着往下执行代码。 否则就会一直等待。

os.system 函数没法获取 被调用程序输出到终端窗口的内容。 如果需要对被调用程序的输出信息进行处理的话， 可以使用 subprocess 模块。

os.startfile 函数

如果我们想达到类似文件浏览器双击打开一个文件的效果可以使用 os.startfile 函数。

这个函数的参数可以是任何 非可执行程序 文件

os.startfile('d:\\统计数据.xlsx')

可以调用该xlsx对应的关联程序（Excel）来打开该文件。

subprocess 模块

Popen 是 subprocess的核心，子进程的创建和管理都靠它处理。

• Python模块之subprocess用法实例详解 - 腾讯云开发者社区-腾讯云
• subprocess --- 子进程管理 — Python 3.9.14 文档

线程和进程

创建新线程

# 从 threading 库中导入Thread类
from threading import Thread
from time import sleep
 
 
# 定义一个函数，作为新线程执行的入口函数
def threadFunc(arg1, arg2):
    print('子线程 开始')
    print(f'线程函数参数是：{arg1}, {arg2}')
    sleep(5)
    print('子线程 结束')
 
 
if __name__ == '__main__':
    print('主线程执行代码')
 
    # 创建 Thread 类的实例对象
    thread = Thread(
        # target 参数 指定 新线程要执行的函数
        # 注意，这里指定的函数对象只能写一个名字，不能后面加括号，
        # 如果加括号就是直接在当前线程调用执行，而不是在新线程中执行了
        target=threadFunc,
 
        # 如果 新线程函数需要参数，在 args里面填入参数
        # 注意参数是元组， 如果只有一个参数，后面要有逗号，像这样 args=('参数1',)
        args=('参数1', '参数2')
    )
 
    # 执行start 方法，就会创建新线程，
    # 并且新线程会去执行入口函数里面的代码。
    # 这时候 这个进程 有两个线程了。
    thread.start()
 
    # 主线程的代码执行 子线程对象的join方法，
    # 就会等待子线程结束，才继续执行下面的代码
    thread.join()
    print('主线程结束')
 

共享数据的访问控制

from threading import Thread, Lock
from time import sleep
 
bank = {
    'count': 0
}
 
bankLock = Lock()
 
 
# 定义一个函数，作为新线程执行的入口函数
def deposit(theadidx, amount):
    # 操作共享数据前，申请获取锁
    bankLock.acquire()
 
    balance = bank['count']
    # 执行一些任务，耗费了0.1秒
    sleep(0.1)
    bank['count'] = balance + amount
    print(f'子线程 {theadidx} 结束')
 
    # 操作完共享数据后，申请释放锁
    bankLock.release()
 
 
if __name__ == '__main__':
    theadlist = []
    for idx in range(10):
        thread = Thread(target=deposit,
                        args=(idx, 1)
                        )
        thread.start()
        # 把线程对象都存储到 threadlist中
        theadlist.append(thread)
    for thread in theadlist:
        thread.join()
 
    print('主线程结束')
    print(f'最后我们的账号余额为 {bank["count"]}')
 

deamon线程

from threading import Thread
from time import sleep
 
 
def threadFunc():
    sleep(1)
    print('子线程 结束')
 
 
if __name__ == '__main__':
    # thread = Thread(target=threadFunc)
    # thread.start()
    # print('主线程结束')
    thread = Thread(target=threadFunc,
                    daemon=True  # 设置新线程为daemon线程
                    )
    thread.start()
    print('daemon主线程结束')
 

多线程

Python 官方解释器 的每个线程要获得执行权限，必须获取一个叫 GIL （全局解释器锁） 的东西。

这就导致了 Python 的多个线程 其实 并不能同时使用 多个CPU核心。

所以如果是计算密集型的任务，不能采用多线程的方式。

from threading import Thread
 
def f():
    while True:
        b = 53*53
 
if __name__ == '__main__':
    plist = []
    # 启动10个线程
    for i in range(10):
        p = Thread(target=f)
        p.start()
        plist.append(p)
 
    for p in plist:
        p.join()

多个CPU核心的运算能力，可以使用Python的多进程库。

from multiprocessing import Process
 
def f():
    while True:
        b = 53*53
 
if __name__ == '__main__':
    plist = []
    for i in range(2):
        p = Process(target=f)
        p.start()
        plist.append(p)
 
    for p in plist:
        p.join()

from multiprocessing import Process, Manager
from time import sleep
 
 
def f(taskno, return_dict):
    sleep(1)
    # 存放计算结果到共享对象中
    return_dict[taskno] = taskno
 
 
if __name__ == '__main__':
    manager = Manager()
    # 创建 类似字典的 跨进程 共享对象
    return_dict = manager.dict()
    plist = []
    for i in range(10):
        p = Process(target=f, args=(i, return_dict))
        p.start()
        plist.append(p)
    for p in plist:
        p.join()
    print('get result...')
    # 从共享对象中取出其他进程的计算结果
    for k, v in return_dict.items():
        print(k, v)
 

JSON

序列化和反序列化

Python中内置了json这个库，可以 方便的把内置的数据对象 序列化为json格式文本的字符串。

import json
 
historyTransactions = [
 
    {
        'time': '20300101070311',  # 交易时间
        'amount': '3088',  # 交易金额
        'productid': '45454455555',  # 货号
        'productname': 'iphone30'  # 货名
    },
    {
        'time': '20300101050311',  # 交易时间
        'amount': '18',  # 交易金额
        'productid': '453455772955',  # 货号
        'productname': '饼干'  # 货名
    }
 
]
 
if __name__ == '__main__':
    # dumps 方法将数据对象序列化为 json格式的字符串
    jsonstr = json.dumps(historyTransactions)
    print(jsonstr)
 

import json
 
historyTransactions = [
 
    {
        'time': '20300101070311',  # 交易时间
        'amount': '3088',  # 交易金额
        'productid': '45454455555',  # 货号
        'productname': 'iphone30'  # 货名
    },
    {
        'time': '20300101050311',  # 交易时间
        'amount': '18',  # 交易金额
        'productid': '453455772955',  # 货号
        'productname': '饼干'  # 货名
    }
 
]
 
if __name__ == '__main__':
    # dumps 方法将数据对象序列化为 json格式的字符串
    jsonstr = json.dumps(historyTransactions)
    print(jsonstr)
    print('================')
    print(json.dumps(historyTransactions, ensure_ascii=False, indent=4))
    print('================')
    jsonstr = '[{"time": "20300101070311", "amount": "3088", "productid": "45454455555", "productname": "iphone7"}, {"time": "20300101070311", "amount": "18", "productid": "453455772955", "productname": "\u5999\u5999\u5999"}]'
    translist = json.loads(jsonstr)
    print(translist)
    print(type(translist))
 

装饰器

Python中装饰器通常用来装饰函数、或者类的方法。

通常被装饰后的函数， 会在原有的函数基础上，增加一点功能。

装饰器经常被用在库和框架中， 给别的开发者使用。

这些库的开发者预料到 使用者 开发的函数可能需要 一些增强的功能。

但是 这些库的开发者 没法去改使用者的代码， 就可以把这些增强的部分做在 装饰器函数中。

这样使用者，只需要在他们的函数前面上@xxx 就使用了这些增强的功能了。

基础示例：

import time
 
 
# 定义一个装饰器函数
def sayLocal(func):
    def wrapper():
        curTime = func()
        return f'当地时间： {curTime}'
 
    return wrapper
 
 
@sayLocal
def getXXXTime():
    print()
    return time.strftime('%Y_%m_%d %H:%M:%S', time.localtime())
 
 
if __name__ == '__main__':
    # 装饰 getXXXTime
    # getXXXTime = sayLocal(getXXXTime)
    print(getXXXTime())
 

进阶示例-被装饰的函数有参数：

import time
 
 
def sayLocal(func):
    def wrapper(*args, **kargs):
        curTime = func(*args, **kargs)
        return f'当地时间： {curTime}'
 
    return wrapper
 
 
@sayLocal
def getXXXTimeFormat1(name):
    curTime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
    return f'{curTime} ，数据采集者：{name} '
 
 
@sayLocal
def getXXXTimeFormat2(name, place):
    curTime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
    return f'{curTime} ，数据采集者：{name} , 采集地：{place}'
 
 
if __name__ == '__main__':
    print(getXXXTimeFormat1('张三'))
    print(getXXXTimeFormat2('张三', place='北京'))
 

进阶示例-装饰器函数自身有参数：

# 添加输出日志的功能
def logging(flag):
    def decorator(fn):
        def inner(num1, num2):
            if flag == "+":
                print("--正在努力加法计算--")
            elif flag == "-":
                print("--正在努力减法计算--")
            result = fn(num1, num2)
            return result
 
        return inner
 
    # 返回装饰器
    return decorator
 
 
# 使用装饰器装饰函数
@logging("+")
def add(a, b):
    result = a + b
    return result
 
 
@logging("-")
def sub(a, b):
    result = a - b
    return result
 
 
if __name__ == '__main__':
    result = add(1, 2)
    print(result)
 
    result = sub(1, 2)
    print(result)
 

加密

典型应用场景：

校验拷贝下载文件

校验信息有效性

使用 Python 内置库 hashlib 创建hash值。

示例：

import hashlib
 
if __name__ == '__main__':
    # 使用 md5 算法
    # m = hashlib.md5()
    # 如果你想使用别的哈希算法，比如， sha256 算法，只需要修改为对应的函数 sha256()即可
    m = hashlib.sha256()
 
    # 要计算的源数据必须是字节串格式
    # 字符串对象需要encode转化为字节串对象
    m.update("ML李嘉图|mllijaitu".encode())
 
    # 产生哈希值对应的bytes对象
    resultBytes = m.digest()
    # 产生哈希值的十六进制表示
    resultHex = m.hexdigest()
    print(resultHex)
 

SSH远程操作

Python第三方库 Paramiko 就是作为ssh客户端远程控制Linux主机 的。

• Python自动化运维 - paramiko模块介绍及使用 - 知乎

exec_command 是每次执行都是 新打开一个channel的东西执行，
 
每个channel都是命令执行的环境，每执行命令都是一个新的执行环境，不在上次执行的环境里面，
 
相当于 每次都在各自的执行环境里面，和前面的执行环境没有关系。
 
多个命令一起执行，用分号隔开，像这样：
 
stdin, stdout, stderr = ssh.exec_command("cd testdir;pwd")
 

操作单台主机：

# 单台主机操作
import paramiko
 
#############################配置信息#####################################
# 登陆参数设置
hostname = ""
host_port = 22
username = "root"
password = ""
 
 
########################################################################
 
def ssh_client_con():
    """创建ssh连接，并执行shell指令"""
    # 1 创建ssh_client实例
    ssh_client = paramiko.SSHClient()
    # 自动处理第一次连接的yes或者no的问题
    ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy)
    # 2 连接服务器
    ssh_client.connect(
        port=host_port,
        hostname=hostname,
        username=username,
        password=password
    )
    # 3 执行shell命令
    # 构造shell指令
    shell_command = "ls"
    stdin, stdout, stderr = ssh_client.exec_command(shell_command)
    # 输出返回信息
    stdout_info = stdout.read().decode('utf8')
    print(stdout_info)
    # 输出返回的错误信息
    stderr_info = stderr.read().decode('utf8')
    print(stderr_info)
 
 
def sftp_client_con():
    # 1 创建transport通道
    tran = paramiko.Transport((hostname, host_port))
    tran.connect(username=username, password=password)
    # 2 创建sftp实例
    sftp = paramiko.SFTPClient.from_transport(tran)
    # 3 执行上传功能
    local_path = ""  # 本地路径
    remote_path = ""  # 远程路径
    put_info = sftp.put(local_path, remote_path, confirm=True)
    print(put_info)
    print(f"上传{local_path}完成")
    # 4 执行下载功能
    save_path = ""  # 本地保存文件路径
    sftp.get(remotepath=remote_path, localpath=save_path)
    print(f'下载{save_path}完成')
    # 5 关闭通道
    tran.close()
 
 
if __name__ == '__main__':
    # 调用函数执行功能
    ssh_client_con()
    # sftp_client_con()
 

Python面向对象编程

类变量与实例变量

# 创建一个学生类
class Student:
    # number属于类变量，不属于某个具体的学生实例
    number = 0
    
    # 定义学生属性，初始化方法
    # name和score属于实例变量
    def __init__(self, name, score):
        self.name = name
        self.score = score
        Student.number = Student.number + 1
    
    # 定义打印学生信息的方法
    def show(self):
        print("Name: {}. Score: {}".format(self.name, self.score))
 
# 实例化，创建对象
student1 = Student("John", 100)
student2 = Student("Lucy", 99)
 
print(Student.number)  # 打印2
print(student1.__class__.number) # 打印2

类方法

有些变量只属于类，有些方法也只属于类，不属于具体的对象。

你有没有注意到属于对象的方法里面都有一个self参数, 比如__init__(self), show(self)?

self是指对象本身。

属于类的方法不使用self参数， 而使用参数cls，代表类本身。

另外习惯上对类方法我们会加上@classmethod的修饰符做说明。

class Student:
    # number属于类变量，不属于某个具体的学生实例
    number = 0
 
    # 定义学生属性，初始化方法
    # name和score属于实例变量
    def __init__(self, name, score):
        self.name = name
        self.score = score
        Student.number = Student.number + 1
 
    # 定义打印学生信息的方法
    def show(self):
        print("Name: {}. Score: {}".format(self.name, self.score))
 
    # 定义类方法，打印学生的数量
    @classmethod
    def total(cls):
        print("Total: {0}".format(cls.number))
 
 
if __name__ == '__main__':
    # 实例化，创建对象
    student1 = Student("John", 100)
    student2 = Student("Lucy", 99)
 
    Student.total()  # 打印 Total: 2
 

类的私有属性和私有方法

类里面的私有属性和私有方法以双下划线__开头。私有属性或方法不能在类的外部被使用或直接访问。

# 创建一个学生类
class Student:
 
    # 定义学生属性，初始化方法
    # name和score属于实例变量, 其中__score属于私有变量
    def __init__(self, name, score):
        self.name = name
        self.__score = score
    
    # 定义打印学生信息的方法
    def show(self):
        print("Name: {}. Score: {}".format(self.name, self.__score))
 
# 实例化，创建对象
student1 = Student("John", 100)
 
student1.show()  # 打印 Name: John, Score: 100
student1.__score  # 打印出错，该属性不能从外部访问。

@property

# 创建一个学生类
class Student:
 
    # 定义学生属性，初始化方法
    # name和score属于实例变量, 其中score属于私有变量
    def __init__(self, name, score):
        self.name = name
        self.__score = score
 
    # 利用property装饰器把函数伪装成属性
    @property
    def score(self):
        print("Name: {}. Score: {}".format(self.name, self.__score))
 
 
if __name__ == '__main__':
    # 实例化，创建对象
 
    student1 = Student("John", 100)
 
    student1.score  # 打印 Name: John. Score: 100
 

类的继承

# 创建父类学校成员SchoolMember
class SchoolMember:
 
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def tell(self):
        # 打印个人信息
        print('Name:"{}" Age:"{}"'.format(self.name, self.age), end=" ")
 
 
# 创建子类老师 Teacher
class Teacher(SchoolMember):
 
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)  # 利用父类进行初始化
        self.salary = salary
 
    # 方法重写
    def tell(self):
        SchoolMember.tell(self)
        print('Salary: {}'.format(self.salary))
 
 
# 创建子类学生Student
class Student(SchoolMember):
 
    def __init__(self, name, age, score):
        SchoolMember.__init__(self, name, age)
        self.score = score
 
    def tell(self):
        SchoolMember.tell(self)
        print('score: {}'.format(self.score))
 
 
if __name__ == '__main__':
    teacher1 = Teacher("John", 44, "$60000")
    student1 = Student("Mary", 12, 99)
    teacher1.tell()
    student1.tell()
 

静态变量和静态方法

# 创建一个学生类
class Student:
    # number属于类变量，定义在方法外，不属于具体实例
    number = 0
 
    # 定义学生属性，初始化方法
    # name和score属于实例变量，定义在方法里
    def __init__(self, name, score):
        self.name = name
        self.score = score
        Student.number = self.number + 1
 
    # 定义打印学生信息的方法
    def show(self):
        print("Name: {}. Score: {}".format(self.name, self.score))
 
    # 静态方法无法使用cls和self参数访问类或实例的变量
    @staticmethod
    def func1():
        print("this is static function!")