python入门总复习

文章目录

• 总复习
• 1.计算机核心组件:
• 2.python解释器
• 3.pycharm编辑器:
• 4.编程语言分类:
• 5.变量
• 6.垃圾回收机制
• 7.查看变量三大特征
• 8.变量名的命名规范
• 9.python中八大数据类型
• 10.字符编码
• 11.文件处理
• 12.函数基础
• 13.名称空间与作用域
• 14.函数对象、函数嵌套与闭包
• 15.装饰器
• 16.迭代器
• 17.生成器
• 18.三元表达式
• 19.列表生成式
• 20.生成器表达式(生成式)
• 21.匿名函数与内置函数
• 22.递归:
• 23.面向过程编程
• 24.模块
• 25.包
• 26.常用内置模块
• 27.第三方模块:
• 28.防止模块被导入时自动执行测试代码
• 29.软件开发目录规范
• 30.enumerate

总复习

1.计算机核心组件:

    - CPU         
    - 内存 
    - 硬盘
    - 输入设备: 键盘、鼠标 
    - 输出设备: 显示器、音响.. 

2.python解释器

• 将人类编写好的代码转成机器能看得懂的字符。
• 解释器的作用:帮你执行python代码。

3.pycharm编辑器:

​ - 编辑器的作用:可以更好的编写python代码，编辑器内部有很多强大的功能。 能够快速编写代码。

4.编程语言分类:

• 机器语言(机器能直接看懂):

  比如: 01010101

• 汇编语言(让人能看懂一点点):

  比如: a —> 01101001

• 高级语言(让人类能直接看懂):

  比如: print(‘hello’)

  高级语言是更接近于人类的语言。

• 解释型:
  一遍解释(翻译)一遍执行, 类似于同声传译。
  优点:
  开发效率高，可跨平台，一份代码可以多个平台使用。
  缺点:
  执行效率相比于编译型低。

• 编译型:
  先一次性编译然后再执行，类似于 “有道翻译”。
  优点:
  执行效率高，稳定性高
  缺点:
  开发效率相比于解释型语言要低。
  不可跨平台。

• 解释型语言的种类:
  python: 10级别
  java: 8
  php: 3

• 编译型语言的种类:
  C

5.变量

​ 变量指的是可变化的量。

- 变量名: 可以与变量值绑定关系，通过变量名可以访问变量值。     
- 赋值符号（=）: 是用来将变量名与变量值绑定关系。       
- 变量值: 变量值 指的是 “数据”， 存放在内存中。    

6.垃圾回收机制

注意: GC就是用来做垃圾回收机制的东西。

• 变量名 = 变量值 # 添加一个引用计数

  当变量值的引用计数为0时，垃圾回收机制会“不定时”释放资源。

7.查看变量三大特征

- id
- type
- value   

8.变量名的命名规范

• 驼峰命名法: 在写类名的时候使用

  首字母大写命名–>比如: JasonSb

• 下划线命名法: 推荐使用 -->比如: jason_sb

9.python中八大数据类型

• int:

  number = 100 # number = int(100)

  不可变类型

• float
  salary = 1.0

  salary = float(1.0)

  不可变类型

• str
  str1 = ‘tank’ # str1 = str(‘tank’)
  不可变类型
  按照索引取值
  str1[1] # 取第二个值
  str1[1:10:2] # 顾头不顾尾
  内置方法 :
  str1.split() # 切分
  str1.strip() # 去左右两边的空格
  str1.strip(‘i’) # 去左右两边的i # tank10
  str1.join([‘tank’, ‘10’]) # 字符串的拼接,必须是字符串类型
  str.startswith() 判断字符串开头，若正则返回True，否则返回False
  str.endswith() 判断字符串结尾，若正则返回True，否则返回False
  str.isdigit()判断字符串是否是数字，若正则返回True，否则返回False
  str.replace(‘旧的’, ‘新的’)新旧替换
  str.count(‘字符’)获取某个字符的数量
  str.find(‘字符’)查找字符的位置 索引 可能是面试题 # 找不到返回-1
  str.index(‘字符’) # 找不到报错

• list
  list([v1, v2…]) 在[]内，可以存放多个值，每个值以逗号隔开。
  可变类型
  常用内置方法:
  list.append() # 追加
  list.insert() # 插入值到指定的索引中
  list.pop() # 取出某个值，默认取出最后一个
  list.remove() # 真正的删除元素
  list.extend() # 列表合并
  list.sort(reverse=True) # 默认升序 ， reverse=True降序
  list.copy() # 浅拷贝

• tuple
  tuple((v1, v2…))
  不可变类型

