python

恭喜你！在后悔之前看到了这篇最详细的python学习脉络。包含python的方方面面，从初级到高级，学完之后可以直接去面试10万年薪公司。给自己多学一个一技之长，技多不压身，何乐而不为呢。喜欢请点赞收藏！关注我，能持续获取优质导图哦。

Python

• 基础
  • string、list、tuple
    • list
      • 列表是动态的, 长度大小不固定, 可以任意的增加、删除、修改
        • append
          • list01.append(1)
            • 添加单个元素到列表中
        • __sizeof__
          • list01_size = list01.__sizeof__()
            • 查看列表大小
        • list增
          • append
            • 添加至列表末尾
          • insert
            • 插入到指定位置
          • extend
            • 整体扩充到指定列表
        • list删
          • remove
            • 指定元素删除
          • pop
            • 指定元素索引号删除
          • clear
            • 清空列表
        • list改
          • reverse
            • 把列表中的元素位置反转
          • sort
            • 按照从小到大的顺序排序,但限于列表中只有一种元素
          • list01[2] = "string"
            • 指定索引号直接更改索引位置上的元素值
        • list查
          • count
            • 统计特定元素的个数
              • number = list01.count(1)
          • index
            • 按照给定的索引范围查找指定元素的索引号
              • index = list01.index(3.14, 0, len(list01))
    • tuple
      • 元组是静态的, 长度大小固定, 不能增删改
        • tuple的查询方法
          • count
            • tuple01 = (2, 4.445, True, False, "String Type")
            • number = tuple01.count(1)
            • 统计元素1的数量
          • index
            • index = tuple01.index("String Type")
            • 查找元素"String Type"的索引号
    • string
      • split
        • str01_split = str01.split(" ")
          • 以空格作为分隔符对字符串进行分割操作,生成的是一个列表
      • replace
        • str01_replace = str01.replace('o', '0')
          • 替换字符串中的旧字符为新字符
      • str01 = str01[1:] + "P"
        • 字符串的加法
      • strip
        • str01.strip(str)
          • 去掉首尾的str,不填参数时默认为空格
        • str01.lstrip(str)
          • 去掉开头的str
        • str01.rstrip(str)
          • 去掉尾部的str
    • list与tuple之间可以相互转换
      • list02 = tuple(list01)
      • tuple02 = list(tuple01)
    • tuple、list都支持索引查询、切片操作
      • list01_len = len(list01) tuple01_len = len(tuple01)
        • 求列表(元组)的长度
      • for index in range(len(list01))
        • 利用索引遍历列表
      • for index in range(len(tuple01)):
        • 利用索引遍历元组
      • for element in list01:
        • 直接对列表中的元素进行遍历
      • for element in tuple01:
        • 直接对元组中的元素进行遍历
  • dict&set
    • dict字典的基本操作
      • 字典的查询方式
        • 取字典中键对应的值,利用字典中的键(唯一)取到对应的值
          • print(ips['1.1.1.1'])
        • 遍历字典中的键(唯一的),会生成单一的字符串或数字
          • for keys in ips.keys():
        • 遍历字典中的值(不唯一),会生成单一的字符串或数字
          • for values in ips.values():
        • 遍历字典中的键值对,会生成由键和值组成的元组
          • for item in ips.items():
      • 字典的增
        • setdefault
          • 新增,如果字典中原有则无改变
        • update
      • 字典的删
        • pop
          • 删除指定键值对
        • popitem
          • 删除最后一个键值对
        • clear
          • 清空字典
        • del dic
          • 删除字典
      • 字典的改
        • update
    • Set集合的基本操作
      • add
        • 在集合中添加单个数据
      • update
        • 在集合中添加多个数据
      • remove
        • 删除集合中指定的元素
  • file文件操作
    • 文件的读取操作 file = open(file="./txtFile/kingdoms.txt", mode="r", encoding="utf8")
      • read
        • content = file.read()
          • 读取全文
      • readline
        • content = file.readline()
          • 读取文件中的行
      • readlines
        • content = file.readlines()
          • 读取文章中所有的行,把各个行作为列表中的元素
    • 文件的写操作 file = open(file="./txtFile/king.txt", mode="a", encoding='utf8')
      • write
        • 写入操作
      • writelines
        • 一次性添加多行内容
  • Json
    • Json格式序列化
      • dumps只把数据类型转换成字符串
        • json_str = json.dumps(test_dict)
      • dump把数据类型转换成字符串并存储在文件中
        • with open('params.json', 'w') as fout:
        • params_str = json.dump(params, fout)
          • dumps将数据转换成字符串,并写入文件
      • loads只把字符串转换成数据类型
      • load把文件打开从字符串转换成数据类型并输出
        • with open('params.json', 'r') as fin:
        • original_params = json.load(fin)
          • load将数据转换成字典类型,并赋值到变量
  • 函数
    • global
      • 不能随意的更改全局变量,除非加上global关键字
    • nonlocal
      • 函数嵌套中,内部函数想要修改外部函数的变量,需要加上nonlocal
  • 高级函数
    • os
      • 企业案例: 递归统计目录中的文件夹及文件 import os dirC = fileC = 0 def getDir(path): for file in os.listdir(path): fileAbs = os.path.join(path, file) if os.path.isdir(fileAbs): global dirC dirC += 1 getDir(fileAbs) else: global fileC fileC += 1 return dirC, fileC dirCount, fileCount = getDir("/Users/chaoliu/Documents") print('dirCount: {}, fileCount: {}'.format(dirCount, fileCount))
      • os.path
        • os.path.isdir(name)
          • 判断name是不是一个目录,name不是目录就返回false
        • os.path.isfile(name)
          • 判断name是不是一个文件,不存在name也返回false
        • os.path.exists(name)
          • 判断是否存在文件或目录name
        • os.path.getsize(name)
          • 获得文件大小,如果name是目录返回0L
        • os.path.abspath(name)
          • 获得绝对路径
        • os.path.split(name)
          • 分割文件名与目录
        • os.path.splitext()
          • 分离文件名与扩展名
        • os.path.join(path,name)
          • 连接目录与文件名或目录
        • os.path.basename(path)
          • 返回文件名
        • os.path.dirname(path)
          • 返回文件路径
      • os.listdir(dirname)
        • 列出dirname下的目录和文件
      • os.getcwd()
        • 获得当前工作目录
      • os.chdir(dirname)
        • 改变工作目录到dirname
      • os.remove(dir)
        • dir为要删除的文件夹或者文件路径
      • os.rmdir(path)
        • path要删除的目录的路径,必须为空
    • 高阶函数
      • map(function, iterable)
        • # map(function, iterable) # 第一个参数function就是一个能实现某种功能的函数 # 第二个参数iterable就是一个可以遍历的集合 # map的功能就是对集合中每个元素都使用function从而返回结果(返回的结果是迭代器) def func01(element): return element ** 2 list01 = [1, 2, 3] n = map(func01, list01) print(list(n))
        • 第一个参数function就是一个能实现某种功能的函数
        • 第二个参数iterable就是一个可以遍历的集合
        • map的功能就是对集合中每个元素都使用function从而返回结果(返回的结果是迭代器)
      • filter(function, iterable)
        • # filter(function, iterable) # 第一个参数function就是一个能实现某种功能的函数 # 第二个参数iterable就是一个可以遍历的集合 # filter的功能就是对集合中每个元素进行过滤符合条件(True)的留下,不符合条件(False)的剔除掉 def residual(element): if element % 2 == 0: return element result = filter(residual, range(10)) print(list(result))
        • filter的功能就是对集合中每个元素进行过滤符合条件(True)的留下,不符合条件(False)的剔除掉
      • reduce(function, iterable)
        • # reduce(function, iterable) # 第一个参数function就是一个能实现某种功能的函数 # 第二个参数iterable就是一个可以遍历的集合 # reduce的功能就是返回集合中所有元素相乘的结果 from functools import reduce def nick(x, y): return x * y number = [1, 2, 3, 4, 5] prod = reduce(nick, number) print(prod)
        • reduce的功能就是返回集合中所有元素相乘的结果
  • 匿名函数
    • 使用匿名函数快速生成列表
      • square = [(lambda x: x**2)(x) for x in range(10)]
    • 使用匿名函数针对字典中的IP访问次数排序
      • ips = [('1.1.1.1', 12), ('2.2.2.2', 43), ('3.3.3.3', 11), ('4.4.4.4', 76), ('5.5.5.5', 16)]
      • ips.sort(key=lambda x: x[1])
    • sorted(iterable, key=functions, reverse=True/False)
      • ips = [('1.1.1.1', 12), ('2.2.2.2', 43), ('3.3.3.3', 11), ('4.4.4.4', 76), ('5.5.5.5', 16)]
      • ipsOpera = sorted(dict(ips).items(), key=lambda x: x[1], reverse=True)
      • 第一个参数iterable就是一个可以遍历的集合
      • 第二个参数function就是一个能实现某种功能的函数或表达式
      • 第三个参数reverse=True/False标定是否实现反序
      • 注意: sorted()本身就具备排序功能
  • decorator装饰器
    • 简单的装饰器
      • def myDecorator(func): # 定义装饰器 def wrapper(): print('wrapper of decorator') func() return wrapper # @myDecorator # 语法糖 def greet(): print('hello world') Greet = myDecorator(greet) # 装饰器中传入函数,并赋值变量 Greet() # 使用变量调用函数
      • 上述代码中, 变量Greet指向了装饰器内部函数wrapper(), 而wrapper()又会去调用传入的函数greet, 调用greet之前,会先去打印‘wrapper of decorator’再调用greet函数, 从而打印‘hello world’, 这时我们就完成了对greet函数的装饰操作.
    • 带参数的装饰器
      • 如果原函数是带有参数的函数, 调用时需要传递参数到原函数, 但是又想利用装饰器对其进行装饰, 请参照如下例子.
        • def myDecorator(func): def wrapper(message): print('use decorator...') func(message) return wrapper @myDecorator def greet(info): print(info) greet('hello world')
      • 如果原函数中需要传入多个参数, 又想使用装饰器对其装饰, 可以参照如下列子.
        • def myDecorator(func): def wrapper(*args, **kwargs): print('use decorator...') func(*args, **kwargs) return wrapper @myDecorator def greet(name, classic): print(name, classic) greet('hello', 'world')
    • @functiontools.wraps(func)
      • 解决原函数改变的问题
        • import functools def myDecorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): print('use decorator...') func(*args, **kwargs) return wrapper @myDecorator def greet(name, sex): print('My name: {}, Sex: {}'.format(name, sex)) greet('bavduer', 'm') print(greet.__name__) print(help(greet))
  • 面向对象OOP
    • 类: 指把具有相同特性和行为的对象抽象为类, 类的特性通过数据来体现、类的行为通过函数来实现
    • 类的特性: 称为属性, 代表着这个类共有的数据
    • 类的行为: 称为方法, 方法可以对类内的数据(也就是属性)进行操作从而得出想输出的结果
    • @classmethod
      • 类方法(比实例化更加清晰的创建类)
    • @staticmethod
      • 静态方法(与类基本没关系,可以再类内完成)
  • 反射, 封装, 继承
    • 继承
      • - 子类可以继承父类的属性, 同时还可以修改父类的属性值, 就是自定义值
      • - 子类可以继承父类的方法, 同时还可以对父类的方法进行功能性改造
      • - 继承属性时要进行特殊声明, 而继承方法的时候则什么也不需要做; 值得说明的是属性和方法是一起被继承的
    • 封装
      • 封装: 在声明类的过程中把属性、方法全部放在类中, 在需要的时候在外部进行调用, 使用者并不需要知道内部方法是怎么实现的. 更加高级的玩法是把子类中共用的方法全部集中到父类中, 使得程序更加简洁有力, 逻辑更加清晰.
        • - 子类对象 不能在自己的方法内部直接访问父类的私有属性或私有方法
        • - 子类对象 可以通过父类的公有方法间接访问到 私有属性或 私有方法
    • 内省
      • isinstance
      • 内省: 就是把实例中的属性, 方法利用dir()函数结构化成列表数据结构显示出来
      • 这种机制方便我们使用isinstance(实例名, (类名01, 类名02, ..., 类名n)) 函数来检查某个实例是否是来自某个类, 传入isinstance()函数中的元组里的关系属于**或者**关系
    • 反射
      • hasattr
        • hasattr()查询对象中的方法,返回bool值
      • getattr
        • getattr()获取对象中的方法,利用字符串获取其中的方法,用变量接收
      • delattr
        • delattr()删除对象中的属性
      • setattr
        • setattr()设置对象中的属性
  • 面向对象高级编程
    • 魔术方法
      • __init__
        • 构造函数(实例化时调用)
      • __del__
        • 析构函数(实例回收时调用)
      • __str__
        • 当对象被print打印时会被自动的调用
      • __new__
        • 声明多个对象时可以节约内存(也称单实例模型), 相当于换了一种声明类的方式
      • __call__
        • 让使用实例时可以像使用函数一样简单
  • 异常处理
    • try…except…finally…
      • Exception是其他所有非系统异常的基类,能够匹配任意非系统异常
    • 自定义异常抛出
      • raise
