目录
pycharm： 下载 PyCharm：JetBrains 为专业开发者提供的 Python IDE
Windows版本--修改默认项目存放位置（C:\Users\...\Envs）
元组只有单个元素时，元组类型会自动转换成元素类型，如何处理这个现象？
实现函数参数自定义（预设置值）的功能（partial）：两种方式
第一种：不指定被设置函数的参数关键字，按照函数自定义的参数顺序进行值预设置
u：定义unicode字符串，防止中文字符串乱码，因此用来指定编码
相关网址
组件：PyPI · The Python Package Index
web框架
1.Django
2.Flask
刷题
IDE
pycharm： 下载 PyCharm：JetBrains 为专业开发者提供的 Python IDE
pip的使用（安装第三方库）
安装卸载
# 安装第三方包
pip install grpcio
# 卸载第三方包,输入Y确认删除
pip uninstall grpcio切换镜像源，加速安装可能被墙的第三方库
# 临时指定镜像下载
pip install -i https://pypi.doubanio.com/simple/ --trusted-host pypi.doubanio.com grpcio可选镜像源列表
指定版本下载
# 指定版本
pip install grpc==1.43.0虚拟环境的使用
virtualenvwrapper
Windows版本
注意点
1、windows版本不支持git bash窗口，只可使用windows自带的cmd窗口；
# 安装命令
pip install virtualenvwrapper-win
# 生成隔离环境 -p：指定虚拟环境的python版本 dir：实际安装python.exe的路径 python_env_name：虚拟环境的名称
mkvirtualenv -p dir/python.exe python_env_name
# 删除隔离环境
rmvirtualenv python_env_nameWindows版本--修改默认项目存放位置（C:\Users\...\Envs）
增加系统变量（WORKON_HOME）
通过计算机->右键选择属性->高级系统设置->环境变量->增加系统变量->填写键值->手动创建指定的目录
打开CMD窗口进行测试：
1.在目录中建立测试目录；
2.输入workon，出现测试目录则表示设置成功；
重置目录操作
1、将原本的文件修改名字
shop_learn ==> shop_learn_bak
2、重新创建环境目录
mkvirtualenv shop_learn
3、将原目录的项目文件复制到新的环境目录中，删除备份文件夹
复制：shop_learn_bak ==> shop_learn
删除：shop_learn_bak
Windows版本--常用虚拟环境命令
#列出虚拟环境列表
workon
#新建虚拟环境
mkvirtualenv [虚拟环境名称]
#启动/切换虚拟环境
workon [虚拟环境名称]
#离开虚拟环境
deactivate基本语法
运算符
除法
单个斜杆 / 结果是浮点数类型；两个//结果是整数类型；
乘法
乘幂使用**
比较运算符
区分数据类型，如1 == '1' 结果为False
逻辑运算符
or运算符--有真取真，全假取尾假，全真取首真；and运算符--有假取假，全假取首假，全真取尾真
进制的表示形式
二进制
前缀是0b，再加上二进制数字
八进制
前缀是0o，再加上八进制数字
十六进制
前缀是0x，再加上十六进制数字
其他进制转二进制
使用bin函数
bin(10)、bin(0o11)、bin(0xF)
其他进制转十进制
使用int函数
int(0b11)、int(0o33)
其他进制转十六进制
使用hex函数
其他进制转八进制
使用oct函数
基本数据类型
整型int
浮点型float
布尔值bool
注：首字符大写：True、False
复数complex
字符串 str
注：三引号可以做换行输出
字符串运算
加：拼接字符串
乘：按基数复制字符串
字符串截取
获取字符串中单个字符：str[index]
获取字符串中某段字符：str[start:length]
列表（数组）list
列表运算
加：合并列表
乘：按基数复制列表元素
列表截取
获取列表中单个元素：list[index] 结果可为字符串也可为列表
获取列表中多个元素：list[start:length] 结果为列表（左开右闭，取左小于右）
列表追加元素
元组 tuple
语法与列表相似
元组只有单个元素时，元组类型会自动转换成元素类型，如何处理这个现象？
在单个元素后加上逗号即可
列表与元组的区别
list 是可变的对象，元组 tuple 是不可变的对象；列表可追加元素，元组不可变
序列
特点：有序，可通过索引取值，可进行切片（取范围值）
集合set
特点：无序，不支持索引取值，不可进行切片，不存在重复值
使用场景：求差集{} - {}、并集{} & {}、合集{} | {}、空集set()
字典dict
特点：与集合格式一致，内容由键值对组成
配置基于python开发的VSCode
python基本插件
python语法规范插件 （两种方式）
1.安装完python语法组件后，如果编辑器直接在右下角弹出以下弹框，则直接进行安装即可
2.手动pip安装pylint包，没有出现第一种方式的弹框，则可以通过pip进行命令行安装
pip install pylint 流程控制
if、elif、else
if 逻辑条件:
逻辑
elif 逻辑条件:
逻辑
else:
逻辑while、else、continue、break
# continue 跳过某个元素
# break 直接结束循环
while 逻辑条件:
逻辑
else:
执行完的逻辑for、else、continue、break
# col可表示集合、序列、字典
# continue 跳过某个元素
# break 直接结束循环
for item in col:
逻辑
else:
执行完的逻辑# 实现多次循环
# range(start,stop) start：开始处 stop：偏移量
# range(start,stop,step) start：开始处 stop：偏移量 step：步长
for item in range(start,stop)
逻辑
else:
执行完的逻辑
注：字典数据类型获取每个子元素的键值，使用字典变量.items()
dictVal = dict({'A1': 'dong', 'B1': 'xiao', 'C1': 'ji'})
for key,value in dictVal.items():
print(key,value)
三目运算符
python通过if else实现三目运算符的逻辑，没有单独的语法实现三目运算符；
包、模块
注
1.包内如果不存在__init__.py文件，则仅是文件夹
2.包和模块是不会被重复导入的，只会导入一次
3.避免循环引入
# 文件1 loop1.py
from loop2 import ltwo
lone = 'hello world'
print(ltwo)
# 文件2 loop2.py
from loop1 import lone
ltwo = '调用了吧'
__init__.py
1.通过__ALL__变量可以控制当前包导入的库
文件调用模块的方法
1.import、as
# import 导入
# as 模块别名
import allmodule.module as a
print(a.variables)2.from、import
# from 从模块目录（moduleDir）或者模块（module）
# import 导入目录（module）或者单个变量或函数（variable）或者整个模块的变量与函数（*）
from moduleDir/module import module/varisable,variable2/*
print(module.variable)
print(variable)注：引入多个变量导致单行过长需要换行时可使用\或者()来实现（推荐使用()）
# \
from moduleA import oneone,twotwo,threethree,\
fourfour# ()
from moduleA import (oneone,twotwo,threethree,
fourfour)模块内置变量
__name__ 获取模块的命名空间
1.__name__为'__main__'时，表示文件为入口文件，否则为模块文件；
__package__ 获取模块所属的包
__doc__ 获取模块的注释（... ...）
1__doc__可用于获取python所有模块的注释
__file__ 获取模块的绝对路径
函数
代码格式
def functionName(paramList):
pass返回结果：可返回1个或多个结果
# 定义函数
def calc(first, two):
add = first + two
sub = first - two
mul = first * two
div = first / two
return add, sub, mul, div
# 调用
addResult, subResult, mulResult, divResult = calc(4, 4)
# 打印结果
print(addResult, subResult, mulResult, divResult)
参数
必须参数：调用函数时必须传入的参数；
关键字参数：可根据函数的参数名作为关键字进行非顺序传参，调用函数传入的关键字必须与函数的关键字名称一致；
# 定义函数
def calcResult(first, second):
return first + second
# 调用函数
result = calcResult(second=20, first=10)
# 打印
print(result)默认参数：定义函数参数列表时，默认参数会设置默认值，如果调用函数时，默认参数传值则以传值为准，否则以设置的默认值为准；
可变参数： 有声明符号*或**的参数即为可变参数，可变参数的类型为元组（tuple）或字典（dict）
注：声明了可变参数，其后边的参数在调用参数时，需要通过关键字参数形式进行传值，这是因为可变参数会把其后的所有参数都列入元组中，归类为一个可变参数
参数name为必需参数， 因此所有传入的实参都被归类与可变参数内时，name未传值，因此报错
def changeParam(*params,name,age = 20):
print(params)
print(name)
print(age)
changeParam(1,2,3,'东小记',30) 
给必需参数name以关键字参数进行传入，声明name非可变参数的元素，即可正常调用函数
changeParam(1,2,3,'dongge',30,name='hello') 
注：当传入关键字参数时， 声明可变参数需要使用**
变量作用域
全局变量：只能在块区域定义
def defineGlobal():
global gv
gv = 1
defineGlobal()
print(gv)
gv = 2
print(gv)
面向对象
代码格式
注：
self是实例方法的必传参数关键字，等同于本类的实例化对象，关键字可修改成其他名称，如self改为this
cls是类方法的必传参数关键字，等同于本类，同self一样，关键字可修改成其他名称
class Person():
leg = '100cm'
__hair = 'black'
# 实例方法
def jump(self):
print('类内部调用属性' + self.leg)
return '必须返回结果'
# 私有实例方法
def __dance(self):
print('类调用私有实例方法')
# 类方法
@classmethod
def cls_jump(cls):
print('类方法调用' + cls.leg)
# 实例化
person = Person()
# 实例化调用实例方法
print('方法调用：' + person.jump())
# 实例化获取类属性
print('获取属性：' + person.leg)
# 类调用类方法
print('方法调用：' + Person.cls_jump())
# 类获取类属性
print('获取属性：' + Person.leg)构造函数
class Person():
def __init__(self):
print('实例化对象时会首先运行此函数')
# 实例化
Person()
打印类或实例化对象的变量
class Person():
name = 'defaultName'
def __init__(self, name):
self.name = name
print('类变量')
print(Person.__dict__)
print('实例对象变量')
print(Person('传个变量').__dict__)
类的属性与方法的公开与私有
公开属性：__attr__（一般是python内置）、attr
公开方法：__function__（一般是python内置）、function
私有属性：__attr
私有方法：__function
继承性
代码格式如下：
class Person():
gender = '未知'
total = '0'
def __init__(self):
print('父类')from Person import Person
class Male(Person):
def __init__(self):
super(Male,self).__init__()
print('子类')
Male() 
多继承的情况如何获取继承类信息？
# 通过打印类的__mro__属性
print(ChildClass.__mro__)class Grandfa(object):
def __init__(self,*args,**kwargs):
print("grandfa")
class Father(Grandfa):
def __init__(self,*args,**kwargs):
print("father1")
super().__init__(*args,**kwargs)
class Child(Father):
def __init__(self,*args,**kwargs):
print("child")
super().__init__(*args,**kwargs)
print(Child.__mro__)
正则表达式
表达式字典
https://baike.so.com/doc/4934015-5154299.html
代码格式
# 引入正则匹配包
import re
# 定义被匹配的值
searchData = 'aB0,cD1.eF2?'
# 获取匹配结果
macthResult = re.findall('\D',searchData)
print(macthResult)获取两个标签中间的内容
import re
mark = '<span id="movie-url">http://www.dongxiaoji.com</span><div>东小记</div>'
# 推荐使用
findallResult = re.findall(
'<span id="movie-url">(.*)</span><div>(.*)</div>', mark)
# 建议使用 查询整个字符串进行匹配
searchResult = re.search(
'<span id="movie-url">(.*)</span><div>(.*)</div>', mark)
# match 在开始找不到则直接结束匹配
matchResult = re.search(
'<span id="movie-url">(.*)</span><div>(.*)</div>', mark)
print(findallResult)
# 使用groups直接把所有结果为元组显示
print(searchResult.groups())
print(matchResult.groups())
# 使用group可以根据需求显示结果个数,1个时为字符串,超过1个时为元组
print(searchResult.group(1))
print(matchResult.group(1, 2))
JSON应用
import json
studentsDict = [
{'gender': '男', 'name': '男1'},
{'gender': '女', 'name': '女1'}
]
studentsJson = '[{"gender": "男", "name": "男1"}, {"gender": "女", "name": "女1"}]'
# 反序列化
print(json.dumps(studentsDict, ensure_ascii=False))
# 序列化
print(json.loads(studentsJson))
枚举应用
from enum import Enum
class Award(Enum):
SPECIAL = '10000元'
TOP = '5000元'
SECOND = '3000元'
THIRD = '1000元'
# 读取标签
print(Award.SPECIAL.name)
# 读取标签值
print(Award.SPECIAL.value)
# 实际应用：根据值获取标签
print(Award('10000元')) 
闭包应用
如何构成？
环境变量+函数定义，闭包在重复调用的过程中，可以保存每次调用的状态，如同声明全局变量
def outer(param):
def inner(x):
# 声明环境变量非局部变量
nonlocal param
new_param = param + x
param = new_param
return param
return inner
closure = outer(1)
print('闭包函数的环境变量对象：',closure.__closure__)
print('闭包的第一个环境变量值：' , closure.__closure__[0].cell_contents)
print(closure(2)) # 1+2 = 3
print(closure(3)) # 3+3 = 6判断是否为闭包，获取闭包的环境变量值
def outer(param,param1):
def inner(x):
return x + param + param1
return inner
closure = outer(1,2)
print('闭包函数的环境变量对象：',closure.__closure__)
print('闭包的第一个环境变量值：' , closure.__closure__[0].cell_contents)
print('闭包的第二个环境变量值：' , closure.__closure__[1].cell_contents)
print(closure(2))
print(closure(3))
lambda表达式应用
python语言中的匿名函数
代码格式
# lambda paramList : express
functionV = lambda a,b,c : a+b+c
print(functionV(1,2,3))
注：
1.express部分只能是表达式
三元表达式应用（三目运算）
代码格式
# returnResult = trueResult if express else falseResult
a = 3
result = a if a == 1 else 2
print(result)
map类应用（可用于遍历）
代码格式
listX = [1,2,3,4,5,6,7,8,9]
listY = [9,2,3,4,5,6,7,8,9]
def cal(x,y):
return x * y
# 参数：第一个为被调用的函数，其他参数个数可根据方法的形参数量而定
result = map(cal,listX,listY)
print(type(result))
print(list(result))
# print(tuple(result))
注：
1.map的参数列表以第一个函数的形参个数为准；
2.map如果存在多个长度不同的参数，结果以长度最短的参数为准；
lambda和map的结合应用
paramA = [1,2,3,4,5]
paramB = [7,8,9]
result = map(lambda a,b : a * a + b,paramA,paramB)
print(result)
print(list(result))
装饰器应用
作用
类似中间件，将需要重复执行或需要提前拦截的逻辑抽离，通过符号@进行引入
代码格式
def printHello(func):
def defineOpera():
print('hello,hello,hello')
func()
return defineOpera
@printHello
def sayGood():
print('say good')
sayGood() 
异常与错误处理应用
理解
错误是可预先知道的；异常是不可预知情况发生的错误；
异常处理：直接抛出（raise）
def div(a,b):
if b == 0:
raise Exception("被除数不能为0")
return a / b
print("请输入除数")
a = int(input())
print("请输入被除数")
b = int(input())
div(a,b)
异常处理：拦截（try except）
def div(a,b):
if b == 0:
raise Exception("被除数不能为0")
return a / b
print("请输入除数")
a = int(input())
print("请输入被除数")
b = int(input())
try:
div(a,b)
except Exception as e:
print('发生错误',e)
print('发生错误的行数',e.__traceback__.tb_lineno)
错误处理（None is not）
def div(a,b):
if b == 0:
return None,"被除数不能为0"
return a / b
print("请输入除数")
a = int(input())
print("请输入被除数")
b = int(input())
# 接收调用结果并进行判断
v,err = div(a,b)
if err is not None:
print(err) 
finally的使用
作用
处理try except代码中必须要执行的逻辑操作（如关闭数据库连接）
代码结构
try:
pass
except Exception as e:
pass
finally:
pass注意点
1.代码执行顺序：try中的逻辑->finally中的逻辑->try中return数据
def testFinally():
listV = []
try:
listV = ["try逻辑段返回的结果"]
return listV
except Exception as e:
pass
finally:
listV.append("finally")
print(testFinally())
2.当finally逻辑代码块中存在return关键字，则返回的数据以finally逻辑块的数据为准，原因在于finally中的逻辑在try逻辑中return前执行
def testFinally():
string = ""
try:
string = "try逻辑段返回的数据"
return string
except Exception as e:
pass
finally:
string = "finally逻辑段返回的数据"
return string
print(testFinally())
命令行的使用
python 执行脚本的绝对路径
python .\dir\python.pypython -m 执行脚本对应的命名空间
python -m dir.python列举概念误区
文件夹的命名需要与包名区分开
在开发工程中，命名不同的文件夹时，应避免与引入的包名一致，否则测试文件引入的包将是自身，导致无法正常使用引入的包
项目中顶级包的指定
与执行文件（入口文件）同级的包目录名才是顶级包，而非执行文件的上N级目录
序列解包和链式赋值
序列解包：被赋值参数数量应该与序列的个数一致
# 赋值
pack = 1, 2, 3
pack1 = (4, 5, 6)
pack2 = [7, 8, 9]
pack3 = [10, 11, 12]
# 解包
a, b, c = pack
d, e, f = pack1
g, h, i = pack2
j, k, l = pack3
# 打印
print(type(pack), a, b, c)
print(type(pack1), d, e, f)
print(type(pack2), g, h, i)
print(type(pack3), j, k, l)
链式赋值
var1 = var2 = var3 = '值'函数与类方法的区别
1.类方法定义时需要传入self关键字
2.在类中定义方法，在模块中定义函数
3.类方法定义时必须设置关键字self（本类的实例化对象），函数按需求设置参数
如何定义参数未知个数的函数
# 随机个数参数与不同类型的参数（关键字）即可兼容
def randomParams(*args,**kw):
pass鸭子类型
概念理解
在任何类中，只要类实现了某个魔术方法，那么就可以使用魔术方法对应的特性。如for循环的使用对应__iter__
代码示例
在自定义类中实现了__iter__魔术方法
class Person(object):
def __init__(self,gender_list):
self.gender = gender_list
def __iter__(self):
return iter(self.gender)
person = Person(("male","female"))
for gen in person:
print(gen)
在自定义类中不实现__iter__魔术方法
class Person(object):
def __init__(self,gender_list):
self.gender = gender_list
person = Person(("male","female"))
for gen in person:
print(gen)
常用辅助函数
reduce函数应用
作用
函数（第一个参数）会对参数序列（第二个参数）中元素进行逻辑处理（由第一个函数的逻辑为准）
计算实例
reduce(lambda x,y: x+y, [1, 2, 3, 4, 5])
计算过程：( ( ( (1+2) + 3) + 4) + 5)
代码格式
reduce函数的第一个函数类型参数，仅有并必须有两个参数；
第三个参数是初始值，以此参数为起始进行函数运算得出最终结果；
from functools import reduce
# reduce结合lambda,在简单的运算场景下,代码更加简洁易读
listA = [2, 2, 2, 2, 2, 3]
resultA = reduce(lambda a, b: (a+b) + 10, listA)
# 无法通过简单表达式实现的场景下,通过在外部定义函数后再进行参数传入也可实现效果
def calcB(a, b):
if b == 3:
result = (a-b) + 10
else:
result = (a+b) + 10
return result
listB = [2, 2, 2, 2, 2, 3]
resultB = reduce(calcB, listB)
print(resultA)
print(resultB)
filter函数应用
作用
通过函数设置过滤条件，对序列进行过滤（函数结果True或False，True留下，False过滤）获取想要的数据
代码格式
# 获取大于10的数据
listA = [10, 11, 12, 13, 14, 15]
resultA = filter(lambda a: a > 10, listA)
print(list(resultA))
获取变量ID，判断变量是否全等
print(id(None) == id(None))
print(id("string") == id("string"))
print(id(123) == id(123))
print(id(True) == id(True))
实现函数参数自定义（预设置值）的功能（partial）：两种方式
第一种：不指定被设置函数的参数关键字，按照函数自定义的参数顺序进行值预设置
第二种：指定被设置函数的参数关键字，对指定参数进行值预设置
from functools import partial
def add(a, b, c):
return a + b + c
if __name__ == '__main__':
# 不指定参数的关键字，即默认按照函数定义的参数顺序进行设置
partial_default = partial(add, 1)
# 指定参数的关键字，即指定参数b,则只需要传入参数a的值即可获得结果
partial_keyword = partial(add, c=3)
print(add(1, 2, 3))
print(partial_default(2, 3))
print(partial_keyword(1, 2))
特别功能点
格式化输出的三种方式（推荐第3种）
name = "dongge"
age = "20"
# 第一种
print("my name is %s,my age is %s"%(name,age))
# 第二种
print("my name is {},my age is {}".format(name,age))
# 第三种(推荐)
print(f"my name is {name},my age is {age}")
f、b、u、r的作用
f：支持大括号里边的python语法
var_one = 'hello'
var_two = 'world'
print(f"输出内容：{var_one}-{var_two}")
b：定义byte类型变量
hello_str = "hello"
hello_byte = b'hello'
print(hello_str,type(hello_str))
print(hello_byte,type(hello_byte))
u：定义unicode字符串，防止中文字符串乱码，因此用来指定编码
u'这是一串带有中文的字符串，hello，world'r：屏蔽反斜杠自动转义机制
tran_str = 'hello\nworld'
no_tran_str = r'hello\nworld'
print(tran_str)
print(no_tran_str)
扫一扫
402
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