• dict
  特点: key是唯一的。
  dict({key:value, …})
  可变类型
  dict[key] # 没有key会报错
  dict.get(key, ‘自定义默认值’) # 没有key会报错，默认返回None
  dict.items() # 返回一个可迭代对象
  dict.keys()
  dict.values()
  dict.fromkeys(‘k1’, []) # 生成字典 —》 {‘k1’: []}

• set
  特点: 内置去重功能。
  set({v1, v2…})
  默认可变类型
  内置方法 :
  set.add()
  set.remove()

• bool:
  True or False
  不可变类型—>值变了，id也变 称之为不可变类型。
  什么是可变？—>值变了，id不变称之为可变类型。

10.字符编码

解决乱码问题

结论: 以什么编码，就以什么解码。

utf-8:存中文是3个字节;存英文是1个字节

gbk: 存中文是2个字节; 存英文是2个字节

11.文件处理

f = open(‘文件名的路径’, ‘打开的模式’, encoding=‘字符编码’)

f.close() # 文件的上下文管理: with ， flask框架的上下文管理（后期学习）

with open(‘文件名的路径’, ‘打开的模式’, encoding=‘字符编码’) as f: # 内部帮你执行f.close()

• 打开模式:

  文本模式:rt,wt,a

  二进制模式:rb,wb,ab

  光标移动:

  f.seek(‘光标移动的位置’, 0) # 开头

  f.seek(‘光标移动的位置’, 1) # 当前

  f.seek(‘光标移动的位置’, 2) # 末尾

• 打开文件取值的优化方式:

  f.read():直接将文件中所有数据一次性取出。

  缺点:内存容易溢出。

• for循环f句柄操作:

  通过for循环，将每一行取出，保证不会内存溢出

  for line in f:

  print(line)

  f.readline(): （了解）

  读取一行，光标移动到第二行。

12.函数基础

函数是一些列功能的结合体，是一个可以重复使用的工具。

• 函数定义:
  def 函数名(参数1, 参数2…):
  ‘’‘注释: 说明函数的作用’’’
  逻辑代码
  return 返回值
• 函数调用
  函数() # 若有参数则要传参
• 定义有参、无参、空函数
  def func1(参数): 逻辑代码pass
  def func2(): 逻辑代码pass
  def func3(): pass
• 函数的参数:
  定义阶段: （参数用来接收调用者传入的)
  位置形参参数
  默认参数
  可变长参数
• 调用阶段: （根据函数的定义者传的）
  位置实参参数
  关键字参数
  注意:
  参数从左到右的顺序
  位置 —》 关键字参数 —》 可变长参数
  函数的返回值:
  返回值可以是一个或者多个
  return 值1 —> 值1
  return 值1, 值2 —> (值1, 值2)

13.名称空间与作用域

• 名称空间:

  在内存中产生，是一个存放名字的地方。
  内置名称空空间: python解释器
  全局名称空空间: 文件中所有(顶着最左边写的)

• 注意: 无论嵌套if, while, for 多少层都是一个。

• 局部名称空空间: 在函数内部定义的。
  查找顺序:当前局部 —》 外层局部 —》 全局 —》 内置
  加载顺序:内置 —》 全局 —》 外层局部 —》 当前局部

• 作用域:

1. 全局作用域:
   内置
   全局
2. 局部作用域
   外层局部
   内层局部
3. global: 在局部可以声明全局名字。
   相当于将全局变量引用到局部中使用或修改。
4. nonlocal: 在内层局部声明外层局部的名字。

14.函数对象、函数嵌套与闭包

函数对象: 函数的名字 —》 函数的内存地址

• 函数嵌套:
  def outer():
  def inner():
  pass
• 闭包:
  为了装饰器作准备，它不是一个独立的技术。闭包是函数嵌套、函数对象、名称空间与作用域的 结合体。
  内层函数封闭:外部不能调用内部的函数.
  外层函数开放:外部能调用外层函数
• 闭包:
  内层函数想要引用外层函数的名字.
  外部想要调用内部的函数，要在外层函数将内层函数的名字返回。
  def outer(x): # 10 # x = 10
  def inner():
  print(x) # 10
  return inner
  inner = outer(10)
  inner() # 实现了外部调用内层函数

15.装饰器

装饰的工具。

• 作用:

  1：在不修改被装饰对象的源代码
  2：在不修改被装饰对象的调用方式

  • 基于1和 2，为被装饰对象添加新功能.

• 无参装饰器:

def wrapper(func):
	def inner(*args, **kwargs): 
        # 调用被装饰对象前添加新功能 
		res = func(*args, **kwargs)  # index()
        # 调用被装饰对象后添加新功能
		return res
	return inner

