【python知识点】锦集

这篇具有很好参考价值的文章主要介绍了【python知识点】锦集。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

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

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

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/-hpip 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 == 0x % 2就是具体的“过滤条件”,满足条件就会将当前元素作为filter()的返回值。

为什么示例 2 的打印结果是 \color{grey}{为什么示例2的打印结果是} 为什么示例2的打印结果是[1, 3, 5, 7, 9] ? ?
当然从从表面上看,x % 2并不是一个判定条件,大家注意它的返回值,x % 2的返回值莫过于01两种,这就对应 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)

打印结果:
【python知识点】锦集,python知识点,python知识点

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',))

打印结果:
【python知识点】锦集,python知识点,python知识点
改进:(为调用show([2023, 'csdn'])时,能遍历其内元素)

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

打印结果:
【python知识点】锦集,python知识点,python知识点

9.2.2 **args格式

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

示例:

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

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

打印结果:
【python知识点】锦集,python知识点,python知识点

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 特点

  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)

打印结果:
【python知识点】锦集,python知识点,python知识点

13、模块

13.1 概述

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

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

导入:

1import 文件名
2from 文件名 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项的示例中我没有刻意去定义s1s2包含相同元素。之所以如此:

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

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

P S : \color{red}{PS:} PS
推荐一个Python专业的个人博客《python 100》(转发)。

本文持续更新中。。。文章来源地址https://www.toymoban.com/news/detail-658838.html

到了这里,关于【python知识点】锦集的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Python小姿势 - 知识点:

    知识点: Python的字符串格式化 标题: Python字符串格式化实例解析 顺便介绍一下我的另一篇专栏, 《100天精通Python - 快速入门到黑科技》专栏 ,是由 CSDN 内容合伙人丨全站排名 Top 4 的硬核博主 不吃西红柿 倾力打造。 基础知识篇以理论知识为主 ,旨在帮助没有语言基础的

    2024年02月01日
    浏览(49)
  • Python知识点(史上最全)

    Python期末考试知识点(史上最全) python简介 type()不会认为子类是一种父类类型。 isinstance()会认为子类是一种父类类型 基础语法 运算符: 算术运算符: 多了一个**,代表 幂方 5**5 就是5的5次方 还多了一个 // 整数除法 逻辑运算符: and,or,not 与,或,非 赋值运算符: 没有+

    2024年02月02日
    浏览(41)
  • Python知识点大全(非常详细)

    1、Python的两种编程⽅式:交互式(随输随运⾏)和⽂件式(主要⽅式;批量运⾏出结果) 2、⼀切皆对象,每个对象由标识(id())、类型(type())和值(print())标识。 3、Python采⽤ 基于值的内存管理 ,不同变量赋值为同⼀个值,ID⼀样,但是只适⽤范围在-5⾄256的整数和短字

    2024年02月09日
    浏览(48)
  • python学习知识点备忘(二)

    1.数字类型         Python 有三种不同的数字类型,分别是: 1.1.整数      整数长度是不受限制的,也就是说它是有无限大的精度。         二进制、八进制 、十进制、十六进制 1.2浮点数   数学意义上的小数在编程里叫浮点数         浮点数在计算机中的存储是存

    2024年02月11日
    浏览(42)
  • Python小姿势 - # Python相关技术知识点

    Python相关技术知识点 标题 在Python中如何处理文件 如果你要处理文件,那么在Python中你需要使用到os模块中的一些方法。 首先,你需要使用os.path.exists方法来判断文件是否存在: ```python if os.path.exists(\\\'file.txt\\\'): print(\\\'文件存在\\\') else: print(\\\'文件不存在\\\') ``` 如果你要创建一个文件

    2024年02月04日
    浏览(43)
  • Python基础知识点-- if 语句

           此文章为Python基础知识点(从入门到实践)--  if 语句,此节Python基础知识点包括:条件测试、if 语句、使用if 语句处理列表、设置 if 语句格式。  目录 一、条件测试 1.1 检查是否相等 1.2 检查是否相等时区分大小写 1.3 检查是否不相等 1.4 数值比较 1.5 检查多个条件

    2024年02月06日
    浏览(44)
  • python常用的函数和知识点

    三元运算符是 if-else 语句的简写。语法是value_if_true if condition else value_if_false。三元运算符是一行代码,可以替代多行 if-else 语句,使你的代码更加简洁。 上面的代码通过检查“a”是否大于“b”,如果为真则返回“a”,如果为假则返回“b”。 enumerate()函数向可迭代对象添加

    2024年02月13日
    浏览(42)
  • python爬虫之selenium知识点记录

    1、概述 selenium本身是一个自动化测试工具。它可以让python代码调用浏览器。并获取到浏览器中加载的各种资源。 我们可以利用selenium提供的各项功能。 帮助我们完成数据的抓取。 2、学习目标 掌握 selenium发送请求,加载网页的方法 掌握 selenium简单的元素定位的方法 掌握 s

    2024年03月09日
    浏览(40)
  • Python之字典(dict)基础知识点

    字典是python当中的一种数据类型,其结果跟之前学过的列表、元组有很大区别,字典内部是一个一对一映射的数据关系。 字典语法: dictionary = {key1:value1, key2:value2, ...} key是字典中的键,value是对应的值 字典必须用大括号{},key与对应的value用“:”连接,中间用“,”断开。

    2024年02月13日
    浏览(44)
  • 【知识点】python中类的相互调用

    在 Python 中,类可以相互调用。这意味着一个类可以访问另一个类的方法或属性。下面是几个例子: 在同一个文件内,不同类的相互调用例子如下: 代码 在上面的代码中, Dealership 类调用了 Car 类。它通过创建一个 Car 对象来添加汽车,并通过循环遍历汽车列表来显示汽车的

    2023年04月10日
    浏览(36)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包