Python全栈工程师系列学习之学习记录

最新推荐文章于 2024-05-13 14:54:22 发布

大聪明Smart

最新推荐文章于 2024-05-13 14:54:22 发布

阅读量766

点赞数 2

分类专栏：全栈文章标签： python

本文链接：https://blog.csdn.net/qq_31910669/article/details/108163621

版权

全栈专栏收录该内容

1 篇文章 0 订阅

订阅专栏

前言

前期贴了很多代码，后期我会全部push到我的码云仓库以及github上，随时更新。有需要的可以fork到你们本地。仓库地址https://gitee.com/libo-sober/learn-python
GitHub地址 https://github.com/libo-sober/LearnPython

Day 01

一、python的历史和种类

今日内容大纲：

cpu 内存硬盘操作系统
cpu: 计算机的运算和计算中心，相当于人类的大脑。飞机。
内存：暂时存储数据，临时加载数据以及应用程序，8G，16G, 32G。速度快，高铁。断电即消失。造价很高。
硬盘：磁盘，长期存储数据。D盘，E盘，文件，片儿，音频等等。500G， 1T。汽车。造价相对低。
操作系统：一个软件，连接计算机的硬件与所有软件之间的一个软件。
python的发展与应用

参考老男孩教育讲师太白金星的博客。
传送门
python的历史

python崇尚优美、清晰、简单。
python2x， python3x源码区别：
python2x：C、Java大牛贡献，重复代码多；代码不规范。
python3x：源码规范，清晰，简单。
python的编程语言分类（重点）
编译型：
将代码一次性全部编译成二进制，然后再执行。
优点：执行效率高。
缺点：开发效率低，不能跨平台。
代表语言：C。
解释型：
逐行解释成二进制，逐行运行。
优点：开发效率高，可以跨平台。
缺点：执行效率低。
代表语言：python。
python的优缺点
见上部分。
python的种类
Cpython：官方推荐解释器。可以转换成C语言能识别的字节码。
Jpython：可以转换成Java语言能识别的字节码。
Ironpython：可以转换成.net语言能识别的字节码。
PyPy：动态编译。

二、安装python解释器以及配置环境变量

安装python解释器流程

官网查找版本
https://www.python.org
选择版本
选择你的版本

在这里插入图片描述

安装

在这里插入图片描述

默认

在这里插入图片描述

改路径

在这里插入图片描述

点击 install

在这里插入图片描述

测试

win + R 键入cmd
在这里插入图片描述
在命令行中输入 python

手动添加环境变量

在这里插入图片描述

点击环境变量后双击path

把你安装的路径加上，然后点击所有打开的窗口的确定键。

三、变量、常量和注释

运行第一个python代码
print(‘Hello world!’) 保存为.py文件
变量

这一节全是基础就不再重复了，可以去B站观看。
python基础变量传送门

Day 02

主要讲了 pycharm 的安装和使用
运算符、while循环和格式化输出等。
原视频传送门

也可以去python菜鸟教程参考学习
python基础菜鸟教程传送门

Day 03

主要为基础数据类型学习

int
bool
str
for循环
这里可以重点学习一下str字符串的操作
菜鸟教程字符串操作

Day 04

python的三大数据类型

Day 05

文件操作的初识
利用python代码写一个很low的软件去操作文件。
需求：
文件路径：path。打开方式：读，写，追加，读写…。编码方式：utf-8,gbk…。

f1 = open('d:\你想看的都在这.txt', encoding='utf-8', mode='r')
content = f1.read()
print(content)
f1.close()
"""
open 内置函数，open底层调用的是操作系统的接口。
f1 变量 f 文件句柄。 对文件进行的任何操作，都要通过文件句柄.操作函数()的方式。
encoding：参数可以默认不写，默认编码本为操作系统默认的编码。
widows:gbk。
Linux：utf-8。
mac:utf-8。
f1.close() 关闭文件
"""
"""
文件操作三部曲：
1.打开文件
2.对文件句柄进行相应的操作
3.关闭文件


C:\Users\libo\AppData\Local\Programs\Python\Python36\python.exe D:/WorkSpace/Pycharm/fullstack/day05/文件的操作.py
详情请查看：
https://me.csdn.net/blog/qq_31910669

Process finished with exit code 0
"""

报错原因：
UnicodeDecodeError：文件存储时与文件打开时编码本运用不一致。
路径分隔符产生的问题：r’d:\你想看的都在这.txt’，加r后不会产生。

