Python-Pandas入门

最新推荐文章于 2024-07-17 21:04:45 发布
最新推荐文章于 2024-07-17 21:04:45 发布
阅读量170 收藏 1
点赞数 1
分类专栏： python 文章标签： Pandas python machine learning deep learning
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36785187/article/details/80875649
版权

Pandas入门

Numpy 和 Pandas有什么不同
Numpy是列表形式的，没有index标签，而Pandas则类似于字典，会带标签。Pandas是基于Numpy构建的。
Pandas主要有俩个数据结构：Series和DataFrame

Series
<<< import pandas as pd
<<< import numpy as np
<<< s = pd.Series([1,3,6,np,nan,44,1])
<<< print(s)
"""
0     1.0
1     3.0
2     6.0
3     NaN
4    44.0
5     1.0
dtype: float64
"""
Series会出出现俩部分，左边的index部分和右边的value部分，在没有指定索引的情况下，会自动创建一个0到N-1的整数型索引。

DataFrame
<<< dates = pd.date_range('20160101', periods = 6)
<<< df = pd.DataFrame(np.random.randn(6,4), index = dates, columns = ['a','b','c','d'])
<<< print(df)
"""
                   a         b         c         d
2016-01-01 -0.253065 -2.071051 -0.640515  0.613663
2016-01-02 -1.147178  1.532470  0.989255 -0.499761
2016-01-03  1.221656 -2.390171  1.862914  0.778070
2016-01-04  1.473877 -0.046419  0.610046  0.204672
2016-01-05 -1.584752 -0.700592  1.487264 -1.778293
2016-01-06  0.633675 -1.414157 -0.277066 -0.442545
"""
DataFrame 是表格形状的数据结构，包含一组有序的列，每一列可以由不同的值类型构成。并且既有行索引也有列索引，可以看作是由Series组成的大字典。我们可以根据每一个不同的索引来挑选数据。
<<< print(df['b'])

