Python学习笔记

Python

​ Python 是一门易于学习、功能强大的编程语言。它提供了高效的高级数据结构，还能简单有效地面向对象编程。Python 优雅的语法和动态类型以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的理想语言。

​ 本文基于Python3 版本学习。

交互模式

在命令行写入 python 即可进入交互模式；

使用 exit() 退出。

基础语法

行和缩进

​ 学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。

缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。

以下实例缩进为四个空格:

if True:
    print ("True")
else:
    print ("False")

以下代码将会执行错误：

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
    # 没有严格缩进，在执行时会报错
  print ("False")

多行语句

Python语句中一般以新行作为语句的结束符。

但是我们可以使用斜杠（ \）将一行的语句分为多行显示，如下所示：

total = item_one + \
        item_two + \
        item_three

语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例：

days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

引号

Python 可以使用引号( ‘ )、双引号( “ )、三引号( ‘’’ 或 “”” ) 来表示字符串，引号的开始与结束必须是相同类型的。

其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""

注释

python中单行注释采用 # 开头。

多行注释使用三个单引号 ''' 或三个双引号 **"""**。

# 第一个注释
print ("Hello, Python!")  # 第二个注释

'''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''

"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""

代码块

缩进相同的一组语句构成一个代码块，我们称之代码组。

像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)。

如下实例：

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 **end=””**：

x="a"
y="b"
# 换行输出
print( x )
print( y )
 
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

以上实例执行结果为：

a
b
---------
a b a b

条件判断

def testIf():
    var1  = 0
    var2 = 20
    if var1 :
        print("var1 表示式为True：", var1)
    if var2 :
        print("var2 表示式为True：", var2)
    # 
    if 1==2:
        print("1==2")
    elif 2==2:
        print("2==2")
    else:
        print("else")
    #
    if 1==1:
        print("1==1")
    elif 2==2:
        print("2==2")

循环

Python 提供了 for 循环和 while 循环（Python 中没有 do..while 循环）:

在循环内控制的语句有 break 、continue。

def testLoop():
    list1 = [1, 2, 3, 4, 5]
    # for循环
    for i in list1:
        print(i)
    for i in range(0, 10):
        print(i)     # 打印0 - 9 
    # while 循环
    a = 1
    while a < 10:
        print(a)
        a += 2

导入模块

在 python 用 import 或者 from…import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： from somemodule import *

导入 sys 模块

import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:
    print (i)
print ('\n python 路径为',sys.path)

导入 sys 模块的 argv,path 成员

from sys import argv,path  #  导入特定的成员
 
print('================python from import===================================')
print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path

数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的”类型”是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串

print (counter)
print (miles)
print (name)

Python 3 中有六个标准的数据类型：

  • Numbers（数字）
  • String（字符串）
  • Tuple（元组）
  • List（列表）
  • Dictionaries（字典）
  • Sets（集合）

Python3 的六个标准数据类型中：

  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

此外还有一些高级的数据类型，如: 字节数组类型(bytes)。

数值 Number

Python 3 数值类型包含： int（整型）、float（浮点型）、bool（布尔型）、complex（复数）。

数值类型的赋值和计算都是很直观的，就像大多数语言一样。内置的 type() 函数可以用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))

<class 'int'><class 'float'><class 'bool'><class 'complex'>

此外还可以用isinstance来判断：

>>>a=111
>>>isinstance(a,int)
True
>>>

isinstance和type的区别在于：

  • type（）不会认为子类是一种父类类型。
  • isinstance（）会认为子类是一种父类类型。

数值运算

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余 
2
>>> 2 ** 5 # 乘方
32

bool（布尔类型）

布尔类型即 True 或 False。

在 Python 中，True 和 False 都是关键字，表示布尔值。

注意：

Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型。

>>> issubclass(bool, int) 
True
>>> True==1
True
>>> False==0
True
>>> True+1
2
>>> False+1
1
>>> 1 is True
False
>>> 0 is False
False

字符串 String

Python中的字符串用单引号 ' 或双引号 "括起来，使用反斜杠 \ 转义特殊字符。

字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号 + 是字符串的连接符， 星号 ***** 表示复制当前字符串，与之结合的数字为复制的次数。实例如下：

str = 'Runoob'  # 定义一个字符串变量