文件操作的读
r, rb, r+,…
r: read(), read(n), readline(), readlines().
rb：操作的是非文本文件。图片、视频、音频。

f1 = open('d:\你想看的都在这.txt', encoding='utf-8', mode='r')
content = f1.read()
print(content)
f1.close()
"""
open 内置函数，open底层调用的是操作系统的接口。
f1 变量 f 文件句柄。 对文件进行的任何操作，都要通过文件句柄.操作函数()的方式。
encoding：参数可以默认不写，默认编码本为操作系统默认的编码。
widows:gbk。
Linux：utf-8。
mac:utf-8。
f1.close() 关闭文件
"""
"""
文件操作三部曲：
1.打开文件
2.对文件句柄进行相应的操作
3.关闭文件
"""

文件的写
w, wb，w+, w+b

# f = open('文件的写', encoding='utf-8', mode='w')
# f.write('随便写一点')
# f.close()

# 如果文件存在，先清空原文件内容，再写入新内容
# f = open('文件的写', encoding='utf-8', mode='w')
# f.write('木子李呢')
# f.close()

# wb
f = open('头像.png', mode='rb')
content = f.read()
# b'\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00\x00H\x00H\x00.......
# print(content)
f.close()
f1 = open('头像2.png', mode='wb')
f1.write(content)
f1.close()

文件的追加
a, ab, a+ , a+b

# 没有文件创建，追加内容
# f = open('文件的追加', encoding='utf-8', mode='a')
# f.write('nihao')
# f.close()
# 有文件时,在原文件的最后边追加
f = open('文件的追加', encoding='utf-8', mode='a')
f.write('李波')
f.close()

文件操作的其他模式

# 先读后写 若无文件不会创建新文件
# 读并追加,顺序不能反
f = open('文件的读写', encoding='utf-8', mode='r+')
content = f.read()
print(content)
f.write('人的一切痛苦,都是对自己无能的愤怒!')
f.close()

打开文件的另一种方式
with … as …

# 优点1:不用手动关闭文件句柄
# with open('文件的读', encoding='utf-8') as f1:
#     print(f1.read())

# 优点2: 一个with可以打开多个open
with open('文件的读', encoding='utf-8') as f1,\
    open('文件的写', encoding='utf-8', mode='w') as f2:
    print(f1.read())
    f2.write('dasdasd a')

# 缺点:待续.

文件的修改

"""
1.以读的模式打开原文件.
2.以写的模式创建一个新文件.
3.将原文件的内容读出来修改成新内容,写入新文件.
4.将原文案金删除.
5.将新文件重命名成原文件.
"""

# low版
import os

with open('alex自述', encoding='utf-8') as f1,\
    open('alex自述.bak', encoding='utf-8', mode='w') as f2:
    old_content = f1.read()
    new_content = old_content.replace('分手', '恋爱')
    f2.write(new_content)

os.remove('alex自述')
os.rename('alex自述.bak', 'alex自述')

分手第1次，第21天后，你找到我说还是喜欢我。我相信了，继续牵着你的手走过校园的每一个角落。

分手第2次，第32天后，你还是回来了，我还笑着跟朋友说“不是我忘不掉，而是人家忘不掉”。

分手第3次，第5天，我们终于不再联系，我拉黑你的QQ，删掉你的号码和相片，丢掉你送的礼物，从此陌路。

分手第3次，第10天，我整理日记，丢掉专门为你写的那本，想着以前我送你的那些日记，现在你还留着吗？

恋爱第1次，第21天后，你找到我说还是喜欢我。我相信了，继续牵着你的手走过校园的每一个角落。

恋爱第2次，第32天后，你还是回来了，我还笑着跟朋友说“不是我忘不掉，而是人家忘不掉”。

恋爱第3次，第5天，我们终于不再联系，我拉黑你的QQ，删掉你的号码和相片，丢掉你送的礼物，从此陌路。

恋爱第3次，第10天，我整理日记，丢掉专门为你写的那本，想着以前我送你的那些日记，现在你还留着吗？

"""
1.以读的模式打开原文件.
2.以写的模式创建一个新文件.
3.将原文件的内容读出来修改成新内容,写入新文件.
4.将原文案金删除.
5.将新文件重命名成原文件.
"""

# 进阶版
import os

