开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Python知识库 -> 【Python】Python知识点小记 -> 正文阅读

[Python知识库]【Python】Python知识点小记

web框架

1.Django

2.Flask

刷题

Python OJ

IDE?

pycharm：?https://www.jetbrains.com/zh-cn/pycharm/download/#section=windows

虚拟环境的使用

virtualenvwrapper

windows版本

# 安装命令
pip install virtualenvwrapper-win
# 生成隔离环境 -p：指定虚拟环境的python版本 dir：实际安装python.exe的路径 python_env_name：虚拟环境的名称
mkvirtualenv -p dir/python.exe python_env_name
# 删除隔离环境
rmvirtualenv python_env_name

windows版本--修改默认项目存放位置（C:\Users\...\Envs）

增加系统变量（WORKON_HOME）：通过计算机->右键选择属性->高级系统设置->环境变量->增加系统变量->填写键值->手动创建指定的目录

打开CMD窗口进行测试：1.在目录中建立测试目录；2.输入workon，出现测试目录则表示设置成功

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.py

python -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函数的第一个函数类型参数，仅有并必须有两个参数；

第三个参数是初始值，以此参数为起始进行函数运算得出最终结果；

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}")