[Python]知识点

进步·于辰

已于 2024-06-02 23:52:57 修改

阅读量1.4w

点赞数 1

分类专栏： Python知识点文章标签： Python知识点

于 2023-08-18 21:10:23 首次发布

本文链接：https://blog.csdn.net/m0_69908381/article/details/132368704

版权

Python知识点专栏收录该内容

1 篇文章 0 订阅

订阅专栏

【版权声明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权）
https://blog.csdn.net/m0_69908381/article/details/132368704
出自【进步*于辰的博客】

注：本文可能不适合 0-Python 基础的博友，因为对于各类知识点，我阐述的宗旨是“阐明使用细节”，而不是基础知识。

1、知识点扩展

细节与使用经验。

2、pip

推荐一篇博文《【Python】pip超详细教程，pip的安装与使用，解决pip下载速度慢的问题》（转发）。
参考笔记二，P51.1；笔记三，P54.1/2。

2.1 命令

暂未整理相关阐述，仅记录了我曾使用过的命令，大家可查阅推荐博文了解细节。

python 配置。

python -v 或 python --version	# 查看python版本
python3		# 进入交互模式，需配置环境变量

# 环境变量
path 指向 xx 和 xx/scripts	# xx 是 python 安装目录

pip 配置。

python -m ensurepip --default-pip		# 安装pip
pip --version	# 查看1pip版本
python -m pip install --upgrade pip		# 更新pip
python -m pip uninstall [-y] pip		# 卸载pip

pip 操作库。

pip install 库名[==版本]		# 下载库
pip install -r 文本文件		# 批量安装库

pip freeze > 路径		# 导出库信息
pip show -f 库名		# 查看库详细信息

pip search 库名		# 搜索本地库
pip list		# 查看已安装库
pip list -o		# 显示可更新库
pip install --upgrade 库名	或	pip install -U 库名		# 升级库

pip uninstall [-y] 库名		# 卸载库
pip uninstall [-y] -r 文本文件路径	# 批量卸载库

若大家不清楚命令参数的含义，可以使用pip --help/-h和pip list --help/-h查看。

2.2 提高pip下载速度

中央库在国外，自定义国内库镜像便可提高库下载速度，方法是在环境变量APPDATA指定位置，创建文件pip/pip.ini，内容示例：

[global]
timeout = 6000
index-url = http://mirrors.aliyun.com/pypi/simple/
trusted-host = mirrors.aliyun.com

相应说明请查阅推荐博文。

4、内置函数

摘要	参数说明	返回值类型/返回值	说明
`list(tuple t)`		列表	将元组转换成列表。不修改原元组
`range(int max)`	序列最大值	序列	此方法作用很多，通常指定一个最大值，返回`0 ~ max - 1`的序列，常用于遍历
`filter(a, b)`	a-方法，即过滤条件；b-序列	序列	过滤序列，需与lambda连用
`input(String tip)`	提示	`str`	键盘输入
`dir([模板名])`		列表	获取对象的模板标识符，无参时返回当前模板标识符
`max(map)`		`str`	返回最大value的key

4.1 `filter(a, b)`

参考笔记二，P34.11、P35.16。

“过滤”是指满足条件，返回 true，否则返回 false，获取满足条件的序列部分进行返回。

示例：

# 示例1
l = [e for e in filter(lambda x: x % 2 == 0, range(10))]
print(l)	# 打印：[0, 2, 4, 6, 8]
# 示例2
l = [e for e in filter(lambda x: x % 2, range(10))]
print(l)	# 打印：[1, 3, 5, 7, 9]

示例中的x % 2 == 0和x % 2就是具体的“过滤条件”，满足条件就会将当前元素作为filter()的返回值。

$\color{grey}{为什么示例2的打印结果是}$ [1, 3, 5, 7, 9] $？$
当然从从表面上看，x % 2并不是一个判定条件，大家注意它的返回值，x % 2的返回值莫过于0和1两种，这就对应 flase 和 true ，所以本质上讲x % 2也是一个判定条件。

5、列表 list

参考笔记二，P25.3~5。

5.1 切片示例

例：list = [1, 2, 3, 4]，则list[-3:] = [2, 3, 4]、list[:3] = [1, 2, 3]，故：list[-3: 3] = [2, 3]。由于[2, 3] = [2, 3, 4] & [1, 2, 3]，因此，list[-3: 3] = list[-3:] 并 list[:3]；
例；list[a: b: x]，其中，a 是起始索引，b 是终止索引，x 是步长。若x > 0，则从左往右切片，否则从右往左切片。