with open('alex自述', encoding='utf-8') as f1,\
    open('alex自述.bak', encoding='utf-8', mode='w') as f2:
    for line in f1:
        # 第一次循环 恋爱第1次，第21天后，你找到我说还是喜欢我。我相信了，继续牵着你的手走过校园的每一个角落。
        # old_line = line.strip() # 去除两边空格
        new_line = line.replace('恋爱', 'alex')
        f2.write(new_line)
os.remove('alex自述')
os.rename('alex自述.bak', 'alex自述')

# 有关清空问题:
# 不关闭文件句柄的情况下多次写入是不会清空之前的内容的

alex第1次，第21天后，你找到我说还是喜欢我。我相信了，继续牵着你的手走过校园的每一个角落。

alex第2次，第32天后，你还是回来了，我还笑着跟朋友说“不是我忘不掉，而是人家忘不掉”。

alex第3次，第5天，我们终于不再联系，我拉黑你的QQ，删掉你的号码和相片，丢掉你送的礼物，从此陌路。

alex第3次，第10天，我整理日记，丢掉专门为你写的那本，想着以前我送你的那些日记，现在你还留着吗？

Day 06

一、初识函数

# s1 = 'dsadasdasdasdasasd'
# # pyhton没有len()的话
# count = 0
# for i in s1:
#     count += 1
# print(count)
#
# count = 0
# l1 = [1, 2, 3, 4, 5, 6]
#
# for i in l1:
#     count += 1
# print(count)

# 代码重复太多
# 代码可读性差
# 函数式编程


def my_len(s):
    count = 0
    for i in s:
        count += 1
    print(count)


s1 = 'dsadasdasdasdasasd'
l1 = [1, 2, 3, 4, 5, 6]

my_len(s1)
my_len(l1)

# 函数：以功能（完成一件事）为导向，登录，注册，len。一个函数就是一个功能。随调随用
# 减少代码重复性，增强代码的可读性

二、函数的结构与调用

def meet():
    print('打开探探')
    print('左滑一下')
    print('右滑一下')
    print('找美女')
    print('悄悄话')
    print('约 ....  走起 ...')
"""
结构：def 关键字，定义函数。
    meet 函数名：与变量设置相同，具有可描述性。
    函数体：缩进。函数中尽量不要出现print。
"""
# 函数什么时候执行？
# 当遇到函数名加括号时执行。
meet()

三、函数的返回值

# 函数的返回值
def meet():
    print('打开探探')
    print('左滑一下')
    print('右滑一下')
    print('找美女')
    print('悄悄话')
    print('约 ....  走起 ...')
    # return '妹纸'
    return '妹子', 123, [22, 33]
# return :在函数中遇到return直接结束函数。
# return：将数据返回给函数的执行者，调用者meet()。
# return饭hi多个元素是以元组的形式返回给函数的执行者。
# ret = meet()
# print(ret)
print(type(meet()))  # <class 'tuple'>
"""
retuen 总结：
    1.在函数中，终止函数。
    2.return 可以给函数的执行者返回值。
        1）return 单个值   单个值
        2）return 多个值   (多个值，)
"""

四、函数的参数

# 函数的参数
# def meet(sex):  # 函数的定义：接受的参数是形式参数。
#     print('打开探探')
#     print('进行筛选：性别:%s' % sex)
#     print('左滑一下')
#     print('右滑一下')
#     print('找美女')
#     print('悄悄话')
#     print('约 ....  走起 ...')


# 函数的传参：让函数的封装的这个功能，盘活。
# 实参，形参。
# meet('男')
# meet('女')  # 函数的执行传的参数：实际参数。
# 函数的传参：实参，形参。
# 实参角度：
# 1.位置参数。从左到右一一对应。
# def meet(sex, age, skill, voice):  # 函数的定义：接受的参数是形式参数。
#     print('打开探探')
#     print('进行筛选：性别:%s，年龄：%s,python: %s, 声音：%s' % (sex, age, skill, voice))
#     print('左滑一下')
#     print('右滑一下')
#     print('找美女')
#     print('悄悄话')
#     print('约 ....  走起 ...')
# meet('女', '18~40', 'python技术好的', '萝莉音')  # 函数的执行传的参数：实际参数。

# 写一个函数，只接受两个int的函数，函数的功能是将较大的数返回。
# def max_num(a, b):
#     # if a > b:
#     #     return a
#     # else:
#     #     return b
#     return a if a > b else b  # 三元运算符


