迭代是更新，每次迭代都是基于上次的结果

每次结果与上次无关 不属于迭代

while True:     print('哈哈') 

每次迭代 都是基于上次的结果

n=0 while n <10:     print(n)     n =1 

内置有__iter__该方法称为可迭代对象

可以通过句点符直接指出的东西叫内置

可迭代对象可以支持for循环

内置有__iter__并且有__next__所有的对象都称为迭代器对象

正因为有迭代器对象的存在，我们才能对字典、集合这些无序类型循环取值

可迭代对象使用iter它将成为迭代器对象

无论迭代器对象调用多少次，双下次都是多少次iter之后，它们仍然是最初的迭代器本身

迭代对象迭代取值

list_1['11','23','32','53'] new_list=list_1.__iter__() print(new_list.__next__()) print(new_list.__next__()) print(new_list.__next__()) >>> 11 23 32 

迭代器反复使用情况

list_1=['11','23','32','53']
print(list_1.__iter__().__next__())
print(list_1.__iter__().__next__())
print(list_1.__iter__().__next__())
print(list_1.__iter__().__next__())
print(list_1.__iter__().__next__())
>>>
11
11
11
11
11

将迭代器对象重复迭代取值

list_1=['11','23','32','53']
new_list_1=list_1.__iter__()
print(new_list_1.__iter__().__next__())
print(new_list_1.__iter__().__next__())
print(new_list_1.__iter__().__next__())
>>>
11
23
32

__iter__ 和__next__还可以写成iter（）

nuw_list_1=iter(list_1)
next(new_list_1)

• 索引取值：
  • 优点：可以反复取任意一个索引对应的值
  • 缺点：不能对无序的容器类型取值
• 迭代取值：
  • 优点：能够对任何迭代器进行取值
  • 缺点：取值只能往后取不能往回取

模块的理解：
模块可以看成是一系列功能的结合体，使用了模块就是拥有了这结合体的所有功能

模块的分类：

同一给执行文件，反复导入相同的模块。导入语句只会执行一次

导入句式一：

在此文件中代码都可已利用被导入文件名后面句点符来使用被导入文件中的功能

优点：能够通过点的形式直接用到该py文件中名字

缺点：权限太大，所有名字都能使用

import 被导入文件名

导入句式二：

使用这种句式，在调用文件内功能时，不用再在名字前面加文件名前缀

优点：指名道姓的选择需要使用的功能名字

缺点：变量名回与当前文件变量名字产生冲突

from 被导入文件名 in 被导入文件

1. 起别名

当导入多个模式时，出现模块文件名相同或文件中名字相同时，可以通过起别名方式，防止模块冲突

from Day21.a import name as n
from Day22.a import name as m

2. 导入多个名字

在import后面，通过逗号隔开，可以一次导入多个名字或多个文件

from Day21 import a,b
print(a,name)
print(b.my_rang(10))

• 导入多个模块功能时尽量分开导入,除非功能都相似，如果是导入同一模块中的名字则可以适用

3. 全导入

在模块空间中使用，from···import句式将名字一次性被全局空间绑定，那么就可以用星号

在模块文件，还可以使用__all__=[‘‘导入的名字’’]控制*能够获取的名字填入的可以获取，没填入的不能获取

from Day21.a import *


print(name)
print(name_1)

py文件中有一个自带的内知名__name__作为执行文件时，运行输出双下main

当py文件作为被导入文件时，输出为该文件名

主要作用：用于开发模块的作者自己测试自己的代码

if __name__ == '__main__':
    #当文件为执行文件时就会执行子代码

• pycharm中可以编写main按tab键自动补全

查找顺序：

1. 先取内存中查找
2. 再去内置中查找
3. 再去sys.path中查找

导入不在同一级目录下文件时

1. sys.path.append(目标文件所在路径)
2. 利用from···import····句式

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

由于pycharm会自动将项目根目录添加到sys.path中，所以查找模块不报错的方式就是从根路径一层层往下找（通过句点符连接下一层目录名）

如果不是用pycharm运行。则需要先将项目根目录添加到sys.path(针对项目根目录的绝对路径可以通过os模块中path.dirname获取)

from Day23.bin import start

相对路径只能在模块中使用，不能再执行文件中使用

相对路径不用参考执行文件所在的路径，直接以当前模块文件路径为准

相对路径在项目比较复杂的情况可能会出错

from..conf import settings

如何理解包：

专业的角度：内部含有__inter__.py目录

直观角度：就是一个文件夹

包的作用：

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

具体使用：

语句格式：import 包名

导入包名其实导入的是里面的双下init.py 文件（该文件相当于是这个包的关键，它那有什么 我们才能从它那获取什么）

在python3解释器中，其实包文件中有没有__inter__.py已经无所谓了，都是可以当作包
但是在python2版本解释器中，为奴见下面必须要有__inter__.py文件才能当作包

拓展知识

我们在编写代码的时候，可以不完全遵循上面的文件名。

start.py可以放在bin文件下也可以直接放在项目根目录

