Python从零

预科

day01

主机核心部件：主板：集成电路板，其他硬件都在主板上 cpu：核心计算单元内存：断电之后内存里的内容消失硬盘：断电之后还能永久保存的元件电源：保证电压的稳定外设：输入输出设备的总成
操作系统：总管：对硬件和软件的总体调配

编程语言：（Python Java C PHP 。。。）为了让人与电脑进行对话编程语言有很多种
解释器：把代码转化成机器能认识的指令

day02

git config --global user.name ""校验远程仓库

git config --global user.email ""

git init在当前目录新建一个Git代码库

git add .添加文件夹下所有增删改查操作

git commit -m ""提交本次操作，备注为""

git push -u origin master推送代码到远程仓库

git remote add origin 远程添加码云仓库源码

git pull origin master 远程代码拉到本地

git pull origin master --allow-unrelated-histories 解决拉码失败问题

day03

主要内容

markdown常用语法
博客园制作
思维导图
排bug技巧

markdown常用语法

用#+空格实现

一级标题

二级标题

。。。。。。。。

六级标题

代码块
```
三个实现
```
python is a ...

单行代码，用“``”
列表

有序列表
```
~~~
```

无序列表

```

跟内容

跟内容

跟内容 ```

链接

[目标地址名字](目标地址的地址)
通过快捷键：ctrl + k

百度

键盘快捷键之缩进
- 往前缩进shif+tab
- 往后缩进tab
图片：
- md文件传输时图片丢失的两种解决办法
  - 保存时，点击左上角的文件，选择导出PDF
  - 借助网络上的平台，把文件上传上去，然后用网络地址代替

分割线

---实现分割线的效果
+++实现分割线的效果
***实现分割线的效果

字体样式
- 加粗
- ```
**加粗**
```
- 倾斜
- ```
*倾斜*
```
- 加粗倾斜
- ***加粗倾斜***
- 颜色黄绿色<span style="color:yellowgreen">黄绿色</span>
- 字体宋体黄绿色黄绿色<span style = "font -family:宋体">黄绿色</span>

思维导图

有层级关系
从大范围到具体
要求：每周至少上交一篇思维导图，上交码云。

编程语言

编译型

C

C++

......

解释型

Python

PHP

......

Python

基础语法

基础数据类型

str

方法&操作

int

bool

list

.....

函数

......

进阶

面向对象

......
思维导图制作工具：
- 推荐使用：https://www.processon.com
- x-mind
常用快捷键：
- 建立子分局
- 建立兄弟分区
思维导图何时可用，何时不可用。
- 确定的东西，并且有联系，用思维导图帮助我们总结记忆。
- 两个事物之间没有必然联系，不适合用思维导图。
学会使用思维导图去整理

博客

https://github.com/search?q=%E5%8D%9A%E5%AE%A2%E5%9B%AD%E4%B8%BB%E9%A2%98

好处：走上人生巅峰的捷径，好处非常多

什么样的内容能作为博客发表？

系技术，以你自己的观点发表。

借鉴国外的一些新技术或者新研究

自己的笔记，要求自己的笔记要成体系。

    1. 写博客的平台
       + 博客园：学不完的技术，但是这个平台的推广不好，页面比较low。
       + CSDN:推广非常好，广告做的比较好

排bug技巧

http://www.stackoverflow.com/

根据错误类型推算，错误哪里出的原因。
百度搜索
stackoverflow
建议：自己搞一个bug集合，搞得特别好的可以公开展示，加分

码云的日常操作

要求：

每日代码&笔记上传码云
1. 每日作业通过老师给的issues写作业，并回复老师的issues
每周至少一次思维导图，并上传码云
前期每周一次周末大作业上传码云
大笔记每周至少更新一次，上传码云

day01

python的历史

2000年，内存回收机制 2004年，同年目前最流行的web框架Django诞生

2008 python3诞生

2020年不在更新python2.7

python2：

源码不统一，有重复的功能代码

python3：

源码统一，没有重复的功能代码

python是一个什么编程语言

编译型：一次性翻译（C）

优点：运行速度快
缺点：翻译时间长

解释型：一行一行翻译（Python）

优点：开发效率高（翻译时间短）
缺点：运行速度慢

Python是一门动态解释性的强类型定义语言

python的种类

Cpython（官方推荐）

Jython lroPython PyPy（特殊）

变量

变量定义的规则：

变量有数字，字母，下划线组成
不能以数字开头
不能使用python中关键字
不能使用中文和拼音
区分大小写
变量名要具有可描述性
推荐写法
- 驼峰体 AgeOfOldboy = 98
- 下划线 age_of_oldboy = 98(官方推荐)

常量

变量名全部大写就是常量--常量建议不进行修改
常量在配置文件中声明使用

注释

#单行注释（当行注释）#

#多行注释''''''   """"""
被注释的内容是不会执行的

基础数据类型初识

字符串	--str(用于存储一些数据)
在python中只要是引号引起来的就是字符串

数字	--int
用于计算和比较
在赋值的时候先执行等号右边的内容
python3:除法的时候返回的是小数（浮点数）
python2:除法的时候返回的是整数（向下取整）
a = "alex"
b = "dsb"
c = a + b #字符串拼接
print(c)
#字符串+：字符串和字符串相加
#字符串*：字符串和数字相乘
布尔值	--bool（用于判断）
True 对	--真
False 错	--假

列表

元组

字典

集合

用户交互（输入/输出）

input（提示语句！） --输入

msg = input("请输入您的内容：")
#int("5")---> 5
print(int(msg) + 5)
#type	--查看数据类型
#int()	--将字符串类型强制转换成整型
#python3中的input获取到的内容都是字符串

#python2中的input获取的内容就是数据本身

print（） --输出

流程控制语句

单 if

if -- 如果

if 条件：

缩进官方推荐4个空格，Tab 空格和tab不能混合使用

money = 10 
print("从学校走")
if money >= 10:
    print("买个炸鸡")
    print("买个啤酒")
print("走啊走")
print("到家了")

if else 二选一

if 条件：

缩进结果

else：

缩进结果

print(123)
money = 1000
if 3>2:
    print("这是如果执行了")
    print
else:
    print("这是否则执行了")
print(345)

if elif elif elif 多选一或不选

if 条件：

   结果

elif 条件：

   结果

elif 条件：

	结果
elif 条件：
	结果
    
    
if 3>2:
    print("这是A")
elif 4>3:
    print("这是B")
elif 5>3:
    print("这是C")
elif 6>3:
    print("这是D")

if elif elif else 多个选一个

if 条件:
    结果
elif 条件:
    结果
elif 条件:
    结果
else:
    结果
    
    
if 3>2:
    print("A")
elif 4>3:
    print("B")
elif 5>6:
    print("C")
else:
    print("D")

if if if 多个条件选多个

if 条件:
    结果
if 条件:
    结果
if 条件:
    结果

if 3>2:
    print("A")
if 4>2:
    print("B")
if 6>3:
    print("C")

if 嵌套

if 条件:
    if 条件:
        结果
sex = "女"
age == 30
if sex == "女":
    if age ==30:
        print("进来坐一坐")
    else:
        print("隔壁找太白")
else:
    print("滚犊子")

day02

while

while 循环 --死循环

while循环通过条件和break能够终止循环

break -- 必须在循环中使用

break --终止当前循环，并且break下方代码不会执行

continue -- 跳出本次，继续下次循环（伪装成循环体中最后一个代码）

continue -- 必须在循环中使用，并且下方的代码不会被执行

while --关键字

if 条件:

结果

while 条件:

循环体

while True:
	print("爱情买卖")
	print("痒")
	print("年少有为")
	print("浮夸")
	print("威风堂堂")
	print("大悲咒")
	print("情锁")

num = 2 
while num > 0:
    print("爱情买卖")
	print("痒")
	print("年少有为")
	print("浮夸")
	print("威风堂堂")
	print("大悲咒")
	print("情锁")
    num = num - 1
    (执行两次)

while True:
    print("爱情买卖")
    break
    print(1234)
#break -- 必须在循环中使用
#break -- 终止当前循环，并且break下方代码不会执行

while True:
    print("爱情买卖")
    print("痒")
    continue
    print("年少有为")
#continue -- 跳出本次循环，继续下次循环（伪装成循环体中最后一行代码）

使用while输出10 -57 的数字（包含10和57）

num = 10
while num <= 57:
    print(num)
    num = num + 1

使用while 输出100 - 10 的数字（包含10和100）

num = 100
while num >= 10:
    print(num)
    num = num -1

flag = True
while flag:
    print(123)
    flag = False
else:
    print(234)

格式化

#%s -- 占字符串的位置(%s数字，字符串都能进行填充)
#%d|%i --占数字的位置
#%% 转义 --转换成普通的百分号
#占的位置和填充时必须要一一对应
#填充的时候按照顺序填充

name = input("name:")
age = input("age:")
addr = input("addr:")
phone = input("phone:")
info = """
-------- info--------
姓名:%s
年龄:%s
公司:%s
电话:%s
-------- end --------
"""%(name,int(age),addr,int(phone))
print(info)

msg = "%s的学习进度是2%s"(12,13)
print(msg)
#占的位置和填充时必须要一一对应
#填充的时候按照顺序填充

name = "日莫"
print(f"{name}的学习进度2%")

python3.6版本及以上才能使用f

msg = f"""--------info--------
姓名：{input('name')}
年龄:{input('age')}
公司:{input('addr')}
电话:{input('phone')}
-------- end --------"""
print(msg)