# c = max_num(100, 1000)
# print(c)
# 2. 关键字参数
# 一一对应，顺序可以不打乱
# def meet(sex, age, skill, hight, weight):  # 函数的定义：接受的参数是形式参数。
#     print('打开探探')
#     print('进行筛选：性别:%s，年龄：%s,技术: %s, 身高：%s, 体重： %s' % (sex, age, skill, hight, weight))
#     print('左滑一下')
#     print('右滑一下')
#     print('找美女')
#     print('悄悄话')
#     print('约 ....  走起 ...')
# meet('女', '25', 'python技术好的', 174, 130)  # 函数的执行传的参数：实际参数。
# meet(sex='女', age='25', weight=100, hight=174, skill='python技术好的')
# # 函数：传入两个字符串参数，将两个参数拼接完成后形成的结果返回
# def func(s1, s2):
#     return s1 + s2
# print(func(s1='Hello', s2='libo！'))
# 混合参数
# 位置参数一定要在关键字参数前边
# def meet(sex, age, skill, hight, weight):  # 函数的定义：接受的参数是形式参数。
#     print('打开探探')
#     print('进行筛选：性别:%s，年龄：%s,技术: %s, 身高：%s, 体重： %s' % (sex, age, skill, hight, weight))
#     print('左滑一下')
#     print('右滑一下')
#     print('找美女')
#     print('悄悄话')
#     print('约 ....  走起 ...')
#     return '筛选结果：性别：%s, 体重： %s' % (sex, weight)
# # print(meet(25, weight=100, '女', hight=174, skill='python技术好的')) 位置参数未在关键字参数前边 报错
# print(meet('女', 25, weight=100, hight=174, skill='python技术好的'))
"""
实参角度：
    1.位置参数 按照顺序，一一对应
    2.关键字参数，一一对应
    3.混合参数：位置参数一定要在关键字参数的前边
"""
# 形参角度
# 1.位置参数 与实参角度的位置参数是一种
# 写一个函数，检测传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
# def func(l1):
#     # l2 = l1
#     # if len(l1) > 2:
#     #     l2 = l1[0:2]
#     # return l2
#     # return l1[0:2] if len(l1) > 2 else l1
#     return l1[0:2]
# print(func([1,2,3,4,5]))
# print(func([1,]))

# 默认参数
# 默认参数一定得在最后。
# 默认参数设置的意义：普遍经常用的。
# def meet(age, skill='python技术好的', sex='女'):  # 函数的定义：接受的参数是形式参数。
# #     print('打开探探')
# #     print('进行筛选：性别:%s，年龄：%s,技术: %s' % (sex, age, skill))
# #     print('左滑一下')
# #     print('右滑一下')
# #     print('找美女')
# #     print('悄悄话')
# #     print('约 ....  走起 ...')
# # # print(meet(25, 'pytohn技术好的'))
# # # print(meet(25,'pytohn技术好的', sex='男'))
# # print(meet(25,'运维技术好的', sex='男'))

# 形参角度：
# 1.位置参数
# 2.默认参数 经常用的参数

Day07

今日内容大纲

1.如何在工作中不让别人看出来你是培训出来的？

