第一周总结

基础软件的简介

1.腾讯会议
2.谷歌浏览器，（火狐浏览器也行）
3.百度网盘
4.EV录屏
5.Typora文本编辑器（收费，建议使用pj版）
6.网易有道翻译
7.背单词的软件

课程学习的一些阶段

1.python基础
2.网络并发编程
3.Mysql数据库
4.前段开发
5.django框架
6.drf,实战项目

****** 为了避免遗忘，最好重复记忆 ******

****** 每天记忆单词，编程中会用到 ******

软件的下载与安装

1.最好是在官网下载，使用搜索引擎搜索以后，点击带有官方标识的进行下载。
2.安装的时候尽量选择自定义安装，不要安在系统盘里，不然电脑会越来越卡。

网络博文的编写

1.博客园
2.csdn
3.掘金
4.印象笔记

各软件的作用

1.谷歌浏览器：搜索引擎。
2.微信：截图功能。
3.百度网盘：资料分享。
4.typora：必须掌握的一款编辑器。
5.nodepad++：在windows上非常好用的一款编辑器。

文件的安装路径

1.尽量不要选择安装到c盘下
2.安装的路径尽量简单一些

绝对路径与相对路径

1.绝对路径：不需要参考系。例：中国上海浦东周浦
2.相对路径：需要参考系。  例：隔壁最起眼的那个小伙

注：浏览器里输入的网址其实也是一个路径。

typora的主要功能介绍

1.语言环境：
2.创建一个新的编辑页面：

     ctrl+N

3.保存文件：

     ctrl+S

4.导出：
- 可以导出为各种形式。例：pdf，png，xml，docl。
5.视图功能：
6.字体大小：
7.主题：

markdown语法

1.标题：

  1 几个#就几级标题(# 一级标题）
  2 ctrl+（数字键1\2\3\4\5\6 加几就是几级标题）

2.子标题：

  1 * 小标题
  2 + 小标题