# 被装饰对象:
def index(参数1):
    print('from index..')
    index = wrapper(index)
    index(实参1)  # inner(实参1)       

• 有参装饰器

 # 有参装饰器:  ---> 本质上就是无参装饰器
def login_auth(name):            # 无参装饰
    def wrapper(func):
        def inner(*args, **kwargs):
            # 对name做一个权限认证
            if name == 'tank':
                # 调用被装饰对象前添加新功能
                res = func(*args, **kwargs)  # index()
                # 调用被装饰对象后添加新功能
                return res
            else:
                print('你不是tank，get out!')
          return inner
       return wrapper
 
@  login_auth('tank')  # wrapper
@wrapper
def index():
    pass

• 叠加装饰器:

  装饰顺序:
  从下往上

  执行顺序:
  从上往下

16.迭代器

迭代的工具。

• 可迭代对象:

  凡是内置有__iter__()，都是可迭代对象。

• 迭代器对象:

  凡是内置有__iter__()与__next__()，都是迭代器对象。

  优点:

  可以不依赖索引取值

  节省内存

  缺点:

  取值麻烦

  无法获取长度

  for line in 可迭代对象: ----》 in: 将“可迭代对象”转成“迭代器对象”

• 内置有捕获异常机制:

while True:
	try:
        迭代器.__next__()
        except StopIteration:
            break  

17.生成器

​ 生成器是一个自定义的迭代器， 生成器本质上就是一个迭代器。

如何生成:

- yield
def func():
    yield 1
    yield 2
    yield 3
    g = func()
    g.__next__()
    next(g)
    # ---> 生成了生成器对象，然后每执行一次__next__，
    # 会取出一个值，到下一个yield会暂停。   

18.三元表达式

​ res = 条件成立的值 if 条件 else 条件不成立的值

19.列表生成式

[line for line in 可迭代对象] # —》 list —》[line1, line2…]

[[1, 2, 3, line] for line in 可迭代对象] # [line1, line2…]

优点: - 可以依赖索引取值，取值方便 - 可以获取长度

缺点: - 占用内存空间

20.生成器表达式(生成式)

(line for line in 可迭代对象) # —> 生成器

优点: - 不占用内存空间

缺点: - 不可以依赖索引取值，取值不方便 - 不可以获取长度

21.匿名函数与内置函数

• lambda 参数: 返回值
• 注意: 匿名函数必须配合内置函数使用，否则毫无意义
• 内置函数:
  max(key=匿名函数) # 最大值
  min(key=匿名函数) # 最小值
  sorted(key=匿名函数) # 排序，默认升序，reverse=True降序
  map(匿名函数) # 映射
  reduce(匿名函数, ) # 合并
• 导入 :from functools import reduce
  reduce()
  filter(匿名函数,) # 过滤

22.递归:

• 递推:

  先递推，重复往下执行函数本身，每一次执行都会更接近于终止条件。

• 回溯:
  当递推遇到一个终止条件，开始回溯，一层一层往上推导。

23.面向过程编程

是一门编程思想:

核心是 “过程” 二字，过程指的是解决问题的步骤，即先干什么再干什么

基于该编程思想编写程序，就好比一条工厂流水线，一种机械式的思维方式。

24.模块

模块本质上就是一个.py后缀的文件。

模块是一系列功能（变量，函数）的结合体。

更好管理python代码

• 三种来源:
  内置
  第三方
  自定义的
• 四种表现形式: # 关注的:
  1. 包下带有__init__.py的文件夹中的一组py文件。
  2. python解释器自带的。
  3. 模块的导入方式:
     import 模块名字
     from 模块 import 函数/变量名
  4. 导入模块时发生的事情:
     1.先执行当前执行文件，生成一个当前文件的名称空间。
     2.会执行被导入的模块，会生成一个被导入模块的名称空间。
     3.将被导入模块的名称空间加载到内存中。
• 首次导入模块发生的事情:
  import demo
  import demo
  import demo
  在执行文件中导入多次相同的模块，会只加载首次导入的模块的名称空间。

25.包

注意: 包也可以称之为模块。

包是内部带有__init__.py的文件夹。

包是一系列模块的结合体，用来管理模块。

• 导入包时发生的事情：
  1.会先执行包下面的__init__.py，产生一个名称空间。
  2.会将包中的所有模块都加载__init__.py的名称空间中。
  3.当在执行文件中使用包中的模块，指向的是__init__.py的名称空间。
  由__init__.py来帮我们管理模块。
• 导入包的方式:
  import 包.模块名
  from 包 import 模块名
  from 包.模块 import 模块中名字 （变量名/函数名）

26.常用内置模块