第一天环境安装等等，小白各种问。
项目需求不清晰，也不敢问。
一定要学会自主学习，有自己解决问题的能力。
2.形参角度
万能参数
- 的魔性用法
仅限关键字参数
形参的最终顺寻
3.名称空间
全局名称空间
加载顺序，取值顺序。
作用域
4.函数的嵌套（高阶函数）
5.内置函数(globals locals）
6.关键字：nonlocal global

昨日内容回顾

1.函数是以功能为导向，减少重复代码，提高代码的可读性。
2.函数结构

def func():
	函数体

3.函数的调用：func()

func()
func()
func()
# 写一次执行一次

4.函数的返回值

终止函数
return单个值
return多个之：（1，2，3，‘alex’）
5.函数的参数
实参角度：位置参数，关键字参数，混合参数。
形参角度：位置参数，默认参数。
今日内容学习记录
https://github.com/libo-sober/LearnPython/tree/master/day07

今日总结

参数：万能参数，仅限关键字参数，参数的顺序，*的魔性用法：聚合和打散。
名称空间，作用域，取值顺序，加载顺序。
globals() locals()
高阶函数：执行顺序。
以上全是重点。

Day08

今日内容大纲

global nonlocal
函数名的运用
新特性：格式化输出。
迭代器：
- 可迭代对象
  字面意思：对象？python中一切皆对象。一个实实在在存在的值，对象。
  可迭代？：更新迭代。重复的，循环的一个过程，更新迭代每次都要新的内容。
  可以进行循环更新的以恶搞是实实在在的值。
  专业角度：可迭代对象？内部含有”iter“方法的对象，可迭代对象。
  目前学过的可迭代对象？str list tuple set dict range 文件句柄
- 获取对象的所有方法并且以字符串的形式表现出来

# 获取一个对象的所以方法：dir()
s1 = 'sdsdasasdas'
print(dir(s1))
l1 = [1,2,3]
print(dir(l1))
print('__iter__' in dir(l1))  # True

- 判断一个对象是否是可迭代对象
- 小结
字面意思：对象？python中一切皆对象。一个实实在在存在的值，对象。
专业角度：可迭代对象？内部含有”__iter__“方法的对象，可迭代对象。
优点：1.存储的数据直接能显示，比较直观。2.拥有的方法比较多，操作很方便。
缺点：1.占用内存。2.不能直接通过for循环，不能直接取值。
- 迭代器
- 迭代器的定义
	字面意思：更新迭代，器：工具：可更新迭代的工具。
	专业角度：内部含有内部含有”__iter__“方法并且含有"__next__"方法的对象就是迭代器。
	可以判断是否是迭代器：有”__iter__“ and "__next__"方法在不在dir(对象)
	文件句柄`with open('wenjian', encoding='utf-8', mode='w') as f1:
print('__iter__' in dir(f1) and '__next__' in dir(f1))` 输出True。
	
- 判断一个对象是否是迭代器
- 迭代器的取值

s1 = 'dasdasdas'
obj = iter(s1)  # s1.__iter__()
# print(obj)  # <str_iterator object at 0x0000022770E5EB70>
print(next(obj))  # d
print(obj.__next__())  # a

l1 = [11,22,33,44,55]
obj = l1.__iter__()
print(obj.__next__())
print(obj.__next__())
print(obj.__next__())
print(obj.__next__())
print(obj.__next__())

- 可迭代对象如何转化成迭代器
- while循环模拟for循环机制

# while循环模拟for循环机制
l1 = [1,2,3,4,5,6,7,8]
# for i in l1:  # 先转换成迭代器
#     print(i)
# 将可迭代对象转换成迭代器
obj = l1.__iter__()
while True:
    try:
        print(next(obj))
    except StopIteration:
        break

- 小结
	字面意思：更新迭代，器：工具：可更新迭代的工具。
	专业角度：内部含有内部含有”__iter__“方法并且含有"__next__"方法的对象就是迭代器。
	可以判断是否是迭代器：有”__iter__“ and "__next__"方法在不在dir(对象)
	优点：1.节省内存。2.惰性机制，next一次，去一个值。
	缺点：速度慢。以时间换空间。2.不走回头路。
- 可迭代对象与迭代器的对比
	可迭代对象是一个操作方法比较多，比较直观，存储数据相对小的一个数据集。对数据灵活处理，内存足够。
	迭代器：节省内存，可以记录位置。数据量过大。

昨日内容回顾

函数的参数：
- 实参角度：位置参数，关键字参数，混合参数。
- 形参角度：位置参数，默认参数，仅限关键字参数，万能参数。
- 形参角度参数顺序：位置参数–>*args–>默认参数–>仅限关键字参数–>**kwargs
*的魔性用法：
- 函数定义时：代表聚合。
- 函数调用时：代表打散。
python中存在三种空间：
- 内置名称空间：存储的时内置函数：print、input…
- 全局名称空间：py文件存放的时py文件（出去函数，类内部的）变量，函数名与函数的内存地址的关系。
- 局部名称空间：存放的是函数内部的变量与值的对应关系。
加载顺序：内置名称空间–>全局名称空间–>局部名称空间（执行函数的时候）
取值顺序：就近原则即LEGB原则。
- 局部作用域只能引用全局变量，不能修改。

name = 'alex'
def func():
	name = name + 'sb'  # 报错

作用域：
- 全局作用域：内置名称空间+全局名称空间。
- 局部作用域：局部名称空间。
函数的嵌套
gloabls() （获取全部的变量） locals()(获取当前的变量)
今日学习代码记录
https://github.com/libo-sober/LearnPython/tree/master/day08

今日总结

默认参数的坑，作用域的坑（重点）
格式化输出
函数名的应用
对比：迭代器是什么？迭代器的优缺点。（重点）可迭代对象如何转化成迭代器。

Day09

今日内容大纲
1. 毒鸡汤课
  
  坚持、努力！
2. 生成器
  - yield
  - yeild return
  - yeild from
3. 生成器表达式
4. 内置函数I
昨日内容回顾作业讲解
1. 可迭代对象
  - 可以更新得带的实实在在的值。
  - 内部含有’_iter()'方法的。
  - str list tuple sict set range
  - 优点：操作方法多，操作灵活，直观。
  - 缺点：占用内存。
2. 迭代器
  - 可以更新迭代的一个工具（数据结构）。
  - 内部含有iter() 且含有 __next(0)_方法的。
  - 文件句柄。
  - 优点：节省内存。惰性机制。
  - 缺点：不直观，速度相对慢，操作方法单一，不走回头路。
3. 格式化输出。
4. 函数名的运用。
5. 默认参数是可变的数据类型坑，作用域的坑。
今日内容
- 生成器
  - 什么是生成器？：python社区，生成器与迭代器看成是一种。生成器的本质就是迭代器。唯一的区别：生成器是我们自己用python代码构建的数据结构。迭代器都是提供的，或者转化得来的。
    - 获取生成器的三种方式：
      - 生成器函数。
      - 生成器表达式。
      - python内部提供的一些。
  - 生成器函数获得的生成器。
  - yield
  - yeild return
  - yeild from
- 生成器表达式，列表推导式
  - 用一行代码去构建一个比较复杂有规律的列表。
  - 列表推导式：
    - 循环模式：[变量(加工后的变量) for 变量 in iterable]
    - 筛选模式：[变量(加工后的变量) for 变量 in iterable if 条件]
    - 循环模式
    - 今日内容笔记：https://github.com/libo-sober/LearnPython/tree/master/day09
今日总结
1. 生成器
  2. 生成器函数yield
  3. yield与return区别。 yield from
  4. 列表推导式，生成器表达式。（重点）
  5. 内置函数：今天讲的内置函数，了解。
预习内容
1. lambda表达式。
2. 内置函数II。
3. 闭包。

Day 10

今日内容大纲
- 如何学习？
- 一定要把预习加上！
- 分配比例：
  - 1/3总结
昨日内容回顾作业讲解
- 生成器：生成器就是迭代器，生成器是自己用python代码写的。
  - 生成器函数
  - 生成器表达式
  - python内部提供的
- 如何判断你的函数，还是生成器函数？
  - yield
  - yield return区别
- 吃包子。（重点）
- yield from 将一个可迭代对象，编程一个生成器。
- 列表推导式，生成器表达式。
  - 循环模式：[变量（加工和的变量）for 变量 in iterable]
  - 筛选模式：[变量（加工和的变量）for 变量 in iterable if 条件]
- 内置函数？68.
今日内容

https://github.com/libo-sober/LearnPython/tree/master/day10

今日总结

匿名函数。
内置函数。

闭包

# 闭包：  多用于面试题：什么是闭包？闭包有什么作用？
# 1. 闭包只能存在嵌套函数中。
# 2. 内层函数对外层函数非全局变量的引用（使用），就会形成闭包。
# 被引用的非全局变量也称作自由变量，这个自由变量就会与内层函数产生一个绑定关系，
# 自由变量不会在内层中消失。
# 闭包的作用：保证程序的安全性。

预习内容

前情回顾

今日内容

https://github.com/libo-sober/LearnPython/tree/master/day04

while循环
- why: 大气循环，吃饭上课睡觉，日复一日，因果轮回。程序中也有输入用户密码。
- what：while无限循环。
- how:怎样使用？
  1. 基本结构：
```
while 条件：
    循环体
```
  2. 初始循环体
```
while True:
    print('我们不一样')
    print('狼爱上羊')
    print('庐州月')
    print('人间')
```
  3. 终止循环
    
    break
    
    条件

for 循环

# for 循环
"""
有限循环

for 变量 in iterable:
    pass
"""
for i in s1:
    print(i)

# break continue
# for else:  while else: 用法一样

字符串操作
代码块
- ```
# 代码块
# 我们所有的代码都需要以来代码块执行
# 一个文件就创建一个代码块
# 交互式命令下一行就是一个代码块
```
- 两个规则：同一个代码块下，有一个机制，不同的代码块下，遵循另一个机制。
- 同一个代码块下的缓存机制。
  - 前提条件：同一个代码块内。
  - 机制内容：Python在执行同一个代码块的初始化对象的命令时，会检查是否其值是否已经存在，如果存在，会将其重用。换句话说：执行同一个代码块时，遇到初始化对象的命令时，他会将初始化的这个变量与值存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，如果有同样的记录那么它会重复使用这个字典中的之前的这个值。所以在你给出的例子中，文件执行时（同一个代码块）会把i1、i2两个变量指向同一个对象，满足缓存机制则他们在内存中只存在一个，即：id相同。
  - 优点：节省内存，提升性能。
  - 使用的对象：int,bool,str
- 不同代码块下的缓存机制。
  - 小数据池
  - Python自动将-5~256的整数进行了缓存，当你将这些整数赋值给变量时，并不会重新创建对象，而是使用已经创建好的缓存对象。
    
    python会将一定规则的字符串在字符串驻留池中，创建一份，当你将这些字符串赋值给变量时，并不会重新创建对象，而是使用在字符串驻留池中创建好的对象。
    
    其实，无论是缓存还是字符串驻留池，都是python做的一个优化，就是将~5-256的整数，和一定规则的字符串，放在一个‘池’（容器，或者字典）中，无论程序中那些变量指向这些范围内的整数或者字符串，那么他直接在这个‘池’中引用，言外之意，就是内存中之创建一个。
- 总结：
  - 面试题考。
  - 回答的时候一定要分清楚：同一个代码块下适用一个缓存机制，不同代码块下适用于另一个缓存机制（小数据池）。
  - 小数据池：数据范围是-5~256
  - 缓存机制的优点：提升性能，节省内存。
python基础数据类型只集合：set。容器型的数据类型，它要求里面的元素是不可变的数据，但是它本身是可变的数据类型。集合是无序的。{}。
- 集合的作用：
  - 列表的去重。
  - 关系测试：交集，并集，差集，…。
  - pass
深浅copy（面试会考）
- 浅copy
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Mwsr4Nox-1599472804554)(C:\Users\libo\AppData\Roaming\Typora\typora-user-images\image-20200907161008553.png)]
- 深copy
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tH93bS0J-1599472804557)(C:\Users\libo\AppData\Roaming\Typora\typora-user-images\image-20200907165332618.png)]