"""
2016-01-01   -2.071051
2016-01-02    1.532470
2016-01-03   -2.390171
2016-01-04   -0.046419
2016-01-05   -0.700592
2016-01-06   -1.414157
Freq: D, Name: b, dtype: float64
"""
当然也可以创建一组不指定行标签和列标签的数据df1:
<<< df1 = pd.DataFrame(np.arange(12).reshape((3,4)))
<<< print (df1)
"""
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
"""
这样，就会采用默认的0到N-1的方式来index，还有另外一种生成df的方法，例如df2:
<<< df2 = pd.DataFrame({'A':1.,
        'B':pd.Timestamp('20130102),
        'C':pd.Series(1,index = list(range(4)), dtype = 'float32'),
        'D':np.array([3] * 4, dtype = 'int32'),
        'E':pd..Categorical(["test", "train", "test", "train"]),
        'F':'foo'})
<<< print(df2)

"""
     A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
2  1.0 2013-01-02  1.0  3   test  foo
3  1.0 2013-01-02  1.0  3  train  foo
"""
如果想要查看数据类型，可以用dtype这个属性：
<<< print(df2.dtypes)

"""
df2.dtypes
A           float64
B    datetime64[ns]
C           float32
D             int32
E          category
F            object
dtype: object
"""
查看序号以及每种数据的名称以及值分别为：
<<< print(df2.index)
# Int64Index([0, 1, 2, 3], dtype='int64')

<<< print(df2.columns)
# Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')

<<< print(df2.values)
"""
array([[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo']], dtype=object)
"""
想查看数据的总结，则采用方法describe():
<<< df2.describe()

"""
         A    C    D
count  4.0  4.0  4.0
mean   1.0  1.0  3.0
std    0.0  0.0  0.0
min    1.0  1.0  3.0
25%    1.0  1.0  3.0
50%    1.0  1.0  3.0
75%    1.0  1.0  3.0
max    1.0  1.0  3.0
"""
翻转数据也是采用:
<<< print(df2.T)

"""                   
0                    1                    2  \
A                    1                    1                    1   
B  2013-01-02 00:00:00  2013-01-02 00:00:00  2013-01-02 00:00:00   
C                    1                    1                    1   
D                    3                    3                    3   
E                 test                train                 test   
F                  foo                  foo                  foo   

                     3  
A                    1  
B  2013-01-02 00:00:00  
C                    1  
D                    3  
E                train  
F                  foo  

"""
对index排序输出则用sort:
<<< print(df2.sort_index(axis = 1, ascending = False))

"""
     F      E  D    C          B    A
0  foo   test  3  1.0 2013-01-02  1.0
1  foo  train  3  1.0 2013-01-02  1.0
2  foo   test  3  1.0 2013-01-02  1.0
3  foo  train  3  1.0 2013-01-02  1.0
"""
对数据值排序输出则是：
<<< print(df2.sort_values(by='B'))
"""
     A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
2  1.0 2013-01-02  1.0  3   test  foo
3  1.0 2013-01-02  1.0  3  train  foo
"""

Pandas选择数据

简单的选取DataFrame中的数据：
<<< print(df['A'])
<<< print(df.A)

"""
2013-01-01     0
2013-01-02     4
2013-01-03     8
2013-01-04    12
2013-01-05    16
2013-01-06    20
Freq: D, Name: A, dtype: int64
"""
选择跨越行则是：
<<< print(df[0:3])
"""
            A  B   C   D
2013-01-01  0  1   2   3
2013-01-02  4  5   6   7
2013-01-03  8  9  10  11
"""
<<< print(df['20130102':'20130104'])

"""
A   B   C   D
2013-01-02   4   5   6   7
2013-01-03   8   9  10  11
2013-01-04  12  13  14  15
"""
如果df[3:3]将会是一个空的对象。后者选择20130102到20130104之间的数据，并且包括这俩个标签

我们还能通过loc来定义某行或者所有行，然后选其中某列或者所有列（":"代表所有）
<<< print(df.loc['20130102'])
"""
A    4
B    5
C    6
D    7
Name: 2013-01-02 00:00:00, dtype: int64
"""

<<< print(df.loc[:,['A','B']])
"""
             A   B
2013-01-01   0   1
2013-01-02   4   5
2013-01-03   8   9
2013-01-04  12  13
2013-01-05  16  17
2013-01-06  20  21
"""

<<< print(df.loc['20130102',['A','B']])
"""
A    4
B    5
Name: 2013-01-02 00:00:00, dtype: int64
"""

根据序列iloc来定位，可以选某一个，连续选，或者跨行选：
<<< print(df.iloc[3,1])
# 13

<<< print(df.iloc[3:5,1:3])
"""
             B   C
2013-01-04  13  14
2013-01-05  17  18
"""

<<< print(df.iloc[[1,3,5],1:3])
"""
             B   C
2013-01-02   5   6
2013-01-04  13  14
2013-01-06  21  22

"""

混合俩种选择方式的ix：
<<< print(df.ix[:3,['A','C']])
"""
            A   C
2013-01-01  0   2
2013-01-02  4   6
2013-01-03  8  10
"""
还可以通过判断指令选择，约束某项条件然后选择出当前所有数据：
<<< print(df[df.A>8])
"""
             A   B   C   D
2013-01-04  12  13  14  15
2013-01-05  16  17  18  19
2013-01-06  20  21  22  23
"""

Pandas设置值
可以根据位置设置loc和iloc来直接修改：
<<< df.iloc[2,2] = 1111
<<< df.loc['20130101','B'] = 2222

"""
             A     B     C   D
2013-01-01   0  2222     2   3
2013-01-02   4     5     6   7
2013-01-03   8     9  1111  11
2013-01-04  12    13    14  15
2013-01-05  16    17    18  19
2013-01-06  20    21    22  23
"""
或者根据条件来设置：
<<< df.B[df.A>4] = 0
"""
                A     B     C   D
2013-01-01   0  2222     2   3
2013-01-02   4     5     6   7
2013-01-03   8     0  1111  11
2013-01-04  12     0    14  15
2013-01-05  16     0    18  19
2013-01-06  20     0    22  23
"""

或者整行或者整列来设置：
<<< df['F'] = np.nan
"""
             A     B     C   D   F
2013-01-01   0  2222     2   3 NaN
2013-01-02   4     5     6   7 NaN
2013-01-03   8     0  1111  11 NaN
2013-01-04  12     0    14  15 NaN
2013-01-05  16     0    18  19 NaN
2013-01-06  20     0    22  23 NaN
"""
也可以添加一个Series序列，但是长度必须要对齐：
<<< df['E'] = pd.Series([1,2,3,4,5,6], index=pd.date_range('20130101',periods=6))
"""
             A     B     C   D   F  E
2013-01-01   0  2222     2   3 NaN  1
2013-01-02   4     5     6   7 NaN  2
2013-01-03   8     0  1111  11 NaN  3
2013-01-04  12     0    14  15 NaN  4
2013-01-05  16     0    18  19 NaN  5
2013-01-06  20     0    22  23 NaN  6
"""

Pandas处理丢失的数据（NaN）
直接去掉含有NaN的行或者列，采用dropna()
<<< df.dropna(
<<<     axis=0,     # 0: 对行进行操作; 1: 对列进行操作
<<<     how='any'   # 'any': 只要存在 NaN 就 drop 掉; 'all': 必须全部是 NaN 才 drop
<<<     )
"""
             A     B     C   D
2013-01-03   8   9.0  10.0  11
2013-01-04  12  13.0  14.0  15
2013-01-05  16  17.0  18.0  19
2013-01-06  20  21.0  22.0  23
"""
或者填充为其他值：
<<< df.fillna(value=0)
"""
             A     B     C   D
2013-01-01   0   0.0   2.0   3
2013-01-02   4   5.0   0.0   7
2013-01-03   8   9.0  10.0  11
2013-01-04  12  13.0  14.0  15
2013-01-05  16  17.0  18.0  19
2013-01-06  20  21.0  22.0  23
"""
也可以判断是否含有缺失数据NaN，为True表示含有
<<< df.isnull()
"""
                A      B      C      D
2013-01-01  False   True  False  False
2013-01-02  False  False   True  False
2013-01-03  False  False  False  False
2013-01-04  False  False  False  False
2013-01-05  False  False  False  False
2013-01-06  False  False  False  False
"""
<<< np.any(df.isnull()) == True  
# True

Pandas导入与导出数据
csv、excel、json、html与pickle都是同样前缀代码.

import pandas as pd #加载模块

#读取csv
<<< data = pd.read_csv('student.csv')

#打印出data
<<< print(data)

<<< data.to_pickle('student.pickle')

Pandas合并
axis=0是默认值，因此未设定任何参数时，函数默认axis=0。

<<< import pandas as pd
<<< import numpy as np

#定义资料集
<<< df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'])
<<< df2 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
<<< df3 = pd.DataFrame(np.ones((3,4))*2, columns=['a','b','c','d'])

#concat纵向合并
<<< res = pd.concat([df1, df2, df3], axis=0)

#打印结果
<<< print(res)
#     a    b    c    d
# 0  0.0  0.0  0.0  0.0
# 1  0.0  0.0  0.0  0.0
# 2  0.0  0.0  0.0  0.0
# 0  1.0  1.0  1.0  1.0
# 1  1.0  1.0  1.0  1.0
# 2  1.0  1.0  1.0  1.0
# 0  2.0  2.0  2.0  2.0
# 1  2.0  2.0  2.0  2.0
# 2  2.0  2.0  2.0  2.0

但是我们发现，他的index值会重叠，所以如果需要重置，则使用：
#承上一个例子，并将index_ignore设定为True
<<< res = pd.concat([df1, df2, df3], axis=0, ignore_index=True)

#打印结果
<<< print(res)
#     a    b    c    d
# 0  0.0  0.0  0.0  0.0
# 1  0.0  0.0  0.0  0.0
# 2  0.0  0.0  0.0  0.0
# 3  1.0  1.0  1.0  1.0
# 4  1.0  1.0  1.0  1.0
# 5  1.0  1.0  1.0  1.0
# 6  2.0  2.0  2.0  2.0
# 7  2.0  2.0  2.0  2.0
# 8  2.0  2.0  2.0  2.0

而怎么根据关键字key来合并和，这个用于数据表中比较多：

<<< import pandas as pd

#定义资料集并打印出
<<< left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                             'A': ['A0', 'A1', 'A2', 'A3'],
                             'B': ['B0', 'B1', 'B2', 'B3']})
