数据类型

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__':# 指定编码方式为 utf8f = open('D:/Code2022/Python/pythonProjectStudy/table_contents/tmp.txt', 'w', encoding='utf8')# write方法会将字符串编码为utf8字节串写入文件f.write('李嘉图：祝大家学有所成！')# 文件操作完毕后， 使用close 方法关闭该文件对象f.close()# 指定编码方式为utf8f = 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 osif __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 sleepbank = {'count': 0
}bankLock = Lock()# 定义一个函数，作为新线程执行的入口函数
def deposit(theadidx, amount):# 操作共享数据前，申请获取锁bankLock.acquire()balance = bank['count']# 执行一些任务，耗费了0.1秒sleep(0.1)bank['count'] = balance + amountprint(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 sleepdef 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 Threaddef f():while True:b = 53*53if __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 Processdef f():while True:b = 53*53if __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 sleepdef f(taskno, return_dict):sleep(1)# 存放计算结果到共享对象中return_dict[taskno] = tasknoif __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 jsonhistoryTransactions = [{'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 jsonhistoryTransactions = [{'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 timedef 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 resultreturn inner# 返回装饰器return decorator# 使用装饰器装饰函数
@logging("+")
def add(a, b):result = a + breturn result@logging("-")
def sub(a, b):result = a - breturn resultif __name__ == '__main__':result = add(1, 2)print(result)result = sub(1, 2)print(result)

加密

典型应用场景：

校验拷贝下载文件

校验信息有效性

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

示例：

import hashlibif __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 = nameself.score = scoreStudent.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 = nameself.score = scoreStudent.number = Student.number + 1# 定义打印学生信息的方法def show(self):print("Name: {}. Score: {}".format(self.name, self.score))# 定义类方法，打印学生的数量@classmethoddef 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 = nameself.__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 = nameself.__score = score# 利用property装饰器把函数伪装成属性@propertydef 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 = nameself.age = agedef 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 = scoredef 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 = nameself.score = scoreStudent.number = self.number + 1# 定义打印学生信息的方法def show(self):print("Name: {}. Score: {}".format(self.name, self.score))# 静态方法无法使用cls和self参数访问类或实例的变量@staticmethoddef func1():print("this is static function!")