今日总结

is id == 三个方法会用。
缓存机制优点。
深浅copy：理解什么是浅copy和深copy，课上练习题。
集合：列表去重，关系测试。

day11

今日内容大纲
1. 装饰器：本质就是闭包。
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OuCIVubg-1599568281033)(C:\Users\libo\AppData\Roaming\Typora\typora-user-images\image-20200908194149735.png)]
2. 标准版装饰器执行流程：
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OvF3znDc-1599568281036)(C:\Users\libo\AppData\Roaming\Typora\typora-user-images\image-20200908195335638.png)]
3. 最标准版装饰器
```
def wrapper(f):
    def inner(*args, **kwargs):
        """添加额外的功能：执行被装饰函数之前的操作"""
        ret = f(*args, **kwargs)
        """添加额外的功能：执行被装饰函数之后的操作"""
        return ret
    return inner
```
昨天内容回顾以及作业讲解
1. 匿名函数：一句话函数。多余内置函数，列表推导式结合。
2. 内置函数：*** 加Key的。min max sorted map reduce filter
3. 闭包：
  1. 内层函数对外层函数非全局变量的使用。
  2. 一定要存在于嵌套函数中。
  3. 保证数据安全。自由变量不会在内存中消失，而且全局还引用不到。
今日内容

https://github.com/libo-sober/LearnPython/tree/master/day11
今日总结
预习内容