运算符

算数运算符

+
-
*
/
%(取余)
**（幂/次方） 
//（整除/地板除 - 向下取整）

比较运算符
```
> < >= <= == != 
```

赋值运算符

= 
+= 自加
a = 10
a+=1 #a = a+1
print(a)
-=自减
*=自乘
a = 10 
a *= 2# a= a*2
print(a)
/=
//=
**=
%=

4.逻辑运算符

数字非零的都是真
and 与 
and运算都为真才是真，有一个为假就是假。
and运算都为真的时候选择and后边的内容。
and运算都为假的时候选择and前面的内容。
or  或 
or运算只要有一个真就是真
or运算都为真的时候选择or前面的内容
or运算都为假的时候选择or后面的内容
not 非 -- 不是
优先级：() > not > and >or

5.成员运算符

in 在

not in 不在

6.编码初识

ascii 256

1字节

不支持中文

gbk（国标）

英文 1字节

中文 2字节

万国码 unicode

中文和英文4个字节

1字节 == 8位

utf-8 最流行的编码集（密码本）

英文 1

欧洲 2

亚洲 3

win - 编码集gbk

linux - 编码utf-8

mac - 编码 utf-8

ascii码：

不支持中文

用1个字节

gbk（国标）：

英文用1个字节

中文两个字节

unicode（万国码）

英文4个字节

中文4个字节

utf-8

英文1个字节

欧洲2个字节

亚洲3个字节

单位转换：

1字节 == 8位 <==> 1B ==8b *******
1B = 8b
1KB = 1024B
1MB = 1024KB
1GB = 1024MB  
1TB = 1024GB  #最常用的就是TB
1PB = 1024TB
1EB = 1024PB

day02 总结

1.while 循环

while 条件：

循环体

改变条件
break

break：终止当前循环

continue：跳出本次循环，继续下次循环（伪装成循环体中最后一行）
while 条件：

循环体

else：

结果

#当while循环体中出现了break就不会再执行else

2.格式化

%s - 字符串

%d - 数字

%% - 转义

%（按照位置顺序填充，一一对应）

3.运算符

算法

比较

赋值

逻辑 and or not

成员

4.编码初识

win - 编码集gbk

linux - 编码utf-8

mac - 编码 utf-8

ascii码：

不支持中文

用1个字节

gbk（国标）：

英文用1个字节

中文两个字节

unicode（万国码）

英文4个字节

中文4个字节

utf-8

英文1个字节

欧洲2个字节

亚洲3个字节

1字节 = 8位

1B（Bytes） == 8b（bit）

day03

int --整型

python3:全部是整型

python2：整型，长整型long

用于计算和比较

123 ---10进制

print(bin(30))

10进制转2进制

2进制转10进制

布尔值

转换

int ，str ，bool

a = bool(-1)

print(a)

a = int(True)
print(a)
a = int(False)
print(a)

#整形中只要是非零的就是True

布尔值 0 --False 1--True

字符串中只要没有内容就是False

字符串详解

str --字符串：

python中只要是引号引起来的就是字符串

#字符串：用于数据存储，存储少量数据

a = "meet"
#字符串中每一个字母或者字符都称为元素
#"meet"
# 0123
#"m e e t"
#-4-3-2-1
#索引（下标） ：从左向右排 
#索引的时候不能超出索引最大值

切片

print(a[5:11])#[索引值][起始位置(包含):终止位置(不包含)]
#切片的时候可以超出索引值
print(a[21:])  [21(起始位置):(默认到最后)]
print(a[:])[(默认从最开始):(默认打最后)]
print(a[-6:-2:1])
步长决定查找的方向

字符串的方法

字符串是不可变数据类型，字符串是有序的

name = "alex"
a = name.upper()#全部大写   a= name.lower()#全部小写
print(name)

name = "alex"
print(name.startswith('a',2，3))#以什么开头--返回的是布尔值
print(name.endswith('x',0,2))#以什么结尾--返回的是布尔值

name = "alexwusirtaibai"
print(name.count("i"))#统计，计数

user = input("username:")
pwd = input("password:")
if user == 'alex' and pwd == "alexdsb":
    print("登陆成功！")
else:
    print("账号或密码错误！")
    
    
pwd = " alexdsb "
a = pwd.strip()#脱 默认脱(脱头尾两端的空格，换行符\n,制表符\t)
print(a)


pwd = "alexasdsba"
a = pwd.strip("a1")#去除头尾两端指定的内容
print(a)


name = "alex wusir"
name.split() #分割(默认空格，换行符\n,制表符\t)
print(a) #['alex','wusi']
name.split("_",2)

name = "alex,wusir,taibai"
name.replace(",",".") #替换
name.replace(",",".",1)#全部替换
print(a)

字符串格式化
name = "{}今年:{}".format("宝元",18)#按照位置顺序进行填充
name = "{1}今年:{0}".format("宝元",18)#按照索引进行填充
name = "{name}今年:{age}".format(name="宝元",age=18)#按照名字进行填充
print(name)
%s f  format


is 系列 是进行判断  返回的是布尔值

msg ="123"
print(msg.isdigit())#判断字符串中的内容是不是全是数字（阿拉伯数字）
print(msg.isdecimal())#判断是不是十进制数
print(msg.isalnum())#判断是不是数字，字母，中文
print(msg.isalpha())#判断是不是字母，中文


总结：
upper  全部大写
lower  全部小写
startswith
endswith
count
strip
replace
format
isdecimal()
isalnum()
isalpha()


msg = "今天是个好日子"
print(msg)

公用的方法：len
print(len(msg))

#使用while循环打印字符串中每个元素
i = 0
while i < len(msg):#while 0 < 16:
    print(msg[i])
    i += 1

for循环

msg = "今天是个好日子"
print(msg)

公用的方法：len
print(len(msg))

#使用while循环打印字符串中每个元素
i = 0
while i < len(msg):#while 0 < 16:
    print(msg[i])
    i += 1
    
    
for i in msg:
    print(i)
    
for 关键字
i   变量名(可以任意修改)
in  关键字
msg 可迭代对象

可迭代对象:python数据类型中除了int，bool其余都可以迭代

msg = "今天是个好日子"
for a in msg:
    pass #过 占位
    #print(a)
print(a)

for i in "abc":
    pass #占一行的位置
	print(i)
   

for i in "abc":
    ...  # 和pass功能一样
print(12)

for循环在循环的时候就已经进行了赋值

day03总结

# 1.整型及布尔值转换
    # Python3: 都是整型
    # Python2: 整型, 长整型

    # 10  -   2 bin()
    # 2   -   10 int("1110",2)

    # 数字:只要不为零全都是True
    # 字符串:只要有内容就是True

# 2.索引,切片,步长

    # 索引:
    #     从左向右
    #     从右向左
    #     索引不能超出索引最大值
    #
    # 切片:
    #     [起始位置:终止位置]
    #     顾头不顾尾
    #     终止位置可以超出
    #     [:]  [从头到尾]

    # 步长:
    #     [起始位置:终止位置:步长]
    #     步长决定查找方向
    #     决定查找时迈的步子
    #     [::-1] 将字符串进行反转
切片和步长 的时候可以超出界限
切片的时候返回的结果，就是原数据本身
# 3.字符串方法
    #     upper        *****
    #     lower        ****
    #     startswith   ***
    #     endswith     ***
    #     count        ****
    #     strip        ******
    #     split        ******
    #     replace      ******
    #     format       ***
    #     isdecimal()  ***
    #     isalnum()    ***
    #     isalpha()    ***

# 4.for循环

# for 关键字
# i   变量(可以任意修改)
# in  关键字
# 可跌代对象(int,bool)除外

# for i in "abc":
#     pass  # 占一行的位置 pass下方的代码会进行执行
# print(i)


# for 循环在循环的时候就已经进行了赋值

# for i in "abc":
#     ...  #  ...和pass功能一样


for i in "abc":
    print(i)

day04

今日内容

列表
元组
range

列表

a = "meet" #在字符串中只要是占一个位置的就是一个元素
lst = [1,2,3,4] #列表中只要用逗号隔开的就是一个元素

啥是列表？

数据类型之一，存储数据，大量的，存储不同类型的数据

定义一个列表

lst = [1,2,"alex,True",["钥匙","门禁卡"],["银行卡"]]
print(lst)

别的语言成为数组的就是python中的列表

列表 -- 容器

列表是一种有序的容器支持索引
列表是一种可变数据类型原地修改

lst = [1,2,3,4]

列表的增加

lst.append(13) #追加  在最末尾的地方进行添加
lst.insert()  #插入 尽量少使用

lst.extend()  #迭代添加

lst.extend("ALEX")
print(lst)
for i in [1,2,3,4]:
    lst.append(i)
print(lst)

列表的删除

lst = [1,2,3,4,3]
lst.remove(3) #通过元素的名字进行删除 只能删除第一个，从左向右删除
print(lst)

lst.pop()  # 弹出  默认删除最后一个，并且具有返回值，返回的值是弹出的内容。 通过索引进行删除
print(lst)


lst = [1,2,'3',4,3]
print(repr(lst.pop(2))) #repr()查看当前数据的原生态
print(lst)

lst.clear()  #清空
print(lst)


del lst[4]#通过索引删除
del lst[2:5]#通过切片删除
del lst[1:5:2]#通过步长删除
print(lst)

列表的修改

