万字超详细python基础解析_解析python

1 Python简介

Python是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

• 解释性：这意味python在运行过程中没有编译这个过程
• 交互式：意味着可以直接运行代码而不用像c语言一样在main函数中执行代码
• 面向对象的语言：意味着python支持面向对象或代码封装的编程技术

2 Python编码

• 如果 python 源码文件 没有声明编码格式，python 解释器会默认使用 ASCII 编码
• 可以在文件头写#encoding=gbk等修改python默认的编码格式或者# -- coding: UTF-8 --修改
• 若文件中出现与编码格式不一致的字符时python解释器就会报错
  

3 python模块安装之pip

• pip是Python的包安装程序。其实pip就是python标准库中的一个包，可以用来管理python标准库中的包，也可以用来安装非python标准库的包
• 一般python安装包已经自带pip
• pip使用
  • 可以在cmd界面中用pip help install查看安装使用说明
  • 可以直接pip install+包名来安装包
  • 安装时还可以指定版本安装包,例下：

    pip install SomePackage              # 最新版本
    pip install SomePackage==1.0.4       # 指定版本
    pip install 'SomePackage>=1.0.4'     # 最小版本
    1
    2
    3

• 查看安装包信息
  • pip freeze 查看已经安装的包及版本信息
  • 还可以导出包信息到指定文件。如：pip freeze > requirements.txt，文件名称随意；也可以使用 pip install -r requirements.txt，两者等效。
• 包卸载
  • 卸载包命令：pip uninstall <包名>
  • 批量卸载，把包信息导入到文件 pip uninstall -r requirements.txt
• 包升级
  • pip install -U <包名> 或：pip install <包名> --upgrade
• 列出安装包
  • pip list 查看已经安装的包及版本信息
  • pip list -o 查看可更新的包信息
• 显示包所在目录及信息
  • pip show <包名>
  • pip show -f <包名> 查看包的详细信息
• 搜索包
  • pip search <关键字>

4 python的缩进规则

• python一般用新行作为语句的结束标识
• python中用缩进来区分代码块
• Python PEP8 编码规范，指导使用4个空格作为缩进。
• 但是在复杂代码中会选择用2个空格作为缩进，使代码更容易读懂
• 物理行与逻辑行区别
  • 物理行：代码编辑器中显示的代码，每一行内容是一个物理行
  • 逻辑行：Python解释器对待吗进行介绍，一个语句是一个逻辑行
  • 相同的逻辑行要保持相同的缩进
  • ":"标记一个新的逻辑层
    增加缩进表示进入下一个代码层
    减少缩进表示返回上一个代码层
  • 使用；可以把多个逻辑行合成一个物理行
  • 使用\可以把逻辑行分成多行

5 标识符

• 标识符是编程时使用的名字，用于给变量、函数、语句块等命名，Python 中标识符由字母、数字、下划线组成，不能以数字开头，区分大小写。
• 以下划线开头的标识符有特殊含义
  • _xxx ，表示不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 导入
  • 双下划线开头的标识符，如：__xx，表示私有成员
  • 双下划线开头和结尾的标识符，如：xx，表示 Python 中内置标识，如：init() 表示类的构造函数

5.1 关键字

• 自定义标识符时不能使用关键字

6 转义字符

• 需要在字符中使用特殊字符时，就需要用到转义字符，在python里用反斜杠‘\’转义字符。
• 当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转义(转换一个含义)
• ·当字符串中包含换行、回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符当字符串中包含换行、回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符
  

7 注释

• Python 解释器在执行代码时会忽略注释，不做任何处理。
• 注释最大的作用就是提高代码的可读性
  

7.1 单行注释

# 注释内容
1

7.2 多行注释