• 进阶
  • 模块
    • 将函数封装，使用from （filename） import （functions_name classname）
  • 反射导入模块
    • __impor__
      • pages = __import__('(指定的一个模块)', fromlist=True)
  • 标准库
    • fnmatch fnmatch() 函数根据指定的模式来匹配文件名或字符串。
      • fnmatch
        • 判断文件名是否符合特定的模式。
      • fnmatchcase
        • 判断文件名是否符合特定模式，并且区分大小写。
      • filter
        • 返回输入列表中符合特定模式的文件名列表。
      • translate
        • 将通配符模式转换成正则表达式。
    • os
      • os.walk
        • 遍历当前目录及其子目录下所有的文件, walk()会返回一个三元组(dirpath, dirnames, filenames)
          • dirpath
            • 保存的当前目录
          • dirnames
            • 当前目录下的子目录列表
          • filenames
            • 当前目录下的文件列表
      • os.path
        • os.path.isdir(name)
          • 判断name是不是一个目录,name不是目录就返回false
        • os.path.isfile(name)
          • 判断name是不是一个文件,不存在name也返回false
        • os.path.exists(name)
          • 判断是否存在文件或目录name
        • os.path.getsize(name)
          • 获得文件大小,如果name是目录返回0L
        • os.path.abspath(name)
          • 获得绝对路径
        • os.path.split(name)
          • 分割文件名与目录
        • os.path.splitext()
          • 分离文件名与扩展名
        • os.path.join(path,name)
          • 连接目录与文件名或目录
        • os.path.basename(path)
          • 返回文件名
        • os.path.dirname(path)
          • 返回文件路径
      • os.listdir(dirname)
        • 列出dirname下的目录和文件
      • os.getcwd()
        • 获得当前工作目录
      • os.chdir(dirname)
        • 改变工作目录到dirname
      • os.remove(dir)
        • dir为要删除的文件夹或者文件路径
      • os.rmdir(path)
        • path要删除的目录的路径,必须为空
    • sys
      • sys.exit(number)退出当前程序并返回括号中的状态码
    • re
      • 支持正则表达式模块
    • random
      • 验证码生成器 # coding: utf8 # author: bavduer # usage: study random import random def verificationCode(number): """ product verification code of user input number :param number: verification code's number :return: verification code """ vCode = '' for n in range(number): nums = random.randint(0, 9) word = chr(random.randint(65, 90)) middle = random.choice([nums, word]) vCode += str(middle) return vCode verCode = verificationCode(4) print(verCode) userInput = input('Please input verification code: ') if userInput.lower() != verCode.lower(): print('your Stupid !') else: print('please load...')
      • 随机产生字符
        • random.random()
          • 随机产生一个0-1之间的小数
        • random.uniform(0-9)
          • 随机产生一个0-9之间的小数
        • random.randint(1-9)
          • 随机产生一个1-9之间的整数
        • random.choice(list)
          • 随机输出列表中的某个元素
        • random.shuffle(list)
          • 打乱列表中的元素
    • logging
      • 日志处理模块
        • formatters
          • 日志格式化器
        • handlers
          • 日志处理器
        • loggers
          • 日志记录器
        • import logging.config logging.config.fileConfig('./logconfig.ini')
  • 第三方模块
    • psutil
      • 监控模块,用以采集系统基础信息
        • CPU(信息)
          • psutil.cpu_times()
            • 获取cpu信息 import psutil cpuInfo = psutil.cpu_times() # 获取cpu完整信息 print('User Time: ', cpuInfo.user) print('System Time: ', cpuInfo.system) print('IOwait Time: ', cpuInfo.iowait) print('Idle Time: ', cpuInfo.idle) cpuCount = psutil.cpu_count() print('Cpu Count: ', cpuCount)
            • .user
              • 执行用户进程的时间百分比
            • system
              • 执行内核进程和中断的时间百分比
            • iowait
              • 由于IO等待而使CPU处于idle(空闲)状态的时间百分比
            • idle
              • CPU处于idle状态的时间百分比
        • 内存Memory(信息)
          • psutil.virtual_memory()
            • # 获取完整的物理内存信息 import psutil memInfo = psutil.virtual_memory() print('Memory Total: {:.2f}GB'.format(memInfo.total/1024/1024/1024)) print('Memory Used: {:.2f}GB'.format(memInfo.used/1024/1024/1024)) print('Memory Free: {:.2f}GB'.format(memInfo.free/1024/1024/1024)) print('Memory Buffer:{:.2f}GB'.format(memInfo.buffers/1024/1024/1024)) print('Memory Cache: {:.2f}GB'.format(memInfo.cached/1024/1024/1024))
            • total(内存总数)
            • used(已使用的内存数)
            • free(空闲内存数)
            • buffers(缓冲使用数)
            • cache(缓存使用数)
            • swap(交换分区使用数)
          • psutil.swap_memory()
            • # 获取完整的虚拟内存信息 swapInfo = psutil.swap_memory() print(swapInfo)
        • 磁盘Disk(信息)
          • psutil.disk
            • psutil.disk_partitions()
              • 获取磁盘整体情况
            • psutil.disk_usage('/')
              • 获取指定分区的使用情况
            • psutil.disk_io_counters()
              • 获取硬盘总的IO个数和读写信息
            • psutil.disk_io_counters(perdisk=True)
              • 获取单个硬盘IO个数和读写信息
        • 网络Network(信息)
          • psutil.net_io_counters()
            • bytes_sent(发送字节数)
            • bytes_recv(接收字节数)
            • packets_sent(发送数据包数)
            • packets_recv(接收数据包数)
        • psutil(管理进程的方式)
          • import psutil allPid = psutil.pids() # print(allPid) process = psutil.Process(25766) print(process.name()) # 获取进程名字 print(process.exe()) # 获取进程执行路径 print(process.status()) # 获取进程状态 print(process.num_threads()) # 获取进程开启的线程数 print(process.create_time()) # 获取进程创建时间 print(process.cpu_times()) # 获取user、system 两个 CPU 时间 print(process.memory_percent()) # 获取进程内存利用率 print(process.memory_info()) # 获取进程内存rss、vms信息 print(process.io_counters()) # 进程IO信息,包括读写IO数及字节数
          • psutil.pids()
            • 获取所有进程PID
          • psutil.Process()
            • 获取单个进程的名称、路径、状态、系统资源利用率等信息
    • paramiko
      • 可以对远程服务器进行命令或文件操作
        • # 基于用户名和密码连接远程服务器
          • import paramiko client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect( hostname='192.168.161.10', port=22, username='root', password='1' ) _, stdout, stderr = client.exec_command(command='ls adb', timeout=10) # 输入的命令 print(stdout.read().decode('utf-8')) print(stderr.read().decode('utf-8')) client.close()
        • # 基于秘钥对儿连接远程服务器
          • import paramiko client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) private = paramiko.RSAKey.from_private_key_file(filename='/Users/chaoliu/.ssh/id_rsa') client.connect( hostname='192.168.161.10', port=22, username='root', pkey=private ) _, stdout, stderr = client.exec_command(command='cat /etc/passwd', timeout=1) print(stdout.read().decode('utf-8')) print(stderr.read().decode('utf-8')) client.close()
        • # 基于加密通道传输
          • import paramiko private = paramiko.RSAKey.from_private_key_file(filename='/Users/chaoliu/.ssh/id_rsa') transport = paramiko.Transport(('192.168.161.10', 22)) transport.connect(username='root', pkey=private) client = paramiko.SSHClient() client._transport = transport _, stdout, stderr = client.exec_command(command='cat /etc/shadow', timeout=1) print(stdout.read().decode('utf-8')) print(stderr.read().decode('utf-8')) transport.close()
        • # 基于加密通道进行上下传文件
          • import paramiko private = paramiko.RSAKey.from_private_key_file(filename='/Users/chaoliu/.ssh/id_rsa') transport = paramiko.Transport(('192.168.161.10', 22)) transport.connect(username='root', pkey=private) sftp = paramiko.SFTPClient.from_transport(transport) sftp.get(remotepath='/opt/file_test.txt', localpath='./file001.txt') sftp.put(localpath='./file001.txt', remotepath='/opt/module.txt') transport.close()
    • subprocess
      • 主要用于利用python部署自动化脚本
        • subprocess.Popen
          • args
            • 字符串或者可迭代对象(列表/元组)
          • shell
            • 指定是否使用本地系统shell执行命令(True/False)
          • cwd
            • 设置子进程的当前目录
          • env
            • 指定子进程的环境变量(默认从父进程继承环境变量)
          • universal_newlines
            • 不同系统的的换行符不同,当该参数设定为true时,则表示使用\n作为换行符
    • pymysql
      • import time import pymysql def nowTime(): #t = datetime.datetime.now() #date = '{}{}{}{}{}{}'.format(t.year, t.month, t.day, t.hour, t.minute, t.second) date = time.strftime('%Y%m%d%H%M%S', time.localtime()) return date client = pymysql.connect( host='1.1.1.1', user='bavduer', password='xxxxxxxx', db='monitor', cursorclass=pymysql.cursors.DictCursor ) try: with client.cursor() as cursors: insert = 'INSERT INTO webserver VALUES({}, {}, {}, {});' cursors.execute(insert.format(int(nowTime()), 80, 85, 90)) client.commit() with client.cursor() as cursors: select = 'SELECT * FROM {}' cursors.execute(select.format('webserver')) result = cursors.fetchall() print(result) finally: cursors.close()
    • openpyxl
      • 打开文件-->>表格选择-->>数据写入/读取-->>保存文件
        • 打开文件
          • workbook = openpyxl.load_workbook('monitor.xlsx')
          • 新建文件
            • # One: 新建文件 workbook = openpyxl.Workbook() sheet = workbook.active sheet['A1'] = time.strftime('%Y%m%d%H%M%S', time.localtime()) workbook.save('monitor1.xlsx')
          • 打开已经存在的文件
            • # Two: 打开已经存在的文件 workbook = openpyxl.load_workbook('monitor2.xlsx') sheet = workbook.active sheet['A1'] = time.strftime('%Y%m%d%H%M%S', time.localtime()) workbook.save('monitor2.xlsx')
        • 表格选择
          • 选择sheet的方式
            • 获取活动表格,默认选择你退出时所在的表格
              • sheet = workbook.active
            • 直接创建新的sheet来添加数据
              • # 方式一: 直接创建新的sheet来添加数据 workbook = openpyxl.load_workbook('monitor.xlsx') sheet = workbook.create_sheet(title='nginxLog', index=0) sheet['A1'] = 'nginxLog' workbook.save('monitor.xlsx')
            • 指定打开
              • # 方式二: 指定打开 workbook = openpyxl.load_workbook('monitor.xlsx') sheet = workbook['nginxLog'] sheet['B1'] = 'nginxLog' workbook.save('monitor.xlsx')
          • sheet写入方式
            • import openpyxl workbook = openpyxl.load_workbook('monitor.xlsx') sheet = workbook.create_sheet(title='nginxLog', index=0) sheet['A1'] = 'nginxLog' sheet.append(['date, cpu, memory, disk']) sheet.append([2018813142512, 65, 40, 60]) workbook.save('monitor.xlsx')
        • 读取数据生成报表
  • request: 网络请求模块