注：实际切片内容并不一定是按照[a, b)（即 a → b）或(b, a]（即 b → a）规则进行切片。由于a/b/x三者都有“正负”两种情形，因此实际的切片情况很多，我暂且没有找到规律，因此只能按照示例1的“拆分”方法进行分析。

具体方法：

1、将 [a: b: x] 拆分d成 [a::x] 和 [:b:x]

2、计算[a::x]
a 为起始索引，若x > 0，则向右取所有；否则，向左取所有。得到：[list[a],...]

3、计算[: b: x]
b 为终止索引，同理，得到：[...,list[b]]

4、结果取两者交集

有点抽象，具体情况需要大家自行测试。

5.2 方法

摘要	返回值类型/返回值	说明
`append(Object o)`		追加一个元素
`extend(List it)`		追加列表
`insert(int i, Object o)`		插入元素
`pop(int i)`	返回被删除元素	删除元素。若不指定，则删除最后一个元素
`remove(Object o)`		移除匹配的第一个元素
`index(Object o)`	索引	查找匹配的第一个元素。找不到报错
`reverse()`		反转列表。相当于`list[::-1]`
`count(Object o)`	int	计数
`sort()`		排序。默认升序，列表所有元素类型必须一致

注：

列表元素类型可混搭；
切片时，索引超出范围不报错。

6、元组 tuple

参考笔记二，P33.1。

说明：

元组自创建后无法修改；
若元组只有一个元素，则末尾必须添加一个","，否则其类型就不是元组，而是此元素类型；
元组无法修改，但支持列表拥有的基本查询系列方法，如：count()、index()，故元组的查询效率高于列表（元组的作用之一）。

示例：

t = (2023)
print(type(t))		# <class 'int'>
t = (2023,)
print(type(t))		# <class 'tuple'>
print(t.count(2023))	# 1
print(t.index(2023))	# 0

7、字典 map

参考笔记二，P33.2。

7.1 说明

添加映射时，若 key 已存在，则覆盖 value；
用“{}”表示空字典；
访问不存在的 key 报错；
当为不存在的 key 赋值时，添加此映射；

示例：

m = {
    "name" : 'yuchen'
}
print(m['year']) 	# 报错：KeyError
m['year'] = 2023
print(m)	# {'name': 'yuchen', 'year': 2023}

7.2 方法

摘要	参数说明	说明
`clear()`		清空字典
`copy()`		复制字典（浅复制）
`fromkeys(a, b)`	a-序列，b-默认值	创建字典。b可不指定
`get(a, b)`	a-key，b-默认值	获取value。b可不指定，若key不存在，则返回`None`
`keys()`		返回包含所有key的列表（看似列表，用`type()`即可验证）。常用于判断字典是否包含某个 key
`values()`		返回包含所有value的列表
`items()`		类似Java中的`map.entrySet()`，常用宇遍历字典

7.2.1 `fromkeys(a, b)`

m = {}  # 空字典

l = [2, 0, 2, 3]
m = m.fromkeys(l)   # 使用列表构建字典
print(m)    # {2: None, 0: None, 3: None}
m = m.fromkeys(l, 0)
print(m)    # {2: 0, 0: 0, 3: 0}

t = (2023,)
m = m.fromkeys(t)
print(m)    # {2023: None}

s = set([2, 0, 2, 3])
m = m.fromkeys(s)
print(m)    # {0: None, 2: None, 3: None}

8、集合 set

参考笔记二，P33.3。

8.1 说明

无重复值；
定义集合必须通过set(序列)；
集合构造可以使用任意序列；
集合不能使用“*”或“连接”；
集合常用宇数字意义上的集合操作，如：交集&、并集|、对称差集^，列表则不行。

示例：

s = {}
print(type(s))
s = set()
print(s)
print(type(s))

s1 = set((2, 0, 2, 3))
print(s1)
s2 = set(['c', 's', 'd', 'n'])
print(s2)

s3 = s1 & s2    # 返回两集合相同元素的集合
print(s3)
s3 = s1 | s2    # 返回两集合所有元素合集（若有相同元素，仅保留一个）
print(s3)
s3 = s1 - s2    # 等同于 s1 - (s1 & s2)，即：返回s1去除s1与s2相同元素后的集合
print(s3)
s3 = s1 ^ s2    # 等同于 (s1 - s2) | (s2 - s1)
print(s3)

打印结果：
在这里插入图片描述

8.2 方法

摘要	参数说明	返回值类型/返回值	说明
`add(Object o)`			追加元素
`remove(Object o)`			移除元素。若元素不存在，报错

9、关于变量

参考笔记二，P34.8。