3.其他：

  1 代码环境：```环境名称
  2 表格：|字段名1|字段名2|
  3 图片：拷贝后 ctrl + v
  4 表情：表情的英语单词
  5 选项：- [ ] 选项1
  6 各种图形：自行百度

计算机的本质

1.计算机又称为通电的大脑。

意味着我们希望计算机能像人脑一样工作。 2.计算机存储数据的本质。
计算机是基于电工作的。而电信号只有高低两种状态。人们为了区分高低状态将其定义为0和1。所以计算机的世界里只有0和1.
如何实现多种事物的存储:
使用01的多位拼接

  注：
二进制数：0,1
八进制数：0,1,2,3,4,5,6,7
十进制数：0,1,2,3,4,5,6,7,8,9
十六进制数：0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f,

3.计算机存储单位的换算：

最小的单位（二进制位，比特位）
1byte（字节）= 8bit
1024byte = 1kb
1024kb = 1mb
1024mb = 1gb
1024gb = 1tb
1024TB = 1PB
1024PB = 1EB

计算机的五大组成部分

控制器

控制计算机各个硬件的工作

运算器

负责数学运算，逻辑运算，是整个计算机的核心所在
- 数学运算：学相关的运算
- 逻辑运算：判断事物是否可行。

存储器（负责存储数据）

外存：不需要电就可以工作，存取数据比较慢。人为不破坏的情况下，可以永久保存数据。
内存：基于电工作，存取数据很快。但是断电之后数据立刻丢失，经常与电脑的cpu一起工作。

输入设备

向计算机内部传递信息（键盘，鼠标）

输出设备

向计算机外部传递信息（显示器，打印机）

五大核心组件的详解

1.控制器（类似于人的大脑）

控制计算机各个硬件的工作

2.运算器（类似于人的大脑）

数学运算、逻辑运算(核心)
"""CPU = 控制器 + 运算器"""

3.存储器（类似于人的记忆）

内存（类似于人的短期记忆）：
- 基于电工作断电数据立刻丢失，但是存取速度快
外存（类似于人的长期记忆）：
- 不基于电工作，断电数据不会丢失，可以永久保存数据，但是速度较慢。

4.输入设备（类似于人的眼睛，耳朵，鼻子）

给计算机内部传递数据

5.输出设备（类似于人的嘴巴，皮肤）

让计算机给外界传递数据

三大核心硬件

cpu

cpu是电脑中真正做事的硬件，一个软件要运行必须要cpu。

内存

cpu只会从内存中读取程序代码然后运行起来。

外存（硬盘）

永久保留数据（电脑中存储的软件，文件其实都被保存到了硬盘）

操作系统简介

功能:协调、管理、调度计算机各个硬件的工作
开发一个专门操作计算机各个硬件工作的程序，程序员只需要在该程序上通过一些简单的指令就可以快速的操作计算机各个硬件。注：这个程序就是"操作系统"，程序员编写的代码都是基于操作系统之上的。如果没有操作系统，那么所有的应用程序都无法执行。操作系统的作用是承上启下的，不可获取。
常见操作系统

PC端:windows\mac\linux

移动端:安卓\IOS\鸿蒙

编程与编程语言

机器语言

1.程序员直接编写的二进制代码。

优缺点：门槛过高，学习成本过大，开发效率极低。

汇编语言

2.用一些简单的英语字母代替二进制数

优缺点：学习成本略微降低，开发效率稍微提高，门槛还是很高。

高级语言

3.使用人类能够直接读懂的字符与计算机交互

优缺点：学习成本大大降低开发效率大大提高门槛也有所降低
常见的高级语言： python，c语言，c++，c#，java，go，php。

编程语言的分类

编译类

c++等将文本一次性整体翻译，执行效率高，速度快。但是出现一点错误那都必须整体重新翻译。

解释性

python 写一句翻译一句，相对于编译型，速度慢，执行效率低。无论是否有错误，翻译的时间都是一样的，因为每次都是逐行翻译。注：python虽然是解释型，但是可以借助于模块和并发编程提升速度，甚至也可以用python去开发游戏。

python发展方向

1.web开发(写网站后端:负责提供数据)
2.人工智能(无人驾驶技术机器学习)
3.网络爬虫(基于网络爬取想要的数据)
4.自动化运维、自动化测试(运维和测试都需要学习python才能涨薪)
5.自动化办公(文秘岗位需要的技能>>>:加分项)
6.金融量化(写代码自动炒股票)
7.数据分析(预测) 注：python是目前所有编程语言中最简单的。

python解释器

解释器版本

python2.x（2.7是目前2.x的最终版，已经停止维护更新，但是一些古旧的项目维护仍然需要该版本）
python3.x （3.6-3.10 版本号不变，语法上几乎是没有变化的）注：在IT领域，涉及到重要的软件，一般情况下不会使用最新版而是使用一个非常稳定版本。

解释器的安装与启动

1.解释器的基本使用(win+r,打开cmd，输入python）

环境变量配置

在cmd命令窗口下查找文件资源：

1.先在当前所在的路径查找
2.如果没有则去环境变量中查找如何查看环境变量：
1.右键点击此电脑选择属性
2.左侧点击高级系统设置
3.点击环境变量，在第二个窗口内双击Path
4.拷贝解释器路径添加到环境变量中
5.重新打开一个cmd窗口即可使用退出当前解释器：
1.exit（）+ 回车

多版本共存

1.下载多个不同版本的python解释器安装程序文件

2.如何切换使用不同版本的解释器：

  1.解释器文件所在的路径肯定需要添加到环境变量里面

  2.需要拷贝修改不同版本解释器的文件名称

系统问题

1.苹果电脑不需要配置环境变量，直接点击下一步即可，苹果电脑自带python27。
2.windows不同的版本环境变量的界面不一致

运行python的多种方式

1.方式1

直接在cmd窗口下进入解释器环境编写

优势在于:操作简单唤起速度快
劣势在于:无法保存代码只能临时使用

2.方式2

先在文本文件中编写代码之后调用解释器执行

优势在于:可以永久保存代码
劣势在于:没有专属的功能，无法提升编写速度

3.方式3

我们写代码也应该有一个对于的软件加快编写速度。例：pycharm

编写代码的软件(IDE工具)

1.vscode

轻量便捷但是需要很多额外的配置（对小白不太友好）

2.sublime

非常全面的代码编写软件（对小白不太友好）

3.pycharm

自身的功能非常的多（对小白相对来说友好很多）

pycharm基本使用

1.如何创建编写代码的文件
2.修改字体代码
3.运行py文件
4.编辑主题选择
5.切换解释器
6.创建多个项目

有三种注释方法：

1.#注释。在需要注释行的前面加上#，即可完成对单行代码的注释。例如

# python的学习
复制代码

2.''' '''注释。在需要注释的文本首尾加上三个' '完成对多行代码的注释。例如。

''' 
python的学习
'''
复制代码

3.""" """注释。在需要注释的文本首尾加上三个" "完成对多行代码的注释。例如.

"""
python的学习
"""

python语法的变量与常量

变量

用于记录可能会经常改变的量例如：年龄，体重等

常量

用于记录可能不经常改变的量例如：身高，学历等

基本使用

我们看到一个朋友，脑海中首先想到他的名字。乃至他的年龄，职业，身高，爱好等。

语法结构

name = 'Tom'

'''
变量的名称/常量的名称 赋值的符号 数据值 
'''
复制代码

python变量与常量的本质

例： name = 'Tom'
当赋值符号存在时，先看赋值符号的右侧，其次看左侧
1.右侧的输入的数据值tom会被存储到内存空间中。
2.给该内存空间绑定一个名称 name。
3.通过name访问到该内存空间中的数据值Tom。
注意：如果我们输入的数据值没有绑定到内存空间的名字，则意味着，我们无法使用该数据，该数据成为垃圾数据，没有任何价值
复制代码

1.右侧的数据值可以被多个名称绑定,如果右侧数据值为一个名称，就让这个数据值左侧的名称绑定右侧被赋值的名称的数据值。
例：a = 1
    b = a
    c = b

2.相同的名称只能绑定一个数据值
例：a = 1
    a = a + 1
    如果右侧是名字与数据值的组合，此时我们如果打印a。
    print（a）
    打印出来的a的数据值就是，做完运算后的数据值与名字绑定的结果。
复制代码

名字的命名规范

1.不能出现除下滑线，数字，字母以外的其他符号

2.数字不能出现在开头

3.命名的名字不能与python中的关键词发生冲突

4.名字取出来之后要看到名字就知道这个代表的什么意思。（推荐用英语单词命名）

名字的命名风格

1.下划线

例：单词彼此之间采用下划线连接user_name

2.驼峰体

例：单词之间的首字母进行大写。或者除开头以外的其他单词首字母大写。

注：一般来说驼峰体和下划线之间都可以进行使用，详细按照公司旨意使用。

常量

python中不存在绝对的常量，所有的名字都可以是变量。我们将纯大写字母表示的变量名看作常量。其他编程语言存在绝对的常量，绑定关系后不可以进行修改。
复制代码

数据类型的概念

在日常生活中数据类型的理解：

表示年龄时用整数。表示体重时用小数。名字和地址则用文本。

而在代码中也需要不同数据类型来表示不同数据状态。

我们查看数据的数据类型可以使用

type（）
复制代码

python语法的基本类型

整型

(关键字：int）其实就是整数。例如：年龄年份

基本使用：

age = 18
year = 2022
复制代码

浮点型

（关键字：float）其实就是小数。例如：身高体重

基本使用：

weight = 75.6
height = 1.83
复制代码

字符型（字符串）

（关键字：str）其实就是文本信息。例如：姓名地址邮箱爱好等。
- 基本使用：

name = 'Tom'
address = "shanghai"
hobby = ''' 睡觉\睡觉\睡觉'''
email = """110@163.com"""
复制代码

解答：字符串内部也可能需要用到引号，为了避免冲突报错，所以定义字符串给出了许多方式。（原因）
明确定义字符串的符合和内部文本的符号，只要不发生冲突就行。（核心）
当三引号左侧没有赋值符合和变量名时。意为注释。 当三引号左侧有赋值符号与变量名是。意为字符串。（解释）

第二周内容总结

基础数据类型

整型(int)

整数

浮点型(float)

小数

字符串(str)

文本信息

列表(list)

中括号括起来，逗号连接，数据值取任意数据类型

字典(dict)

大括号括起来，逗号连接，数据值取任意数据类型。K：V的形式，输出k，内容展现为v。

元组(tuple)

小括号扩起来，逗号连接，数据值取任意数据类型。元组中的数据值不可变。称为：不可变更的列表

集合(set)

大括号括起来，判断有无共同的数据

布尔值(bool)

只有True和False.

交互，运算，赋值，输出

与用户交互

input()   # 输入
print()   # 输出
\r\n,\n,\r   # 换行符 (不同版本解释器略有差异)

格式化输出

%s   # 占位符，任何类型数据都能使用
%d   # 只支持纯数字的占位

运算符

基本运算符

+-*/      # 加减乘除
**        # 次方
//        # 整除
%         # 取模
               
x = x + i   简写为   x += i

==        # 等于
!=        # 不等

逻辑运算符

and      且      一假即假
or       或      一真即真
not      非      取相反
***三者连用()优先级最高，其次是not，and，or

输出结果可能是布尔值也可能是数据值。

and   # 从前往后判断，中间出现一个假，输出为False，全真看末尾输出为（布尔值，数据值）什么就返回什么
or    # 从前往后判断，全为假输出False,否则看第一个真，输出为（布尔值，数据值）什么就返回什么
not   # 输出只会是布尔值
***当三者混用时，按照优先级顺序比对，其次在遵循上面的判断条件

成员运算符

in       # 在一个集体里面     
not in   # 不在一个集体内

列表最小单位单个数值，字符串最小单位单个字符，字典最小单位k值，v不对外展示

身份运算符

is  判断本质是否相同
==  只判断结果是否相同

python，pycharm都会对内存进行优化。

赋值运算（=）

链式赋值        a = b = c = 1
交叉赋值        定义n,m    然后 n, m = m, n
解压赋值        赋值符号左右最少两个值，保证两边赋值个数相等
    num = [1, 2, 3, 4, 5]
    *a, b ,c = num            
    print(a)   [1, 2, 3]
    print(b)   4
    print(c)   5

流程控制

顺序结构

从上往下运行

分支结构

elif,else的出现需要if也出现才行

单if分支

if 条件：
    条件成立执行的子代码

判断的条件也可以是多个用逻辑运算符and,or,not
条件可以是布尔值，表达式。

if,else分支

if 条件：
    条件成立执行的子代码
else：
    不成立执行的子代码

判断的条件也可以是多个用逻辑运算符and,or,not

if,elif,else分支

elif 可以有多个
三者同时出现，只能进入一个分支

if 条件1：
    条件1成立执行的子代码
elif 条件2：
    条件2成立执行的子代码
else：
    1，2 都不成立执行的子代码

if嵌套使用

可以嵌套多层

if 条件：
    条件成立执行子代码
    if 子条件：
        子条件成立执行子子代码
    else：
        子条件不成立执行的子子代码
else：
    条件不成立执行的子代码

循环结构

结束循环体方式：

1.添加结束的条件
2.添加关键词结束循环

while循环

while 条件：
    条件成立执行的子代码

1.判断while后面的条件是否成立如果成立则执行子代码
2.子代码运行完毕，回到while后面的条件判断处，判断条件是否成立
3.成立则继续运行子代码，结束后再次判断while后面的条件是否成立
4.重复进行，条件不成立退出循环

while+break

break只会强制结束自己所在那一层的while循环体代码

while 条件：
    条件成立执行的子代码
    break

while+continue

continue会跳过本次循环直接开始下一次while循环（只会跳过自己所在那一次的）

while 条件：
    条件成立执行的子代码
    continue

while+else

while循环体按照设定条件正常结束，就会执行

while 条件：
    条件成立执行的子代码
else:
    print('正常结束执行的')

死循环：计算数值中死循环不能出现，获取用户输入信息时可以出现
全局标志位：

for循环

for循环的语法结构更加简单，尤其擅长循环取值
比起while循环，while循环能够做的事情更多

for 变量名称 in 可迭代的对象(字符串，列表，字典，元组):
    for循环的循环体代码

1.for循环字典，默认只能取到字典的k
2.for循环字符串，默认每次取单个字符
3.for循环元组数据与列表一致，默认都是单个数据值

for+break

break只会强制结束自己所在那一层的for循环体代码

for 变量名称 in 可迭代的对象:
    for循环的循环体代码
    break

for+continue

continue会跳过本次循环直接开始下一次for循环（只会跳过自己所在那一次的）

for 变量名称 in 可迭代的对象:
    for循环的循环体代码
    continue

for+else

for 变量名称 in 可迭代的对象:
    for循环的循环体代码
else：
    else子代码

for循环没有被强制结束，就会执行else

range方法

range可以当成帮助我们生成存在多个数据值的一个列表
range（）内一个数代表0开始，该数-1结束的列表
range（）内两个数代表第一个数开始，第二个-1结束的列表
range（）内有三个数，第三个数代表去列表时，间隔几取一次值
不同解释器中的range略有差异

第三周内容总结

数据类型的内置方法介绍

整型

没有内置方法

类型转换

字符串内部是纯数字情况可以转换

进制转换

bin()   #十转二    0b是标识
oct()   #十转八    0o是标识
hex()   #十转十六  0x是标识

没有标识默认为十进制

浮点型

没有内置方法

类型转换

整型可以转换

字符串

类型转换

所有类型数据都可转换

浮点型内置方法

1.  索引取值
2.  切片操作
3.  间隔/方向
4.  统计列表中数据值的个数  len()
5.  移除字符串首尾指导的字符 .strip()
6.  切割字符串中指定的字符 .split()
7.  字符串大小写 .lower()/.upper()
8.  字符串格式化输出 .format()
9.  统计指定字符出现次数 .count()
10. 开头结尾的判断 .startswith()/.endswith()
11. 字符串的替换 .replace()
12. 字符串的拼接 +/*/.join()
13. 判断字符串中是否为纯数字 .isdigit()
14. 查找某个字符对应得索引值 .find()/.index()

列表

能被for循环的数据类型都可以转换为列表（整型，浮点型，字符串，字典...）
索引，切片，间隔，方向，统计其实与字符串大同小异

列表内置方法

1. 索引取值
2. 切片操作
3. 间隔/方向
4. 统计列表中数据值的个数  len()
5. 统计某个数据值出现的次数  count()
6. 添加数据值 append()/insert()
   * 在结尾添加时使用append()，括号内无论什么数据类型，都会被当作一个数据值添加。
   * 在任意位置添加时使用insert(),括号内无论什么数据类型，都会被当作一个数据值插入。insert(位置，内容)
7. 列表的拓展（3种方法）
   * 使用for循环通过append()追加
   * 使用 + 拼接
   * 使用extend()添加
8. 删除数据值(三种方法)
   * 使用del通过索引删除
   * 通过remove()对象
   * 使用pop()取出数据值在进行删除
9. 查找数据值
10.修改数据值
11.数据值排序
   * 升序sort()
   * 降序sort(reverse=True)
12.翻转数据值 reverse()
13.数据值的比较运算
   * 不同类型不能进行比对，比对按照位置进行

字典

kv键值对是无序的。
k对v的描述是可变的类型，一般是字符串
字典内很少有数据值的转换，一般直接定义使用

字典的内置方法

1. 取值操作  get()
2. 统计字典键值对的个数 len()
3. 修改增加字典中的数据
   * 键存在修改，不存在添加
4. 删除数据
   * del 
   * pop()
   * 随机删除 popitem()
5. 快速获取键值的数据值
   * keys()获取字典全部的k值
   * values()获取字典全部的v值
   * items()获取全部的kv键值对数据
6. 修改字典数据   update()
   * 键存在就是修改，不存在就是新增
7. 快速构造字典  dict.formkeys()
   * 给一个值默认情况下所有所有键都用该值
8. 键存在与不存在获取的值 setdefault
   * 键存在获取键对应的值，键不存在创建获取新得到的值

元组

支持for循环的数据类型都可以被转换成元组
元组只存在一个数据值时，数据值后必须加逗号
只有一个数据值时，省略逗号，数据类型与该数据值的类型一致

元组的内置方法

1. 索引取值(可以索引但是数据值不可变)
2. 统计元组内的数据值个数 len()
3. 查看与修改元组内的数据

布尔值

无内置方法

集合

数据类型必须是不可变的，且要支持for循环
定义空集合要使用关键字

1. 去重  自动去重
2. 关系运算   
3. 集合的交并补集
     &     共有
     -     各自私有
     |     所有
     ^     私有的和

可变类型与不可变类型

可变类型

list
- 数据值改变，内存地址不发生变化

不可变类型

str/int/float
- 数据值改变，内存地址也发生变化

垃圾回收机制

1.引用计数

不能对循环引用使用引用计数

 a = 1    到此步引用计数为1
 b = a    到此步引用计数为2
 del b    到此步引用计数为1

2.标记清除

对所有数据筛查，找到循环引用并标记删除

a = 1          到此步a引用计数为1
b = 2          到此步b引用计数为1
a.append(b)    到此步a引用计数为2
b.append(a)    到此步b引用计数为2
del a          到此步a引用计数为1          
del b          到此步b引用计数为1

3.分代回收

分三代管理，多进少退，越往后检查频率越低，能够有效的减轻垃圾回收机制的资源损耗

字符编码相关

介绍

1.只有文本文件才有字符编码的概念

2.计算机内部存取数据的本质是二进制
3.计算机与人类文字之间存在一个转换关系。所以我们才能敲出来汉语等语言。
4.转换关系应该有统一的标准，所以字符编码表记录了人类的字符与数字的对应关系

发展（三个阶段）

1.ASSCI码(美国)
- 英文1bytes
2.GBK码(中国)
- 中文2bytes起步，英文1bytes
3.unicode码(万国码)>>utf8(英1中3)
- 2bytes起步

操作

什么形式编码存的就以什么形式编码解码
编码(人类的字符>>计算机的字符)
解码(计算机的字符>>人类的字符)
python2默认的编码是ASCII码。文件头加coding:utf8 ，定义字符串在字符串的前面加u。

文件操作(通过代码读写文件)

1.双击文件图标是从硬盘加载数据到内存
2.文件的保存其实就是将内存中的数据刷到硬盘
3.文件其实是操作系统暴露给用户操作计算机硬盘的快捷方式之一

文件操作简介

open(文件路径,读写模式,字符编码) 打开方式:

方式1: f = open(...) f.close() 
方式2: with open(...) as f: f.read() 
* ps:文件路径字符串的前面应该加一个字母r取消转移

内容补充
- 1.with语法：使用with可以一次性打开多个文件
- 2.使用pass补全语法，不推荐...补全
- 3.一般情况下，英语单词末尾加上able，表示了该单词描述的能力

文件读写模式

只读模式(r) 默认

只能读取不能写
文件路径存在进行读取，不存在报错

只写模式(w)

只能写不能读取
文件路径存在进行清空编写，不存在新建进行编写

只追加模式(a)

只能写不能读
文件路径存末尾追加编写，不存在新建进行编写

补充模式(x,+)

x
- 文件路径存在报错，不存在创建编写
- r+：可读可写文件路径不存在报错
- w+：文件路径不存在创建，存在会覆盖原来内容写入
- a+：写入与a相同，但是可以进行读取操作，一般与seek搭配使用

文件操作模式

文本模式(默认)

1.只能对文本文件进行操作。
2.必须指定 encoding参数。
3.读与写都以字符串为单位。

二进制模式(自己指定)

1.能够操作所有类型的文件。
2.不用指定encoding参数。
3.读和是以bytes为单位

注意事项：
- 二进制模式时read()有时会因为字节数报错，所以注意输出的字节数能与字符对应

文件的操作方法简介

  1.read()            一次性读完文件内容。不会回到头重新读。
                      文件数据较大建议使用for循环
  2.readline()        一次只读一行。
  3.readlines()       按行读取，将所有的内容并组织成列表返回
  4.readable()        判断当前文件是否可读
  5.writable()        判断当前文件是否可写
  6.write()           填写文件内容
  7.writelines()      支持填写容器类型(字典，元组，列表，集合)多个数据值
  8.flush()           将内存中的文件数据立刻刷到硬盘，相当于ctrl+s。

文件内的光标移动

tell()

获取光标移动的字节数

print(f.tell())

seek(offset,whence)

代码控制光标移动

offset表示光标移动的字节
whence表示功能(3种)
     * 0  文件从开头位置移动多少字节
     * 1  文件当前光标位置往后移多少字节
     * 2  文件从末尾移动了多少字节

文件内的数据修改

1.覆盖写
- 读取文件内容从内存中修改完成以后，使用w模式直接把原文件内容进行替换
- 占用空间少，但是数据量较大时内存会溢出
2.重命名
- 读取文件内容从内存中修改完成以后，保存为一个新文件，将原文件删除，对自己文件名进行修改，替代旧文件
- 不会造成内存溢出,但是可能需要占用两个空间,也可能在内存中创建，没有存储到硬盘

函数

函数介绍

更高效的工作，减少重复代码的编写，所以我们需要用到函数
函数与循环的不同之处就在于，函数在不同的位置重复执行相同的代码，而循环是在相同的位置重复执行相同的代码。

函数本质

函数就类似于一把现成的工具
在使用前需要先定义好函数才能使用

函数的语法结构

结构

def 函数名(参数1,参数2):
    '''函数注释''' 
    函数体代码 
    return 返回值

语法

1. def         定义函数的关键字，是固定的 
2.函数名       与变量名相似，要做到见名知意 
3.()括号       定义函数名时后面必须跟括号 
4.参数         参数个数不固定，多个参数时，参数与参数中间加逗号 
* 参数是用于接收外界传递给函数体代码内部的数据 
5.函数注释     类似于说明书，主要是介绍这个函数的功能以及用法 
6.函数体代码   函数的最核心(逻辑代码) 
7.return      控制函数的返回值 
8.返回值       调用函数之后有没有相应的反馈

函数的定义与调用

1.函数必须先被定义之后才可以使用(定义的函数必须在调用的前面)
2.定义函数关键字为def
3.调用函数使用函数名加(),可能需要添加额外的参数
4.函数在定义时只会检测函数体代码的整体语法，不会执行函数体代码
5.函数只有在调用时才会执行函数体代码
6.函数名是什么？
     函数名绑定了一块内存地址，函数体代码存放在其中。
     想要运行函数体代码就需要调用函数
***除定义阶段外，函数名加括号执行优先级最高***

def my_func():    使用def定义一个函数。 
    pass
    my_func()     调用该被定义的函数。

函数的返回值

1.返回值是调用函数之后产生的结果，有没有无所谓
2.获取函数返回值的方式是固定的：变量名 = 函数()
3.有无return关键字，有就获取返回值输出，没有返回none

4.返回值位置有多个数据值用逗号隔开
5.函数体代码有return关键字，后面返回值写什么返回什么
6.代码遇到return立刻结束函数体代码，关键字下面代码不执行

函数的分类

内置函数

python解释器提前定义好的函数，用户可以直接调用。
- 相当于是数据类型独有的一些内置方法
- 内置函数是可以直接进行调用的

数据类型的内置方法必须使用数据类型点(例如：str.)的方式才可以调用

自定义函数

空函数

函数体代码使用pass，没有功能，主要用于项目搭建前期的功能提示。

无参函数

函数定义阶段括号内没有写入参数，使用函数名加括号可以直接调用。

有参函数

函数定义阶段括号内写入参数，调用需要函数名加括号并且给数据值。

函数的参数

主要分两大类
- 形式参数：定义阶段()的参数
- 实际参数：调用阶段()的参数
形参相当于变量名，实参相当于数据值。
函数调用阶段形参会临时与实参进行绑定(动态绑定)，函数运行结束立刻解除绑定(动态解除)
参数从左到右的复杂程度依次增大

位置参数

位置形参
- 在函数定义阶段括号内从左往右依次填写的变量名称之为位置形参

位置实参

在函数调用阶段括号内从左往右依次填写的数据值称之为位置实参

# 1.实参可以是数据值，也可以是绑定了数据值的变量名 
# 2.实参与形参的个数是一致的，不能多或者少。

关键字参数

关键字实参

函数调用阶段括号内为a = 1之类的形式进行传值的就称为关键字实参

# 1.给某一指定的形参传值(打破了位置的限制) 
# 2.位置实参要在关键字实参的前面

默认值参数

默认值形参

在函数定义阶段括号内以a = 1之类的形式填写的形参称之为默认值形参

# 1.在函数定义阶段给形参绑定值，后续调用阶段就可以不用传值 
# 2.调用的时候没有进行传值就使用默认值 
# 3.调用阶段进行了传值就使用新传的值

可变长参数

可变长形参
- 可以打破形参和实参的个数限制，任意传值
- 单个星号* 在形参中可以接受多余的位置参数然后组织成元组的形式赋值给* 后面的变量名
- 两个星号** 在形参中接受多余的关键字参数并组织成字典的形式赋值给** 其后面的变量名

    def name(*x):        # *
        print(x)

    def image(**x): 
        print(x) 
    image() 
    image(name1='tom', age=21 )

第四周内容总结

函数应用介绍

名称空间

名称空间的介绍

名称空间是变量名与数据值绑定关系的地方
- 数据值绑定变量名，就存在名称空间中。使用该变量名就在名称空间查找。
- del删除的是变量名与数据值绑定的关系

名称空间的分类详细

1.内置名称空间
- 解释器运行就有，解释器自带的
- 解释器打开就有，关闭就没了
2.全局名称空间
- 自己创建的变量名在函数体，类体代码外的
- 运行代码文件就有，不运行时没有
3.局部名称空间
- 函数体，类体代码运行时产生的
- 函数体，类体运行有不运行没有
查找顺序与作用域
- 除局部空间只能在当前局部使用，内置与全局任意位置都可使用
- (局部>>全局>> 内置)的查找方式

关键字

global

局部修改全局的不可变数据类型

变量名 = 数据值 
def 函数名(): 
    global 变量名 
    变量名 = 新数据值 
        print(变量名) 
 函数名() 
 print(变量名) # 局部全局都为新数据值

nonlocal

内层局部修改外层局部的不可变数据类型。

函数名的使用方式

1.函数名可以用来被赋值，被当作函数的实参，返回值，与容器类型里的数据值

闭包函数

定义在函数内部，使用外部函数名称空间变量名的是闭包函数

给函数体代码传值时可以通过形参或闭包函数完成。

比较

# 形参传值：
def 函数名(xxx): 
print(xxx)

# 闭包函数：
def 函数名(形参):        # 形参其实就是定义的变量名 
    def 内部的函数名(): 
        print(形参) 
    return 内部的函数名 
新变量名 = 函数名('要传入的数据值')  # 需要什么就传入什么 
新变量名()

递归函数

函数直接(自调)或者间接(互调)调用自己就被称为递归调用
自定义最大调用次数为2000，官方为1000，但是实际会少几次
每次递归循环之后都会比之前简单，用于有结果的事件

装饰器

装饰器就是为了不改变装饰对象内部代码与调用方式去添加功能，但是不能修改。

装饰器语法糖

import time 

@outer # home = outer(真正的函数名home) 
def home(): 
    '''我是home函数 我要热死了!!!'''
    time.sleep(1) 
    print('from home') 
    return 'home返回值' 
home()

装饰器模板

from functools import wraps 
def outer(func_name): 
    @wraps(func_name) 
    def inner(*args, **kwargs): 
        print('执行被装饰对象之前可以做的额外操作') 
        res = func_name(*args, **kwargs) 
        print('执行被装饰对象之后可以做的额外操作') 
        return res
    return inner

@wraps(func_name) 仅仅是为了做到真正的以假乱真

有参装饰器

有参装饰器是给装饰器传递额外参数的。

多层装饰器

多层装饰器可以给一个函数添加多个功能。是从下往上运行的。
多层装饰器中出现多个叠加的语法糖会从最下面的语法糖与下方紧挨着的函数名当作参数传递给@符号后面的函数名
使用多层装饰器一定要捋清楚流程

三元表达式

三元表达式可以有限减少代码使用量，提高含金量。
三元表达式只适合用于二选一的情况，
三元表达式有固定语法，不建议嵌套使用：

数据值1 if 条件 else 数据值2

函数补充知识

生成式

列表生成式

list = [name + '_nb' for name in name_list]

字典生成式

dict ={i :'jason' for i in range(10) if i == 6}

集合生成式

set = {name for name in name_list if name == 'jason'}

匿名函数(没有名字的函数)

可以减少代码

lambda 形参: 返回值

二分法(算法)

二分法就是将一个有序的数据集在中间多次一分为二来查找特定的数据。

# 二分：
       变量名 = len(数据集) // 2

第五周内容总结

内置函数

常见的内置函数

共有68种，部分了解即可

##   1.与数据类型转换相关：

**1.int()     转换为十进制整数       
**2.bool()    转换为布尔值       
**3.dict()    转换为字典    
**4.list()    转换为列表            
**5.float()   转换为浮点型       
**6.tuple()   转换为元组  
**7.str()     转换为字符串         
**8.set()     转换为集合        
**9.bytes()   转换为字节
**10.bin()    转换为2进制           
**11.oct()    转换为8进制        
**12.hex()    转换为16进制
**13.range()  生成一个整数序列   
*14.object()  生成一个object对象   
*15.ord()     返回unicode字符对应整数   
*16.chr()     ASCII码实现字符转换   
*17.slice()   生成一个切片对象     
*18.iter()    生成一个可迭代对象         
*19.enumerate()     枚举             
*20.complex() 生成一个新的复数

##    2.运算相关的:
**1.max() 求最大值      **2.min() 求最小值      **3.sum() 求和     
* 4.abs() 求绝对值      * 5.divmod 求商和余数   * 6.pow() 幂运算   
* 7.round() 四舍五入

变量操作:
**1.globals()         返回当前作用域内的全局变量和其值组成的字典
**2.locals()	         返回当前作用域内的局部变量和其值组成的字典
交互操作:
**1.print()           打印       
**2.input()           输入
文件操作:
**1.open()            指定编码打开文件

##    3.其他较重要函数
**1.help()          返回对象帮助信息      
**2.id()            返回对象的唯一标识符 
**3.len()           返回对象的长度        
**4.type()          返回对象的类型，或者根据传入的参数创建一个新的类型  
**5._import_()      动态导入模块          
**6.format()        格式化显示值
**7.var()           返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列 
**8.filter          过滤                 
**9.map()           映射
**11.next           返回可迭代对象元素值   
**12.zip()          拉链 
* 12.all/any()      判断容器类型中的所有数据值对应的布尔值是否为True 
* 13.reversed()     反转序列生成新的可迭代对象 
* 14.dir()          返回对象或者当前作用域内的属性列表 
* 15.hash()         获取对象哈希值

迭代

基于上一次有所更新就叫做迭代

可迭代对象

内置含有双下iter的就是可迭代对象，可迭代对象都支持循环取值

迭代器对象

内置含有双下iter和双下next的就叫迭代器对象
调用双下iter后，可迭代对象就变为了迭代器对象，但是本体并未改变

迭代取值

迭代取值省去了繁琐的打印，只需要往容器里面放值就可以打印
如果值被取完再取就会报错，并且一旦开始不能回退
for循环取值的内部其实就是一个迭代取值的过程
迭代器重复使用时输出的值取决于可迭代对象是谁
通过打印操作都无法直接看出内部数据的情况，需要时才会打印需要的值

生成器对象

自定义出__iter__和__next__本质为迭代器对象的就是生成器对象
生成器对象不仅会取消对索引取值的依赖，更好的是可以数据类型的内存占用空间
生成器表达式:
- 加小括号输出的就是表达式，存在内存中，需要时才从内存中拿，省内存。
```
l1 = (i**2 for i in range(10) if i > 3) print(l1)
```

yield关键字

1. 函数体代码有yield关键字，第一次调用将函数变为迭代器对象(生成器)，不执行函数体代码。
1. yield可以在函数中出现许多次。
1. yield后有数据值会像return一样返回。
1. yield方法每次遇到从上往下调用__next__方法都会停留到yield前。
5.传值并自动调用__next__方法

异常(bug)

有语法错误和逻辑错误两种，语法错误勿出现
一般的格式

异常捕获实参

为了应对各种可能发生的错误情况，所以需要写异常报错处理

语法结构

try: 
    try监控的可能出错的代码 
except 错误类型1 as e: 
    错误类型1的解决办法
except ...

万能异常语法结构

try: 
    try监控的可能出错的代码 
except Exception/BaseException as e: 
    print(e)

其他异常捕获结构

1.else+finally

try: 
    try监测的可能会出错的代码 
except Exception as e: 
    print('报错了') 
else: 
    print('try监测的代码没有出错，正常结束运行')
finally: 
    print('不管try监测的代码有无报错，最后都会执行finally内的代码')

2.断言

name = 'tom'  
assert isinstance(name, list) 
print('针对name数据使用列表相关操作')

3.主动抛出异常

name = input('输入用户名').strip()
if name == 'jerry':
    raise Exception('不通过')   
else:
    print('通过了')

bug排查从下往上(报错信息>>定位信息>>具体变量>>变量相关位置)

模块

模块是一系列功能的结合体(使用模块就能得到一系列功能)
查找顺序为内存>>>内置>>> sys.path
模块分为三类内置模块，自定义模块，第三方模块

模块的导入

导入语句只会执行一次,不加模块名就使用的执行文件的里的名字
导入的时候要避免循环导入
1.import 模块名
```
import 模块名 
print(模块名.py)
```

2.from 模块名 import 模块名里的名字

from 模块名 import 模块名内的名字 
print(模块名内的名字)

from...import...比起import可以指定使用名字，不会被扒光。不用加模块名前缀，但是名字容易产生冲突
补充知识
- 起别名：多个模块由不同人文件名相同或原有文件名复杂
- 多导入：出自同一个模块或多个模块功能相似才能一起导入，不然尽量分开
- 全导入：需要使用模块名称空间很多的名字只能使用form...import...
```
 所有py文件都自带__name__内置名
     执行: 双下name的结果是双下main
     被导入: 双下name的结果是模块名
     
 双下name一般用于开发模块的作者测试自己的代码:
     if __name__ == '__main__':
