大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。
Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺
一.列表，元祖，：
1.元祖：
（1）创建：
tuple01 = ()#创建空元组
tuple01 = (2，) #元组中只包含一个元素时，需要在元素后面添加逗号
tuple01 = (‘joe’,’susan’,’black’,’monika’)
（2）将元组转换为列表：
tup01 = list(tuple01)
（3）查看：
tuple01[0:2] #0-1的元素 的切片， 返回 (‘joe’,’susan’）
tuple01[ 0 ] #返回 ‘joe’
tuple01[ -2] #反向取第二个元素， ‘black’
tuple01[ 1：] #从第二个到最后一个的切片
tuple01[0：10：3] #从0到9，步长为3.，取0,3,6，9
tuple01[：：3] #从头到为尾，步长为3
（4）元组中的元素值是不允许修改的，禁止删除或添加元素，可以del删除整个元祖
（5）连接：
t = （1,2,3）+（4,5,6） #（1,2,3,4,5,6）
#可以使用切片再连接的方式修改元祖元素；或转化为列表
（6）内置函数：
len（t） #长度
max（t）#返回最大元素
min（t）
（7）复制：
tuple01*2 #所有元素复制两倍
（8）元素是否存在：
2 in tuple01 #返回bool
（9）迭代：
for x in tuple01 : print(x)
2.列表：
（1）创建：
list = [1,2,3,4]
（2）参考元祖（2）
（3）添加：
list.append(3)
（4）删除：
del list[1]
（5）操作符：
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| [‘Hi!’] * 4 | [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print x, | 1 2 3 | 迭代 |
（6）转化为元祖：
（7）函数：
| 序号 | 方法 |
|---|---|
| 1 | list.append(obj) 在列表末尾添加新的对象 |
| 2 | list.count(obj) 统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index, obj) 将对象插入列表 |
| 6 | list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj) 移除列表中某个值的第一个匹配项 |
| 8 | list.reverse() 反向列表中元素 |
| 9 | list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序 |
（8）创建一个有规律的二维列表
[[0 for col in range(cols)] for row in range(rows)]
（9）
[x for x in arr if x>5 ] #筛选
[x if x>5 else x+100 for x in arr ]
[x if z else y for x,y,z in zip(arr1,arr2,condition)] #和np.where函数一样的功能；
3.字典：
（1）创建：
dict01 = {‘name1′:’joe’,’name2′:’suan’,’name3′:’anne’}
#不可变类型可以做字典的下标，可变类型不可以，下标不能是列表
（2）访问：
dict01[‘name’]
（3）修改或添加：
dict01[‘address’] = ‘泰国’
#同一个键不能出现两次，否则后者覆盖前者；
（4）删除：
del dict01[‘sex’]
（5）方法：
Python字典包含了以下内置函数：
| 序号 | 函数及描述 |
|---|---|
| 1 | cmp(dict1, dict2) 比较两个字典元素。 |
| 2 | len(dict) 计算字典元素个数，即键的总数。 |
| 3 | str(dict) 输出字典可打印的字符串表示。 |
| 4 | type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 |
Python字典包含了以下内置方法：
| 序号 | 函数及描述 |
|---|---|
| 1 | dict.clear() 删除字典内所有元素 |
| 2 | dict.copy() 返回一个字典的浅复制 |
| 3 | dict.fromkeys(seq[, val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值 |
| 4 | dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值 |
| 5 | dict.has_key(key) 如果键在字典dict里返回true，否则返回false |
| 6 | dict.items() 以列表返回可遍历的(键, 值) 元组数组 |
| 7 | dict.keys() 以列表返回一个字典所有的键 |
| 8 | dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 9 | dict.update(dict2) 把字典dict2的键/值对更新到dict里 |
| 10 | dict.values() 以列表返回字典中的所有值 |
| 11 | pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
| 12 | popitem() 随机返回并删除字典中的一对键和值。 |
二.numpy：
1.numpy创建的数组类型为: numpy.ndarray
2.创建方式：
（1）array方法：
np.array( [1,2,4,5,6] )
np.array( [ [1,2,3] , [3,4,5] ] ) #2*3二维数组
np.array( (1,2,3) ) #传入元祖
np.array( （(1,2,3), (4,5,6) )） #2*3
np.array( [ (1,3,3) , (1,2,3) ] )
（2）zeros,ones,empty方法:
zeros返回全0数组
ones返回全1数组
empty返回全0数组
np.zeros( 6 ) #返回1*6
np.zeros( (2,4) ) #传入元祖，返回2*4数组
np.zeros( (2,4,5) ) #2*4*5
# ones,empty方法使用方式类似
（3）arange方法：
np.arange(5) #默认从0开始，到4的整数数组，默认步长为1
np.array(1,5) #从1开始到4
np.array(1,10,3) #从1到9，步长为3
np.array(10,3,-2) #从10到2，步长为2
（4）linespace，logspace方法：
np.linespace(1,10,5) #从1到10的等差数列，5个数
np.logspace(1,2,5,base=10) #从10**1到10**2的等比数列，5个数，不设base默认以e为底
（5）random模块：
np.random.random( (2,3) ) #传入元祖，2*3数组，元素是0-1随机浮点数，返回类型是列表；
np.random.rand（2,3） #不传元祖,元素是0-1随机浮点数，2*3，
np.random.randn( 2,3 ) #不传元祖 ,元素是服从标准正态分布的随机样本，大部分在[-2,2]之间，2*3
np.random.randint(1,10,(2,3)) #1到9之间的随机整数，2*3
2.ndarray的属性：
arr = np.array(np.random.randint(1,9,(2,3,4)))
arr.ndim #ndarray维度，3
arr.shape #形状 （2,3,4）
arr.size #元素个数 ，24
arr.itemsize #每个元素占字节数 ，4
arr01 = np.array([1,2,3,4,5],dtype = np.float32) #dtype 指定元素类型 有int,float32,float64,double多种类型
arr02 = arr01.astype(np.int) #修改元素类型
arr02.dtype #返回元素类型
3.修改形状：
（1）
arr01 = np.random.randint(1,9,(3,4))
arr04.shape = (4,3) #先把3*4数组变成一维列表，再排成4*3数组；数组元素总数不变的；
例：
修改前：
[[1, 5, 6, 3],
[4, 4, 6, 4],
[1, 1, 7, 6]]
修改后：
[[1, 5, 6],
[3, 4, 4],
[6, 4, 1],
[1, 7, 6]]
arr01.shape = (12) # [1, 5, 6, 3, 4, 4, 6, 4, 1, 1, 7, 6]
（2）reshape：
arr01.reshape(2,6)
降维操作：
arr01 = np.random.randint(1,9,(3,4,5))
arr07.reshape(5,-1) #3*4*5维数组变成5*n；n=12
（3）升维操作：
arr1 = np.random.randint(1,9,(2,2))
arr1[:,np.newaxis，:] #把2*2变成2*1*2
4.数组的运算：
（1）数组与标量的运算：
arr01+10
arr01-10
arr01*10
arr01/10
arr01**2
10**arr01 #每个数组元素与标量运算
（2）数组与数组的运算
arr02+arr03
arr02-arr03
arr02*arr03
arr02/arr03
arr02**arr03 #数组与数组形状一致
#特殊情况：
例：A：2*3*4 与 B：2*1*4可以运算，A的每个2*1*4与B运算；这样的要求就是B有一维是1，其他维和A一致；
或 A：2*3*4 与 B：3*4可以运算，A的每个3*4和B运算；但B：2*4则不能；要求B和A低的维度形状相同；
（3）矩阵积：
arr01.dot(arr02)
4.索引：
（1）
arr09 = np.random.randint(1,9,(3,3,4))
[[[3, 2, 4, 5],
[3, 2, 4, 2],
[2, 1, 8, 8]],
[[8, 1, 8, 8],
[6, 1, 6, 2],
[7, 7, 8, 5]],
[[7, 6, 8, 6],
[8, 7, 4, 4],
[1, 6, 5, 5]]]
arr09[:,:,:] #全部，和arr09一样
arr09[1] #第二个3*4数组；
[[8 1 8 8]
[6 1 6 2] [7 7 8 5]]
arr09[:,1] #3*4
[[3 2 4 2]
[6 1 6 2] [8 7 4 4]]
arr09[:,:,1] #3*3
[[2 2 1]
[1 1 7] [6 7 6]]
arr09[0,0,0]
# 3
（2）arr10[:,:] = 100 #直接修改arr10数组元素的值；
（3）切片：
arr11 = np.ones((2,6)) #
[[ 1. 1. 1. 1. 1. 1.]
[ 1. 1. 1. 1. 1. 1.]]
arr11[:1] #
[[ 1. 1. 1. 1. 1. 1.]]
（4）花式索引：
arr12 = np.arange(32).reshape(8,4)
[[ 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, 25, 26, 27],
[28, 29, 30, 31]]
arr12[0,3] #标准索引，返回3
arr12[ [0,3,5] ] #返回第0，3,5行
[[ 0 1 2 3]
[12 13 14 15] [20 21 22 23]]
arr12[[0,3,5],[0,1,2]] #返回第0行第0列，第3行第1列，第5行第2列的那个数组成的数组；
[ 0 13 22]
arr12[np.ix_( [0,3,5] , [0,1,2] ) ] #有索引器，返回3*3，第0行第0列，第3行第1列，第5行第2列
[[ 0, 1, 2],
[12, 13, 14],
[20, 21, 22]]
（5）布尔索引：
第一种：
arr12 = np.random.randint(1,9,(3,4))
[[6, 6, 5, 6],
[6, 1, 7, 7],
[5, 1, 1, 8]]
arr12<5
[[False, False, False, False],
[False, True, False, False],
[False, True, True, False]]
arr12[arr12<5]
[1, 1, 1]
#索引（arr1<5）和 原数组形状相同，返回 一维
第二种：
arr1[ [true,false,false] ]
[[6, 6, 5, 6]]
#注意：返回的二维数组；
5.常用的一元函数：
np.abs(arr) #abs,fabs 计算整数、浮点数或者复数的绝对值，对于非复数，可以使用更快的fabs
np.sqrt(arr) #计算各个元素的平方根
np.square(arr) #计算各个元素的平方
np.exp(arr) #计算各个元素的指数e的x次方
np.log(arr)
np.log2(arr)
np.log1p(arr) #分别计算自然对数、底数为2的log以及底数为e的log(1+x)
np.sign(arr) #计算各个元素的正负号: 1 正数，0：零，-1：负数
np.ceil(arr) #向上取整
np.floor(arr) #向下取整
np.rint(arr) #四舍五入
np.var( arr ) #求该arr方差 ，所有元素
6.ndarray的其他操作：
（1）转置
arr13.T #矩阵转置操作
#多维数组转置不常用，所以不讲了；
（2）拉伸：
arr = np.random.randint(1,9,(2,2))
[[5, 7],
[4, 1]]
np.tile(arr,3) #横向拉伸3次
[[5 7 5 7 5 7]
[4 1 4 1 4 1]]
np.tile(arr,(3,3)) #横向拉伸3次，纵向拉伸3次
[[5 7 5 7 5 7]
[4 1 4 1 4 1] [5 7 5 7 5 7] [4 1 4 1 4 1] [5 7 5 7 5 7] [4 1 4 1 4 1]]
（3）聚合：
arr = np.random.randint(1,9,(2,3))
#arr可以调用的聚合函数有mean，sum，max，min，std，var，axis=1对每一列聚合，axis=0对每一行聚合
#std标准差
arr.mean(axis = 1) #1*3
arr.mean(axis = 0) #2*1
（4）where:
np.where([[True, False], [True, True]] , [[1, 2], [3, 4]] , [[9, 8], [7, 6]])
#三个数组形状相同，第一个数组元素是true，选第二个数组元素，否则选第三个数组元素；
（5）去重：
np.unique(arr)
#去除重复元素，如果arr是多维的，返回一维的；
三.dataFrame:
dataFrame是比ndarray多了行标，列标的数组；
创建方式为：
import pandas as pd
df = pd.DataFrame(index=[1,2,3],columns=[4,5,6])
在机器学习算法中，ndarray比dataFrame好操作，所以：
可以接收dataFrame类型，然后转化为dnarray类型：
df.values；
发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/170303.html原文链接：https://javaforall.cn
【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛
【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...