db目录 之后会被数据库软件替代

log目录之后也会被专门的日志服务替代

1. namedtiple 具名

生成可以使用名字来访问元素内容得tuple

from collections import namedtuple
point=namedtuple('三维坐标'，['x','y','z'])
res_1=point(2.5,6)
print(re_1,res_2)

2. deque 双端队列

可以从左右两边添加或删除元素

from collections import deque
dt_1=deque()
dt_1=append(111)
dt_1=append(222)
dt_1=append(33)
dt_1=appendleff(444) # 从左变添加元素
print(dt1)
dt1.popleft() #从左边删除

3. orderedDict有序字典

可以将字典变得有序，顺序按键值添加得顺序

from collections import ordered Dict
od_1=orderedDict([('a',1),('b',2),('c',3)])

4. defaultdict

可以给字典键值添加一个默认得数据类型

lst= ['A', 'B', 'C', 'D', 'e']
dic = defaultdict(int)
res=1
for i in lst:
    dic[i] +=1


print(dic)
>>>>>>>>>>>>>>>>>>>>>>>>>>
defaultdict(<class 'int'>, { 
        'A': 1, 'B': 1, 'C': 1, 'D': 1, 'e': 1})

5. counter 元素计数

可以将容器中元素进行计数，元素与个数组为键值对，返回一个字典

list=[5,4,4,6,4,5,6,1,3,5,1,1,]
res = 'abcdeabcdabcaba'
from collections import Counter
res1 = Counter(res)
res2=Counter(list)
print(res1,res2)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Counter({ 
        'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1}) Counter({ 
        5: 3, 4: 3, 1: 3, 6: 2, 3: 1})

1. time.time

输出一个时间戳

import time

print(time.time)

2. time.gmtime 结构化时间

输出当前 结构化时间 或将时间戳转结构化时间

import time
print(time.getime())

3. time.strftime格式化时间

输出当前格式化时间，或将结构化时间转为格式化时间

print(time.strftime('%y-%m-%d %H:%M:%S'))

res=time.localtime()
print(res)
print(time.strftime('%y-%m-%d %H:%M:%S',res))

4. time.strptime格式化转结构化

格式化时间转为结构化时间

print(time.strptime('22-07-14 18:36:04','%y-%m-%d %H:%M:%S'))

与time模块类似，都是与时间操作有关

1. datetime获取精确的时间

import datetime

res=(datetime.datetime.today()) #取现在的时间 非常精确
print(res)
print(res.date())

在提取中的时间中可以通过句点符 关键字来提取对应的值

2. timedelta()通过括号内内加参数来定义时间差

import datetime
res=(datetime.datetime.today())
time_1=datetime.timedelta(hours=24)
res_2=(res + time_1)  # 通过时间加时间差 得出将来时间
print(res_2)  
print(res_2 - res)  #通过将来时间 减现在时间 得出时间差

时间功能扩展

import datetime
print(datetime.datetime.now()) # 获取当前东八区时间
print(datetime.datetime.utcnow()) # 获取0时区时间
print(datetime.datetime(2023, 7, 15, 15, 16)) 定义一个时间

os模块主要是根据当前程序所在的操作系统打交道

sys模块主要是根python解释器打交道的

• sys.path 查看程序环境变量
• sys.cersion 查看python 解释器 当前版本信息
• sys.platform 查看当前平台

查看程序环境变量 解释器等信息

import sys
print(sys.path) # 查看程序环境变量
print(sys.version)
print(sys.platform)

• sys.argv

利用python解释器终端运行时该文件，可以接受外界输入

res=(sys.argv)
print(res)
if len(res)==3
username = res[1]
    password = res[2]
    if username == 'kk' and password == '123':
        print('您可以正在执行该文件')
    else:
        print('用户名或密码错误')
else:
    print('请填写用户名和密码')

json模块 也称为序列化模块
json模块是不同编程语言交互必备的模块

json数据格式是字符串

json格式的数据引号都是双引号

• dumps 转为json格式字符串
• loads 转为对应数据类型

import json
dict_1={ 
        'name':'kk','age':'18','gender':'male'}
res=json.dumps(dict_1)  # 利用 dumps将字典转为json 字符串 形式
print(res)
with open(r'username','w',encoding='utf')as f,open(r'username','r',encoding='utf')as read_1:
    f.write(res)  # 将json字符串形式的 字符串写入文件中
    f.flush()  # 保存文件
    res_1=read_1.read()  #将写入的 jason 字符串读出
print(json.loads(res_1)) # 利用loads转回字典

• dump 转为json格式字符串并写入
• load 取出并转为对应数据类型

import json
dict_1={ 
        'name':'kk','age':'18','gender':'male'}
with open(r'username','w',encoding='utf')as f,open(r'username','r',encoding='utf')as read_1:
    json.dump(dict_1,f)  # 利用dunmo直接将字典变为 json格式字符串并自动传入文件中
    f.flush()  # 保存
    print(json.load(read_1)