• time (******) --> time.time() , time.sleep()
  datetime (******)
  –> 格式化时间 —> Format String
  时间的计算:
  日期时间 = 日期时间 + or - 时间对象（时间间隔对象）
  时间对象 = 日期时间 + or - 日期时间
• random:
  random.random() —> 随机获取 0——1 的浮点数
  random.uniform(1, 10) —> 随机获取 1——0 的浮点数
  random.randint(1, 10) —> 随机获取 1——0的整数
  random.choice(根据索引取值的可迭代对象) —> 随机获取可迭代对象某一个值
  random.shuffle(根据索引取值的可迭代对象) —> 随机打乱
• os

# 获取当前执行文件中的目录(文件夹)
os.path.dirname(__file__)
# 路径拼接
os.path.join('文件的路径', '文件名')
# 判断文件或文件夹是否存在
os.path.exists('文件绝对路径')
# 判断文件夹是否存在
os.path.isdir('文件夹绝对路径')
# 判断文件是否存在
os.path.isfile('文件绝对路径')
# 创建文件夹
os.mkdir()
# 删除文件夹
os.rmdir()  # 注意: 只能删除空的文件夹
# 打印文件夹中所有的文件名
os.listdir('文件夹的路径')

• sys

sys.path  # 环境变量中的路径
sys.path.append('项目目录')
sys.argv  # 获取cmd中的命令行   [py文件路径, 'tank', '123']
# 可以做执行用户的校验，限制某个用户可以执行当前py文件
python3 py文件路径 tank 123

• hashlib

 加密:
    MD5:
    md5_obj = hashlib.md5()
    # 密码加密
    md5_obj.update(密码.encode('utf-8'))
    # 加盐
    md5_obj.update(盐.encode('utf-8'))
    md5_obj.hexdigest()

• 序列化与反序列化

序列化:
将其他数据类型 —》 json数据格式 —》 字符串 —》 写入文件中
反序列化:
读取文件 ----》 字符串 —》 json数据格式 ---- 》 其他数据类型

• json

优点:
可以跨平台
缺点:
不支持python的set

注意: 传入的元组变成列表

json.dumps()
res = 将其他数据类型 ---》 json格式的字符串
f.write(res)
json.loads()
json_res = f.read()
python_data = json.loads(json_res)
json.dump()                内部执行了f.write()
json.load()                内部执行了f.read()

• pickle

优点:
支持python的任意数据类型
可以存入二进制的数据
存取速度快
缺点: （致命的）
不能跨平台使用
只能python自己使用

• collections
  具名元组:

from collections import namedtuple
  namedtuple('对象的名字', 'x y')
  obj = namedtuple('坐标', ['x', 'y'])
  target_obj = obj(10, 20)
  target_obj.x  # 10
  target_obj.y  # 20
  - 有序字典:
  from collections import OrderedDict
  order_dict = OrderedDict({key: value})

• re

正则表达式
正则表达式是一个独立的技术, 由一堆特殊的字符组成。
字符组
元字符
组合使用
re模块
在python中要想使用正则表达式，必须通过re模块来编写。

• subprocess

可以通过python代码往操作系统终端输入命令，并返回结果。

可以远程操控电脑

• logging

注意1: log文件的目录
注意2: log文件名
注意3: log配置字典
注意4:

 logging配置字典:
  LOGGING_DICT = {}
  import logging.config
  logging.config.dictConfig(LOGGING_DICT)
  logger = logging.getLogger('普通用户')
  logger.info('日志打印消息...')    

27.第三方模块:

• requests

- requests.get(url) ---> response
- response.text  # 获取文本数据
- response.content  # 获取二进制数据
- openpyxl:            # 创建文件
    from openpyxl import Workbook
    wb_obj = Workbook()
    wb1 = wb_obj.create_sheet('工作表名字1', 0)
    wb2 = wb_obj.create_sheet('工作表名字2', 1)
    wb1['C30'] = 200
    wb_obj.save('文件名字.xlsx')            # 读取文件
    from openpyxl import load_workbook
    wb_obj = load_workbook('文件名字.xlsx的路径')
    wb1 = wb_obj['工作表名字1']
    print(wb1['C30'].value)  # 200   

28.防止模块被导入时自动执行测试代码

if name == ‘main’:

执行测试代码

29.软件开发目录规范

• 项目目录:

conf:
- settings.py

core：
- src.py  # src ---> source

db：
- data.json
- data.pickle

interface：
- user_interface.py
...

lib：
- common.py

log：
- user_log.log
...

bin/ start.py：
- start.py

readme.txt项目说明书   

30.enumerate

可迭代对象： list， tuple， dict # [1, 2, 3]

enumerate(可迭代对象) —》 g((0, 1), (1, 2), (2, 3))