```

导入的分类

绝对导入

从根目录找，找不到报错，然后手动在sys.path下添加根目录，
    from aaa.bbb.ccc improt 模块名/名字

相对导入

只能在模块文件里面使用
    . 当前路径 
    .. 上一级路径
    ../.. 上上级路径

编程思想简介

小白>>>函数>>>模块>>>面向对象

包

包是为了管理模块放在文件夹中的模块(import 包名)
导入包名其实就是导入了包里的__init__.py,有什么就能用什么
也可以跳过直接导入模块文件不导包
不同环境中包得差异：
- 1.在python2中，含有__init__.py的文件夹才可以被当作包
- 2.在python3中，即使文件夹中没有__init__.py,也会被默认为包。 \

软件开发目录规范

bin文件夹        存储文件的启动文件      start.py 
conf文件夹       用于存储程序的配置文件  settings.py 
lib文件夹        用于存储程序的公共能力  common.py 
core文件夹       用于存储程序的和兴逻辑  src.py 
db文件夹         用于存储程序的数据文件  userinfo.txt 
log文件夹        用于存储程序的日志文件  log.log 
interface文件夹  用于存储程序的接口文件  user.py order.py goods.py readme            用于编写程序的说明，介绍，广告，产品说明书 
requirements.txt  用于存储程序所需的第三方模块名称和版本

编写软件时可以不完全遵守这个文件名

  bin文件下的start.py文件也能直接放到项目的根目录
  db文件夹后期项目会被数据库软件代替
  log文件夹后续也会被专门的日志服务代替

模块的分类

内置模块

常见的内置模块

collections模块

1.具名元组 namedtuple
2.双端队列 deque
3.有序字典 OrderedDict
4.默认值字典 defaultdict
5.简单的计数器 Counter

time模块

* 格式化时间可以在中间帮助时间戳时间和结构化时间的互相转换

1.时间戳时间 time.time()
2.结构化时间 time.gmtime()
3.格式化时间 time.strftime()

datetime模块

* 与time时间类似

os模块

* 主要与操作系统交互

创建目录             mkdir       创建一个单层的目录，目录存在报错，不能创多层
                    makedirs    创建一个多层的目录，目录存在报错，可以创单层
删除目录,文件        rmdir       删除一个内部没有东西的单层目录
                    removedirs  删除一个内部没有东西的多层目录 由内而外
                    remove      删除当前执行文件所在根目录的指定文件
列举指定路径文件名   listdir      括号内不填写，展示当前工作路径下的文件与文件夹，
                                填写要填入目录的绝对路径，以列表的形式展示，其他格式路径会报错
重命名目录和文件     rename       可以对当前工作路径目录，文件重命名。
获取路径            getcwd       当前工作的路径，得到的是绝对路径
                                在相对路径创建新目录，改变当前工作目录到新目录
改变目录            chdir        改变当前工作目录到指定的路径，获取新目录的绝对路径
                                获取当前文件所在目录的绝对路径
判断路径是否存在     exists       括号里可以放入绝对路径，或者同一级的文件名，目录名
                   isdir        isdir只能用于获取输入的路径是不是目录（文件夹）
                   isfile
路径的拼接          join        可以自动识别当前操作系统并切换正确的分隔符
获取文件的大小       bytes       获取到的是文件字节大小

sys模块

主要与python解释器交互

import sys 

print(sys.path)     # 当前执行文件的系统环境变量，结果统合为一个列表 
print(sys.version)  # 查看python解释器信息 
print(sys.platform) # 查看当前平台的操作系统

json模块

json模块相当于一个媒介，可以实现不同变成语言之间一些对象的转换。例如python中的字典与其他编程语言里的自定义对象
数据基于网络传输所以是二进制，在python中只有字符串可以调用encode方法转为二进制数据，所以json格式的数据也属于字符串
json格式是标志性双引号的字符串

dumps() # 将其他数据类型转换成json格式字符串 
loads() # 将json格式字符串转化成对应的数据类型
dump() # 将其他数据类型以json格式字符串写入文件 
load() # 将文件中json格式字符串读取出来并转换成对应的数据类型

json的实参

自定义模块

自己写的有功能的模块

第六周

第三方模块

别人写的有功能的模块，一般需要在网络下载
必须通过导入才可以使用，下载需要借助pip工具

pip3.8 install 模块名      # 模块名后面可以指定版本号用==连接

因为下载默认用的是国外的镜像源，所以速度会很慢，甚至网络波动会导致下载失败

遇到问题

配置特定的环境
    自行查询
Read timed out
    我们直接欸切换下载源，或者多尝试几次即可 
pip 版本过低
    直接拷贝提示里的更新命令即可

openpyxl模块

openpyxl用于操作excel文件(xlwt,xlrd也行)
操作excel文件可以使用append批量写入

语法

wb = Workbook()            # 创建一个excel工作簿
wb1 = wb.create_sheet()    # 添加或插入一张表单
wb.save()                  # 保存数据
load_workbook()            # 读取excel
max_row                # 显示最大行数
max_column             # 显示最大列数
['？？'].value  
cell(row=？,column=？).value   # 单元格取值

pandas模块底层就是openpyxl，也能操作excel

爬虫

互联网指的是由全世界计算机连接组成的网络，目的是为了共享数据
我们基于互联网访问的别人计算机，叫做服务器
爬虫就是模拟人向浏览器手动发送请求的过程

random模块(随机数)

1. random.random
- 返回0-1之间的随机小数
1. random.randint
- 返回两个整数之间的随机整数，可以取到两端
1. random.sample
- 随机抽样，自定义抽样个数
1. random.shuffle
- 随机打乱顺序

hashlib加密模块

什么是加密？
- 将明文数据处理为密文数据的过程
为啥要加密？
- 为了不让数据轻易泄露
判断当前数据值是否加密？
- 加密后的结果一般是一串没有规律数字字母符号
常见的算法

md5   sha系列   hmac   base64

加密算法
- 加密算法就是对明文数据采用的加密策略
  - 不同加密算法对相同数据加密所得长度，复杂程度也不尽相同。
  - 加密后的结果越长，一般说明加密算法越复杂
加密模块补充
- 1.加密模块一般不能进行反解密
- 2.只要明文数据相同采用相同加密算法得出的密文也相同
  - md5加密往里面添加明文数据必须为bytes类型
- 3.加盐处理就是往密文内添加干扰数据，让数据更难被反解
- 4.动态加盐可以让每一次干扰项都不一样，再一次提高了数据的安全性
加密的实际应用
- 1.用户密码加密
- 2.文件的安全性校验
- 3.大文件加密

subprocess远程命令模块

模拟计算机的cmd命令窗口

logging 日志模块

记录发生事件的时间，状态之类的叫做日志
日志模块放在log目录下的.log文件。按照软件开发目录规范编写使用
字典数据是日志模块固定的配置文件，写完一次之后几乎都不需要动。
- 配置文件中变量名推荐全大写
日志分为

debug等级，info等级，warning等级，error等级，critical等级。

基本使用

import logging 

file_handler = logging.FileHandler(filename='l1.log', mode='a', encoding='utf-8', ) 
logging.basicConfig( 
    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s', 
    datefmt='%Y-%m-%d %H:%M:%S %p', 
    handlers=[file_handler, ], 
    level=logging.ERROR ) 
    
logging.error('我不好!!!')

日志模块的组成
日志配置字典

正则表达式

正则表达式独立存在。可用于各种编程语言
正则表达式也是为了提高写代码的效率，他的本质是通过符号的组合产生特殊含义
python中使用r取消转义，正则表达式需要加匹配数字的斜杠取消转义

正则表达式分类

字符组

[0-9] ,  [a-z] ,  [A-Z]  , [0-9a-zA-Z]    # 表示匹配什么到什么

特殊符号

.                任意字符(除换行符)
\w,\W            字母数字下划线\ 取反
\d               数字
^ , $            字符串开头\结尾
|                什么或什么
()               分组
[]               字符串中的字符，加入^表示除了^以外的字符

量词(贪婪匹配，重复次数)

*    0和n次      +    1和n次      ？      0和1次
{n}  n次        {n,}  n或更多次   {n,m}   n到m次

常见正则百度查询

re模块

在python中使用正则，re模块可以选择(直接导入)

1. findall  筛选符合条件的文本数据
2. finditer 将结果变为迭代器对象(同上)
3. search   匹配到一个符合条件的文本就结束
4. match    匹配一个开头符合条件的内容就不再匹配
5. complie  提前准备好正则，后续反复使用

re模块分组
- findall针对正则会将匹配到的结果优先展示
- findall使用(?:)可以取消分组优先展示
正则索引分组机制
- 组号从一开始，从左到右，依次加1
可以给分组起别名
```
(?P<id>字符)
```

python学习 1-6周知识回顾总结 数据类型基础，函数，模块

第一周总结

基础软件的简介

课程学习的一些阶段

软件的下载与安装

网络博文的编写

各软件的作用

文件的安装路径

绝对路径与相对路径

typora的主要功能介绍

markdown语法

计算机的本质

计算机的五大组成部分

控制器

运算器

存储器（负责存储数据）

输入设备

输出设备

五大核心组件的详解

1.控制器（类似于人的大脑）

2.运算器（类似于人的大脑）

3.存储器（类似于人的记忆）

4.输入设备（类似于人的眼睛，耳朵，鼻子）

5.输出设备（类似于人的嘴巴，皮肤）

三大核心硬件

cpu

内存

外存（硬盘）

操作系统简介

编程与编程语言

机器语言

汇编语言

高级语言

编程语言的分类

编译类

解释性

python发展方向

python解释器

解释器版本

解释器的安装与启动

环境变量配置

多版本共存

系统问题

运行python的多种方式

1.方式1

2.方式2

3.方式3

编写代码的软件(IDE工具)

1.vscode

2.sublime

3.pycharm

pycharm基本使用

python语法的变量与常量

变量

常量

基本使用

语法结构

python变量与常量的本质

名字的命名规范

名字的命名风格

常量

数据类型的概念

python语法的基本类型

整型

浮点型

字符型（字符串）

第二周内容总结

基础数据类型

整型(int)

浮点型(float)

字符串(str)

列表(list)

字典(dict)

元组(tuple)

集合(set)

布尔值(bool)

交互，运算，赋值，输出

与用户交互

格式化输出

运算符

python学习 1-6周知识回顾总结数据类型基础，函数，模块

赋值运算（=）