【版权声明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权)
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()
的返回值。
为什么示例
2
的打印结果是
\color{grey}{为什么示例2的打印结果是}
为什么示例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
包含相同元素。之所以如此:
- 这些细节很简单,大家在其他编程语言或课程、书本或资料上肯定或多或少接触过或完全知道,因此没必要特意举例;
- 本文阐述的宗旨是“阐明使用细节”,而对于其他附属知识并不一定会细致说明。
因此,一些细节需要大家自行测试或查找资料。
P
S
:
\color{red}{PS:}
PS:
推荐一个Python专业的个人博客《python 100》(转发)。文章来源:https://www.toymoban.com/news/detail-658838.html
本文持续更新中。。。文章来源地址https://www.toymoban.com/news/detail-658838.html
到了这里,关于【python知识点】锦集的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!