Python 使用三个连续的单引号'''或者三个连续的双引号"""注释多行内容，如：
'''
注释内容
'''

"""
注释内容
"""
1
2
3
4
5
6
7
8

8 输出函数

• python输出函数为print，无论什么类型的数据都可以直接输出，使用如下：

print(*objects, sep=' ', end='\n', file=sys.stdout)
1

• objects参数：表示输出对象。输出多个对象时，需要用逗号分隔
• sep参数：用来间隔多个对象
• end参数：用来设定以什么结尾
• file参数：要写入的文件对象

#如果直接输出字符串，而不是用对象表示的话，可以不使用逗号
print("Duan""Yixuan")
print("Duan","Yixuan")
 
运行结果如下：
DuanYixuan
Duan Yixuan
可知，不添加逗号分隔符，字符串之间没有间隔
1
2
3
4
5
6
7
8

• 在输出前加r表示原样输出

print(r'\hello word')
# \hello word
1
2

8.1 格式化输出

8.2 精度和宽度控制

• 在“：”后分别加^,<,>分别表示输出居中，左对齐，右对齐
• 第二三种不可控，其他格式控制方式与C语言一样

8.3 转换标志

• 转换标志：-表示左对齐；+表示在数值前要加上正负号；" "(空白字符)表示正数之前保留空格()；0表示转换值若位数不够则用0填充。

p=3.141592653
print('%+3.1f'%p)
# +3.1
1
2
3

p=3.141592653
print('%010.1f'%p)
# 00000003.1
1
2
3

p=3.141592653
print('%-3.1f'%p)
#3.1
1
2
3

8.4 格式字符归纳

控制输出字体样色

9 输入函数

• python使用input()控制键盘录入

input('请输入：')
# 请输入：
1
2

• 一次性输入多个变量

a,b,c=input('请输入：').split(',')
# 录入多个数且用逗号隔开
1
2

• 以上一种方式的类型转换

a,b,c=map(int,input('请输入：').split(','))
# 这样就可以把所有数转换为int类型
1
2

10 变量与常量

• 变量：一般值改变后内存地址随着改变
  
• 局部变量和全局变量
  
• 常量：python没有常规意义上的常量，约定用全大写标识符表示常量，但其值还是可以改变
• 所以后来用户可以自定义类来实现常量

# -*- coding: utf-8 -*-
# python 3.x
# Filename:const.py
# 定义一个常量类实现常量的功能
# 
# 该类定义了一个方法__setattr()__,和一个异常ConstError, ConstError类继承 
# 自类TypeError. 通过调用类自带的字典__dict__, 判断定义的常量是否包含在字典 
# 中。如果字典中包含此变量，将抛出异常，否则，给新创建的常量赋值。 
# 最后两行代码的作用是把const类注册到sys.modules这个全局字典中。
class _const:
    class ConstError(TypeError):pass
    def __setattr__(self,name,value):
        if name in self.__dict__:
            raise self.ConstError("Can't rebind const (%s)" %name)
        self.__dict__[name]=value
        
import sys
sys.modules[__name__]=_const()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# test.py
import const
const.PI=3.14
print(const.PI)
1
2
3
4

11 数据类型

• python常用数据类型：

• 整数类型：
  
• 浮点类型：
• 
• 布尔类型：
  
• 字符串类型：
  

11.1 数据类型转换

• 数据类型转化事项：
  
• 特别注意int()函数有两个参数，如果只有一个参数则转换为整数，如果有第二个参数，则为指定转换的进制

  c='123'
  print(int(c,16))
  #291
  1
  2
  3

12 python运算符

• 算术运算符：
  
  • 整除一正一负向下取整
• 赋值运算符：
  
  • python没有自增自减运算符，自增自减用+=、-+实现
• 比较运算符：
  
• 布尔运算符：
  
• 位运算符：
  

12.1 算术运算符的优先级

• 算术运算符优先级：
  

12.2 对象的布尔值

• python一切皆对象，所有对象都有一个布尔值
  • 可以使用内置函数bool()获取对象的布尔值
• 布尔值为False的对象：

• 其他对象布尔值为True

13 选择结构

• 语法结构：
  
  • python的选择条件可以使用数学方式表达：

  # 与c不一样，c不能连续比较
  if 90<=score<=100
  1
  2

  • else后面不能接条件，只能接：

  if 100>90:
    print('小于')
  else:
    print('大于')
  1
  2
  3
  4

  • 嵌套if
    

13.1 条件表达式

• 基本语法：

print(100 if 100>90 else 90)
# 输出100
# if判断条件为True输出前面，否则输出后面
1
2
3

13.2 pass语句

• pass简介
  

14 循环结构

14.1 range函数

• 用于生成一个整数序列,默认从0开始
• 基础语法：
  

14.2 while循环

• 基础语法：

i=0
while i<5:
    print(i)
    i+=1
# 0 1 2 3 4
1
2
3
4
5

14.3 for-in循环

• 基础语法：
  

for i in range(3):
  print(i)
# 0 1 2
1
2
3

• 不需要变量时：

for _ in range(3):
  print('人生苦短，我用python')
1
2

14.4 流程控制语句

• break语句
  • 基础语法：
    
• continue语句：
  • 基础语法：
    
• else语句：
  • 基础语法：
    

14.5 循环总结

15 列表

• 列表可存储不同类型的值

15.1 列表的基本操作

• 创建列表：

r=[12,"i"]
print(r)
# [12, 'i']
1
2
3

r=list('1234')
print(r)
# ['1', '2', '3', '4']
1
2
3

• 列表的特点：
  
• 获取列表指定元素的索引(index()函数)

l=[1,2,3]
print(l.index(1))
# 0
1
2
3

• 获取列表的多个元素(切片)
  
  • 切片会产生新的列表

l=[1,2,3]
print(l[1:])
# [2, 3]
1
2
3

• 列表查询与遍历
  

  l=[1,2,3]
  print(1 in l)
  # True
  1
  2
  3

• 列表的增加操作
  

  l=[1,2,3]
  # 在末尾加一个元素
  l.append(4)
  print(l)
  # 在末尾加任意多元素，参数为列表
  l.extend([5,6])
  print(l)
  # 在第6个位置加上一个7元素
  l.insert(6,7)
  print(l)
  # 切片，把切出去的部分用新列表替换
  l[1:]=[8]
  print(l)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

• 列表的删除

  

  l=[1,1,2,3]
  # 删除1元素
  l.remove(1)
  print(l)
  # 删除第0个元素，若不指定则删除最后一个元素
  l.pop(0)
  print(l)
  # 切片出第0个到第1个元素
  print(l[0:1])
  # 清除全部元素
  l.clear()
  print(l)
  # 删除列表
  del(l)
  print(l)
  23
  
  # [1, 2, 3]
  # [2, 3]
  # [2]
  # []
  # 报错，没有l变量
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22

• 列表的排序
  

  • sort()不会产生新列表对象
  • sorted()会产生新的列表对象

  l=[3,2,1]
  # 不会产生新对象
  l.sort()
  print(l)
  # 会产生新对象
  r=sorted(l)
  print(l)
  1
  2
  3
  4
  5
  6
  7

• 列表生成式

  • 基本语法：
    • i for i in 迭代器

  # 生成一个1-9元素的列表
  lst=[i for i in range(1,10)]
  1
  2

16 字典

• 以键值对的方式无序存储数据
  
• 把key进过哈希函数计算得出位置
• key要求为不可变序列
• key不可重复

16.1 字典的基本操作

• 创建字典：
  
• 字典元素的获取
  

  s={"张三":100}
  t=s["张三"]
  print(t)
  # 设置默认查找值，当查字典没有的元素时返回默认值
  t=s.get("lisi",99)
  print(t)
  #100
  #99
  1
  2
  3
  4
  5
  6
  7
  8

• key的判断、元素删除、元素新增
  
  
• 获取字典视图
  

  s={"张三":100}
  # 获取所有key
  print(s.keys())
  # 获取所有值
  print(s.values())
  # 获取所有键值对
  print(s.items())
  #dict_keys(['张三'])
  # dict_values([100])
  # dict_items([('张三', 100)])
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

• 字典遍历

  s={"张三":100}
  # item 获取的是key
  # s[item]获取值
  for item in s:
    print(item)
    print(s[item])
  1
  2
  3
  4
  5
  6

• 字典生成式
  
  • 基本语法
    • for({列表:列表 for 列表,列表 in zip(列表, 列表)})

    s=[1,2,3]
    t=[4,5]
    print({s: t for s, t in zip(s, t)})
    1
    2
    3

    • 若zip打包的两个列表元素数目不一样，则按元素数目少的列表打包

16.2 字典总结

17 元组

• 是一个不可变序列

17.1 元组的基本操作

• 元组的创建
  
  • 第一种方式可以省略小括号
  • 第三种方式如果省略逗号，会被认为是元素原来的类型
• 为什么要把元组设计成不可变序列？
  
• 遍历元组：

  t=1,2,3,4
  for i in t:
    print(i)
  1
  2
  3

• 元组生成式
  • 元组没有生成式

18 集合

• 集合是没有value的字典
  

18.1 集合的基本操作

• 集合的创建
  
  • 集合的元素不能重复
  • 空集合创建只能用内置函数进行设置
• 集合的判断，新增，删除
  

  s={1,2,3}
  # 末尾增加一个元素
  s.add(4)
  print(s)
  # 末尾至少增加一个元素
  s.update([5])
  print(s)
  # 删除一个指定元素
  s.remove(2)
  print(s)
  # 删除一个指定元素
  s.discard(1)
  print(s)
  # 一次删除头部一个元素
  s.pop()
  print(s)
  # 清空元素
  s.clear()
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18

• 集合间的关系
  

  s={1,2,3,4}
  t={3,4}
  # 判断集合是否相等
  print(s==t)
  # 判断集合t是否是集合s的子集
  print(t.issubset(s))
  # 判断集合s的父集是否是t
  print(s.issuperset(t))
  # 判断两个集合是否是没有交集
  print(s.isdisjoint(t))
  
  #False
  #True
  #True
  #False
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

• 集合的数学操作
  

  s={1,2,3,4}
  t={3,4,5,6}
  # 集合的交集
  print(s.intersection(t))
  print(s&t)
  
  # 集合的并集
  print(s.union(t))
  print(s|t)
  
  # 集合的差集
  print(s.difference(t))
  print(s-t)
  
  # 集合的对称差集
  print(s.symmetric_difference(t))
  print(s^t)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17

• 集合生成式
  

  print({i for i in range(1,10)})
  1

18.2 元组与集合总结

19 序列总结

• 不可变序列还有字符串

20 字符串

• python基本数据类型，是一个不可变序列

20.1 字符串的驻留机制

• 基本概述
  
  
  • pycharm中对字符串的驻留机制进行了优化，只要是字符串都可以驻留
• 驻留机制优缺点
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SKvBkivX-1645512642755)(https://note.youdao.com/yws/public/resource/92933d878935240680c00793fc3e404c/xmlnote/WEBRESOURCE0dafb644fe2f97462c17e1e63d4b2c26/169)]

20.2 字符串的操作

• 字符串的查询
  

  s='python人生苦短，我用python'
  # 查找子串第一次出现的位置，无子串报错
  print(s.index('python'))
  # 查找子串最后一次出现的位置，无子串报错
  print(s.rindex('python'))
  # 查找子串第一次出现的位置，无子串返回-1
  print(s.find('python'))
  # 查找子串最后一次出现的位置，无子串返回-1
  print(s.rfind('python'))
  
  #0
  #13
  #0
  #13
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

• 字符串的大小写转换
  

  s='人生苦短python，我用Python'
  # 全部字符转换为大写
  print(s.upper())
  # 全部字符转换为小写
  print(s.lower())
  # 大写转小写，小写转大写
  print(s.swapcase())
  # 第一个字符转换为大写，其他字符转换为小写
  print(s.capitalize())
  # 把每个单词第一个字母大写，其他为小写
  print(s.title())
  
  # 人生苦短PYTHON，我用PYTHON
  # 人生苦短python，我用python
  # 人生苦短PYTHON，我用pYTHON
  # 人生苦短python，我用python
  # 人生苦短Python，我用Python
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17

• 字符串对齐
  

  s='人生苦短python，我用Python'
  # 居中
  print(s.center(48))
  # 右对齐
  print(s.rjust(48))
  # 左对齐
  print(s.ljust(48))
  # 右对齐
  print(s.zfill(48))
  1
  2
  3
  4
  5
  6
  7
  8
  9

  
• 字符串的劈分
  

  s='hello,world '
  print(s.split(sep=',',maxsplit=1))
  
  # ['hello', 'world ']
  1
  2
  3
  4

• 字符串的判断
  

  s='hello2022'
  # 判断是否为合法的标识符
  print(s.isidentifier())
  # 判断是否全由空白字符组成
  print(s.isspace())
  # 判断是否全为字母
  print(s.isalpha())
  # 判断是否全为十进制数字
  print(s.isdecimal())
  # 判断是否全为数字
  print(s.isnumeric())
  # 判断是否全为字母和数字
  print(s.isalnum())
  
  #True
  #False
  #False
  #False
  #False
  #True
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20

• 字符串的替换与合并
  

  s='hello2022'
  lst=["1,2,3",'木头人']
  # 将指定子串替换
  print(s.replace('2','1'))
  # 在每两个列表元素中间加一个字符串
  print(s.join(lst))
  
  # hello1011
  # 1,2,3hello2022木头人
  1
  2
  3
  4
  5
  6
  7
  8
  9

• 字符串的比较
  

  s='hello2022'
  r='H'
  print(s>r)
  print(s>=r)
  print(s<r)
  print(s<=r)
  print(s==r)
  print(s!=r)
  
  # True
  # True
  # False
  # False
  # False
  # True
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

• 字符串的切片
  • 由于字符串是不可变序列，字符串的增删改切片等操作都会产生新的对象
• 字符串的编码转换
  
  • 字符串的编码
    • 使用str类的encode方法
  • 字符串的解码
    • 使用decode方法

  s='天涯共此时'
  # 编码
  print(s.encode(encoding='GBK'))
  print(s.encode(encoding='UTF-8'))
  # 解码
  r=s.encode(encoding='GBK')
  print(r.decode(encoding='GBK'))
  
  # b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
  # b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'
  # 天涯共此时
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

  • 编码和解码所使用的的字符编码必须一致否则会报错

21 函数

• 函数就是执行特定任务和完成特定功能的一段代码
• 函数的好处
  1. 复用代码
  2. 隐藏实现细节
  3. 提高可维护性
  4. 提高可读性便于调试
• 函数的创建

  def 函数名(输入参数):
    函数体
    [return xxx]
  1
  2
  3

• 函数参数传递
  
  • 默认值参数
    
  • 其他类型参数
    
    • 如果两个参数都有，则可边的位置参数要在可变的关键字参数前面
    • 当*args，**kwargs接受参数后，*args意思为把args元组里的数据打散为位置参数，**kwargs为把kwargs字典里的数据打散为关键字参数
• 参数总结
  
• 函数内存分析
  • 如果不可变对象，那么在函数体内的修改不会影响实参的值，如果是可变对象，在函数体的修改会影响到实参
• 函数的返回值
  • python支持多返回值
    1. 如果函数没有返回值，return可以省略不写
    2. 函数的返回值如果是一个直接返回类型
    3. 函数的返回值如果是多个，返回的结果是一个元组

21.1 递归函数

• 如果一个函数的函数体调用了函数本身，这个函数就被称为递归函数
  

22 异常处理机制

• 被动掉坑类型(try-expect)
  
  • 当存在多个expect结构时应该按照先子类再父类的顺序捕获异常，为避免遗漏可能出现的异常，可以在最后加BaseException
• try-except-else:
  
• try-except-else-finally:
  
• python常见的BUG类型
  
• traceback模块
  
  • 可以把异常打印在日记文件中
• 手动抛出异常

  if 0<=score<=100:
    print('分数为：',score)
  else:
    raise Exception('分数不正确')
  1
  2
  3
  4

  • 当没有try语句时，异常由python捕获

22.1 BUG总结

23 python类

• 创建python类
  
  • 类之外的叫函数，类里面的叫方法
  • 类属性，类方法，静态方法都可以直接类名.属性名调用，不需要创建对象
• 对象的创建
  
• 动态绑定属性和方法
  
  

  class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def show(self):
        print('我是{},今年{}'.format(self.name,self.age))
  def show():
      print('我是函数')
  stu=Student('李磊',20)
  stu.show()
  stu.show=show
  stu.show()
  
  #我是李磊,今年20
  #我是函数
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

23.1 类总结

24 面向对象的三大特征

24.1 封装

• python没有专门的封装关键字，所以在属性名前用__表示私有

class A:
    __place="吉林"
# 列出A中所有属性
print(dir(A))
print(A._A__place)
# ['_A__place']
# 吉林
1
2
3
4
5
6
7

24.2 继承

class A:
    pass
class B:
    pass
# 继承A，B类 
class C(A,B):
    pass
1
2
3
4
5
6
7

• 方法重写
  

24.3 object类

• object类特殊的方法和属性
  

class C:
    pass
class B(C):
    pass
class A(B,C):
    pass
a=A()
print(a.__class__)# <class '__main__.A'> 输出对象所属类
print(A.__base__)#<class 'object'>  输出类的基类
print(A.__bases__)# (<class '__main__.B'>, <class '__main__.C'>) 输出所有父类
print(A.__mro__)#(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>) 输出基础层次
print(C.__subclasses__())# [<class '__main__.B'>, <class '__main__.A'>]  输出所有子类的列表
1
2
3
4
5
6
7
8
9
10
11
12

• new__与__init(new在前)
  

24,4 多态

• 静态语言和动态语言关于多态的区别
  

24.5 面向对象总结

25 类的浅拷贝与深拷贝

• 基础介绍
  
• 浅拷贝

  import copy
  class CPU:
      pass
  class Disk:
      pass
  class Computer:
          def __init__(self,Disk,CPU):
              self.Disk=Disk
              self.CPU=CPU
  disk=Disk()
  cpu=CPU()
  a=Computer(disk,cpu)
  b=copy.copy(a)
  print(a,a.Disk,a.CPU)
  print(b,b.Disk,b.CPU)
  
  # <__main__.Computer object at 0x016B0A18> <__main__.Disk object at 0x00ACE580> <__main__.CPU object at 0x00A9AF40>
  # <__main__.Computer object at 0x016F4310> <__main__.Disk object at 0x00ACE580> <__main__.CPU object at 0x00A9AF40>
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18

  
• 深拷贝
  • 在浅拷贝基础上拷贝子对象

26 模块化编程

• 模块基础
  
• 创建与导入模块
  
  • 使用import时只能接包名和模块名，from…import可以导入包，模块，变量
  • 同一目录下直接导入
    
    • from post_packaging.method import *
  • 不同目录下导入
    
• python包
  

26.1 主程序运行

26.2 python常用模块

26.3 模块总结

27 python文件操作

• 文件的读写
  
  

  file=open(file,mode='r',encoding='gbk')
  1

• 常用文件处理方式
  
• 文件常用方法
  
  • 文件对象调用完一定要关闭
• with语句
  

with open('a.txt','r) as file:
  print(file.read())
1
2

27.1 os 模块

• 操作目录的方法
  
  • os.walk()会把所有子目录和文件遍历出来
• os.path操作目录常用函数
  

28 python文件打包

• Pyinstaller -F py_word.py 打包exe
• Pyinstaller -F -w py_word.py 不带控制台的打包
• Pyinstaller -F -w -i chengzi.ico py_word.py 打包指定exe图标打包

29 正则表达式

• 正则支持普通字符
• 元字符：
  • \d:匹配一个数字的数字
  • \w:匹配一个数字、字母、下划线
  • \W,\D:匹配与上面取反(\D就是取数字以外的内容)
  • []:取范围
  • .:匹配换行符之外的东西
• 量词：
  • 控制前面元字符出现的频次
  • +:前面元字符出现1次或多次
  • *:前面元字符出现0次或多次，尽可能多的匹配结果
  • ？:前面元字符出现0次或多次
• 惰性匹配
  • 1.*2：以1开头2结尾的尽可能长的字符
  • 1.*？2：以1开头以2结尾尽可能短的字符(惰性匹配)

29.1 re模块

• 预加载
  • obj=re.conpile(r"正则表达式")
  • 先创建一个正则表达对象
  • obj.findall(“字符串”)
• 提取惰性匹配的值
  
  • 也可以用groupdict方法，输出为字典

30 闭包

• 本层函数对外层函数的局部变量的使用，此时内层函数被称为闭包函数
• nonlocal关键字
  • 用来在函数或者其他作用域中使用改变外层(非全局)变量
• global关键字
  • 使局部变量改变全局变量
• 闭包作用
  • 让一个变量常驻于内存
  • 可以在外部使用改变局部变量
  • 可以避免全局变量被修改

def func(fn):
    def inner():
        print('fn进来了')
        fn()
        print('fn出去了')
        return 'f'
    return inner
1
2
3
4
5
6
7

31 装饰器

• 装饰器本质就是闭包，对外部参数的引用
  
• 作用：再不改变原有函数调用下，给函数增加新功能
  
• 被装饰函数的参数问题
  
  • 被装饰函数有参数的话，返回函数和目标函数都要加参数
• 一个函数可被多个装饰器装饰
  
• 通用装饰器写法
  

  32 迭代器

• 迭代器基本概念
  
  
  • 迭代器的特点
    1. 只能向前不能反复
    2. 特别节省内存
    3. 惰性机制

33 生成器

• 本质就是迭代器
• 生成器函数
  

  def order():
    lst=[]
    for i in range(100):
        lst.append(f"衣服{i}")
        if len(lst)==3:
            yield lst
            lst=[]
  gen=order()
  print(gen.__next__())
  print(gen.__next__())
  
  # ['衣服0', '衣服1', '衣服2']
  # ['衣服3', '衣服4', '衣服5']
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

• 推导式
  
• 生成器表达式
  • 优点：用好了特别节省内存
  • 生成器表达式是一次性的
  • 语法：
    • (数据 for循环 if)