print(str)           # 打印整个字符串
print(str[0:-1])     # 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符）
print(str[0])        # 打印字符串的第一个字符
print(str[2:5])      # 打印字符串第三到第五个字符（包含第五个字符）
print(str[2:])       # 打印字符串从第三个字符开始到末尾
print(str * 2)       # 打印字符串两次
print(str + "TEST")  # 打印字符串和"TEST"拼接在一起

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = ‘m’ 会导致错误。

小结：

  • 反斜杠\可以用来转义，使用r可以让反斜杠不发生转义。
  • 字符串可以用+运算符连接在一起，用*运算符重复。
  • Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
  • Python中的字符串不能改变。

列表 List

​ List（列表） 是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

​ 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。列表截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，**-1** 为从末尾的开始位置。

t = ['a','b','c','d','e']

#索引：0   1   2   3    4   索引从前往后递增，从0开始；
#索引：-5  -4  -3  -2  -1   索引从后往前递减，从-1开始；

示例：

>>> t[1:3]
['a','b']

>>> t[3:]
['d','e']

>>> t[:4]
['a','b','c','d']

>>> t[:]
['a','b','c','d','e']

List 内置了有很多方法，例如 append()、pop() 等等，这在后面会讲到。

元组 Tuple

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：

tup = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

print (tup)             # 输出完整元组
print (tup[0])          # 输出元组的第一个元素
print (tup[1:3])        # 输出从第二个元素开始到第三个元素
print (tup[2:])         # 输出从第三个元素开始的所有元素
print (tup + tinytuple) # 连接元组

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。

其实，可以把字符串看作一种特殊的元组。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

如果你想创建只有一个元素的元组，需要注意在元素后面添加一个逗号，以区分它是一个元组而不是一个普通的值，这是因为在没有逗号的情况下，Python会将括号解释为数学运算中的括号，而不是元组的表示。

小结：

  • 与字符串一样，元组的元素不能修改。
  • 元组也可以被索引和切片，方法一样。
  • 注意构造包含 0 或 1 个元素的元组的特殊语法规则。
  • 元组也可以使用 + 操作符进行拼接。

字典 Dict

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用大括号{}表示：代表dict字典数据类型，字典是由键对值组组成。冒号’:’分开键和值，逗号’,’隔开组。

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
 
print(dict['one'])          # 输出键为'one' 的值
print(dict[2])              # 输出键为 2 的值
print(tinydict)             # 输出完整的字典
print(tinydict.keys())      # 输出所有键
print(tinydict.values())    # 输出所有值

集合 Set

​ Python 中的集合（Set）是一种无序、可变的数据类型，用于存储唯一的元素。集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

​ 在 Python 中，集合使用大括号 {} 表示，元素之间用逗号 , 分隔。另外，也可以使用 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是 **{ }**，因为 { } 是用来创建一个空字典。

两种创建语法：

parame = {value01,value02,...}
或者
set(value)

注意：创建一个空集合必须用 set() 而不是 **{ }**，因为 { } 是用来创建一个空字典。

set函数

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。set 语法：

class set([iterable])

参数说明：iterable – 可迭代对象对象；

示例：

set1 = {1, 2, 3, 4}            # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7])      # 使用 set() 函数从列表创建集合
# 更多示例
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

集合基本操作

集合内置方法完整列表

方法 描述
add() 为集合添加元素
clear() 移除集合中的所有元素
copy() 拷贝一个集合
difference() 返回多个集合的差集
difference_update() 移除集合中的元素，该元素在指定的集合也存在。
discard() 删除集合中指定的元素
intersection() 返回集合的交集
intersection_update() 返回集合的交集。
isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset() 判断指定集合是否为该方法参数集合的子集。
issuperset() 判断该方法的参数集合是否为指定集合的子集
pop() 随机移除元素
remove() 移除指定元素,如果元素不存在，则会发生错误。
symmetric_difference() 返回两个集合中不重复的元素集合。
symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union() 返回两个集合的并集
update() 给集合添加元素
len() 计算集合元素个数 
s = set(("Google", "Runoob", "Taobao"))

s.add("Facebook")  # 添加元素
len(s)     # 计算集合元素个数
s.remove("Taobao")    # 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误
s.discard("Taobao")   # 将元素 x 从集合 s 中移除，如果元素不存在，不会发生错误。
s.pop()   # 随机删除集合中的一个元素
x in s  # 判断元素是否在集合中存在
s.clear()   # 清空集合