lst = [1,2,3,4,5]
lst[2] = 80 #通过索引进行修改
lst[1:3] = "alexdsb" #通过切片进行修改,默认步长为1，可以修改的内容必须是可迭代的对象，修改的内容可多可少
print(lst)

lst[1:5:2] = 100,100 #步长不为1的时候必须一一对应

列表的查

for 循环
索引

列表的嵌套

lst = [1,2,[3,4,5["alex[]",True,[[1,2]],90],"wusir"],"taibai"]
lst1 = lst[2]
lst2 = lst1[3]
print(lst2[0])
str_1 = lst[0]
print(str_1[-1])
print(lst[2][3][0][-1])

元组

python数据类型之一

tuple

有序

不可变

定义方式：
tu = (1,2,3)
lst = [1,2,3] 


tu = (1,2,3)
for i in tu:
    print(i)

元组支持查询

元组就是一个不可变的列表

元组的方法

统计
获取索引

tu = (1,2,3,4,5,1,2,1)
print(tu.count(1))


print(tu.index(4)) #通过元素查询索引

元组的用途

tu = (1,2,3)
tu[2] = 80
print(tu)

配置文件中

元组的嵌套

tu = (1,2,3,4,(5,6,7,8,("alex","wusir",[1,23,4])))
print(tu[4][4])

range(范围)

print(range(1,10)) #python3中range是自己range本身
print range(1,10) #python2中打印range获取的是一个列表，列表的元素是1-9
range（1，10）#[起始位置：终止位置]顾头不顾尾
range(1,10,2)#[起始位置:终止位置:步长]默认为1
range(10) #10代表的是终止位置，起始位置默认为0
range的诞生是为了解决不能循环数字
range是一个可迭代对象

for i in range(10):
    print(i)

day05

字典

python的数据类型之一
字典 -- dict
定义： dic = {"key":value} --键值对

字典的作用：

存储数据，大大量，将数据和数据起到关联作用

dic = {"10":"苹果手机","11":"苹果手机"}

所有的操作都是通过键

dic = {"10":"苹果手机","11":"苹果手机","15":"小米手机","True","华为手机",(1,):"oppo手机"，[1,2]:"诺基亚"}
print(dic)

所有的操作都是通过键
键：必须是不可变的数据类型（可哈希），且唯一
值：任意（不可哈希）

字典是可变数据类型，无序的

lst = ["日魔","炮手","豹哥"]
lst1 = ["看动漫","飞机","贴膏药"]

dic = {
    "日魔":"看动漫",
    "炮手":"飞机",
    "豹哥":"贴膏药",
    "宝元":"保健",
    "alex":"吹牛逼"
}
dic.get("日魔")

字典的增：

暴力添加：