<<< right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                              'C': ['C0', 'C1', 'C2', 'C3'],
                              'D': ['D0', 'D1', 'D2', 'D3']})

<<< print(left)
#    A   B key
# 0  A0  B0  K0
# 1  A1  B1  K1
# 2  A2  B2  K2
# 3  A3  B3  K3

<<< print(right)
#    C   D key
# 0  C0  D0  K0
# 1  C1  D1  K1
# 2  C2  D2  K2
# 3  C3  D3  K3

#依据key column合并，并打印出
<<< res = pd.merge(left, right, on='key')

<<< print(res)
     A   B key   C   D
# 0  A0  B0  K0  C0  D0
# 1  A1  B1  K1  C1  D1
# 2  A2  B2  K2  C2  D2
# 3  A3  B3  K3  C3  D3

而合并其实有4中how = ['left', 'right', 'outer', 'inner']，预设值how='inner'。
依据俩组key来合并则需要：
#定义资料集并打印出
<<< left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                      'key2': ['K0', 'K1', 'K0', 'K1'],
                      'A': ['A0', 'A1', 'A2', 'A3'],
                      'B': ['B0', 'B1', 'B2', 'B3']})
<<< right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                       'key2': ['K0', 'K0', 'K0', 'K0'],
                       'C': ['C0', 'C1', 'C2', 'C3'],
                       'D': ['D0', 'D1', 'D2', 'D3']})