集合运算

>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}

>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

数据类型转换

以下几个内置函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数 描述
int(x [,base]) 将x转换为一个整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

示例：

int() 方法参数

  • x ：字符串或数字。
  • base ： 进制数，默认十进制。
>>>int()               # 不传入参数时，得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12',16)        # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18

bytes 类型

​ 在 Python3 中，bytes 类型表示的是不可变的二进制序列（byte sequence）。与字符串类型不同的是，bytes 类型中的元素是整数值（0 到 255 之间的整数），而不是 Unicode 字符。

​ bytes 类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件等等。在网络编程中，也经常使用 bytes 类型来传输二进制数据。

​ 创建 bytes 对象的方式有多种，最常见的方式是使用 b 前缀：此外，也可以使用 bytes() 函数将其他类型的对象转换为 bytes 类型。bytes() 函数的第一个参数是要转换的对象，第二个参数是编码方式

x = b"hello"
y = bytes("hello", encoding="utf-8")
print(x)
print(y==x)   # True

​ 与字符串类型类似，bytes 类型也支持许多操作和方法，如切片、拼接、查找、替换等等。同时，由于 bytes 类型是不可变的，因此在进行修改操作时需要创建一个新的 bytes 对象。

函数

自定义函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

  • 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号**()**。
  • 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  • 函数内容以冒号起始，并且缩进。
  • return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法

def 函数名（参数列表）:
    函数体

以下是调用函数时可使用的正式参数类型：

  • 必需参数
  • 不定长参数
  • 默认参数
  • 关键字参数

必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：

def printme( str ):
   print (str)

# 调用 printme 函数，不加参数会报错
printme()

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数。加了星号（*）的变量名会存放所有未命名的变量参数。不定长参数实例如下：

def printinfo( arg1, *vartuple ):
   print (arg1)
   print (vartuple)
 
# 调用函数: 不定长参数
printinfo( 70, 60, 50 )

默认参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

def printinfo( name, age = 35 ): 
   print ("名字: ", name)
   print ("年龄: ", age)
 
#调用函数：默认参数
printinfo("runoob" )
printinfo("runoob",99 )

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

def printinfo( name, age ): 
   print ("名字: ", name)
   print ("年龄: ", age) 
    
#调用函数
printinfo( age=50, name="runoob" )

匿名函数 lambda

Python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

  • lambda 只是一个表达式，函数体比 def 简单很多。
  • lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
  • lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，内联函数的目的是调用小函数时不占用栈内存从而减少函数调用的开销，提高代码的执行速度。

lambda 函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

设置参数 a 加上 10:

x = lambda a : a + 10
print(x(5))

y = lambda : 10
print(y())

z = lambda a,b : a + b
print(z(5,6))

变量作用域

内置函数

range

range() 函数可创建一个整数列表，一般用在 for 循环中。

函数语法

range(start, stop[, step])

参数说明：

  • start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
  • stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
  • step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

示例：

>>>range(10)        # 从 0 开始到 9
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 10
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]

>>> range(0)
[]
>>> range(1, 0)
[]

标准库

Python 标准库非常庞大，所提供的组件涉及范围十分广泛，使用标准库我们可以让您轻松地完成各种任务。

以下是一些 Python3 标准库中的模块：

  • os 模块：os 模块提供了许多与操作系统交互的函数，例如创建、移动和删除文件和目录，以及访问环境变量等。
  • sys 模块：sys 模块提供了与 Python 解释器和系统相关的功能，例如解释器的版本和路径，以及与 stdin、stdout 和 stderr 相关的信息。
  • time 模块：time 模块提供了处理时间的函数，例如获取当前时间、格式化日期和时间、计时等。
  • datetime 模块：datetime 模块提供了更高级的日期和时间处理函数，例如处理时区、计算时间差、计算日期差等。
  • random 模块：random 模块提供了生成随机数的函数，例如生成随机整数、浮点数、序列等。
  • math 模块：math 模块提供了数学函数，例如三角函数、对数函数、指数函数、常数等。
  • re 模块：re 模块提供了正则表达式处理函数，可以用于文本搜索、替换、分割等。
  • json 模块：json 模块提供了 JSON 编码和解码函数，可以将 Python 对象转换为 JSON 格式，并从 JSON 格式中解析出 Python 对象。
  • urllib 模块：urllib 模块提供了访问网页和处理 URL 的功能，包括下载文件、发送 POST 请求、处理 cookies 等。

