The World Best ST.

python学习

字数统计: 6.1k阅读时长: 27 min
2022/10/16 Share

python基础学习

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#数字
i1 = 123
print(repr(i1))

i2 = 12.3
print(repr(i2))

i3 = 1.2 + 3.4j
print(repr(i3))

i4 = 0b1101
print(repr(i4))

#布尔类型
b1 = True
print(repr(b1))

b2 = 3 > 4
print(repr(b2))

#字符串
s1 = "abc ABC"
print(repr(s1))

s2 = "abc\n\t\rABC"
print(repr(s2))

s3 = "翔宇亭IT乐园"
print(repr(s3))

输出结果:
123
12.3
(1.2+3.4j)
13
True
False
'abc ABC'
'abc\n\t\rABC'
'翔宇亭IT乐园'

#参数是列表
lst = [12,12.1,'A','æ','奥运会']
print(repr(lst))

#参数是元组
t = ('奥运会','A','a','æ')
print(repr(t))

#参数是字典
d = {'字符':'优雅','A':'â','1':1}
print(repr(d))

输出结果: 
[12, 12.1, 'A', 'æ', '奥运会']
('奥运会', 'A', 'a', 'æ')
{'字符': '优雅', 'A': 'â', '1': 1}

class Student:
    name=""
    def __init__(self,name):
        self.name = name

class Teacher:
    name = ""
    def __init__(self,name):
        self.name = name

    def __repr__(self):
        return self.name

S = Student("王涛")
print(repr(S))

T = Teacher("苏炳添")
print(repr(T))

输出结果:
<__main__.Student object at 0x0000000002DB47F0>
苏炳添

isdecimal\isdigit\isnumeric

  • 与 isdecimal() 相比，isdigit() 和 isnumeric() 都能判断 unicode 编码的数字字符串：如 ⑴ 、①和 \u00b2
  • 与 isdigit() 相比， isnumeric() 还能判断 中文数字：如 一千一百零一

def printinfo( arg1, vartuple ):
加了星号 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

def printinfo( arg1, vardict ):
加了两个星号 的参数会以字典的形式导入。

def f(a,b,,c):
声明函数时，参数中星号 可以单独出现
如果单独出现星号 ，则星号 后的参数必须用关键字传入：

1
2
3
4
def f(a,b,*,c):
...     return a+b+c
f(1,2,3)   # 报错
f(1,2,c=3) # 正常

迭代器

需要实现iter()和next()方法

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

继承

class DerivedClassName(Base1, Base2, Base3):
需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法

1
2
3
4
5
6
7
8
9
定义字典的几种方法
dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}