dic["日阳"] = "曹洋"  #字典的添加，添加的是一个键值对
dic["小妹"] = ["听歌","唱歌",吃","烤馕","大盘鸡","葡萄干"]
print(dic)

有则不添加，无则添加

dic.setdefault("元宝",["唱","跳","篮球","喝酒"])
print(dic)

setdefault 分为两步：

先查看键是否在字典
不存在的时候进行添加

字典的删除

dic = {
    "日魔":"看动漫",
    "炮手":"飞机",
    "豹哥":"贴膏药",
    "宝元":"保健",
    "alex":"吹牛逼"
}
dic.get("日魔")
dic.pop("宝元")
print(dic)
print(dic.pop("宝元"))#pop删除通过字典中的键进行删除 返回的也是被删除的值

dic.clear() #清空
print(dic)


del dic  #删除的是整个容器
print(dic)

del dic["alex"] #通过键进行删除
print(dic)
字典中没有remove

字典的改：

dic = {
    "日魔":"看动漫",
    "炮手":"飞机",
    "豹哥":"贴膏药",
    "宝元":"保健",
    "alex":"吹牛逼"
}
dic["alex"] = "dsb" #有则覆盖，没有添加
print(dic)

dic.update({"alex":"上过北大","wusir"："干过前端"}) 
print(dic)

字典的查

dic = {
    "日魔":"看动漫",
    "炮手":"飞机",
    "豹哥":"贴膏药",
    "宝元":"保健",
    "alex":"吹牛逼"
}
dic.get("alex") #查询不到返回None
print(dic.get("元宝","找不到啊"))#查找不到的时候返回自己制定的内容
dic.setdefault("alex") #查询不到返回None
dic["alex"] #查询不到就报错

for i in dic:#查看所有的键
    print(i)
    
for i in dic: #查看所有的值
    print(dic.get(i))

print(dic.keys()) #获取到的是一个高仿列表

print(dic.values()) #获取到的是一个高仿列表
for i in dic.values():#高仿列表支持迭代
    print(i)
    
print(dic.values()[3]) 高仿列表不支持索引

lst = []
for i in dic:
    lst.append(i,dic[i])
print(lst)
print(list(dic.items()))
for i in dic.items():
    print(i)
    
    
 for i in dic.items():
    print(i[0],i[1])

解构:
 面试题
a = 10 
b = 20
a,b = b,a 
print(a)
print(b)

```
a,b = 10,20
print(a)
print(b)
```

解构

lst = [1,2,3,4,5,6,7,8]
print(lst[:2].append(lst[4]))#两个都是列表的时候才能够相加
print(lst1)

print(lst[:2] + list(str(lst[4])))

lst = [1,2,3,4,5,6,7,8]
a,b,_1,_,c,*aa = lst  # *是万能接收
print(a)
print(b)
print(c)

for i in dic.items():
    print(i)
    a,b = i  #自己写的解构
    print(a)
    print(b)

for a,b in dic.items():
    print(a)
    print(b)

字典的嵌套

dic = {
    101:{1:{"日魔":"对象"},
         2:{"隔壁老王":"王炸"},
         3:{"乔碧萝":("日魔","炮手","宝元")},
        },
    102:{1:{"汪峰":{"国际章":["小苹果","大鸭梨"]}},
         2:{"邓紫棋":["泡沫","信仰","天堂","光年之外"]},
         3:{"腾格尔":["隐形的翅膀","卡路里","日不落"]}
         },
    103:{1:{"蔡徐坤":{"唱":["鸡你太美"],"跳":["钢管舞"],"rap":["大碗面"],"篮球":("NBA形象大使")}},
         2:{"JJ":{"行走的CD":["江南","曹操","背对背拥抱","小酒窝","不潮不花钱"]}},
         3:{"Jay":{"周董":["菊花台","双节棍","霍元甲"]}}},
    201:{
        1:{"韦小宝":{"双儿":"刺客","建宁":{"公主":{"吴三桂":"熊"}},"龙儿":{"教主老婆":"教主",}}}
    }
}

day06

今日内容

小数据池 --
深浅拷贝
集合

小数据池

is id
判断两个值是否相等

is --是

小数据池 --int, str,bool

int : -5~256

代码块：

一个py文件，一个函数，一个模块，终端中每一行都是代码块
int ，str ，bool

int：范围（ -5 ~ 正无穷）

a = 1000
b = 1000
print(id(a),id(b))
print(a is b)

str
- ```
a = "asdfgh12345"
b = "asdfgh12345"
print(a == b)
print(a is b)
```
- 字符串：
  - 定义字符串的时候可以是任意的
  - 字符串(字母，数字)进行乘法时，总长度不超过20
  - 特殊符号(中文，符号)进行乘法的时候只能乘以 0 或 1
bool
- True
- False

is 判断的是两边的内存地址是否相同

== 判断两边的值是否相同

小数据池，代码块同在的情况下先执行代码块
str：
- 字母，数字长度任意符合驻留机制
- 字符串进行乘法的时候总长度不能超过20
- 特殊符号进行乘法的时候只能乘0

驻留机制

节省内存空间，提升效率(减少了开辟空间和销毁空间的耗时)

深浅拷贝

以后尽量避免
面试必问

赋值

a = [1,2,3,4]
b = a 
#print(id(a),id(b))
#print(a is b)
#a.append(5)
#print(b)
a.append([1,2,3])
print(b)

浅拷贝

a = [1,2,3,4,5]
b = a.copy()
print(a)
print(b)
print(a == b)


a = [1,2,3,[4,5]]
b = a[:]  #切片 --浅拷贝
print(id(a))
print(id(b))


a = [1,2,3,[4,5]]
b = a[:]
a[-1].append(6)
print(b)

浅拷贝：只拷贝第一层元素的地址，只有修改拷贝的数据第一层（不可变类型）的时候源数据不受影响，给可变数据进行添加的时候源数据会影响

= 是修改 .append是添加可变数据类型能够修改和添加，不可变数据类型只能修改

深拷贝

import copy # 导入copy模块

import copy
a = [1,2,3,[4,5],6]
b = copy.deepcopy(a)
print(id(a[-2]))
print(id(b[-2]))

深拷贝：不可变数据类型内存地址共用，可变数据类型新开辟一个空间 不管嵌套多深

集合

python中数据类型之一
集合 -- set
定义： s = {1,2,3,4}
集合就是一个没有值的字典唯一，不可变无序，可变集合天然去重

面试题：

lst = [1,233,1,1,2,31,231,22,12,3,14,12,3]
print(list(set(list)))

增:

s = {}  #空字典
s1 = set() #空集合
print(type(s))
print(type(s1))


s = set()
s.add("alex")
s.update("wusir")#迭代添加
print(s)

print(set("wusir")) #迭代添加

删

s = {1,23,5,4}
s.remove(4) #通过元素删除
print(s)

s.clera() #清空

s.pop() #随机删除(最小的)
print(s)

改

s = {1,2,3,4,5}
先删后改

查

for 循环

其他操作

差集--
s = {1,23,9,4,5,7}
s1 ={1,2,3,4,5}
print(s - s1)

交集--
print(s & s1)

并集--  | 管道符
print(s | s1)

反交集--
print(s ^ s1)

子集  返回的一个布尔值
print(s > s1)

父集（超集）
print(s < s1)


print(frozenset({1,23,4,5}))# 冻结集合

今天是个好日子 s = "今天是个好日子" print(s.encode("utf-8")) #编码

a = "meet" s1 = a.encode("utf-8") print("meet")

print(b"meet")#只有字母才能这么搞 s2 = s1.decode("utf-8")#解码 print(s2)

必会： python3:默认编码unicode python2：默认编码ascii python2不支持中文

重要: encode()#编码 decode()#解码

用什么编码就要用什么解码
网络传输一定是字节

day07

基础数据类型补充
以后会遇到的坑
二次编码

基础数据类型补充

str（字符串）

a = "alex wusir"
print(a.capitalize())  #首字母大写
print(a.title()) #每个单词首字大写
print(a.swapcase())#大小写转换
print(a.center(20,"*"))  #居中-填充
print(a.find())  #查找 元素查找索引，查找不到时返回-1
print(a.index("c")) 查找 通过元素查找索引，查找不到时就报错
print(a.join("_"))
print("_".join(["1","2","4"]))#拼接，将列表转换成字符串
str+str
str*5
字符串进行加操作，乘操作都是开品新的空间

list（列表）

列表的定义
print(list('123445'))
列表的方法:
lst = [1,23,45,7,8,9]
print(lst.index(4))   #通过元素查找索引
lst.sort()#排序 默认时升序
lst.sort(reverse = True) #降序
print(lst)

lst.sort
lst.reverse()  #反转
print(lst)
print(lst[::-1])# 反转

lst = [1,23,4,5,7,8,9]
lst1 = lst[::-1]
print(lst) #不修改源数据进行反转
print(lst1)

加
lst = [1,2,3,4]
lst + [1,2,3]
print(lst)

乘
lst = [1,2,3] * 5
print(lst)


面试题
lst = [1,[]] * 5 
print(lst)
lst[1].append(6)
print(lst)
列表在进行乘法的时候，元素是共用的

tuple（元组）

面试题
tu = (1)
tu1 = ("alex")
tu2 = (1,)#元组

加
tu = (12,3,4) + (4,5,3,4)
print(tu)

乘
tu = (1,[]) *3
print(tu)
tu[-1].append(10)
print(tu)

dict （字典）

dic = {"key":1,"key2":2,"key3":1}
dic.popitem() #随机删除 python3.6版删除最后一个 popitem返回的是被删除的键值对
print(dic)

面试题：
dic = {}
print(dic.fromkeys("abc",[]))#批量创建键值对"abc":[],"b":[],"c":[]

dic = {}
dic = dic.fromkeys("abc",[])
print(dic)

dic["a"].append(10)
print(dic)
dic["b"] =11
dic["a"].append(10)
print(dic)
fromkeys 第一个参数必须是可迭代对象，会将可迭代对象进行迭代，成为字典的键。第二个参数是值（这个值是共用的）  fromkeys 共用的值是可变数据类型就会有坑，不可变数据类型就没事

基础数据类型总结

可变：
- list
- dict
- set
不可变
- int
- str
- bool
- tuple
有序
- list
- tuple
- str
无序
- dict
- set（集合）

取值方式

索引
- list
- tuple
- str
键
- dict
直接
- int
- bool
- set

数据类型转换

str --int

int --str

str --bool

bool --str

int --bool

bool --int

list --tuple

lst = [1,23,5,4]
print(tuple(lst))

tuple -- list

tu = (1,23,5,4)
print(list(tu))

list --set

lst = [1,23,12,31,23]
print(set(lst))

tuple -- set

tu = (1,2,3,4,5)
print(set(tu))

重要：

list -- str

lst = ["1","2","3"]
print("".join(lst))

str --list

s = "alex wusir 太白"
print(s.split())

目前字典转换，自己实现方法

重点

find
join
列表乘法
元组(1,)
元组乘法
list --str
str --list

死循环
lst = [1,2,3]
for i in lst:
    lst.append(4)
print(lst)

lst = [11,22,33,44]
for i in lst:
    lst.remove()
print(lst)

for i in lst:
    lst.pop()
print(lst)

for i in range(len(lst)):
    del lst[-1]
print(lst)

lst = [11,22,33,44]
lst1 = lst[:]
for i in lst1:
    lst.remove(i)
print(lst)

使用for循环清空列表元素内容，1.从后向前删除，2.创建一个新的容器，循环新的容器删除旧的容器

面试题
lst = [1,[2]]
lst[1] = lst
print(lst)
答案：[1,[...]]

字典和集合

dic = {"key":1,"key1":2}
for i in dic:
    if i =="key1":
       	dic.pop(i)
    else:
        print("没有这个键")
print(dic)
字典和集合在遍历（循环）时不能修改原来的大小（字典的长度），可以进行修改值
 
s = {1,2,3,4,5,6}
for i in s:
    s.pop()
print(s)

二次编码

编码

ascii码：
- 支持：英文，数字，符号 1字节
- 不支持：中文
GBK（国标）
- 支持：英文，数字，，符号 ---ascii 1字节
- 支持：中文 2字节
Unicode（万国码）：
- 支持：英文，数字，，符号 4字节
- 支持：欧洲 4字节
- 支持:亚洲 4字节
utf-8
- 支持：英文，数字，，符号 1字节
- 支持：欧洲 2字节
- 支持:亚洲 3字节

000001101 = 1字节

字节：存储和传输

今天是个好日子
s = "今天是个好日子"
print(s.encode("utf-8")) #编码

a = "meet"
s1 = a.encode("utf-8")
print("meet")

print(b"meet")#只有字母才能这么搞
s2 = s1.decode("utf-8")#解码
print(s2)


必会：
python3:默认编码unicode
python2：默认编码ascii  
python2不支持中文

重要:
    encode()#编码
    decode()#解码
    
    用什么编码就要用什么解码
    网络传输一定是字节

day08

文件操作

找到文件位置
双击打开
进行一些操作 # r --read(读) w --write（写） a --追加
- rb--(读字节)wb ab r+ w+ a+
关闭文件

open() #通过open通过python操作系统进行打开文件

file 文件的位置

encoding 文件的编码

mode默认不写就是r

f文件句柄

读操作

f = open("E:\2345下载\1\a\111",mode = "r",encoding = "utf-8")
print(f.read())  #全部读取
print(f.read(11))#按照字符读取
print(f.readline())#默认尾部有一个\n
print(f.readline().strip)#将\n去除
print(f.readlines())#一行一行读取，全部存储仔列表中

路径转义：

1."D:\\Python_s25\\day088\\t1.txt"
2.r "D:\Python_s25\day088\t1.txt"--推荐使用

路径：

1.绝对路径：从磁盘（C盘）开始查找
2.相对路径：相对于某个文件进行查找

rb

字节操作，不能指定encoding（编码）
open
print(f.read())#全部读取
print(f.read(3))#按照字节读取
print(f.readline())#按照行进行读取

r和rb的区别：

1.r需要指定encoding,rb不需要
2.r模式中的read(3)按照字符读取，rb模式中的read(3)按照字节读取

read 和readlines 如果文件较大时，会出现内存溢出

解决方案：

面试题：
当文件较大时，使用for循环进行读取
f = open('t1',mode="r",encoding="utf-8")
for i in f:
    print(i.strip())

写操作：

w操作--清空写

先清空文件（打开文件的时候清空）
写入内容

当模式为w和a时，有文件就使用当前文件，没有文件就创建一个文件
ff = open("a1",mode="w",encoding="utf-8")
ff.write("123")#写的内容必须是字符串
ff.write("我是一个字符串串")
ff.write("111\n")

wb --清空写(写字节)

f = open('timg.jpg',mode="rb")
f1 = open("g1.jpg",mode="wb")
我 = f.read()
f1.write(content)

a --追加写（文本）

open("a1",mode="a",encoding="utf-8")
f.write("你好啊")

加操作

r+ 读写

f = open("b1",mode="r+",encoding="utf-8")
f.write("今天是周一")
print(f.read())

正确的操作：
f = open("b1",mode="r+",encoding="utf-8")
print(f.read())
f.write("今天是周一")

w+ 写读（有点用）
f= open("b1",mode="w+",encoding="utf-8")
f.write("今天是周一")
f.seek(0)#移动光标
print(f.read())

a+ 追加读 #坑
f= open("b1",mode="a+",encoding="utf-8")
f.write("今天是周一")
f.seek(0)#移动光标
f.write("啊啊啊啊啊")
print(f.read())

其他操作：

seek()移动光标
f = open("a1","r",encoding="utf-8")
print(f.read(5))
f.seek(0,0)#移动光标到文件的头部
f.seek(0,1)#移动光标到当前位置
f.seek(0,2)#移动光标到文件末尾
f.seek(5) #光标是按照字节移动
print(f.read())


查看光标：
f = open("a1","r",encoding="gbk")
print(f.read(3))
print(f.tell())#按照字节进行计算

修改文件

import os #操作系统交互的接口
f = open('a1',"r",encoding="utf-8")
f1 = open('a2',"w",encoding="utf-8")
for i in f:
    i.replace("天","日")
    f1.write(i)
f.close()
f1.close()
os.remove("a1")#删除不能找回
os.rename("a2","a1")

os.rename("a2","a3")
os.rename("a1","a2")


import os #操作系统交互的接口
f = open('a1',"r",encoding="utf-8")
f1 = open('a2',"w",encoding="utf-8")
i = f1.read().replace("天","日")#将文件中全部内容读取  容易导致内存溢出
f1.write(i)
f.close()
f1.close()
os.rename("a2","a3")
os.rename("a1","a2")

with open('a3',"r",encoding="utf-8")as f , open('a2',"r",encoding="utf-8") as f1:
    print(f.read())
    print(f1.read())
    
#1.自动关闭文件
#2.同一时间操作多个文件

文件操作的目的：持久化：永久存储

（数据库之前---文件操作就是代替数据库）

day09

函数
- 定义函数
- 调用函数
- 函数的返回值
- 函数的参数

函数初识

什么是函数？

将某个功能封装到一个空间中就是一个函数
减少重复代码

s = "alexdsb"
n = 0
for i in s:
    n += 1
print(n)

tu = (1,2,3,4,5,6,7)
n = 0
for i in tu:
    n +=1
print(n)

定义函数：

def python中关键字

len 函数名 --变量名一摸一样

()必须要写的格式规定

: 语句结束

def len():
    函数体
    
def my_len():
    n = 0
    for i in dic:
        n +=1
    print(n)

    
my_len()调用

函数的调用

函数名+()就是在调用函数

def yue():
    print("掏出手机")
    print("打开手机")
    print("摇一摇")
    print("聊一聊")
    print("约吗？")
    print("....")
yue()

函数的返回值：

def yue():
    print("打开手机")
    print("打开微信")
    print("打开附近的人")
    print("聊一聊")
    print("见一见")
    print("。。。。")
    return ["小萝莉","人妖","老奶奶","蔡徐坤"] return后没有规则都能扔
#yue()   
girl = yue()
print(girl)
#函数的返回值，返回给函数的调用者
函数名+():
    1.启动函数
    2.接受返回值
    
return 值 ==返回值
return:
1.可以返回任意类型数据
2.return返回多个内容手机元组的形式
3.return下方的代码不执行，并且会终止当前这个函数
4.return不写或写了return后面不写值都返回None
5.return不能终止循环
def func():
    msg = input("请输入内容:")
    if msg == "1":
        while True:
            print("111")
            return 3
    else:
        for i in range(5):
            print(i)
func()

函数的参数

位置参数：一一对应

默认参数：函数定义的时括号中写好的就是默认参数不进行传参使用默认参数，进行传参时使用传递的参数

形参：在函数的定义阶段

位置参数：一一对应按照顺序进行传递变量名不能重复传递的参数可以不使用，但必须有
默认参数：定义阶段提前赋值，如果没有进行传参，就是用它的默认参数
混合参数优先级：位置参数>默认参数

实参：在函数的调用阶段

位置参数：一一对应

关键字参数：按照名字进行传参

混合参数：位置参数和关键字参数混合使用

位置参数 >默认参数（关键字参数）

注意点：参数名字不能重复，优先级不能放反

参数传递后，可以不适用

位置参数是一一对应

return不能终止循环

形参：函数定义阶段括号中的参数叫做形参
实参：在函数调用阶段括号中的参数叫做实参
传参：将实参传递给形参的过程叫做传参

a = 1
b = 2 
def func():
    return a + b
    print(1)
print(func())


def yue(app):#形参
    #函数帮咱们做了一个赋值 app = "默默"
    print("掏出手机")
    print("打开"+app)
    print("摇一摇")
    print("聊一聊")
    print("约吗？")
    print("....")
yue("默默")#实参

三元运算（三目运算）

def func(a,b):
    return a if a > b else b
print(func(6,9))
条件成立的结果  条件 条件不成的结果
条件成立的结果(a) 条件 (if a >b else)  条件不成立的结果(b)
三元运算中只能是 if else

函数是一种编码思维

enumerate 枚举 默认是从0开始数  第一个参数：可迭代对象  第二个参数：数数的起始值

day10

今日内容：

函数的进阶：

动态参数
函数的注释
名称空间
函数嵌套
global nonlocal

动态位置参数

在参数位置用*表示接受任意参数
动态接收参数的时候要注意: 动态参数必须在位置参数后面

def eat(*args):#定义阶段 * 聚合()
    print(args)#tuple
    print(*args) #函数体中的 * 打散（解包）
    #a,b,*c = args
    #print(a,b,c)
eat("麻辣烫","大烧饼","大煎饼","大腰子","韭菜","羊蝎子","黄焖鸡")


def eat(a,b,*c): #位置参数>动态位置参数>默认参数
    print(a)
    print(b)
    print(c)
eat("面条","米饭","馒头","大饼")

*args 大家伙都用的名字，可以进行修改但是不建议修改

**kwargs 大家伙都用的名字，可以进行修改但是不建议修改

函数的定义阶段 * 和 **都是聚合函数体中 * 就是打散，*args 字符串 *kwargs 字典的键

动态默认参数

def eat(a,b,*args,**kwargs):#位置参数>动态位置参数>默认参数>动态默认参数
    print(a)
    print(b)
    print(args) #tuple
    print(kwargs) #dict
eat("面条","米饭",a1 = 1,b1=2)


def eat(*args,**kwargs):#(万能传参)
    print(args)#tuple
    print(kwargs)#字典
lst = [1,2,3,4,5,6]
dic = {'key1':1,'key2':3}
#eat(lst,dic)
#a,b,c,d,e = lst
#k1,k2 = dic
#eat(a,b,c,d,e,k1=dic[k1],k2=dic[k2])

eat(*lst,**dic) #eat(1,2,3,4,5,6)
应用场景：
数据库

动态参数总结

*args （聚合位置参数）大家伙都用的名字，可以进行修改但是不建议修改

**kwargs（聚合关键字参数）大家伙都用的名字，可以进行修改但是不建议修改

函数的定义阶段 * 和 **都是聚合函数体中 * 就是打散，*args 将元组中的元组进行打散 *kwargs 将字典的键获取

形参
- 位置参数
- 动态位置参数：先执行位置参数，位置参数接受后额外的参数动态位置参数进行接受获取的是一个元组
- 默认参数：
- 动态默认参数（默认）：先执行默认参数，默认参数接受后额外的默认参数动他默认参数进行接受，获取的是一个字典
实参：
- ```
* 打散
** 实参时能够使用
```

函数的注释

def my_sum(a: int, b: int):
    """
    求和
    :param a:int
    :param b: int
    :return: int
    """

    return a + b
print(my_sum(8, 6))
print(my_sum.__doc__) #查看函数的注释
print(a._doc_)#查看函数的名字

名称空间

内置空间：Python解释器自带的空间
全局空间：py文件中顶格写的就是全局空间
局部空间：函数体中就是局部空间
- 加载顺序：
  - 内置空间
  - 全局空间
  - 局部空间
- 取值顺序：
  - 局部空间
  - 全局空间
  - 内置空间
- 作用域：
  - 全局作用域：全局 + 内置
  - 局部作用域：局部

函数的嵌套

不管在什么位置，只要是函数名()就是在调用一个函数

混合嵌套：

def fun1():   
    print(111)  
def fun2():   
    print(222)   
    fun1()   
fun2()
print(111)


def fun2():   
    print(222)   
    def fun3():       
        print(666)   
    print(444)   
    fun3()   
    print(888)
print(33)
fun2()
print(555)

函数和函数之前是独立的

global nonlocal

global ：只修改全局

在函数内部修改全局的变量,如果全局中不存在就创建一个变量

nonlocal：只修改局部，修改离弄nonlocal最近的一层，上一层没有继续向上上层查找，只限在局部

a = 10
def func():
    global a 
    a = a + 5
    print(a)
print(a)
func()

今日总结

函数进阶：
- 动态参数
  - *args 动态位置参数
  - **kwargs 动态默认参数
  - 位置>动态位置>默认>动态默认
  - 定义的时候是*是聚合
  - 函数体和实参是打散
  - *args，**kwargs
- 函数的注释
```
函数名._doc_ 查看注释内容
函数名._name_ 查看函数名称
```
- 名称空间
  - 加载
    - 内置空间>全局空间>局部空间
  - 取值
    - 局部空间>全局空间>内置空间（就地原则）
  - 作用域：
    - 全局作用域：全局+内置
    - 局部作用域：局部
- 函数的嵌套
  - 不管在什么位置，只要是函数名()就是在调用函数
- global nonlocal
  - global ：只修改全局
    
    nonlocal：只修改局部，修改离弄nonlocal最近的一层，上一层没有继续向上上层查找，只限在局部

day11

今日内容

函数名的第一类对象及使用
f-strings 格式化
迭代器
- python三大器
  - 迭代器
  - 生成器
  - 装饰器 ---装饰器进阶

函数名的第一类对象及使用

当做值，赋值给变量

def func():
    print(1)
print(func)  #查看的函数的内存地址
a = func
print(a)  
a()

可以当做容器中的元素

lst=[]
dic={}
def func():
    print(1)
def foo():
    print(2)
lst = [func,foo]
print(lst)

函数名可以当做函数的参数

def foo(a):
    a()
    print(111)
def func():
    print(222)
    def f1():
        print(333)
    foo(f1)
func()

函数名可以当做函数的返回值

def func():
    def foo():
        print(111)
 	return foo
func()() #foo()

函数名的第一类对象的使用方式如下：

可以当做值，赋值给变量
可以当作容器中的元素
可以当做函数的参数
可以当做函数的返回值

f-strings

name = input("name:")
age = input("age:")


f"{变量名}"
F"{变量名}"
f"""{变量名}"""
f"{input()}"
f"{3 if 3>2 else 2}"
lst = [1,2,3,4,5]
f"{lst[4]}"
f"{lst[-1]}"

迭代器

可迭代对象：

list
tuple
srt
set
dict
取值方式只能直接看

只要具有__iter__()方法就是一个可迭代对象

lst = [1,2,3,4,5]
for i in lst:
    print(i)

迭代器：工具

具有__iter__()和__next__()两个方法才是迭代器
lst = [1,2,3,4,5]
l = lst.__iter__()#将可迭代对象转换成迭代器
l.__iter__ #迭代器指定__iter__()还是原来的迭代器
print(l.__next__())

for循环的本质：重要
while True:
    try:#监听
    	print(l.__next__())
    except StopIteration:#报错退出
        break
        
        
        
lst = [1,2,3,4,5]
l = iter(lst)
# iter()和__iter__()是一样的 推荐使用iter()
python3:
    iter()和__iter__()都有
    next()和__next__()都有
python2:
    iter()
    next()

迭代器的优点：

惰性机制 ---节省空间

迭代器的缺点：

不能直接查看值，迭代器查看到的是一个迭代器的内存地址
一次性，用完就没有了
不能逆行（后退）

空间换时间：容器存储大量的元素，取值时间短，但是容器占用空间较大

时间换空间：迭代器就是节省了空间，但是取值时间较长

可跌代对象:

具有iter()方法就是一个可迭代对象
迭代器是基于上一次停留的位置，进行取值
迭代器：具有iter()和next()方法就是一个迭代器

day12

今日内容

生成器
推导式
内置函数

什么是生成器

核心：生成器的本质就是一个迭代器

迭代器python自带的
生成器程序员自己写的一种迭代器

生成器编写方式：

基于函数编写
- ```
def func():
    print("这是一个函数")
    return "函数"
func()

def func():
    print("这是一个生成器")
    yield "生成器"
func()

#函数体中出现yield代表要声明一个生成器
generator-----生成器
print(func())
获取到的是一个生成器的内存地址
func() #生成一个生成器
print(func().__next__())#启动生成器
```
- yield和return的区别：
  - 相同点：
    - 都是返回内容
    - 都可以返回多次，但是return写多个只会执行一个
  - 不同点：
    - return终止函数 yield是暂停生成器
    - yield能够记录当前执行位置
- 一个yield对应一个next
- 生成器的作用是节省空间
可迭代对象：
- 优点：list，tuple，str 节省时间，取值方便，使用灵活(具有自己的私有方法)
- 缺点：大量消耗内存
迭代器：
- 优点：节省空间
- 缺点：不能直接查看值，使用不灵活，消耗时间，一次性，不可逆
生成器：
- 优点：节省空间，人为定义
- 缺点：不能直接查看值，消耗时间，一次性，不可逆
使用场景：
- 当文件或容器数据量较大时，建议使用生成器
数据类型都是可迭代对象
```
数据类型（python3：range（） |python2：xrange（））都是可迭代对象 __iter__()
```
文件句柄是迭代器
```
__iter__() __next__()
with open("a.txt","w",encoding="utf-8") as f
```
send()不讲
- 没有send方法就是一个迭代器，具有send方法的就是一个生成器
yield from 将可迭代对象逐个返回

yield将可迭代对象一次性返回
推导式方式编写

推导式

lst = []
for i in range(10):
    lst,append(i)
print(lst)

列表推导式
普通循环：
print([i for i in range(10)]) 
print([变量 for循环])

筛选模式
lst = []
for i in range(10):
    if i %2 ==0:
        lst.append(i)
print(lst)

print([i for i in range(10) if i %2==0])
print([ 加工后的变量 for循环 加工条件])

集合推导式：
普通循环：
print({i for i in range(10)})
{变量 for循环}
筛选：
print({i for i in range(10) if i%2==1})
{加工后的变量 for循环 加工条件}

字典推导式：
普通循环
print({i:i+1 for i in range(10)})
{键:值 for循环}
筛选
print({i:i+1 for i in range(10) if i%2 ==0})
{加工后的键:值 for循环 加工条件}

生成器推导式：
普通模式
print((for i in range(10))
(变量 for循环)
筛选模式
tu = (i for i in range(10) if i >5)
      （加工后的变量 for循环 加工条件）
      for i in tu:
      print(i)

内置函数一

eval() # 神器一
exec() # 神器二
注意：禁止使用

print(hash("123"))
hash()作用就是区分可变数据类型和不可变数据类型

help()查看帮助信息

callable()#查看对象是缶可调用

print(int("010101",16))转换进制

print(float(3))浮点数

print(complex(20))复数

print(bin(100)) 十进制转二进制

print(oct(10)) 十进制转八进制

print(hex(10)) 十进制转16进制

print(divmod(5,2)) #求(商，余)

print(round(4.66)) #保留小数位

print(pow(2,2))#幂 pow 两个参数是求幂 三个参数是求幂后的余

print(bytes("alex",encoding = "utf - 8"))#将字符串进行编码

print(ord("b")) #通过元素获取当前表位的序号
print(chr())#通过表位序号查找元素

print(repr()) 查看数据的原生态--给程序员使用的
print(a) 给用户使用的

lst = [1,2,3,4,5]
print(all(lst))判断容器中的元素是否都为真
lst = [1,2,3,4,5,0,1,23]
print(any(lst)) 判断容器中的元素是否有一个为真

print(globals()) #查看全局空间变量
print(locals()) #查看当前空间变量

day13

今日内容

匿名函数
内置函数二
- 普通
- 高阶
闭包

匿名函数 ==一行函数

匿名函数的名字叫做lambda
```
def func():
    print(123)
func()
```
lambda == def ==关键字 :声明函数

#x是普通函数的形参(位置,关键字...)可以不接收参数(x:可以不写)
#:后边x是普通函数的函数值(只能返回一个数据类型)(:x 后必须写)
lambda x:x
print((lambda x:x+6))(5)
print([lambda :5][0]())
print((lambda :5))()
a = lambda :5
a()

面试题拆解:
lst = []
for i in range(5):
    def func():
        return i
    lst.append(func)
    
lst = [] # [lambda x:x+1,lambda x:x+1]
for i in range(2):
    lst.append(lambda x:x+1)
print(lst[-1](5))

lst = [lambda x:x+1 for i in range(5)]
print(lst[0](5))

tu = (lambda :i for i in range(3))
print(next(tu)())
print(next(tu)())
print(next(tu)())


def func():
    for i in range(3):  # i = 0 1 2
        def foo():      # foo1  foo2  foo3
            return i
        yield foo       # foo1  foo2  foo3
g = func()
print(next(g)())  # foo1
print(next(g))  # foo2
print(next(g))  # foo3

lst = [lambda :i for i in range(3)]
print(lst[0]())

tu = (lambda :i for i in range(3))
print(next(tu)())
函数体中存放的是代码
生成器体中存放的也是代码
#就是yield导致函数和生成器的执行结果不统一

lst = [lambda x:x+5 for i in range(2)]
print([i(2) for i in lst])

lst = [] # [lambda x:x+5,lambda x:x+5]
for i in range(2):
    lst.append(lambda x:x+5)
new_lst = []
for i in lst:
    new_lst.append(i(2))
print(new_lst)


lst = (lambda x:x+5 for i in range(2))
print([i(2) for i in lst])

def func():
    for i in range(2):
        f = lambda x: x + 5
        yield f

g = func()
lst = []
for i in g:
    lst.append(i(2))
print(lst)

lst = [lambda x:x*i for i in range(2)]
print([i(2) for i in lst])  #[2,2]

lst = [] # [lambda x:x*i,lambda x:x*i]
for i in range(2):
    lst.append(lambda x:x*i)
# print(i)
new_lst = []
for em in lst:
    new_lst.append(em(2))
print(new_lst)


lst = (lambda x:x*i for i in range(2))
print([i(2) for i in lst])  #[0,2]

def func():
    for i in range(2):
        f = lambda x:x*i
        yield f
g = func()
lst = []
for i in g:

    lst.append(i(2))
print(lst)

func = lambda x:[i for i in x]
print(func('afafasd'))

print(list('afafasd'))

内置函数

普通

print(dict(k = 1,v=2,c=3))

dic1 = {'key1':1,'key2':2}
dic2 = {'a':1,'b':2}
print(dict(**dic1,**dic2))

print(dict([(1,2),(3,3)]))

sep:每一个元素之间的分割的方法 默认" "
end:print执行完后的结束语句 默认\n
print(1,2,3,end = "")
file:文件句柄 默认是显示到屏幕
print(1,2,3,4,file= open('test','w',encoding = 'utf-8'))
print() #flush 刷新

sum()求和 #可迭代对象容器,容器的元素必须是数字   
sum([1,2,34,78],100)  指定开始位置的值

abs()#绝对值

print(dir(list)) #查看当前对象所有方法 返回的是列表

zip()拉链  将两个可迭代对象合成一个元组  当长度不一致时选择最短的进行合并
lst1 = [1,2,34,5]
lst2 = ['alex','wusir','宝元']
print(list(zip(lst1,lst2)))#拉链
面试题:
print(dict(zip(lst1,lst2)))

print(format("alex",'>20'))#右对齐
print(format("alex",'<20'))#左对齐
print(format("alex",'^20'))#居中
print(format(10,'b')) #bin 2进制
print(bin(10))
print(format(10,'o')) #oct 8进制
print(format(10,'x')) #hex 16进制
print(format(0b1010,'d')) #digit 十进制

print(list(reversed("alex")))

高阶函数

filter --过滤

lst = [1,2,3,4,5,6]
print(list(filter(lambda x:x>3,lst)))

def func(a):
    return a>1
print(list(filter(func,lst)))

def f(func,arvg):
    lst = []
    for i in arvg:
        ret = func(i)
        if ret:
            lst.append(i)
    return lst
def foo(a):
    return a>2
print(f(foo,[1,2,3,4]))
foo不加括号是表示一个函数的内存地址
 内部做了一个for循环   
#filter() 
#1.指定过滤的规则(函数名的内存地址)
#2.要过滤的数据  可迭代对象

map映射函数(将可迭代对象中对的每个元素都执行指定的函数)

print(list(map(lambda x:x,[1,2,3,4])))
map()    函数名(对每个元素进行执行指定的方法,可迭代对象)

sorted(排序)

可迭代对象,key=制定规则

print(sorted([1,2,3,4,5,6],reverse = True))#reverse是否是倒序 ,True倒序  False正序
print(sorted([1,2,3,4,5,6],key = abs ))#key指定排序规则 

lst =[1,3,2,5,4]
lst2 = sorted(lst)
print(lst)#原列表不会改变
print(lst2)#返回的新列表是经过排序的
lst = ["三国演义","红楼梦","铁道游击队","西游记","水浒传","活着"]
print(sorted(lst,key=len))
字典:
 lst =[{"age":19},{"age1":20},{"age2":80},{"age3":10}]
print(sorted(lst,key=lambda x:list(x.values())))
print(sorted(lst,key=lambda x:list(x.keys()),reverse=True))

dic = {1:'a',3:'c',2:'b'}
print(sorted(dic)) #字典排序返回的就是排序后的key

max()--最大值可迭代对象,key=指定规则

print(max([10,12,13,15,-16],key=abs))

min()--最小值可迭代对象,key=指定规则

reduce 累计算

from functools import reduce #从functools工具箱中拿来了reduce工具
def func(x,y):
    return x+y
print(reduce(func,[1,2,3,4,5]))
print(reduce(lambda x,y:x+y,[1,2,3,4,5]))

闭包

在嵌套函数内,使用(非本层变量)非全局变量就是闭包

def func():
    a = 1
    def foo():
        print(a)
    print(foo.__closure__)#判断是不是闭包  返回None就不是闭包
func()

闭包的作用:

保护数据的安全性
装饰器

day14

今日内容

装饰器

装饰器:面试笔试必问

开放封闭原则:

代码扩展进行开放
修改源代码是封闭

在不修改源代码及调用方式,对功能进行额外的添加就是开放封闭原则

装饰器

装饰(额外功能) 器:工具(函数)

import time

#print(time.time())  #时间戳 小数
def index():
    time.sleep(2)  #  停留  秒 
    print("这是小明写的功能")
start_time = time.time()
index()
print(time.time() - start_time)


第一版装饰器   
def index():
    time.sleep(2)  
    print("这是小明写的功能")
    
def func():
    time.sleep(2)  
    print("这是小刚写的功能")
    
def red():
    time.sleep(2)  
    print("这是小红写的功能")
    
def times(func):
    def foo():
        start_time = time.time()#被装饰函数执行前干的事
        func()
        print(time.time() - start_time) #被装饰函数执行后干的事
    return foo
index = times(index)
index()

定义  函数名  () 不写 格式 写了传参
def foo():
    print("被装饰的函数")
    
def warpper(func):  #func ==foo函数的内存地址
    def inner():
        print("宝元最骚")
        func()  #foo()
        print("宝元最胖")
    return inner  #不能加括号  #return None
foo = warpper(foo) #不能加括号 foo = warpper(None)
foo()





def warpper(f):
    def inner():
        print("111")
        f()
        print("222")
    return inner

@warpper
def func(): #func = warpper(func)
    print("被装饰的函数1")
@warpper
def index(): #index = warpper(index)
    print("被装饰的函数2") 
   
func()
 #python帮咱们做的一个东西,语法糖
 #要将语法糖放在被装饰的函数正上方

def warpper(f):
    def inner(*args,**kwargs):
        print("11442")
        ret = f(*args,**kwargs)
        print("5152")
        return ret
    return inner
def func(*args,**kwargs):
    print(f"{args,kwargs}")
    return "445"
func = warpper(func)
print(func(1,12,5,45,1,455,1,a = 1))   标准版装饰器拆解

def warpper(f):
    def innner(*args,**kwargs):
        print("被装饰函数执行前")
        ret = f(*args,**kwargs)
        print("被装饰函数执行后")
        return ret
    return innner
@warpper
def func(*args,**kwargs):
    print(f"被装饰的{args,kwargs}")
    return "我是func函数"
print(func(1,21,5,2,5,2,1,a=1))

标准版装饰器

day15

今日内容

装饰器进阶
- 有参装饰器在标准版装饰器外层添加一层,额外需要多调用一层
- 多个装饰器装饰一个函数
递归

1.有参装饰器

语法糖:@auth(参数)

def auth(argv):
    def warpper(func):
        def inner(*args, **kwargs):

            if argv == "博客园":
                print("欢迎登录博客园")
                user = input("user:")
                pwd = input("pwd:")
                if user == "alex" and pwd == "dsb":
                    func(*args, **kwargs)
            elif argv == "码云":
                user = input("user:")
                pwd = input("pwd:")
                if user == "alex" and pwd == "dsb":
                    func(*args, **kwargs)

        return inner

    return warpper
def foo():
    print("被装饰的函数")
msg = input("请输入你要登录的名字:")
a = auth(msg)
foo = a(foo)
foo()

def auth(argv):
    def wrapper(func):
        def inner(*args,**kwargs):
            if argv:
                print("我加上功能了!")
                func(*args,**kwargs)
            else:
                func(*args,**kwargs)
        return inner
    return wrapper

def foo():
    print("这是一个点燃")
    
wrapper = auth(False)
foo = wrapper(foo)
foo()



def auth(argv):
    def wrapper(func):
        def inner(*args,**kwargs):
            if argv:
                print("我加上功能了!")
                func(*args,**kwargs)
            else:
                func(*args,**kwargs)
        return inner
    return wrapper
@auth(False)  #@auth ==foo =wrapper(foo)=auth(False)  flask框架  搭网站的
def foo():
    print("这是一个点燃")
foo()

多个装饰器装饰一个函数

多个装饰器装饰一个函数时,先执行离被装饰函数最近的装饰器

小技巧 :v

def auth(func):
    def inner(*args,**kwargs):
        print("额外增加了一道 锅包肉")
        func(*args,**kwargs)
        print("锅包肉 38元")
    return inner

def wrapper1(func):
    def inner(*args,**kwargs):
        print("额外增加了一道 日魔刺生")
        func(*args,**kwargs)
        print("日魔刺生 白吃")
    return inner

def wrapper2(func):
    def inner(*args,**kwargs):
        print("额外增加了一道 麻辣三哥")
        func(*args,**kwargs)
        print("难以下嘴")
    return inner
@auth
@wrapper1
@wrapper2
def foo():
    print("这是一个元宝虾饭店")
foo()  

def foo():
    print("这是一个元宝虾饭店")
    #多个装饰器装饰一个函数时,先执行离被装饰函数最近的装饰器
foo = wrapper2(foo)
foo = wrapper1(foo)
foo = auth(foo)
foo()

递归

递: 一直传参

归: 返回 return

一递一归归的时候不能间断

不断调用自己本身 (无效递归 --死递归)

递归的最大深度(层次)  官方说明1000 实际测试 998/997
def func():
    print(1)
    func()
func()

有明确的终止条件

def func(n):
    if n == 3:
        return
    return func(n+1)
func(1)

meet = [["北京",["alex","wusir","太白金星","闫龙","景女神",["邢姨",["肖帮主","吴老板",["张晓波","王胜辉"]]]]],
        ["上海",["林海峰"],],
        ["深圳",["日天"]]]

def func(m):
    for i in m:
        if type(i) == list:
         func(i)
        else:
            print(i)
func(meet)

day16

今日内容

自定义模块
time
datetime
random

自定义模块

分类认证 ,视频,评论

模块能干什么?

文件化管理提高可读性,避免重复代码
拿来就用(避免重复造轮子) python中类库特别多

定义一个模块

一个文件就是一个模块(模块就是一个工具箱工具(函数))

import

import test 导入拿test工具箱只能将整个工具箱拿来导模块不能加后缀名

import导入同一个模块名时,只执行一次

import时会做三件事:

将test.py文件中所有代码读取到当前文件
当前文件开辟独立空间
等待被调用

import和from的区别:

from 只能执行导入的功能
import 能执行整个模块中所有的功能
from会容易将当前文件中定义的功能覆盖
from比import灵活

import只能导入当前文件夹下所有的模块

import后边不能加点操作

import和from使用的都是相对路径

import sys #和python解释器交互的接口

print(sys.path)

sys.path.append()

模块导入顺序:

append

内存> 内置>第三方>自定义

insert

内存>自定义>内置>第三方

import test as t #工具箱名字过长时可以起别名 避免覆盖之前的内容

#飘红不代表报错

from test import t1 #从test工具箱中将t1这个工具拿过来
t1()  
from test import t1 as t
def t1():
    print("2454")
t1()
t()

as支持import和from

from和import 推荐使用from

注意事项:(了解)

字节码
不能交叉导入,导入
自定义模块不能和内置模块重复

模块的两种用法

通过if __name__='__main__'判断
#当文件被当做模块被调用的时候__name__返回的当前模块名
#当文件当做脚本执行时__name__返回的__main__

当做模块被导入
当做脚本被执行

只有py文件当做模块被导入时,字节码才会进行保留

pip install 模块名安装第三方模块

以后导入模块会产生的坑

注意自己定义模块的名字
注意自己的思路---循环导入时建议导入模式放在需要的地方

不建议一行导入多个模块

import from

from test import * #拿整个工具箱

通过__all__控制要导入的内容

time

import time #内置模块 --标准库
print(time.time())#时间戳 浮点数 1970年1月1日00:00:00
time.sleep(3) #秒
#将时间戳转换成结构化时间
print(time.localtime(time.time())) #命名元组  (不写) 当前时间戳
print(time.localtime(time.time())[0])
print(time.localtime(time.time()).tm_year)
print(time.localtime(15500000))
#将结构化时间转换成字符串
time_g = time.localtime(150000000)
time.strftime("%Y-%m-%d %H:%M:%S",time_g)
#将字符串转换成结构化时间
str_time = "2018-10-1 10:11:22"
time.strptime(str_time,"%Y-%m-%d %H:%M:%S")
#将结构化时间转换成时间戳
print(time.mktime(time_g))
%Y 年
%m 月
%d 日
%H 小时
%M 分钟
%S 秒

datetime

from datetime import datetime,timedelta
print(datetime.now())#获取当前时间
print(datetime(2018,10,1,10,10,10))
print(datetime(2018,10,1,10,10,10) - datetime(2018,10,30,10,10,10))#指定时间

#将对象转换成时间戳
d = datetime.now()
print(d.timestamp())

#将时间戳转换成对象
import time
f_t = time.time()
print(datetime.fromtimestamp(f_t))

#将对象转换成字符串
d = datetime.now()
print(d.strftime("%Y-%m-%d %H:%M:%S"))
#将字符串转换成对象
s = "2018-12-31 10:11:12"
print(datetime.strptime(s,"%Y-%m-%d %H:%M:%S"))

#可以进行加减法
print(datetime.now() - timedelta(day = 20))
print(datetime.now() - timedelta(hours = 20))

random ---随机数

import random
print(random.randint(1,50))#选择1-50之间随机的整数
print(random.random()) #默认0-1之间的随机小数,不包含1
print(random.uniform(1,3))#1-10之间随机小数,不包含10

print(random.choice((1,2,3,4,5,6,7)))#从容器中随机选择一个
print(random.choice((1,2,3,4,5,6,7),k=3))#从有序容器中随机选择3个元素,以列表的形式返回,会出现重复元素
print(random.sample((1,2,3,4,5,6,7),k=3))#从容器中随机选择3个元素,以列表的形式返回,不会出现重复元素 返回的是列表

print(random.randrange(1,10,2))#随机的奇数或随机的偶数

lst = [1,2,3,4,5,6,7]
random.shuffle(lst)  #洗牌  将有序的数据打散
print(lst)

day17

今日内容

软件开发规范
序列化 json pickle
os 文件夹文件路径
sys 4
hashlib
collection

软件开发规范 --文件

几百行 --大几万行

当代码存在一个py文件中时

不便于管理修改增加
可读性差
加载速度慢

Django ---雏形

约定俗称

启动文件启动接口 starts bin文件夹
公共文件大家需要的功能 common lib文件夹
配置文件(静态文件)变量 settings conf文件夹 (数据库连接 redis)
主逻辑核心 (函数,类) src.py core文件夹
用户相关数据账号和密码等文件 register db文件夹
日志记录重要信息,记录开发人员的行为 logg.log log文件夹

sys -- python解释器做交互

import sys
print(sys.path)  #模块查找的顺序 ***
print(sys.argv)  #只能在终端执行 cmd
print(sys.modules) #查看加载到内存的模块
print(sys.platform) #查看当前操作系统平台 mac --darwin  win --win32
mac --linux 查看ls
win     dir
print(sys.version) #查看当前解释器的版本

序列化:

json
pickle

json

4个方法 2组
- dumps loads --用于网络传输
- dump load --用于文件存储

用于网络传输

dic = '{"key":1}'
手写
new_dic ={}
k,v = dic.replace("{","").replace("}","").repalce('"',"").split(":")
new_dic[k] = v
print(new_dic["key"])

import json
s = json.dumps(dic)
print(s,type(s))

d= json.loads(s)
print(d,type(d))

json是所有语言共有的语言沟通桥梁

将数据类型转换成字符串(序列化),将字符串转换成原数据类型(反序列)

序列化:
- 字典 ,列表,元组序列后自动变成列表

用于文件存储
dic = {"key":1}
json.dump(dic,open("a","a",encoding="utf-8")) #将原数据类型转换成字符串,写入到文件操作中
print(json.load(open("a","r",encoding = "utf-8"))['key']) #将文件中的字符串转换成原数据类型


dic = {"key":1}
f = open("a","a",encoding="utf-8")
f.write(json.dumps(dic)+"\n")
f1 = open("a","r",encoding = "utf-8")
for i in f1:
    print(json.loads(i),type(json.loads(i)))
    
    
dic = {"key":"宝元"}
print(json.dumps(dic,ensure_ascii =False,sort_keys =True))

pickle

只有python有,几乎可以序列python中所有数据类型,匿名函数不能序列

import pickle
def fun():
    print(1)
a = pickle.dumps(func)  #将原数据类型转换成类似字节的内容
print(pickle.loads(a)) #将类似字节的内容转换成原数据类型

os

工作路径

import os  #os是和操作系统做交互,给操作发指令
print(os.getcwd())  #获取当前文件工作的路径
print(os.chdir("绝对路径")) #路径切换
print(os.getcwd())

print(os.curdir) 目录
print(os.pardir) 父目录

文件夹

os.mkdir("a2")  #创建文件夹
os.rmdir("a2")  #删除文件夹
os.makedirs('a1/a2/a3')  #递归创建文件夹
os.removedirs("a1/a2/a3")  #递归删除文件夹
os.listdir("绝对路径")  #查看当前文件夹下所有的内容

文件

os.remove("绝对路径") #删除文件,彻底删除,找不回来
os.rename("绝对路径") #重命名

路径

os.path.abspath("相对路径") #返回的是绝对路径***
os.path.split("路径")#将路径分割成一个路径和一个文件名
print(os.path.dirname("路径"))  #获取到父目录  ***
print(os.path.basename("路径")) #获取文件名字
print(os.path.join("D:\Python","day17","test"))#路径拼接 ***

判断

print(os.path.exists("")) #判断路径是否存在
print(os.path.isabs("绝对路径"))#判断是不是绝对路径
print(os.path.isdir("")) #判断是不是文件夹
print(os.path.isfile("")) #判断是不是文件

print(os.path.getsize("")) #获取文件大小

hashlib

Python 2与Python 3的区别

源码
- Python 2：源码不统一，源码重复
- Python 3：源码统一，源码不重复
input
- Python 2 中的input获取到的就是数据本身
- Python 3 中的input获取到的内容都是字符串
除法
- Python 2：除法返回的是整数（向下取整）
- Python 3：除法返回的是浮点数
print语句
- Python 2 中print语句有的包含括号，有些不包含
- Python 3 中print语句必须有括号
整型
- python 2：整型，长整型long
- python 3：全是整型
print(range(1,10))
- Python 3：中打印range时自己本身
- Python 2：中打印range获取的是一个列表，列表的元素是1-9
编码
- python 2：中默认编码ASCII，不支持中文
- python 3 ：中默认编码Unicode
range
- Python 2 ：中打印range获取的是一个列表，列表的元素是1-9
- Python 3 ：中打印range时是自己本身

python从开始到灭亡

Python从零

预科

day01

day02

day03

主要内容

markdown常用语法

一级标题

二级标题

六级标题

思维导图

博客

排bug技巧

码云的日常操作

day01

python的历史

python是一个什么编程语言

python的种类

变量

常量

注释

基础数据类型初识

用户交互（输入/输出）

流程控制语句

day02

while

格式化

运算符

单位转换：

day02 总结

day03

int --整型

布尔值

字符串详解

字符串的方法

for循环

day03总结

day04

今日内容

列表

啥是列表？

列表 -- 容器

列表的增加

列表的删除

列表的修改

列表的查

列表的嵌套

元组

元组的用途

元组的嵌套

range(范围)

day05

字典的增：

字典的删除

字典的改：

字典的查

解构

字典的嵌套

day06

今日内容

小数据池

代码块 ：

is 判断的是两边的内存地址是否相同

== 判断两边的值是否相同

驻留机制

深浅拷贝

赋值

浅拷贝

深拷贝

集合

增:

删

改

查

其他操作

day07

基础数据类型补充

基础数据类型总结

数据类型转换

代码块：

迭代器：工具