<<< print(left)
#    A   B key1 key2
# 0  A0  B0   K0   K0
# 1  A1  B1   K0   K1
# 2  A2  B2   K1   K0
# 3  A3  B3   K2   K1

<<< print(right)
#    C   D key1 key2
# 0  C0  D0   K0   K0
# 1  C1  D1   K1   K0
# 2  C2  D2   K1   K0
# 3  C3  D3   K2   K0

#依据key1与key2 columns进行合并，并打印出四种结果['left', 'right', 'outer', 'inner']
<<< res = pd.merge(left, right, on=['key1', 'key2'], how='inner')
<<< print(res)
#    A   B key1 key2   C   D
# 0  A0  B0   K0   K0  C0  D0
# 1  A2  B2   K1   K0  C1  D1
# 2  A2  B2   K1   K0  C2  D2

<<< res = pd.merge(left, right, on=['key1', 'key2'], how='outer')
<<< print(res)
#     A    B key1 key2    C    D
# 0   A0   B0   K0   K0   C0   D0
# 1   A1   B1   K0   K1  NaN  NaN
# 2   A2   B2   K1   K0   C1   D1
# 3   A2   B2   K1   K0   C2   D2
# 4   A3   B3   K2   K1  NaN  NaN
# 5  NaN  NaN   K2   K0   C3   D3

<<< res = pd.merge(left, right, on=['key1', 'key2'], how='left')
<<< print(res)
#    A   B key1 key2    C    D
# 0  A0  B0   K0   K0   C0   D0
# 1  A1  B1   K0   K1  NaN  NaN
# 2  A2  B2   K1   K0   C1   D1
# 3  A2  B2   K1   K0   C2   D2
# 4  A3  B3   K2   K1  NaN  NaN

<<< res = pd.merge(left, right, on=['key1', 'key2'], how='right')
<<< print(res)
#     A    B key1 key2   C   D
# 0   A0   B0   K0   K0  C0  D0
# 1   A2   B2   K1   K0  C1  D1
# 2   A2   B2   K1   K0  C2  D2
# 3  NaN  NaN   K2   K0  C3  D3
而怎么根据index来合并呢？
#定义资料集并打印出
<<< left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                     'B': ['B0', 'B1', 'B2']},
                     index=['K0', 'K1', 'K2'])
<<< right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
                      'D': ['D0', 'D2', 'D3']},
                     index=['K0', 'K2', 'K3'])

<<< print(left)
#     A   B
# K0  A0  B0
# K1  A1  B1
# K2  A2  B2

<<< print(right)
#     C   D
# K0  C0  D0
# K2  C2  D2
# K3  C3  D3

#依据左右资料集的index进行合并，how='outer',并打印出
<<< res = pd.merge(left, right, left_index=True, right_index=True, how='outer')
<<< print(res)
#      A    B    C    D
# K0   A0   B0   C0   D0
# K1   A1   B1  NaN  NaN
# K2   A2   B2   C2   D2
# K3  NaN  NaN   C3   D3

#依据左右资料集的index进行合并，how='inner',并打印出
<<< res = pd.merge(left, right, left_index=True, right_index=True, how='inner')
<<< print(res)
#     A   B   C   D
# K0  A0  B0  C0  D0
# K2  A2  B2  C2  D2