{x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

文件

1
2
3
with open('/tmp/foo.txt', 'r') as f:
...    read_data = f.read()
f.closed

Numpy

ndarray数据类型

直接用list进行初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
data1 = [1,2,3,4]
arr1 = np.array(data1)
print(arr1)

# 二位数组
data2 = [[1, 2, 3, 4], [2, 3, 4, 5]]
arr2 = np.array(data2)
print(arr2)

# 全0数组
np.zeros(10)
# 全1数组
np.ones((3,6))
# 全空数组
np.empty((2, 3, 2))
# 等差数组: 一个0-9的数组, start不填默认是0, 步长不填默认是1
np.arange(10)
# 对角线全部为1的正方形
# 以下两个方法的区别在于eye可以控制行列和对角线的偏离值(离对角线的距离), identity不行
np.eye(4) 或者 np.identity(4)

# 取行数
print("arr2[1:3]", arr2[1:3])
# 取列数
print("arr2[:, 0:2]", arr2[:, 0:2])
print("arr2[1, 0:2]", arr2[1, 0:2])

# 生成一个4*3的随机数组
np.random.randn(4,3)

names = np.array(['bob','aa','bob','bb'])
print(names == 'bob') => [true, false, true, false]
arr2[names='bob'] => 会输出第一行和第三行数据
arr2[names='bob', 1:] => 会输出第一行和第三行数据中从第二行开始的列
arr2[arr2 < 0] = 0 => 将所有小于0的数据修改为0

arr = np.empty((8,4))
for i in range(8):
    arr[i] = i
arr[[4, 5, 0, 6]] => 意思是获取第四行,第五行, 第一行, 第六行的数据, 拼成一个二维数组

# np.where
np.where(条件, 满足条件选项, 不满足条件选项)
# 例如:
con = np.array([True, False, True, False])
np.where(con, 数组1(或者标量), 数组2(或者标量))
# 例如:将数组arr中大于0的改成2, 小于0改成-2
np.where(arr > 0, 2, -2)
# 例如:将数组arr中大于0的改成2, 小于0不变
np.where(arr > 0, 2, arr)

# any/all
# any:检查数组中是否存在True, all:检查数组中是否都是True

take 取出索引相应值

从数组中取出目标索引对应的值

1
2
3
4
5
6
7
a = [1,2,3,4,5,6]
np.take(a, [0,1,4])
# 输出[1,2,5]

np.take(a, [[0,1],[2,3]])
# [[1, 2],
# [3, 4]]

ravel 将数组拉成一维数组

np.ravel(arr) 或者
arr.ravel()

flattern 将数组拉成一维数组

arr.flattern()

reshape 形状变换

1.数组元素不能改变
2.转换前元素个数必须符合转换之后的元素个数

1
np.arange(12).reshape(3,4)

flatten 拉平

1
2
a = np.array([1,2],[3,4])
a.flatten => [1,2,3,4]

hstack 水平组合

1
2
3
4
5
6
7
8
9
# 一维组合
a = [1,2,3]
b = [4,5,6]
np.hstack((a,b)) => [1,2,3,4,5,6]

# 二维组合
a = [[1],[2],[3]]
b = [[4],[5],[6]]
np.hstack((a,b)) => [[1,4],[2,5],[3,6]]

concatenate

axis=0 指的是水平连接, axis=1指垂直连接
它会降维连接, 例如:

1
2
3
a = [[1],[2],[3]]
b = [[4],[5],[6]]
np.concatenate((a,b), axis=0) => [[1],[2],[3],[4],[5],[6]]

vstack 垂直组合

1
2
3
a = [1,2,3]
b = [4,5,6]
np.vstack((a,b)) => [[1,2,3],[4,5,6]]

dstack 深度组合

1
2
3
a = [1,2,3]
b = [4,5,6]
np.dstack((a,b)) => [[1,4],[2,5],[3,6]]

row_stack

1
2
3
a = [1,2,3]
b = [4,5,6]
np.row_stack((a,b)) => [[1,2,3],[4,5,6]]

column_stack

1
2
3
a = [1,2,3]
b = [4,5,6]
np.row_stack((a,b)) => [[1,4],[2,5],[3,6]]

vsplit 按照行拆分

1
2
3
x = np.arange(16).reshape(4,4)
result = np.vsplit(x,4)
# 这里最终会拆成4行

tile 平铺函数

第一个参数是需要重复的对象, 第二个重复的次数

1
2
3
4
5
6
7
# 重复一维数组
np.tile((1,2,3),2)
# 结果: [1,2,3,1,2,3]

# 重复二维数组
np.tile([[1,2],[3,4]], 2)
# 结果: [[1,2,1,2],[3,4,3,4]]

repeat(a, repeats, aixs=None) 函数

将每个元素repeat一下, 跟tile有所不同

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
np.repeat((1,2,3),2)
# 结果: [1,1,2,2,3,3]

axis=1 , 按照列重复, axis=0, 按照行重复
x = np.array([[1,2],[3,4]])
print(np.tile(x, 2))
# [[1 2 1 2]
# [3 4 3 4]]

print(np.repeat(x, 2, 0))
#[[1 2]
# [1 2]
# [3 4]
# [3 4]]

print(np.repeat(x, 2, 1))
# [[1 1 2 2]
# [3 3 4 4]]

print(np.repeat(x, [1,2], 0))
# 第一行重复1次, 第二行重复2次
# [[1 2]
# [3 4]
# [3 4]]

delete 删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
numpy.delete(arr,obj,axis=None)

x = np.array([[1,2,3],[3,4,5]])
print(np.delete(x, 0, 1))
# 删除第一列
#[[2 3]
# [4 5]]

print(np.delete(x, 0, 0))
# 删除第一行
# [[3 4 5]]

print(np.delete(x, [0,2], 1))
# 删除第一列和第三列
# [[2]
# [4]]

insert 插入数据

1
2
3
4
5
6
7
8
9
numpy.insert(arr, obj, value, axis=None)

obj指的是需要插入的位置, value是需要插入的值

x = np.array([[1,2,3],[3,4,5]])
print(np.insert(x, 1, [1, 1], 1))
# 在第一列插入一列数据
#[[1 1 2 3]
# [3 1 4 5]]

append 插入数据

1
2
np.append(arr, value, axis=None)
# 加数据在最后

savetxt 将数据存储到文件中

1
savetxt(fileName, data, header(储存文件第一行内容), footer(储存文件最后一行内容))

读取csv文件

1
2
3
4
5
6
7
8
9
10
11
12
13
1. loadtxt(filepath, dtype(类型,默认是float),delimiter, usecols(选择那几列进行加载), unpack(如果为True, 分列读取), skiprows(跳过前n行))
np.loadtxt('test.csv',delimiter=',')
loadtxt的功能是读入数据文件，这里的数据文件要求每一行数据的格式相同。没有数据头的文件可以用这个

unpack参数可以将列拆到变量里
c, v = loadtxt(filepath, delimiter=',', unpack=True)

2. genfromtxt(文件名, 分隔符 , 是否有标题列)
# 如果是行数是1,,3 那解析出来就是(1, nan, 3) -> nan是not a number的意思

a = np.genfromtxt('test.csv',delimiter=',', names=True)
a[0] : 选出第一行
a[标题名]: 选出标题对应对应的一列

T 转置

1
2
3
4
x = np.array([[1,2,3],[3,4,5]])
print(x.T)

x.transpose(1,0,2)

mean 平均数计算

1
2
3
4
5
6
7
arr = np.array([[1,2,3],[3,4,5]])
arr.mean(axis = 1) 与 np.mean(arr)相同, 将每一行的所有列累加, 计算平均数
# [2. 4.]
arr.mean() - 计算全部的数的平均

arr.mean(axis = 0) 按照行计算平均数
# [2. 3. 4.]

sum 计算和

1
2
3
4
5
arr = np.array([[1,2,3],[3,4,5]])
arr.sum(axis = 0) 按行算和
# [4 6 8]

arr.sum() 算总和

cumsum和cumprod 统计操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#[[0 1 2]
#[3 4 5]
#[6 7 8]]

# 按行相加
arr.cumsum(0)
#[[ 0 1 2]
#[ 3 5 7]
#[ 9 12 15]]

# 按行相乘
arr.cumprod(0)
#[[ 0 1 2]
#[ 0 4 10]
#[ 0 28 80]]

max和min

1
2
3
4
5
6
arr.max()
# 求出数组中的最大值
arr.max(0)
# 求出每行的的最大值
arr.min()
# 求出数组中的最小值

argmin、argmax

获取最小值和最大值的坐标

average 平均数

计算加权平均数:
np.average(arr, weight(数组))

np.average(arr, ‘权重数组’)

ptp 取范围

获取范围 = 最大值 - 最小值

np.ptp(arr)

median 取中位数

np.median(arr)

sort 行排序

np.sort(arr)

msort 列排序

np.msort(arr)

var 方差

np.var(arr)

diff 后一个元素减去前一个元素

np.diff(arr)

[1,2,4,8] => [1, 2, 4]

std 标准差

np.std(arr)

linspace 等差数列

np.linspace(0,1,10) => 在0-10之间生成等差数列

np.linspace(0,1,10,endpoint=false) => 在0-9之间生成等差数列

meshgrid 生成网格点坐标矩阵

json

loads和load

1
2
3
4
5
6
7
json.loads(json字符串)
# 可以将json字符串转换成字典

json.load(文件) :
with open('test.json', 'rb') as f:
    data = json.load(f)
    print(data)

内存管理机制

引用计数

引用计数增加

  1. 对象被创建：x=4
  2. 另外的别人被创建：y=x
  3. 被作为参数传递给函数：foo(x)
  4. 作为容器对象的一个元素：a=[1,x,’33’]

引用计数减少

  1. 一个本地引用离开了它的作用域。比如上面的foo(x)函数结束时，x指向的对象引用减1。
  2. 对象的别名被显式的销毁：del x ；或者del y
  3. 对象的一个别名被赋值给其他对象：x=789
  4. 对象从一个窗口对象中移除：myList.remove(x)
  5. 窗口对象本身被销毁：del myList，或者窗口对象本身离开了作用域。

垃圾回收

  1. 垃圾收集器会检查引用计数为0的对象, 将他们回收, 两个对象互相引用的时候也会被清除
  2. 循环垃圾回收器, 确保释放循环应用

内存池机制

分为大内存和小内存, 大于256字节, 使用malloc进行分配, 小于256字节, 使用内存池进行分配

内存池分为：Block、Pool、Arean、usedpool

拆包

通常使用*进行拆包

1
2
3
4
5
6
7
lista=[1,2,3]
print(*lista)
会拆成3个变量

dicta={"a":1, "b":2}
print(**dicta)
拆成a=1,b=2

封包

返回多个变量后赋值给一个变量

1
2
3
4
5
6
7
8
9
10
def fengbao2(**kargs):
    print(kargs)

fengbao2(a=1,b=1)
# kargs会变成一个字典

def fengbao(*args):
    print(args)
# args是一个元祖
fengbao(1,2)

推导式/生成器表达式

yield

使用了 yield 的函数被称为生成器（generator）
元组推导式（生成器表达式）

yield from

总的来说asyncio比线程优越的地方就是：协程不像线程那样需要频繁进行上下文切换、加锁、解锁，这些过程，所以协程之间切换的时间开销将大幅减小，效率上将大幅提高

yield from iterable本质上等于for item in iterable: yield item的缩写版

file

1
2
with open("./router.py") as f:
    print(f.readlines())

上下文

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
    """
    with...as 语句退出或者发送异常时会执行这个方法
    :param exc_type: 异常类型
    :param exc_val: 异常信息
    :param exc_tb: 异常栈
    :return: with...as...语句内抛出的异常将以exc_type, exc_val, exc_tb这三个参数传入,
    返回False时这个异常还会向上抛出,也就是抛出给main,返回True时将不会再向外抛出,被抑制
    """
    print(f"exc_type:{exc_type}")
    print(f"exc_val:{exc_val}")
    print(f"exc_tb:{exc_tb}")
    if exc_type is Exception:
        ...
    self.file.close()
    # 如果这里返回了false, 会再往上抛出, 返回true的话就直接被处理了
    return True

if __name__ == '__main__':
    with FileContextManager("./router.py") as file:
       raise Exception("自定义异常信息") from None
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 生成器函数上加上@contextlib.contextmanager 装饰器可以将它变成一个上下文管理器
@contextlib.contextmanager
def file_context_manager(file_path:str):
    f = open(file_path)
    try:
        print("into try...")
        yield f
        print("out yield...")
    except Exception as e:
        # 异常处理
    finally:
        print("into finally...")
        f.close()


if __name__ == '__main__':
    with file_context_manager("./router.py") as f:
        print(f.readlines())
    # into
    # try...
    # print(f.readlines())
    # out
    # yield ...
    # into finally...

设计模式

单例模式

可以用以下四种方式来实现单例模式

  • 使用模块
  • 使用 __new__
  • 使用装饰器（decorator）
  • 使用元类（metaclass）

使用模块

Python 的模块就是天然的单例模式, 直接将函数和数据定义在另一个文件中

1
2
3
4
5
#tests1.py
class MyClass(object):
    def foo(self):
        print('MyClass.foo')
my_class_obj=MyClass()

使用new方法

1
2
3
4
5
6
7
8
9
10
class MyClass(object):
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(MyClass, cls).__new__(cls, *args, **kwargs)
        return cls._instance

class HerClass(MyClass):
    a = 1

装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from functools import wraps

def singleton(cls):
    instances = {}

    @wraps(cls)
    def getinstance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return getinstance

@singleton
class MyClass(object):
    a = 1

元类

元类就是用来创建类的“东西”。元类就是类的类。type就是创建类对象的类

在写一个类的时候为他添加__metaclass__属性, python就会用它来新建类, 如果没有这个就会默认用type类

1
2
3
4
5
6
7
8
9
10
class Singleton(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class MyClass(metaclass=Singleton):
   pass

继承

super(Person,self).__init__(name,age)
super后面的第一个参数是指从哪一个类之后开始找(不包含这个类)
super后面的第二个参数是指方法解析顺序(MRO(Method Resolution Order))是怎么样的, 比如说下面的例子就是Male -> Person -> Animal -> Object

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Animal():
    def __init__(self,name):
        self.name = name

class Person(Animal):
    def __init__(self,name,age):
        super().__init__(name)
        self.age = age
        print('Person')

class Male(Person):
    def __init__(self,name,age):
        # 这里会报错, 因为他取的是Person的父类, 也就是Animal, 但是Aniaml的init方法只有一个参数, 所以会报错
        super(Person,self).__init__(name,age)
        # 所以应该改成↓
        super(Person,self).__init__(name)
        print("Male")

m = Male('xiaoming',12)
super(Male,m).__init__('xiaoming',12)
print(m.__dict__)

MRO

  1. 子类永远在父类前面
  2. 如果有多个父类，会根据它们在列表中的顺序被检查
  3. 如果对下一个类存在两个合法的选择，选择第一个父类

如何查看方法解析顺序

class.__mro__和class.mro()

例如: 

1
2
d = D()
D.__mro__

动态创建类

type(类名, 父类的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）)

1
2
3
4
5
6
7
8
9
10
11
12
# 不继承其他类
class Foo(object):
    bar=True

# 可以这样动态创建
Foo = type('Foo', (), {'bar':True})

# 继承其他类
class FooChild(Foo):
    pass

FooChild = type('FooChild', (Foo,),{})

设计模式六大原则

  1. 开闭原则 - 拓展开放, 修改关闭
  2. 里氏代换原则 - 子类可替换父类
  3. 依赖倒转原则 - 接口抽象
  4. 接口隔离原则 - 类之间的依赖关系应该建立在最小接口上
  5. 迪米特法则 - 不需要知道其他的类是怎么实现的
  6. 单一职责原则

设计模式

https://www.cnblogs.com/superhin/p/17486255.html
https://baijiahao.baidu.com/s?id=1758410771062793648&wfr=spider&for=pc

sys模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
os._exit() 用于在线程中退出
sys.exit() 用于在主线程中退出

os._exit(n)： 直接退出, 不抛异常, 不执行相关清理工作。常用在子进程的退出。

sys.exit(n) ：退出程序引发SystemExit异常，可以捕获异常执行些清理工作。n默认值为0，表示正常退出，其他都是非正常退出。还可以sys.exit(“sorry, goodbye!”); 一般主程序中使用此退出

exit()/quit()跟sys.exit(n)没什么区别，也抛出SystemExit异常。一般只在shell命令行页面退出python。

sys.version ：获取Python解释程序的版本信息
sys.platform ：返回操作系统平台名称

sys.stdin.readline() ：与input功能一样, 就是比input会多一个\n
input ：输入, 不会记录\n

sys.stdout.write('hello' + '\n')
print('hello')

sys.argv ：命令行参数List，第一个元素是程序本身路径

datetime模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# date
datetime.date(yyyy, MM, dd)：表示日期的类，主要用于处理年、月、日；
默认输出格式是yyyy-MM-dd
datetime.date.today()：获取当前时间
datetime.date.today().weekday()：返回当前日期是星期几
datetime.date.fromtimestamp(1576244364)：通过时间戳转成时间
datetime.date.today().today.year：获取年，month月，day日

# time
datetime.time：表示时间的类，主要用于处理时、分、秒；默认格式是hh:mm:dd
datetime.time.hour：获取小时，minute：分，second：秒，microsecond：微秒

# datetime
datetime.datetime：表示日期时间的类，date类和time类的综合使用，可以处理年、月、日、时、分、秒；
datetime.datetime.timestamp()：获取时间戳
datetime.datetime.now()：现在的时间点

# datetime和date都可以进行相减,可以算出两个时间的间隔

# timedelta
datetime.timedelta：表示时间间隔，即两个时间点的间隔，主要用于做时间加减的
例如:
t1 = timedelta(weeks = 2, days = 5, hours = 1, seconds = 33)
t2 = timedelta(days = 4, hours = 11, minutes = 4, seconds = 54)
t3 = t1 - t2
# 可以算出2个时间点之间的时间间隔

t = timedelta(days = 5, hours = 1, seconds = 33, microseconds = 233423)
print("total seconds =", t.total_seconds())
算出时间点的秒数, 这里就是5天1小时33秒, 折出来的秒数

strftime() - 格式化时间, 从日期转为字符串
datetime.datetime.now().strftime("%m/%d/%Y, %H:%M:%S")

strptime() - 格式化时间，从字符串转为日期
date_string = "21 June, 2018"
date_object = datetime.strptime(date_string, "%d %B, %Y")
print("date_object =", date_object)

datetime.tzinfo：时区的相关信息。
# 时区建议使用pytz模块

Pandas

比较核心的模块是Series和DataFrame

Series

Series是类似一个一维数组, 由一组数据和索引组成, 一般索引在左边, 值在右边

obj = Series([2,1,7,-4,9])

0 2
1 1
2 7
3 -4
4 9 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
obj = Series([2,1,7,-4,9])

# 默认索引是从0开始递增的整型
obj.values => [2,1,7,-4,9]
obj.index => RangeIndex(start=0, stop=4, step=1)

# 也可以指定index
obj1 = Series(['aa','bb','cc'], index=['a1','a2','a3'])
print(obj1.index) => Index(['a1', 'a2', 'a3'], dtype='object')

# 指定索引范围输出

obj[['a1', 'a3']]
obj['a1':'a3']

+ 并集运算

s1+s2 => 形成s1和s2的并集, 两个都有的话则相加, 如果有一个没有那么就是NaN

删除指定项

s1 = s.drop(‘索引’)

Frame

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 初始化
data = {'Number':[1,2,3,4,5], 'Name':['Alvin','Teresa','Elly','James','Nancy'], 'Scores':[98.5, 100.0, 93.0,98.5,90.5]}
frame = DataFrame(data)

索引|Name|Number|Scores
0|Alvin|1|98.5
1|Teresa|2|100.0
2|Elly|3|93.0
..|..|..|..

# 初始化时指定列和索引
frame3 = DataFrame(data, columns=['Number','Name','Scores','Age'], index=['No.01','No.02','No.03','No.04','No.05'])

frame3['Number']或者frame3.Number => 选出number列的所有值

# 另一种初始化方式
data = {'Beijing':{'2001':2.4, '2002':2.9,'2003':3.1}, 'Tianjin':{'2001':2.3, '2002':2.7}}
# 创建DataFrame对象
frame = DataFrame(data)
索引 Beijing Tianjin
2001 2.4 2.3
2002 2.9 2.7
2003 3.1 NaN

+ 并集

d1 + d2 => 对应位置两个都有值就相加, 但凡有一个没有就是NaN

算数方法

add, sub, mul, div

删除指定项

df1 = df.drop([‘索引1’,’索引2’], axis=0)

s1.add(s2, fill_value=0) => s1与s2进行加法运算, 没有的位置补0

二维数组和一位数组的运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
arr = np.arange(12).reshape((3,4))
# 输出 arr
print arr
# 输出0行数据
print arr[0]
# 二维数组与0行数据的差
print arr-arr[0]
# 结果:
#[[0 0 0 0]
#[4 4 4 4]
#[8 8 8 8]]

这种行为也叫广播
Series和DataFrame的运算, 与上面逻辑一致

df = DataFrame(np.arange(12).reshape((4,3)), columns=list('ade'))
# 输出df
print df
# 根据df创建一个Series
s = df.ix[0]
# 输出s
print s

df1 = df.ix[[0,1],column=[列1,列2]]

对Series和DataFrame用索引排序

Series:
s.sort_index()

DataFrame:
df.sort_index(axis=0/1, ascending=True/False)
axis不填默认行索引, ascending不填默认升序

对Series和DataFrame用值进行排序

Series: s.sort_values()

NaN默认在最后

DataFrame:
按列排序
df.sort_index(by='列')

按多个列排序
df.sort_index(by=['列1','列2'])

reindex 重建索引

Series:
通过reindex可以重新构建索引

重新建一个a,b,c,d的索引, 如果原来没有的话则补充为0obj.reindex(['a','b','c','d'], fill_value=0, method=ffill/bfill)

method有几个选项: ’ffill’或’pad 使用前面的值填充, ’bfill’或’backfill 使用后面的值填充

DataFrame:
print frame.reindex(index=[‘a’,’b’,’c’,’d’], columns=new_columns, method=’ffill’)

group by

1
2
3
4
5
6
7
8
9
10
data = pandas.DataFrame([[1,2,3],[1,5,6],[7,8,9]], columns=['A','B','C'])
group = data.groupby(by=['A'])
print(group.size())

# 结果:
#A
#1    2
#7    1

print(group.sum())

stack

1
2
3
4
5
6
7
8
9
10
11
12
13
14
data.stack()

0  A    1
   B    2
   C    3
1  A    1
   B    5
   C    6
2  A    7
   B    8
   C    9
dtype: int64

Process finished with exit code 0

merge 合并 理解成2个dataframe取交集

如果行列能够对上, 那么就可以取出来
pandas.merge(a, b)

concat 合并

理解成union
pandas.merge([a,b], axis=0)和pandas.merge([a,b], axis=1)

append 追加

上下连接, 跟pandas.merge([a,b], axis=0)一样,
a.append(b)

read_csv

读取数据: pd.read_csv('文件路径')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
name age
zhangsan 8
lisi     5

data = pd.read_csv('file.csv')
# 索引
print(data.index) => 0到1
# 列
print(data.columns) => ['name','age']
# 数据个数
print(len(data)) => 2
# 行列数
print(data.shape) => (2,2)
# 打印头部, 默认展示前5行
print(data.head(n))
# 打印尾部, 默认展示后5行
print(data.tail(n))
# 打印数据信息
print(data.info())

matplotlib

最基础的模块是pyplot

pyplot.plot(x轴数据, y轴数据, 样式)
样式: b–, b表示线的颜色blue, –表示虚线

使用pyplot.show()显示图型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
fig = plt.figure()
# 创建三张子图
ax1 = fig.add_subplot(2,2,1)
ax2 = fig.add_subplot(2,2,2)
ax3 = fig.add_subplot(2,2,3)
# 显示
plt.show()

.add_subplot(行数，列数，位置)
位置是按照从左往右，从上到下自动排列

Axes对象
Title是图像标题, Axis是坐标轴, Label是坐标轴标注, Tick是刻度线

plt.xlabel()
plt.ylabel()
plt.title()
plt.legend(): 标示不同图形的文本标签图例
plt.tight_layout(): 固定我们的布局, 避免出现子表

# 创建子图第一种方法
plt.subplot(2,2,1) -> 直接回将plt切换到这个子表, 调用plt.plot(x,y)对子表进行赋值

# 创建子图第二种方法
pc1=plt.subplot2grid((3,3),(1,1),rowspan=1,colspan=2)
↑首先理解成一个坐标轴, (3,3)指的是大表的大小, (1,1)指的是这个图左上角的坐标, rowspan指占一行, colspan指占2行
通过pc1来操作这个子表

# 创建子图第三种方法
引入matplotlib.gridspec函数
# 创建了一个3*3的表
gs = gridspec.GridSpec(3,3)
# 占据第一行三列
plt.subplot(gs[0,:])
# 占据第二行,第三列
plt.subplot(gs[1,2])

# 创建子图第四种方法
c,((pc1,pc2),(pc3,pc4))plt.subplots(2,2)
将4个区域赋值给pc1,pc2,pc3,pc4, 这里为什么还有c这个值呢?因为c可以统一控制这四个子图

# 散点图
plt.scatter(x,y,alpha(透明度),c(设置颜色),s(控制点大小),marker(控制点的形状))

# 直方图
plt.hist(data,bins(方块的个数),normed(),facecolor(颜色),edgecolor(直方图勾边颜色))

# 条形图
plt.bar(data, left(柱子在x轴上的坐标),height(长条形高度),width(长条形宽度),label(标签))

# 饼图
plt.pie(data,explode(设置各部分突出),label(设置各部分标签))
plt.axis("equal") => 设置饼图是否是圆的

# 等高线图
plt.contour()

# 3D曲面
from mpl_toolkits.mplot3d import Axes3D
ax3d=Axes3D(plt.figure())
ax3d.plot_surface()

# 解决无法显示中文问题
lot.rcParams['font.sans-serif']=['SimHei']

scipy

linalg 线性代数

1
2
3
4
5
6
7
8
9
10
11
# 矩阵求逆
linalg.inv()

# Ax = b, 求解x
linalg.sovle(A, b)

# 解决线性最小二乘法
linalg.lstsq

# 计算矩阵A的特性值和特性向量
linalg.eig(A)

plotly

graph_objs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
trace = graph_objs.Scatter(x轴数据, y轴数据, mode="", name="线的名字")
# mode = "marker" => 散点图
# mode = 'lines+markers' => 折线+散点
data = graph_objs.Data([trace])
plotly.iplot(data)

# 3D图
surface = Surface(x=x, y=y, z=z)
data = Data([surface])

# 柱状图
trace2 = graph_objs.Bar(
    x=['giraffes', 'orangutans', 'monkeys'],
    y=[12, 18, 29],
    name='LA Zoo'
)

# 饼图
trace = graph_objs.Pie(labels=labels, values=values,
             hoverinfo='label+percent', textinfo='value', 
             textfont=dict(size=20),
             marker=dict(colors=colors, 
                         line=dict(color='#000000', width=2)))

plotly.iplot([trace])

plotly, matplotlib, bokeh,Seaborn的区别

matplotlib: Matplotlib应该是最广泛使用的Python可视化工具，支持的图形种类非常多
plotly: 非常强大的Python可视化库，Plotly内置完整的交互能力及编辑工具，支持在线和离线模式
bokeh: 一个专门针对Web浏览器的呈现功能的交互式可视化Python库
Seaborn: 用于补充matplotlib函数. sns.setstyle来设置样式, sinplot来输出结果, despine来移除左边及底部轴线, color_palette调色, distplot默认绘制直方图和kdeplot核密度估计图, joinplot二元变量分布函数,stripplot来绘制散点图但点会重合, swarmplot也可以绘制散点图但点不会重合,boxplot来绘制箱位图,violinplot绘制小提琴图,implot和regplot跟拟合有关,FacetGrid绘制网格图表

原文作者：itibanst

原文链接：https://st19950627.github.io/2022/10/16/python学习/

发表日期：October 16th 2022, 8:11:22 pm

更新日期：July 18th 2023, 11:58:37 pm

版权声明：本文采用知识共享署名-非商业性使用 4.0 国际许可协议进行许可

CATALOG
  1. 1. python基础学习
    1. 1.1. isdecimal\isdigit\isnumeric
    2. 1.2. 迭代器
    3. 1.3. 继承
    4. 1.4. 文件
    5. 1.5. Numpy
      1. 1.5.1. ndarray数据类型
        1. 1.5.1.1. take 取出索引相应值
        2. 1.5.1.2. ravel 将数组拉成一维数组
        3. 1.5.1.3. flattern 将数组拉成一维数组
        4. 1.5.1.4. reshape 形状变换
        5. 1.5.1.5. flatten 拉平
        6. 1.5.1.6. hstack 水平组合
        7. 1.5.1.7. concatenate
        8. 1.5.1.8. vstack 垂直组合
        9. 1.5.1.9. dstack 深度组合
        10. 1.5.1.10. row_stack
        11. 1.5.1.11. column_stack
        12. 1.5.1.12. vsplit 按照行拆分
        13. 1.5.1.13. tile 平铺函数
        14. 1.5.1.14. repeat(a, repeats, aixs=None) 函数
        15. 1.5.1.15. delete 删除
        16. 1.5.1.16. insert 插入数据
        17. 1.5.1.17. append 插入数据
        18. 1.5.1.18. savetxt 将数据存储到文件中
        19. 1.5.1.19. 读取csv文件
        20. 1.5.1.20. T 转置
        21. 1.5.1.21. mean 平均数计算
        22. 1.5.1.22. sum 计算和
        23. 1.5.1.23. cumsum和cumprod 统计操作
        24. 1.5.1.24. max和min
        25. 1.5.1.25. argmin、argmax
        26. 1.5.1.26. average 平均数
        27. 1.5.1.27. ptp 取范围
        28. 1.5.1.28. median 取中位数
        29. 1.5.1.29. sort 行排序
        30. 1.5.1.30. msort 列排序
        31. 1.5.1.31. var 方差
        32. 1.5.1.32. diff 后一个元素减去前一个元素
        33. 1.5.1.33. std 标准差
        34. 1.5.1.34. linspace 等差数列
        35. 1.5.1.35. meshgrid 生成网格点坐标矩阵
    6. 1.6. json
      1. 1.6.1. loads和load
    7. 1.7. 内存管理机制
      1. 1.7.1. 引用计数
        1. 1.7.1.1. 引用计数增加
        2. 1.7.1.2. 引用计数减少
      2. 1.7.2. 垃圾回收
      3. 1.7.3. 内存池机制
    8. 1.8. 拆包
    9. 1.9. 封包
    10. 1.10. 推导式/生成器表达式
      1. 1.10.1. yield
      2. 1.10.2. yield from
    11. 1.11. file
      1. 1.11.1. 上下文
    12. 1.12. 设计模式
      1. 1.12.1. 单例模式
        1. 1.12.1.1. 使用模块
        2. 1.12.1.2. 使用new方法
        3. 1.12.1.3. 装饰器
        4. 1.12.1.4. 元类
    13. 1.13. 继承
      1. 1.13.1. MRO
        1. 1.13.1.1. 如何查看方法解析顺序
    14. 1.14. 动态创建类
    15. 1.15. 设计模式六大原则
    16. 1.16. 设计模式
    17. 1.17. sys模块
    18. 1.18. datetime模块
    19. 1.19. Pandas
      1. 1.19.1. Series
        1. 1.19.1.1. + 并集运算
        2. 1.19.1.2. 删除指定项
      2. 1.19.2. Frame
        1. 1.19.2.1. + 并集
        2. 1.19.2.2. 算数方法
        3. 1.19.2.3. 删除指定项
      3. 1.19.3. 二维数组和一位数组的运算
      4. 1.19.4. 对Series和DataFrame用索引排序
      5. 1.19.5. 对Series和DataFrame用值进行排序
      6. 1.19.6. reindex 重建索引
      7. 1.19.7. group by
      8. 1.19.8. stack
      9. 1.19.9. merge 合并 理解成2个dataframe取交集
      10. 1.19.10. concat 合并
      11. 1.19.11. append 追加
      12. 1.19.12. read_csv
    20. 1.20. matplotlib
    21. 1.21. scipy
      1. 1.21.1. linalg 线性代数
    22. 1.22. plotly
      1. 1.22.1. graph_objs
    23. 1.23. plotly, matplotlib, bokeh,Seaborn的区别
Total : 39
2023
2022
2021
2020
2019
Apollo Docker Dynamic Datasource ELK 日志系统 Gradle hexo K8S Linux List Set Map SLF4J 日志 JDK8 Restful adobe 插件 Token Session Cookie SpringBoot LIVER 定时任务 leetcode Electron JAVA 算法 回溯法 资产托管 托管 测试 Redis Api 递归 设计模式 编程规范 推荐系统 前端 React vue