day12

今日内容大纲

昨日内容回顾作业讲解

装饰器：完美的呈现了开放封闭原则。装饰器的本质：闭包。

def wraper(f):
    def inner(*args, **kwargs):
        """执行被装饰函数之前的操作"""
        ret = f(*args, **kwargs)
        """执行被装饰函数之后的操作"""
        return ret
    return inner

今日内容
1. 自定义模块：
  - 什么是模块：本质就是一个.py文件，封装语句的最小单位。
  - 自定义模块：实际上就是定义.py文件，其中可以包含，变量定义，可执行语句，for循环，函数定义等等，它们统成为模块的成员。
2. 模块的运行方式：
  - 脚本方式：直接用解释器执行，或者pycharm中右键运行。
  - 模块方式：被其他的模块导入。为导入它的模块提供资源（函数定义，类定义，变量等）。
3. __name__的使用：
  - 在脚本方式运行时，_name__是固定的字符串：_main
  - 在义模块方式导入时，__name__就是本模块的名字。
4. 系统导入模块时的路径
  - 内存中：如果之前成功导入模块，直接使用已经存在的模块
  - 内置路径中：安装路径下：Lib
  - PYTHONPATH：import时寻找模块的路径。（一般不用。）
  - sys.path:是一个路径的列表。
  如果都找不到，就报错。
  
  动态修改sys.path。
  
  os.path.dirname()获取某个路径的父路径。通常用于获取当前模块的相对路径。
