[Python]知识点

【版权声明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权）
https://www.cnblogs.com/cnb-yuchen/p/18031984
出自【进步*于辰的博客】

注：本文可能不适合 0-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、名字空间
• 最后

1、知识点扩展

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()的返回值。

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

5、列表 list

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

5.1 切片示例

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]；
2. 例；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()			排序。默认升序，列表所有元素类型必须一致

注：

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

6、元组 tuple

参考笔记二，P33.1。

说明：

1. 元组自创建后无法修改；
2. 若元组只有一个元素，则末尾必须添加一个","，否则其类型就不是元组，而是此元素类型；
3. 元组无法修改，但支持列表拥有的基本查询系列方法，如：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 说明

1. 添加映射时，若 key 已存在，则覆盖 value；
2. 用“{}”表示空字典；
3. 访问不存在的 key 报错；
4. 当为不存在的 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 说明

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

示例：

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 分类

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

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就不会将其视为一个元素。

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

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

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

即指明其是一个字典。

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

10、Lambda表达式

参考笔记二，P34.10。

10.1 特点

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

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项。

模板搜索顺序：

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

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是变量值。

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

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

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

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

最后

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

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

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

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

PS：推荐一个Python专业的个人博客《python 100》（转发）。

本文持续更新中。。。