摘要：这周没什么编程作业但是学习内容偏理论化，知识量很多。虽然说缓了一下进度，虽然我有几天预习了一下后面内容，但是我觉得预习对我来说作用不大，虽然说作用不大，但是还是有些知识内容加深了印象。我觉得还得跟着自己的节奏走。多复习之前学的知识点，掌握好今天学习的内容就好了，多余时间可以敲点代码，这一天时间基本这样没了。

周总结

一、常见内置函数

内置函数：提前定义好，直接拿来使用。

二、可迭代对象

1. 迭代就是更新换代，每次迭代都需要基于上一次的成果

2. 内置：通过 . 句点符直接点出方法

3. 内置有__inter__方法都叫做可迭代对象

   • 可迭代对象：

     字符串，列表，字典，元组，集合，文件对象（本身就是迭代器对象）

   • 不可迭代对象

     整型，浮点型，布尔值，函数名

   • 可迭代对象能够支持for循环

三、迭代器对象

作用：

? 迭代器对象给我们提供一种不依赖于索引取值的方式。

? 解决了对无序类型循环取值。

1. 判断迭代器对象

   内置有__iter__和__next__的对象都成为迭代器对象

2. 可迭代对象与迭代器对象的关系

   可迭代对象调用__iter__方法之后就会变成迭代器对象

3. 迭代器对象迭代取值

   res = 'xz'.__iter__() 将其变成一个迭代器对象
   print(res.__next__()) # x
   print(res.__next__()) # z
   

4. 迭代器使用

   l = [1, 2, 3, 4, 5]
   print(l.__iter__().__next__()) #每次产生一个新的迭代器
   
   res = l.__iter__()
   print(res.__iter__().__next__()) #每次使用都是同一个迭代器对象
   

5. 针对双下方法简写

   res = l.__iter__()  ------>iter(l)
   res.__next__() ------->next(res)
   

6. 迭代器对象特殊的地方

   节省内存。

四、for循环的原理

1. 语法结构：

   for 变量名 in可迭代对象：
   	循环体代码
   

2. for循环原理：

   1.for会自动将in后面数据调用__iter__()变成迭代器对象
   2.之后每次循环调用__next__()取值
   3.最后没有值__next__()会出错，for能够自动处理该错误的，让循环正常结束。
   

实现列表队列和堆栈：
	队列:先进先出
	堆栈:先进后出
用pop内置方法索引来实现。
pop(索引值，索引值指定位置取)

五、异常捕获

1. 异常简介：程序在运行过程中如此出现异常会导致整个程序的结束。‘bug’

2. 异常类型：NameError , ImportError , IndexError , KeyError ......

3. 异常分类：语法错误，逻辑错误

4. 异常捕获简介：提前预测可能要出现的问题并提前给出处理的措施

5. 基本语法结构：

   try:
       可能会出现的代码（被try监控）
   except 错误类型  as e:  #e就是具体错误的原因
       对应错误类型的解决措施
   
   万能异常：Exception  /  BaseException
   
   异常捕获其他操作补充
   
   else |  finally
   
   else:try检测的代码没有出错的情况下正常运行结束，就会执行else子代码。
   finally:try检测的代码无论有没有出错，最后都会执行finally子代码。
   
   assert   断言
   也是检测语句，如果不成立就会报错。
   
   raise  主动抛出异常
   检测语句成不成立，成立就会主动抛出异常
   raise Exception('反正就是长得帅！！！')
   
   注意：异常捕获能尽量少用就少用
   
   for循环内部的本质：就是可迭代对象--->迭代器对象--->异常捕获
   
   

六、生成器对象（自定义迭代器对象）

1. 本质：迭代器对象

   生成器是我们自定义写出来的。

   迭代器是解释器提供的。

2. 目的：优化代码，节省内存，是一种通用的取值方式（一种不依赖索引取值）

3. 代码：

   def index():
       print('你好！')
       yield xz,wyb
       
   print(index)
   res = index()
   print(res)
   res.__next__()
   1.当代码有yield的关键字，那么函数名第一次加括号调用不会执行函数体代码，而是由普通的函数变成了迭代器对象（生成器），将返回值赋给生成器。
   2.yield可以在函数代码中出现多次，每次调用__next__方法都会从上往下执行直到遇到yield代码停留在此。
   3.yield后面如果有数据值，就会像return一样返回出去。
   如果数据值多而且用逗号隔开，则会自动组织成元组返回。
   

4. yield：

   res.send()  #传值并调用__next__方法
   将值传给yield赋值左边的变量名，并调用__next__()方法。
   

七、生成器表达式

列表生成式 --- 中括号
l1 = [i**2  for i in range(10) if i > 3]
	print(l1)
l2 = (i**2 for i in range(10) if i > 3)
	print(l2)

八、模块

1. 模块简介：一系列功能的结合体

2. 模块的分类：内置模块（解释器自带），自定义模块（自己写的），第三方模块

3. 模块导入：

   在真正项目中，所有文件的py文件名称都是英文，没有所谓的编号和中文。

4. 导入模块的句式1 import句式

   • 先执行代码文件的代码。执行代码会创建的一个全局名称空间。
   • import md就是运行模块文件，并创建一个全局名称空间。
   • 如果执行文件想获取模块文件里的名字，则需要通过 . (模块里的名字)的方式就可以使用到被导入文件名称空间里的名字。

5. 导入模块的句式1 for...import句式

   • 先执行文件，创建执行文件的名称空间
   • from md import money 创建被导入文件的名称空间
   • 执行被导入文件的代码，将产生的名字存储到到导入文件的名称空间。
   • 在执行文件中获取指定的名字，指向被导入文件的名称空间。