9.1 分类

必须参数：指方法调用时必须指定的参数；（其实就如 java 中的实参，要求个数、类型对应）
关键字参数：指方法调用时通过形参名=值的方式指定实参，故可忽略实参顺序；
默认参数：指方法定义时已指定默认值的参数，且必须定义在最后；（调用时可不指定）
可变参数：指不能在定义方法时确认参数的个数和内容（类型）所使用的参数；
组合参数。

9.2 可变参数

9.2.1 `*args`格式

接收“序列”（列表、元组、集合），相当于Java中的可变参数，args的类型是tuple。

示例：

def show(*args):
    for e in args:
        print(e)

# 如 java 中的”xx...“，会将一组数自动封装成数组，在此处是序列
show(2023, 'csdn')

# java 中的可变参数也可这样定义实参，不过不允许直接这样初始化（也有点多此一举）
# 而在此处，尽管 [2023, 'csdn'] 是一个序列，但 args 仅将其视为一个元素，因此无法遍历（直接打印出“[2023, 'csdn']”）
show([2023, 'csdn'])

# (2023, ), ('csdn',)是两个元组，最后，args 会封装成 ((2023, ), ('csdn',))
show((2023, ), ('csdn',))

打印结果：
在这里插入图片描述
改进：（为调用show([2023, 'csdn'])时，能遍历其内元素）

def show(*args):
    for e in args:
        if isinstance(e, list):
            for i in e:
                print(i)
        else:
            print(e)

打印结果：
在这里插入图片描述

9.2.2 `**args`格式

表示“字典”（固定），实参必须是关键字参数（也可是字典，但需要使用**标识）。

示例：

def show(**args):
    # 因为 args 固定为字典，因此可调用成员方法 items()
    for k,v in args.items():
        print(k, v)

show(year=2023, flag='csdn')

打印结果：
在这里插入图片描述

9.2.3 特殊用法

（我暂不知如何陈述，看示例）

1、上述*args的示例也可这样改：

l = [2023, 'csdn']
show(*l)
# 或：
show(*range(10))

即指明其是一个列表，这样*args就不会将其视为一个元素。

$\color{red}{总结}$ ：若实参是一组数，如：1, 2, 3，则*args可将其封装成元组；若实参为序列，如：{1, 2, 3}、range(10)，则*args会将其视为一个元素或报错（此时就需采用此特殊用法）。

2、**args的实参可使用字典，上述**args的示例可这样改：

m = {
    'year': 2023,
    'flag': "csdn"
}
show(**m)

即指明其是一个字典。

$\color{red}{补充：}$ 若*args与**args连用，也可使用此特殊用法进行指定。不过，顺序不可调换，使用关键字参数也不行。

10、Lambda表达式

参考笔记二，P34.10。

10.1 特点

lambda 语句块只会执行一次，不存在被外部程序反复调用可能；
在某些函数必须使用函数作为参数，但是函数本身十分简单且只有一处使用。

10.2 示例

简化函数。

def calculate(x, y):
    return x + y, x - y

t = calculate(10, 20)

lambda改进：

f = lambda x, y: [x + y, x - y]	# 相当于方法定义
print(type(f))	# 打印：<class 'function'>
t = f(10, 20)

（冒号）:左边是参数列表，右边是返回值。

11、面向对象

参考笔记二，P35.13、P36.1。

（注：以下阐述都基于类）

1、构造方法__init__(self)的返回值必须是None，即无返回值。（指无返回值，并不是说需要手动指定return None）

2、所有方法（除了静态方法、类方法）的第1个参数默认为self，代指实例，可自定义名。

3、在所有方法中，由self定义的变量都是成员变量；而直接定义的变量不是成员变量，仅是局部变量，其生命周期仅在函数内，在方法外定义的变量是类变量。
示例：

# 此示例中的3个 name 是3个变量，即3个定义，没有重赋值
class Platform:
    name = 'csdn'   # 定义类变量
    def __init__(self, name):
        self.name = 'bilibili'  # 定义成员变量
        self.name = name    # 为成员变量 name 重赋值

        # 这不是为类变量/成员变量 name 重赋值，而是定义局部变量
        # 因此在此示例中，在类外无法访问
        name = '博客园'

print(Platform.name)    # 访问类变量，打印：csdn

# 实例化。实例化时，由于仅定义了一个带有一个参数的构造方法，因此需要指定一个实参
p1 = Platform("开源中国")
print(p1.name)  # 访问成员变量，打印：开源中国

4、在变量前加__（双下划线）表示私有变量。在 java 中，私有成员变量的作用域为当前类，而 python 中私有实例变量（即成员变量）的作用域为所有方法（因为第2点）。
示例：