解决overlapping问题：
<<< import pandas as pd
#定义资料集
<<< boys = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'age': [1, 2, 3]})
<<< girls = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'age': [4, 5, 6]})

使用suffixes解决overlapping的问题
<<< res = pd.merge(boys, girls, on='k', suffixes=['_boy', '_girl'], how='inner')
<<< print(res)
#    age_boy   k  age_girl
# 0        1  K0         4
# 1        1  K0         5

PzySeere
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python-pandas基础习题与答案
07-06
Python中的pandas与matplotlib,numpy等库进行数据分析的一些基础代码。
数据分析-pandas入门-案例分析
09-08
本文将深入探讨在"数据分析-pandas入门-案例分析"中的关键知识点，帮助你更好地掌握Pandas的使用。 首先，让我们来关注分类数据。在数据科学中，分类数据是指那些可以被归入特定类别或种类的数据，如性别、国籍或...
数据分析-pandas入门-数据聚合与分组
09-08
系列文章“Python数据分析之Pandas入门（中）”的第七小节，主要介绍了在载入、合并和准备数据集后，可能还需要对源数据集进行过滤、变换和分割等操作。，本节内容与 中的“六、数据规整”一同作为将用于报告的数据...
《量化交易入门（十三）Python开发－pandas》配套源码
03-30
《量化交易入门（十三）Python开发－pandas》配套源码提供了实践示例，帮助读者更好地理解和应用相关知识。 1. **pandas简介**： pandas是Python的一个数据分析库，它提供了高效的数据结构，如Series（一维数据...
wotkit-example-python-pandas:一个示例 Python 应用程序，演示了一个使用 Pandas 库进行数据分析的 Python 应用程序
05-31
入门 使用pip安装 Flask。 Flask 是 Python 应用程序的微框架 ( )。 pip install Flask 安装 Flask OAuth，一个使用oauthlib与远程 OAuth 应用程序交互的 Flask 扩展（ ） pip install Flask-OAuthlib 我们需要...
cv2读取和保存图片
m0_53291740的博客
07-12 267
cv2.imwrite('b\\img1.png',img)#b存在就可以保存进去。如果b存在，c不存在，程序不会报错，也不会保存图片。如果目录b不存在就会存到当前文件夹。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 785
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
华为od机试真题 — 代表团坐车(Python)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
07-17 526
【华为od机试真题 】代表团坐车(Python) 某组织举行会议，来了多个代表团同时到达，接待处只有一辆汽车可以同时接待多个代表团，为了提高车辆利用率，请帮接待员计算可以坐满车的接待方案输出方案数量。
IPython 日志秘籍：%logstate 命令全解析
2401_85812026的博客
07-17 489
logstate命令是 IPython 日志系统的重要组成部分，它帮助我们掌控日志记录的状态。通过本文的介绍，你应该对如何在 IPython 中使用%logstate查看日志状态有了更深入的理解。记住，合理利用日志系统，可以让你的数据探索过程更加透明和可追溯。本文详细介绍了 IPython 的%logstate命令，包括其基本概念、基本用法、输出解析以及实战示例。希望本文能够帮助读者更好地利用 IPython 的日志系统，优化数据探索和科学计算的工作流。记住，掌握%logstate。
Python每日一题：回文数
xiongxiaoxuan的博客
07-16 234
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。给你一个整数 x ，如果 x 是一个回文整数，返回 true；否则，返回 false。解释：从左向右读, 为 -121。从右向左读, 为 121-。因此它不是一个回文数。先将整数x转化为字符串形式，判断x和它的反转形态是否完全相等。解释：从右向左读, 为 01。需注意：True和False首字母大写！提示：-231
N7翻译实战
最新发布
tjl521314_21的博客
07-17 224
本周完成项目实战用于训练一个简单的序列到序列（seq2seq）模型以实现英语到法语的翻译。数据预处理、模型构建、训练以及可视化损失的过程。本周学习了构建和训练一个简单的seq2seq模型用于英语到法语的翻译，对前面的知识做了一个综合的运用。
Gradio从入门到精通（1）---快速入门
疯狂飙车的蜗牛的博客
07-15 1358
Gradio 是一个开源 Python 包，允许您为机器学习模型、API 或任何任意 Python 函数快速构建演示或 Web 应用程序。然后，您可以使用 Gradio 的内置共享功能在几秒钟内共享指向演示或 Web 应用程序的链接。无需 JavaScript、CSS 或 Web 托管经验！Gradio最大的特点就是简单，便捷，短短几行代码就可以快速构建大模型web应用程序；当前很多人工智能模型的演示都是使用Gradio打造的；您会注意到，为了制作第一个演示，您创建了该类的实例。
sklearn基础教程：掌握机器学习入门的钥匙
AIGC绘图领域探索者，热衷于将创意与技术融合，致力于分享前沿AI绘图技巧与心得，让我们一起开启视觉艺术的新篇章。
07-13 969
是基于Python的一个开源机器学习库，它建立在NumPy、SciPy和matplotlib之上，提供了大量的算法和工具，用于数据挖掘和数据分析。无论是简单的线性回归，还是复杂的神经网络，sklearn都能提供直观易用的接口。作为Python中最为流行的机器学习库之一，以其简洁的API、丰富的算法和强大的功能赢得了广大用户的青睐。通过本文的介绍，相信你已经对sklearn有了初步的了解，并能够开始进行一些基础的机器学习任务。
文件在Linux下为binary格式在Windows下为utf-8格式
qq_38220334的博客
07-17 263
想着是不是之前遇到的问题，有可能是文件中含有特殊字符，然后用vim命令来编辑这个文件，发现，还真是含有一个特殊字符，然后将它删除掉，文件就变成utf-8格式的文件了。在Windows下和Mac下都是没有问题的，在华为云服务器上也是没问题的（操作系统不是centos），但是在自己搭建的Linux服务器（centos）上是有问题的。用shell或者Python脚本去将这个文件转为utf-8格式的，但是都失败了。
AIGC专栏13——ComfyUI 插件编写细节解析-以EasyAnimateV3为例
Bubbliiiing的学习小课堂
07-13 3598
最近在给EasyAnimateV3写ComfyUI的工作流，以方便别人测试。学习了ComfyUI的基本操作，也看了一下别人是怎么写的，自己也折腾了一下。在人工智能艺术创作的领域里，Stable Diffusion 凭借其开放源代码的特性，吸引了众多开发者与艺术家的目光，并且因为强大的社区支持而展现出强大的影响力。Stable Diffusion 的两大主流创作平台分别是 Stable Diffusion WebUI 与 ComfyUI。
Python进阶 2024/7/10
weixin_73793099的博客
07-12 270
open（）打开函数name:打开的目标文件的字符串，可以包含文件所在的具体路径mode：访问模式，只读，只写，追加encoding：编码格式，推荐使用UTF-8r：只读w：用于写入a:用于追加，如果该文件已经存在，新的内容会被写到已有的内容之后；如果文件不存在，创建新文件进行写入。
ios CCUIAlertActivityView.m
编程语言技巧经验分享
07-17 413
// // CCUIAlertActivityView.m // CCFC // // #import "CCUIAlertActivityView.h" #import "CCNSNumber.h" #import "CCU
智能优化算法之模拟退火算法SA
Argulo的博客
07-13 351
模拟退火算法（Simulated Annealing, SA）是一种基于热力学原理的随机优化算法，最早由 S. Kirkpatrick, C. D. Gelatt 和 M. P. Vecchi 于 1983 年提出。在优化过程中，算法允许在一定概率下接受较差的解，以避免陷入局部最优解。在每次迭代中，从当前路径的邻域中随机选择一个新路径。计算新路径的长度，并根据接受准则决定是否接受新路径。：绘制城市坐标图和优化过程中最佳路径长度的变化曲线。：调用模拟退火算法，并输出最佳路径和最佳路径长度。
多线程编程中的条件变量及其优化
weixin_41489908的博客
07-13 204
本套课在线学习视频（网盘地址，保存到网盘即可免费观看）：链接：https://pan.quark.cn/s/7220b198cf00在多线程编程中，条件变量是一种用于线程间通信和同步的机制。通过使用条件变量，可以有效地协调线程间的关系，优化资源利用，并减少线程在CPU资源上的不必要占用。本文将通过Python示例代码，详细介绍如何在多线程环境中使用条件变量。
Python pandas入门：数据结构与创建
"Python数据分析之pandas学习是一篇深入介绍如何使用pandas库进行数据处理和分析的文章...这个概述涵盖了pandas的基本概念、核心数据结构的创建方法以及它们在数据分析中的应用场景，适合初学者入门和进阶者深化理解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值