6. 两种导入句式的优缺点

   	import	from...import
   优点	通过句点符方式可以使用到模块内所有的名字，并且不会冲突。	指名道姓的使用指定的名字，并且不需要加模块前缀。
   缺点	什么都可以点，有时候并不想让所有名字都能使用	名字及其容易产生冲突，绑定关系被修改。

7. 补充知识

   • 起别名：

     情况一：多个模块文件名相同时，我们可以将文件名换个新名字。

     情况二：原有的模块的文件名复杂。

   • 导入多个名字：

     import句式：导入方式建议多个模块功能相似才能适应 不相似尽量分开导入

     from ... import ...句式:多个名字出自于一个模块文件

   • 全导入

     只能在from ... import ...句式使用。

     from md import * # *表示所有

     在模块文件中可以使用__all__ = [字符串的名字] 控制*能够获取的名字

   • 循环导入问题

     • 循环导入简介：两个文件彼此导彼此。
     • 使用彼此名字可能在还没准备好的情况下就使用了。
     • 如何解决循环导入保存现象：彼此在使用名字前，先准备好。

九、判断文件类型

1. 所有py文件中都自带一个__name__内置名
2. 当py文件是被导入时，__name__的结果是__main__
3. 当py文件是执行文件的时候 __name__的结果是模块名（文件名）
4. if __name__== '__main__':

十、模块的查找顺序

1. 先去内存中查找
2. 再去内置中查找
3. 再去sys.path 中查找（程序系统环境变量）
4. 不能创建一个和内置模块相同的文件名
5. 导入模块的时候一定要知道谁是执行文件：所有的路径都是参照执行文件来。
6. 通用的方式 ：sys.path.append(目标文件所在的路径)
7. 利用from...import句式:from xxx import md

十一、绝对导入与相对导入

1. 只要涉及到模块的导入，那么sys.path永远以执行文件为准。

2. 绝对导入：其实就是执行文件所在的 sys.path为起始路径，往下一层层查找。

   由于pycharm会自动将项目根目录添加到sys.path中所查找模块肯定不报错的。

3. 相对导入：

   只能在模块文件中使用，不能在执行文件中使用。

   相对导入在项目中比较复杂的情况下可能会出错。

十二、包的概念

1. 如何理解包

   内部含有__init__.py的文件

2. 包的作用

   内部存放多个py文件（模块文件），仅仅是为了更方便管理模块文件。

3. 具体使用

   导入包名其实导入是里面 __init__.py文件

   其实也可以跨过__init__.py直接将其他模块文件导入包里面。

4. 注意：针对python2解释器，文件夹下面必须要有___init__.py才能被当做包。python3无所谓。

十三、编程思想的转变

1. 小白阶段：按需求从上往下堆叠代码

2. 函数阶段：将代码按照功能不同封装成不同函数

3. 模块阶段：根据功能的不同封装成不同的函数

   目的是为了更加方便快捷高效的管理资源

十四、软件开发目录规范

十五、常见内置模块

1. collections

   内置方法	作用	举例
   namedtuple	生成可以使用名字来访问元素内容的tuple	point = namedtuple('二维坐标系', ['x', 'y'])
   deque	双端队列，高效实现插入和删除操作的双向列表，适合用于队列和栈。	q = deque(['a', 'b', 'c']) q.append('x') q.appendleft('y')
   OrderedDict	有序字典，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：	od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
   defaultdict	带有默认值的字典	dict1 = defaultdict(list)

2. 时间模块之time模块

   时间的三种格式：

   1. 时间戳 time.time() 机器能识别的时间
   2. 结构化时间 time.gmtime()
   3. 格式化时间 time.strftime() 人能够看懂的时间字符串

   1.时间戳：时间戳表示的是从1970年1月1日00:00:00开始按秒计算到今天的时间
           print(time.time())
   2.本地的时间：print(time.localtime())
   3.时间戳-->结构化时间
   	print(time.gmtime()) #UTC时间，与英国伦敦当地时间一致
    
   4.按照某种格式显示的时间（格式化的字符串形式的时间）：strftime_time
   	print(time.strftime('%Y-%m-%d %H-%M-%S'))
       %X可以表示后面的%H-%M-%S
       print(time.strftime('%Y-%m-%d %X'))
      
   5.结构化时间-->时间戳　
   	time.mktime(结构化时间)
   6.结构化时间-->字符串时间
   	time.strftime("格式定义","结构化时间")
      
   7.字符串时间-->结构化时间
   	time.strptime(时间字符串,字符串对应格式)
   
   

3. 时间模块之datetime

   date        年月日   
   datetime    年月日 时分秒
   
   timedelta-时间差
   res1 = datetime.date.today()
   tl = datetime.timedelta(days=5)
   rint(res1 + tl)  # 2022-07-20
   print(res1 - tl)  # 2022-07-10
   timedelta括号内有很多参数 没有的时间可以通过换算得来
   
   读取的时间是系统的本地时间
   print(datetime.datetime.now())
   
   读取的时间一直都是系统的“世界标准时间”
   print(datetime.datetime.utcnow())
   
   以时间字符串的形式
   c =datetime.datetime(2017, 5, 23, 12, 20)
   print('指定日期：', c) 
   

十六、os模块

os模块主要跟当前程序所在的操作系统打交道。

十七、sys模块

sys模块主要是跟python解释器打交道。

十八、json模块

1. json模块也称为序列化模块
2. json模块是不同编程语言之间数据交互必备的模块（处理措施）
3. 数据基于网络传输肯定是二进制，那么在python中只有字符串可以调用encode方法转换成二进制数据，所以json格式的数据也属于字符串。
4. json格式的数据的特征：字符串类型，引号是标志性的双引号
5. json有四个方法，两两搭配。
6. 涉及到用户数据的存储 可以单用户单文件