Python
Python
简介
Python变量和数据类型：Python有多种基本数据类型，包括整数（int），浮点数（float），字符串（str），列表（list）和字典（dict）等，变量在Python中不需要声明，直接赋值即可。
x = 10;
y = 3.14;
z = "Hello,world!"
my_list = [1,2,3,4,5]
my_dict = {"name":"john","age":25}Python条件语句: Python使用if、elif（else if的缩写）和else关键字来进行条件判断。
x = 10
if x > 0:
print("x is positive")
elif x < 0:
print("x is negative")
else:
print("x is zero")Python循环: Python使用for和while关键字来进行循环。
# 使用for循环遍历列表
for i in [1, 2, 3, 4, 5]:
print(i)
# 使用while循环
x = 0
while x < 5:
print(x)
x += 1Python函数: Python使用def关键字来定义函数。
def greet(name):
print("Hello, " + name + "!")
greet("Alice")
列表（List）
- Python的列表是一种数据结构，可以包含任何类型的数据，如整数，字符串，元组等，列表是可变的，意味着你可以在创建列表后可更改，添加或删除列表中的元素。
//在这个列表中，我们有一个整数（1），一个字符串（'Hello'），一个浮点数（3.14）和一个布尔值（True）。 |
特性以及操作
索引：你可以通过索引访问列表中的元素。索引是从0开始的。例如，my_list[0] 将返回第一个元素，即1。
切片：你也可以访问列表的一部分，这称为切片。例如，my_list[1:3] 将返回从索引1开始到索引（不包括）的所有元素，即[‘Hello’, 3.14]。
列表是可变的，你可以更改列表中的元素。例如，my_list[1] = ‘World’ 将把第二个元素（’Hello’）更改为’World’。
添加元素：你可以使用 append() 方法在列表的末尾添加新元素，或者使用 insert() 方法在指定位置插入新元素。
删除元素：你可以使用 remove() 方法删除指定的元素，或者使用 pop() 方法删除指定索引处的元素。
长度：你可以使用 len() 函数获取列表的长度，即它包含的元素数量。
常用的方法
- append(item):列表末尾添加一个新的元素
my_list = [1,2,3] |
2.. extend(iterable):在列表末尾添加另一个列表
my_list = [1,2,3] |
- insert(index,item):指定索引位置插入一个元素
my_list = [1,2,3] |
- remove(item):删除列表中第一个出现的指定元素
my_list = [1,2,3,2] |
- pop(index):删除并返回指定索引位置的元素，若没有则删除并返回最后一个元素
my_list = [1,2,3] |
- index(item):用于查找列表中第一个出现的指定元素的索引
my_list = [1,2,3,2] |
- count(item):这个方法用于计算列表中指定元素出现的次数
my_list = [1,2,3,2] |
sort():这个方法用于对列表进行排序
my_list = [3, 1, 4, 1, 5, 9, 2]
my_list.sort()
print(my_list) # 输出: [1, 1, 2, 3, 4, 5, 9]reverse():用于反转列表
my_list = [1,2,3,4,5] |
元组（Tuple）
- 元组是一种不可变的序列类型，在Python中，元组是用圆括号（）创建的。元组中的元素可以是不同类型的，如整数，浮点数，字符串，甚至可以包含其他的复杂类型，如列表，字典或其他元组。
my_tuple = (1,2,3,'a','b','c') |
特性
- 不可变性： 一旦元组被创建，你就不能增加、修改或删除元组中的元素。这意味着元组是哈希的，可以用作字典的键。
- 有序性： 元组中的元素有固定的顺序，可以通过索引访问。
- 允许重复的元素： 元组可以包含重复的元素。
- 可以包含不同类型的元素： 元组的元素可以是任何类型。
常用的方法
- tuple.count(x):返回元组中元素x出现的次数
t = (1,2,3,2,4,2) |
- tuple.index(x):返回元组中元素x第一次出现的索引，如果元组中不存在元素x，会抛出一个异常
t = (1,2,3,2,4,2) |
- len(tuple):返回元组的长度
t = (1,2,3,2,4,2) |
max(tuple) 和 min(tuple)：返回元组中的最大值和最小值
t = (1,2,3,2,4,2)
print(max(tuple)) # 输出4，因为4是元组t中的最大值
print(min(tuple)) # 输出1，因为1是元组t中的最小值tuple(seq):将序列seq转换为元组
list1 = [1,2,3,4,5] |
基本操作
- 创建元组
tup1 = ('physics', 'chemistry', 1997, 2000) |
访问元组
tup1 = ('physics', 'chemistry', 1997, 2000)
print(tup1[0]) # 输出 'physics'切片操作
tup1 = (1, 2, 3, 4, 5)
print(tup1[1:4]) # 输出 (2, 3, 4)合并元组
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3) # 输出 (12, 34.56, 'abc', 'xyz')元组解包
tup1 = ('physics', 'chemistry', 1997, 2000)
# 解包（unpack）
subject1, subject2, year1, year2 = tup1
print(subject1) # 输出 'physics'
print(year1) # 输出 1997计算元素个数
tup1 = ('physics', 'chemistry', 1997, 2000)
print(len(tup1)) # 输出 4检查元素是否存在
tup1 = ('physics', 'chemistry', 1997, 2000)
print(1997 in tup1) # 输出 True元素索引
tup1 = ('physics', 'chemistry', 1997, 2000) |
- 元素计数
tup1 = (1, 2, 3, 1, 2, 3, 2, 2)
print(tup1.count(2)) # 输出 4
集合（Set）
特性
无序性：集合中的元素没有特定的顺序，因此不能通过索引或切片来访问元素。
唯一性：集合中的每个元素都是唯一的，即集合中不能有重复的元素。
可变性：可以添加或删除集合中的元素，但集合本身是不可哈希的，因此不能作为其他集合的元素或字典的键。
基本操作
- 创建集合
s = {1, 2, 3, 4} |
- 添加元素
s = {1, 2, 3} |
- 删除元素
s = {1, 2, 3, 4, 5} |
- 判断元素是否存在
s = {1, 2, 3, 4, 5} |
- 集合的运算
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
print(s1.union(s2)) # 输出：{1, 2, 3, 4, 5, 6}
print(s1.intersection(s2)) # 输出：{3, 4}
print(s1.difference(s2)) # 输出：{1, 2}
print(s1.symmetric_difference(s2)) # 输出：{1, 2, 5, 6}
常用方法
discard()：删除集合中的指定元素，如果元素不存在，不会抛出错误。
s = {1, 2, 3}
s.discard(4)
print(s) # 输出：{1, 2, 3}pop()：随机删除集合中的一个元素。
s = {1, 2, 3}
s.pop()
print(s) # 输出可能是：{1, 2} 或 {2, 3} 或 {1, 3}clear()：清空集合。
s = {1, 2, 3}
s.clear()
print(s) # 输出：set()union()：返回两个集合的并集
s1 = {1, 2, 3}
s2 = {3, 4, 5}
print(s1.union(s2)) # 输出：{1, 2, 3, 4, 5}intersection()：返回两个集合的交集
s1 = {1, 2, 3} |
difference()：返回集合的差集
s1 = {1, 2, 3}
s2 = {3, 4, 5}
print(s1.difference(s2)) # 输出：{1, 2}symmetric_difference()：返回两个集合的对称差集
s1 = {1, 2, 3} |
issubset()：判断集合是不是被其他集合包含
s1 = {1, 2}
s2 = {1, 2, 3, 4, 5}
print(s1.issubset(s2)) # 输出：Trueissuperset()：判断集合是否包含其他集合
s1 = {1, 2}
s2 = {1, 2, 3, 4, 5}
print(s2.issuperset(s1)) # 输出：True
基本概念
并集：两个集合的并集是包含两个集合所有元素的集合。
交集：两个集合的交集是同时包含在两个集合中的元素组成的集合。
差集：集合A与集合B的差集是包含在集合A但不包含在集合B中的元素组成的集合。
对称差集：两个集合的对称差集是只包含在一个集合中但不同时包含在两个集合中的元素组成的集合。
字典（Dictionary）
特性
- 无序性：字典中的元素没有特定的顺序，它们并不按照插入的顺序存储
- 键的唯一性：字典中的键必须是唯一的，如果在创建字典时同一个键被赋值两次，后一个值会被记住。
- 可变性：字典是可变的，我们可以添加，删除或修改字典中的键值对。
基本操作
- 创建字典
# 使用大括号创建字典 |
- 访问字典中的值
dict1 = {'name': 'Alice', 'age': 20} |
- 修改字典
dict1 = {'name': 'Alice', 'age': 20} |
- 删除字典元素
dict1 = {'name': 'Alice', 'age': 20, 'gender': 'Female'} |
常用的方法
dict.keys():返回一个包含字典所有键的视图对象
d = {'name': 'Tom','age':20}
print(d.keys()) #dict_keys(['name','age'])dict.values():此方法返回一个包含字典所有值的视图对象
d = {'name': 'Tom', 'age': 20} |
- dict.items(): 此方法返回一个包含字典所有（键, 值）元组的视图对象。
d = {'name': 'Tom', 'age': 20} |
dict.get(key, default): 此方法返回字典中键为key的值；如果没有这样的键，则返回default。
d = {'name': 'Tom', 'age': 20}
print(d.get('name')) # 输出：'Tom'
print(d.get('gender', 'N/A')) # 输出：'N/A'dict.setdefault(key, default): 如果字典中包含有给定键，则返回该键对应的值，否则将该键和default值插入字典中，并返回default。
d = {'name': 'Tom', 'age': 20}
print(d.setdefault('name', 'N/A')) # 输出：'Tom'
print(d.setdefault('gender', 'N/A')) # 输出：'N/A'
print(d) # 输出：{'name': 'Tom', 'age': 20, 'gender': 'N/A'}dict.update(other): 将other字典的键/值对更新到当前字典中。
d = {'name': 'Tom', 'age': 20}
d.update({'age': 21, 'gender': 'male'})
print(d) # 输出：{'name': 'Tom', 'age': 21, 'gender': 'male'}dict.pop(key, default): 删除并返回字典中键为key的值，如果没有这样的键，则返回default。
d = {'name': 'Tom', 'age': 20}
print(d.pop('age')) # 输出：20
print(d.pop('gender', 'N/A')) # 输出：'N/A'
print(d) # 输出：{'name': 'Tom'}dict.clear(): 删除字典内所有元素。
d = {'name': 'Tom', 'age': 20}
d.clear()
print(d) # 输出：{}
Python的函数
- 定义函数:
你可以定义一个由自己想要功能的函数，以下是简单的规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
def hello_world(): |
函数参数：
在Python中，函数的参数可以有默认值，也支持使用可变参数。def greet(name, msg="Good day!"):
"""
This function greets to the person passed in as parameter
"""
print("Hello", name + ', ' + msg)
greet("Kate")
greet("Bruce", "How do you do?")匿名函数
Python使用lambda来创建匿名函数。意即不再使用def语句这样标准的形式定义一个函数。
lambda只是一个表达式，函数体笔def简单多sum = lambda arg1:arg1 + arg2
print("Value of tatal:",sum(10,20))全局和局部变量：
在函数内部，你可以引用全局变量。如果你需要在函数内部改变全局变量，那么global关键字就派上用场了，如果不修改全局变量，可以使用局部变量。x = 10
def example():
global x
y = 5
x += y
print("local x:", x)
print("local y:", y)
example()
print("global x:", x)错误和异常处理
try/except语句def diveide(x,y):
try:
result = x/y
except ZeroDivisionError:
print ("除数不能为零！")
return None
else:
return result函数的递归
最好需要一个明确的退出条件，否则无限递归导致程序崩溃def factorial(n):
if n == 0
return 1
else:
return n * factorial(n-1)高阶函数
Python支持高阶函数，可以接受其他函数作为参数或返回一个函数的函数。这是函数式编程的一个重要特性，可以用来创建代码def apply_func(func,x,y)
return func(x,y)
操作文件
打开文件：我们使用内置的
open()函数来打开一个文件。这个函数接收两个参数：文件名和模式。模式可以是'r'（读取，默认值），'w'（写入，如果文件存在则清空内容），'a'（追加，不清空文件内容，从文件末尾开始写入），或'b'（二进制模式）。f = open('myfile.txt', 'r')
读取文件：我们可以使用
read()函数来读取文件的全部内容，或者使用readline()来一次读取一行。还可以使用readlines()来一次读取所有行并返回一个列表。content = f.read()
line = f.readline()
lines = f.readlines()写入文件：我们可以使用
write()函数来写入文件。f = open('myfile.txt', 'w')
f.write('Hello, World!')关闭文件：当我们完成文件操作后，应该使用
close()函数来关闭文件。f.close()
with语句：在处理文件对象时，使用with关键字是一个好习惯。它的优点是文件会在语句结束后自动关闭，即使发生异常也是如此。
with open('myfile.txt', 'r') as f:
print(f.read())操作文件和目录：Python的os模块提供了许多操作文件和目录的函数，如
os.remove()删除文件，os.rename()重命名文件，os.mkdir()创建新目录，os.rmdir()删除目录等。import os
os.remove('myfile.txt')
os.rename('oldname.txt', 'newname.txt')
os.mkdir('newdir')
os.rmdir('olddir')
异常处理
在Python中，异常处理涉及以下几个关键词：try, except, finally, raise。
下面是一个简单的例子：
try: |
在这个例子中，我们尝试除以零，这会引发一个 ZeroDivisionError。由于我们在 except 语句中处理了这个错误，所以程序会打印出 “You can’t divide by zero!”，而不是完全崩溃。
finally 语句是一个可选的语句，无论 try 块中的代码是否引发异常，它都会执行。这在需要确保文件正确关闭或网络连接正确终止等情况下非常有用。
raise 语句允许程序员自己引发异常。例如，如果你正在编写一个函数，你可以使用 raise 语句来引发一个 TypeError，如果函数的参数不是你期望的类型。
def add_numbers(a, b): |
在这个例子中，如果 add_numbers 的参数不是整数，那么函数就会引发一个 TypeError。
模块与包
模块是Python代码的一种组织形式，它将相关的代码组织在一个文件中，以便于代码的复用和维护。你可以使用import语句来导入模块。例如：
import math |
在这个例子中，我们导入了math模块，然后使用了它的sqrt函数来计算16的平方根。
Python的包是一种更高级的模块组织方式。它可以包含多个模块。一个包就是一个包含特殊文件 init.py 的目录，这个文件告诉Python这个目录应被视为一个Python包。
例如，如果你有以下目录结构：
my_package/ |
你可以这样导入和使用包中的模块：
from my_package import module1 |
在这个例子中，我们导入了my_package包中的module1模块，并调用了它的some_function函数。
常用包和模块简介
1. numpy: 这是Python中用于数值计算的主要库。它提供了强大的多维数组对象和工具来处理这些数组。 |
面向对象编程（OOP）
- 类与对象：在Python中，几乎所有的东西都是对象，具有其属性和方法。类是对象的蓝图或圆形。我们可以使用类来创建对象，这些对象将具有类定义的属性和行为。
class MyClass: |
- 继承：继承允许我们定义一个继承所有办法和属性的类。父类是被继承的类，子类是继承父类的类。
class Person: |
- 多态：多态是指同一操作作用于不同的对象，可以产生不同的结果。这意味着每个对象可以根据其类型以自己的方式响应常见的方法。
class Cat: |
- 封装：封装是面向对象编程的一个主要原则，隐藏了对象的内部状态和实现细节，只提供了一组接口。
class Computer: |
常用标准库
OS
提供了许多与操作系统交互的函数，如创建目录（Mkdir）,更改当前工作目录（chdir），获取当前工作目录（getcwd）等。
os.mkdir('new_dir') |
| 函数名 | 描述 |
|---|---|
| os.name | 获取当前的操作系统名称 |
| os.getcwd() | 获取当前的工作目录 |
| os.chdir(path) | 改变当前的工作目录到指定的路径 |
| os.listdir(path) | 列出指定路径下的所有文件和目录 |
| os.mkdir(path) | 在指定的路径下创建一个新的目录 |
| os.rmdir(path) | 删除指定的目录 |
| os.rename(src, dst) | 重命名文件或目录，从src到dst |
| os.remove(path) | 删除指定的文件 |
| os.path.join(path1, path2, …) | 将多个路径组合后返回 |
| os.path.split(path) | 返回路径的目录名和文件名 |
| os.path.exists(path) | 检测指定路径是否存在 |
| os.path.isdir(path) | 检测指定路径是目录 |
| os.path.isfile(path) | 检测指定路径是文件 |
json
data = {'name': 'John', 'age': 30, 'city': 'New York'} |
re
提供了对正则表达式的支持，正则表达式是一个特殊的序列，能够帮助你匹配或者找到其他字符串，使用特定的语法规则。
Python re模块函数
| 函数 | 描述 |
|---|---|
re.match() |
从字符串的开始位置匹配正则表达式，如果开始位置匹配不成功，match()返回None |
re.search() |
扫描整个字符串并返回第一个成功的匹配 |
re.findall() |
返回一个列表，包含所有匹配的子串 |
re.sub() |
用于替换字符串中的匹配项 |
re.compile() |
用于编译正则表达式，生成一个正则表达式对象 |
正则表达式元字符
| 元字符 | 描述 |
|---|---|
. |
匹配除了换行符以外的任何字符 |
^ |
匹配字符串的开始 |
$ |
匹配字符串的结束 |
* |
匹配0次或多次前面的正则表达式 |
+ |
匹配1次或多次前面的正则表达式 |
? |
匹配0次或1次前面的正则表达式 |
\d |
匹配任何数字，等价于[0-9] |
\D |
匹配任何非数字字符，等价于[^0-9] |
\s |
匹配任何空白字符，等价于[\t\n\r\f\v] |
\S |
匹配任何非空白字符，等价于[^\t\n\r\f\v] |
\w |
匹配任何字母数字字符，等价于[a-zA-Z0-9_] |
\W |
匹配任何非字母数字字符，等价于[^a-zA-Z0-9_] |
简单的re模块例子
import re |
collections
实现了特殊的容器数据类型，提供了Python内置的dict，list，set，tuple之外的更多数据类型。
- **
namedtuple()**：namedtuple是一个函数，它用来创建一个自定义的元组对象，并且规定了元组元素的个数，可以用属性而不是索引来引用元组的某个元素。
from collections import namedtuple |
- **
deque**：deque是一个双端队列，它可以从两端添加或删除元素。在需要添加和删除元素时，deque提供了更优于list的性能。
from collections import deque |
- **
Counter**：Counter是一个简单的计数器，例如，它可以用来统计字符的个数：
from collections import Counter |
你还可以对Counter对象执行各种数学运算操作：
c1 = Counter(a=3, b=2) |
- **
OrderedDict**：OrderedDict是一个字典子类，它记住了字典元素添加的顺序：
from collections import OrderedDict |
- **
defaultdict**：defaultdict是一个字典子类，它提供了一个工厂函数为字典查询提供默认值：
from collections import defaultdict |
Python应用
数据分析
pandas
一个开源的Python类库，用于数据分析，数据处理，数据可视化
Pandas读取数据
Pandas 提供了多种读取数据的方法，可以读取各种类型的文件，包括 CSV、Excel、SQL 数据库等。下面是一些常用的读取数据的方法：
- 从 CSV 文件读取数据：
import pandas as pd |
- 从 Excel 文件读取数据：
import pandas as pd |
- 从 SQL 数据库读取数据：
import pandas as pd |
注意，这些方法都会返回一个 DataFrame 对象，这是 Pandas 中用于数据操纵的主要数据结构。
你可以使用 df.head() 来查看 DataFrame 的前几行，以确保数据已经正确加载。
此外，这些函数都有许多可选参数，可以帮助你更精细地控制数据的加载过程。例如，pd.read_csv 允许你指定分隔符类型、处理缺失值、跳过特定的行等。你可以查阅 Pandas 的文档以获取更多信息。
数据结构
Series
Series是Pandas中的一维标签化数组，可以容纳任何数据类型，包括整数，字符串，浮点数，Python对象等。它是由一组数据（各种NumPy数据类型）以及一组与之相关的数据标签组成，可以把它看作是一个带有标签的一维数组
Serise多种创建方法
Pandas的Series是一个一维的数据结构，有点类似于Python的列表或数组，但是它有一些额外的功能，例如可以为每个元素指定一个标签（或者说索引）。
以下是创建Series的一些方法：
- 用Python列表创建Series：
import pandas as pd |
- 用NumPy数组创建Series：
import numpy as np |
- 用Python字典创建Series，字典的键会被用作Series的索引：
import pandas as pd |
- 用标量创建Series，该标量值会被广播到指定的索引：
import pandas as pd |
以上就是创建Pandas Series的四种常用方法，每种方法都有其适用的场景，你可以根据实际需要选择使用。
Series索引
在Pandas中，Series对象的索引类似于Python的字典，它可以用来访问和操作数据。
创建Series时，可以通过index参数来指定索引。如果不指定，Pandas将自动创建一个从0开始的整数索引。
例如，创建一个带有指定索引的Series：
import pandas as pd |
此代码将输出：
a 1.0 |
你可以像字典一样使用索引来访问和修改Series中的元素：
print(s['a']) # 输出：1.0 |
还可以使用.loc和.iloc方法来进行索引。.loc用于基于标签的索引，而.iloc用于基于位置的索引：
print(s.loc['a']) # 输出：100.0 |
DataFrame
DataFrame是Pandas中的二维标签化数据结构。你可以把它看作是一个电子表格或SQL表，或者是Series对象的字典。它通常是最常用的pandas对象。与Series一样，DataFrame可以容纳多种类型的输入。
多种方法创建DataFrame
import pandas as pd |
DataFrame特性
表格结构：DataFrame是一个表格，有行有列，每一列可以包含不同的数据类型，如整数，浮点数，字符串等。
标签索引：DataFrame通过行和列的标签进行索引，你可以使用列名或行标签来访问数据。
3.灵活性：你可以执行各种数据操作，如筛选,切片，合并，聚合和重塑，以满足数据分析和处理和需求。
DataFrame基本操作
访问列数据：使用列名或标签访问列数据。
df['Name'] # 访问 'Name' 列
增加和删除列：你可以轻松地添加和删除列。
df['City'] = ['New York', 'San Francisco', 'Los Angeles'] # 添加新列
df.drop('Age', axis=1, inplace=True) # 删除 'Age' 列数据筛选：使用条件筛选数据。
df[df['Age'] > 30] # 筛选年龄大于 30 的行
聚合操作：进行统计和聚合计算。
df[df['Age'] > 30] # 筛选年龄大于 30 的行
数据排序：按列的值排序 DataFrame。
df[df['Age'] > 30] # 筛选年龄大于 30 的行
查询数据
模拟一组数据
import pandas as pd |
布尔索引
#选择年龄大于30的行 |
.loc 和 .iloc
- label指定行列
result = df.loc[0, 'City']
- 使用值列表哦批量查询
result = df.loc[['Alice','Bob'],'City']
- 使用数值区间进行范围查询
result = df.loc['Alice':'Charlie',Salary]
- 使用条件表达式查询
result = df.loc[df['Salary'] < 7000 : ]
- 调用函数查询
result = df.loc[lambda df:(df["Salary"] < = 7000) & (df["Salary"] > = 5000) ]
.isin
#选择城市为'Paris'或'Tokyo'的行 |
.query
#选择工资大于6000的行 |
新增数据列
使用直接赋值
import pandas as pd
#创建一个DataFrame
df = pd.DataFrame({'A': [1, 2, 3],
'B': [4, 5, 6]})
#新增一个名为'C'的列，并赋值为一个列表
df['C'] = [7, 8, 9]使用assign()方法
import pandas as pd
#创建一个DataFrame
df = pd.DataFrame({'A': [1, 2, 3],
'B': [4, 5, 6]})
#使用assign()方法新增一个名为'C'的列，并赋值为一个列表
df = df.assign(C=[7, 8, 9])
统计函数
| 函数 | 描述 |
|---|---|
sum() |
计算数字的总和 |
mean() |
计算平均值 |
median() |
计算中位数 |
mode() |
计算众数 |
variance() |
计算方差 |
stddev() |
计算标准差 |
min() |
找到最小值 |
max() |
找到最大值 |
numpy 库 |
强大的数组和矩阵操作 |
pandas 库 |
数据处理和分析，提供数据结构和统计函数 |
scipy 库 |
高级的统计函数和科学计算工具 |
当涉及到统计函数时，以下是每个函数的简单示例：
sum(): 计算数字的总和numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(total) # 输出：15mean()或average(): 计算平均值numbers = [12, 18, 24, 30, 36]
average = sum(numbers) / len(numbers)
print(average) # 输出：24.0median(): 计算中位数numbers = [5, 3, 8, 2, 7]
numbers.sort()
n = len(numbers)
if n % 2 == 0:
median = (numbers[n//2 - 1] + numbers[n//2]) / 2
else:
median = numbers[n//2]
print(median) # 输出：5mode(): 计算众数from statistics import mode
data = [1, 2, 2, 3, 3, 3, 4]
result = mode(data)
print(result) # 输出：3variance(): 计算方差from statistics import variance
data = [5, 8, 10, 12, 15]
result = variance(data)
print(result) # 输出：11.0stddev(): 计算标准差from statistics import stdev
data = [5, 8, 10, 12, 15]
result = stdev(data)
print(result) # 输出：3.3166247903554
7. `min()` 和 `max()`: 找到最小值和最大值
```python
numbers = [15, 8, 22, 3, 11]
min_val = min(numbers)
max_val = max(numbers)
print(min_val) # 输出：3
print(max_val) # 输出：22
numpy
首先，让我们导入numpy库。在你的Python环境中，你可以这样做：
import numpy as np |
我们使用 “as” 关键字给numpy库起了一个别名 “np”，这样在我们的代码中就可以使用 “np” 来代替 “numpy”，使代码更简洁。
创建数组
在numpy中，最基本的对象是ndarray对象，也就是n维数组。我们可以使用np.array()函数来创建一个数组。例如：
arr = np.array([1, 2, 3, 4, 5]) |
这将会创建一个一维数组，并输出 [1 2 3 4 5]。
数组的属性
创建了数组之后，我们可以查看一些数组的属性。例如：
print("Shape of the array: ", arr.shape) |
shape 属性返回一个元组，表示数组的形状（即各维度的大小）。dtype 属性则返回数组中元素的数据类型。
多维数组
我们不仅可以创建一维数组，还可以创建多维数组。例如，我们可以创建一个2x3的二维数组：
arr_2d = np.array([[1, 2, 3], [4, 5, 6]]) |
这将会输出：
[[1 2 3] |
数组的索引和切片
我们可以使用索引和切片来访问和修改数组中的元素。例如：
print(arr[0]) # 输出数组的第一个元素 |
数学运算
- 加法：
numpy.add(x, y)，对应元素相加。
import numpy as np |
- 减法：
numpy.subtract(x, y)，对应元素相减。
print(np.subtract(x, y)) # Output: array([-3, -3, -3]) |
- 乘法：
numpy.multiply(x, y)，对应元素相乘。
print(np.multiply(x, y)) # Output: array([ 4, 10, 18]) |
- 除法：
numpy.divide(x, y)，对应元素相除。
print(np.divide(x, y)) # Output: array([0.25, 0.4 , 0.5 ]) |
- 幂运算：
numpy.power(x, y)，对应元素做幂运算。
print(np.power(x, y)) # Output: array([ 1, 32, 729], dtype=int32) |
- 平方根：
numpy.sqrt(x)，计算数组各元素的平方根。
print(np.sqrt(x)) # Output: array([1. , 1.41421356, 1.73205081]) |
三角函数，如 numpy.sin(x)、numpy.cos(x)、numpy.tan(x)等。
指数和对数，如
numpy.exp(x)、numpy.log(x)、numpy.log10(x)等。
随机数生成
numpy.random.rand(d0, d1, ..., dn): 生成一个给定形状的数组，数组中的值均匀分布在[0, 1)中。
示例：
import numpy as np |
numpy.random.randn(d0, d1, ..., dn): 返回一个由d0, d1, …, dn确定的形状的数组，数组中的值来自标准正态分布。
示例：
import numpy as np |
numpy.random.randint(low, high=None, size=None, dtype='l'): 返回随机整数，范围区间为[low, high)，high默认为None。
示例：
import numpy as np |
- numpy.random.random(size=None)`: 返回随机的浮点数，在半开区间 [0.0, 1.0)。
示例：
import numpy as np |
numpy.random.choice(a, size=None, replace=True, p=None): 从一个给定的一维数组中生成随机数。
示例：
import numpy as np |
注意：为了获得可重复的结果，我们可以使用numpy.random.seed()函数设置随机数种子。
蒙特卡洛模拟
这是一个使用NumPy进行蒙特卡洛模拟的例子。在这个例子中，我们将使用蒙特卡洛模拟来估计圆周率π的值。
基本思想是这样的：我们在一个边长为1的正方形内随机撒点，然后计算落在1/4圆内（半径为1）的点的数量。由于圆的面积是πr²，正方形的面积是1，所以落在1/4圆内的点的数量除以总的点的数量，大约等于π/4。
以下是Python代码：
import numpy as np |
这个代码运行后，会打印出一个π的估计值，这个值应该会接近真实的π值（3.14159…）。随着模拟次数n的增加，这个估计值会越来越接近真实的π值。
.jpg)
.jpg)
.jpg)
.jpg)
.jpg)