class Platform:
    def __init__(self, name):
        self.__name = name

    def getName(self):
        return self.__name

p1 = Platform('csdn')
print(p1.getName()) # 打印：csdn

5、在方法前加__表示私有方法，私有方法只能在类内部调用，实例不能直接调用。（此性质与Java相同）
示例：

class Platform:
    def __init__(self, name):
        self.__name = name

    def __getName(self):
        return self.__name

    def toString(self):
        print('name = ' + self.__getName())

p1 = Platform('csdn')
p1.toString()   # 打印：name = csdn

6、实例无法修改类变量，若修改（赋值），则其实是创建一个同名的成员变量。
示例：

class Platform:
    name = 'csdn'
    def getName(self):
        return self.name

p1 = Platform()
print(Platform.name)    # 打印：csdn
print(p1.name)    # 打印：csdn
r = p1.getName()
print(r)    # 打印：csdn
# 从打印结果可看出，访问顺序是：成员变量 → 类变量

p1.name = 'bilibili'
print(Platform.name)    # 打印：csdn
print(p1.name)    # 打印：bilibili
r = p1.getName()
print(r)    # 打印：bilibili
# 从打印结果可以看出，p1.name 不是访问类变量 name，而是定义成员变量 name

7、在类内，修改类变量的方法只有3种：1、重新定义；2、通过类名调用；3、在类方法内通过cls调用，因此总结第6点。

8、静态方法的定义是在def前添加@staticmethod，其作用是用于存放逻辑性代码，这些逻辑和类本身没有实际性的交互，即不涉及方法和属性的操作；静态方法不绑定类也不绑定实例，相当于给方法添加了一个前缀。（暂不知静态方法具体的作用，其调用方式与类方法相同）

9、类方法的定义是在def前添加@classmethod，第1个参数默认为cls，代指类本身，可自定义名。
示例：

class Platform:
    name = 'csdn'

    @classmethod
    def setName(cls, name):
        cls.name = name

print(Platform.name)    # 打印：csdn

Platform.setName('bilibili')
print(Platform.name)    # 打印：bilibili

12、异常处理

参考笔记二，P36.4/5。

示例：

class DigiProcess:
    def checkZero1(self, n):
        try:
            x = n / 0
        except Exception as e:
            print(e)
        finally:
            print("error")

    def checkZero2(self, n):
        try:
            x = n / 0
        except Exception as e:
            raise Exception("divide zero")

d = DigiProcess()

d.checkZero1(2023)

try:
    d.checkZero2(2023)
except Exception as e:
    print(e)

打印结果：
在这里插入图片描述

13、模块

13.1 介绍

参考笔记二，P36.6/7。

“模块”指可反复使用（调用）的源代码文件。

导入：

1、import 文件名
2、from 文件名 import xx

xx 是代码块名，如：方法名、类名。

示例：（以第11项的示例作为模块，其全限定名是test.T1。此示例在另一个文件中）

from test.T1 import DigiProcess

d = DigiProcess()
d.checkZero1(2023)

可用__name__测试。_-name__表示当前模块名。如果与当前文件名相同，说明是被导入模块；如果结果是__main__，说明是当前运行文件。

13.2 标准库

参考笔记二，P37.1、P42.3、P51.2。

13.2.1 sys库

sys.platform	# 识别操作系统
sys.argv	# 获取命令行参数

# x 是可选参数，此参数会成为返回值，用于捕获 sys.exit() 的调用情况，
# 0-正常退出，其他为异常
sys.exit(x)		# 退出程序

# 所谓模块搜索路径，即导入模块（import）时，搜索模块的位置与顺序
# 返回一个列表，故可自行添加搜索路径
sys.path	# 获取模块搜索路径

# 在首次运行时，会将模块信息导入其中，
# 再次启动时从中获取模块信息，以加快运行速度
sys.modules 	# 获取模块“缓存”（字典）

sys.argv用于获取命令行参数，命令行参数的指定可参考【细节、经验】的第4.2项。

模板搜索顺序：

当前目录；
shell 变量pythonpath对应目录；
默认目录（项目目录）。

13.2.2 os库

os.path.dirname(__file__)	# 获取文件目录，__file__ 是当前文件的绝对路径

os.getCwd()	# 获取当前路径
os.chdir(str)	# 切换当前路径

os.rename(a, b)		# 重命名文件，a、b 是文件绝对路径
os.path.exists()	# 判断文件/目录是否存在
os.path.isfile()	# 判断是否是文件
os.path.isdir()		# 判断是否是目录
os.environ		# 获取系统环境变量
os.mkdir()		# 创建单层目录
os.makedirs()	# 创建多层目录