datetime

import datetime

#获取当前日期和时间
current_datetime = datetime.datetime.now()
print(current_datetime)        # 2023-07-17 18:37:56.036914

# 获取当前日期
current_date = datetime.date.today()
print(current_date)             # 2023-07-17

# 格式化日期
formatted_datetime = current_datetime.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_datetime)  # 输出：2023-07-17 15:30:45

json

import json
 
# Python 字典类型转换为 JSON 对象
data = {
    'no' : 1,
    'name' : 'Runoob',
    'url' : 'https://www.runoob.com'
}
 
json_str = json.dumps(data)
print ("Python 原始数据：", repr(data))
print ("JSON 对象：", json_str)

# 将 JSON 对象转换为 Python 字典
data2 = json.loads(json_str)
print ("data2['name']: ", data2['name'])

进阶用法

pip

pip 是 Python 包管理工具，该工具提供了对 Python 包的查找、下载、安装、卸载的功能。

软件包也可以在 https://pypi.org/ 中找到。目前最新的 Python 版本已经预装了 pip。

# 查看是否已经安装 pip 可以使用以下命令：
pip -V

# 安装 numpy 包：
pip install numpy

# 移除 numpy 包：
pip uninstall numpy

# 如果要查看我们已经安装的软件包，可以使用以下命令：
pip list

第三方类库

requests

Python requests 是一个常用的 HTTP 请求库，可以方便地向网站发送 HTTP 请求，并获取响应结果。

requests 模块比 urllib 模块更简洁。安装 requests 库：

pip install requests
# 导入 requests 包
import requests

# 发送请求
x = requests.get('https://www.runoob.com/')

# 返回网页内容
print(x.text)

Anaconda 发行版

​ Anaconda 是一个数据科学和机器学习的软件套装，它包含了许多工具和库，让您能够更轻松地进行编程、分析数据和构建机器学习模型。Anaconda 发行版包含了 Python。

Anaconda 包及其依赖项和环境的管理工具为 conda 命令，文与传统的 Python pip 工具相比 Anaconda 的 conda 可以更方便地在不同环境之间进行切换，环境管理较为简单。

NumPy

​ NumPy 提供了真正的数组功能以及对数据进行快速处理的函数，是Python中相当成熟和常用的库。

​ NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代商业的 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。

SciPy

​ SciPy 是一个开源的基于 Numpy 的 Python 算法库和数学工具包。

​ Scipy 是一个用于数学、科学、工程领域的常用软件包，可以处理最优化、线性代数、积分、插值、拟合、特殊函数、快速傅里叶变换、信号处理、图像处理、常微分方程求解器等。 。

​ SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。

​ NumPy 和 SciPy 的协同工作可以高效解决很多问题，在天文学、生物学、气象学和气候科学，以及材料科学等多个学科得到了广泛应用。

Matplotlib

Matplotlib 可能是 Python 2D-绘图领域使用最广泛的套件。它能让使用者很轻松地将数据图形化，并且提供多样化的输出格式。

爬虫

在Python中，编写爬虫时有许多优秀的框架可供选择。以下是几个常用的爬虫框架及其特点

Scrapy

特点：

  • 功能强大，适合大规模爬取。
  • 内置支持异步请求、数据管道、中间件等功能。
  • 支持分布式爬取（结合Scrapy-Redis）。
  • 社区活跃，文档丰富。

适用场景：

  • 需要爬取大量数据。
  • 需要结构化数据存储（如导出为JSON、CSV或存储到数据库）。
  • 需要处理复杂的爬取逻辑（如动态页面、反爬虫机制）。

BeautifulSoup + Requests

特点：

  • 简单易用，适合初学者。
  • BeautifulSoup 用于解析HTML/XML，Requests 用于发送HTTP请求。
  • 灵活性高，适合小规模爬取。

适用场景：

  • 需要快速实现简单的爬虫。
  • 目标网站结构简单，反爬虫机制较弱。

README

参考：

​ python 官方文档

​ https://www.runoob.com/python3/python3-tutorial.html

​ https://www.liaoxuefeng.com/wiki/1016959663602400

Python
#Python
Python学习笔记
http://jackpot-lang.online/2024/10/27/机器学习/Python学习笔记/
作者
Jackpot
发布于
2024年10月27日
许可协议