```
import sys
import os
# print(os.path.dirname((__file__)) + '/aa')
sys.path.append(os.path.dirname((__file__)) + '/aa')
```
5. 导入模块的多种方式：
  - import xxx：导入一个模块的所有成员。
  - import aaa, bbb：一次性导入多个模块的成员。不推荐这种写法，分开写。import os,sys 这俩是黄金搭档可以一起写。
  - from xxx import a：从某个模块中导入指定的成员。
  - from xxx import a,b,c：从某个模块中导入多个成员。
  - form xxx import *：从一个模块中导入所以的成员。
6. import xxx 和 form xxx import *的区别
  - 第一种方式在使用其中成员时，必须使用模块名作为前缀。不容易产生命名冲突。
  - 第二种方式在使用其中成员时，不用使用模块名作为前缀，直接使用成员名即可。容易产生命名冲突。在后面定义的成员名生效（把前面的覆盖了）。
  - 怎么解决名称冲突问题？
    - 改用 import xxx。
    - 自己避免使用同名。
    - 使用别名解决冲突
  - 使用别名：alias
    - 给成员起别名，避免名称冲突。from my_modul import age as a
    - 给模块器别名，目的简化书写。import my_modul as m
7. form xxx import *默认控制成员被导入
  1. 默认情况下，所以的成员都会被导入。
  2. __all__是一个列表，用于表示本模块可以被外界使用的成员。元素时成员名组成的字符串。
  3. 使用__all__控制哪些成员可以被外界使用只对于 from import 起作用
8. 相对导入
  1. 针对某个项目中的不同模块之间进行导入，叫做相对导入。
  2. 只有一种格式：from 相对路径 import xxx
    1. 相对路径：包含了待你好的一个相对路径。
    2. .表示的是当前的路径。
    3. …表示的是父路径
    4. …表示的是父路径的父路径
```
# 相对导入同项目下的模块
# from ..z import zz    # 容易象外界暴露zz模块
from ..z.zz import *
```
```
# 不使用相对导入的方式，导入本项目中的模块
# 通过当前文件的路径找到你想导入的z的路径
import os,sys
sys.path.append(os.path.dirname(os.path.dirname(__file__)) + '/z')
from zz import *
```
9. 常用模块：time，datatime，random
  1. random
    1. 此模块提供了随机数获取的相关的方法。官方文档（C:\Users\libo\AppData\Local\Programs\Python\Python36\Doc）
    2. random.random()：获取[0.0,1.0)范围内的浮点数。
    3. random.randint(a,b)：获取[a,b]范围内的一个整数。
    4. random.uniform(a,b)：获取[a,b)范围内的浮点数。
    5. random.shuffle(x)：把参数指定的数据中的元素混洗，其中参数为变的数据类型。
    6. random.sample(x,k)：从x中随机抽取k个数据，组成一个列表返回。
今日总结

函数总结思维导图
这个思维导图是在ProcessOn中画的有想用的可以点击此链接注册并绑定微信号免费克隆
GitHub仓库
https://github.com/libo-sober/LearnPython/tree/master/day12
预习内容

大聪明Smart

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python全栈工程师系列学习之学习记录

文章目录前言Day 01一、python的历史和种类二、安装python解释器以及配置环境变量前言Python全栈工程师系列学习之学习记录。Day 01一、python的历史和种类今日内容大纲：cpu 内存硬盘操作系统cpu: 计算机的运算和计算中心，相当于人类的大脑。飞机。内存：暂时存储数据，临时加载数据以及应用程序，8G，16G, 32G。速度快，高铁。断电即消失。造价很高。硬盘：磁盘，长期存储数据。D盘，E盘，文件，片儿，音频等等。500G， 1T。汽车。造价相对低。
复制链接

扫一扫