13.2.3 math库

# 常数
math.pi		# 圆周率
math.e		# 自然常数

# 运算函数
math.ceil(number)	# 向上取整
math.floor(number)	# 向下取整
math.pow(number, number)	# 指数运算
math.log(对数, [底数])	# 对数计算，底数默认为 e
math.sqrt(number)	# 平方根

# 三角函数：与Java中相同

# 角度与弧度换算
math.degrees(number)	# 弧度 → 角度
math.radians(number)	# 角度 → 弧度

此库中的很多函数与Math类中的很多方法相似/相同。

13.2.4 random库

random.random()		# 生成 0 ~ 1 一个浮点数
random.uniform(min, max)	# 生成一个指定范围的浮点数
random.randint(min, max)	# 生成一个指定范围的整数
random.choice(序列)		# 获取序列一个元素
random.shuffle(list)	# 打乱列表

15、关于创建实例

参考笔记二，P42.1。

__new__(cls)是静态方法，就底层而言，其实它才是创建实例的方法，即构造方法。而__init__(self)的作用仅是为实例进行初始化，即为属性赋值。故前者在后者之前被调用，只有当前者返回cls实例时，后者才会被调用。

因此，底层创建实例的过程是：将__new__(cls)创建后返回的实例cls传入__init__(self)进行初始化。

若想测试此过程，可重写这2个方法：

class Platform:
    def __new__(cls, *args, **kwargs):
        print(cls)
        return cls

    def __init__(self):
        print(self)

c1 = Platform() # 打印：<class '__main__.Platform'>
c1.__init__(c1) # 打印：<class '__main__.Platform'>

当调用Platform()实例化时，底层调用了__new__()，返回实例cls，然后手动传入__init__()进行初始化。（当然这个示例的证明效力有点不够，大家对这个知识点先有个了解就行）

17、名字空间

参考笔记二，P51.3。

名字空间的类型是字典，用于记录变量的轨迹，key是变量名，value是变量值。

局部名字空间特指当前函数或类的方法，记录了参数和局部变量；
全局名字空间特指当前模块，记录了函数、类、引入模块、模块级变量（指在类外定义的变量）和常量；
内置命名空间，记录了内置函数和异常，对任何模块都是全局的。

在运行时可直接访问名字空间，示例：

locals()		# 返回内置本地变量，包括自定义变量
globals()	# 返回模块级变量
# 这2个函数都是内置函数

变量访问顺序：局部 → 全局 → 内置。

最后

本文中的例子是为了方便大家理解、以及阐述相关知识点而简单举出的，不一定有实用性，仅是抛砖引玉，

比如：集合运算&，返回两集合的相同元素，而第8.1项的示例中我没有刻意去定义s1、s2包含相同元素。之所以如此：

这些细节很简单，大家在其他编程语言或课程、书本或资料上肯定或多或少接触过或完全知道，因此没必要特意举例；
本文阐述的宗旨是“阐明使用细节”，而对于其他附属知识并不一定会细致说明。

因此，一些细节需要大家自行测试或查找资料。

$\color{red}{PS}$ ：推荐一个Python专业的个人博客《python 100》（转发）。

本文持续更新中。。。

进步·于辰

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
3
评论
[Python]知识点

这篇文章是关于Python各类知识点的小结，包括：特殊标识符、特殊方法、list等。望对大家有帮助！如果文中阐述不全或不对的，多多交流。
复制链接

扫一扫

专栏目录

[Python]知识点

文章目录

1、知识点扩展

2、pip

2.1 命令

2.2 提高pip下载速度

4、内置函数

4.1 filter(a, b)

5、列表 list

5.1 切片示例

5.2 方法

6、元组 tuple

7、字典 map

7.1 说明

7.2 方法

7.2.1 fromkeys(a, b)

8、集合 set

8.1 说明

8.2 方法

9、关于变量

9.1 分类

9.2 可变参数

9.2.1 *args格式

9.2.2 **args格式

9.2.3 特殊用法

10、Lambda表达式

10.1 特点

10.2 示例

11、面向对象

12、异常处理

13、模块

13.1 介绍

13.2 标准库

13.2.1 sys库

13.2.2 os库

13.2.3 math库

13.2.4 random库

15、关于创建实例

17、名字空间

最后

“相关推荐”对你有帮助么？

4.1 `filter(a, b)`

7.2.1 `fromkeys(a, b)`

9.2.1 `*args`格式

9.2.2 `**args`格式