[已收纳]python之基础语法

15195775117

python列表操作与IDL的区别之一：

python的+表示连接，IDL表示对应元素相加：
[1,2,3]+[4,5,6]
输出：[1, 2, 3, 4, 5, 6]



python的*表示自我复制：
[1,2,3]*3
输出：[1, 2, 3, 1, 2, 3, 1, 2, 3]

15195775117

什么是python模块？
一个.py脚本文件就是一个模块！相当于IDL的一个.pro文件。
IDL脚本要求文件名与主程序名一致，Python模块名没有这种要求。



模块的导入：
import FirstPythonPro
print(FirstPythonPro.f(2,3),FirstPythonPro.g(2,3))
c=FirstPythonPro.Claim()
print(c)
c.k('大音希声')
结果：
6 5
<FirstPythonPro.Claim object at 0x000002422F6A9A58>
大音希声
只要当前脚本与需要导入的.py文件在同一级文件夹里就可以顺利导入了。
对比：
IDL调用其他pro需要将其编译或者放入当前目录，python则是import

有时模块名很长，引用时比较冗长，可以使用as设置昵称，后面使用昵称即可：
import FirstPythonPro as FPP
print(FPP.f(2,3),FPP.g(2,3))
c=FPP.Claim()
print(c)
c.k('大音希声')

导入a、b、c3个模块：
import a,b,c


零散技巧：
Spyder清屏指令：clear，跟matlab一样，快捷键ctrl+L
Spyder批量注释与取消：ctrl+1
Python3不能用pyhht（包括EMD）
Python脚本名不能跟包名一样！！！

对列表、元组、字符串、集合、字典的操作：
对二维列表的操作类似C语言：
a=[[1,2,3],
   [4,5,6],
   [7,8,9]]
print(a[0][1])
结果：2
print(a[0])
结果：[1, 2, 3]


列表元素个数？len(list)
某元素在列表中出现的次数？列表.count(元素)
将元素插入列表：列表.insert(索引,元素)

a=[4,5,3,9,6,8,7,1,0,2,5]
print('元素数目：',len(a))
a.append(999)
print('追加元素：',a)
print('元素5有几个：',a.count(5))
a.insert(2,888)
print('插入元素：',a)
a.reverse()
print('反转：',a)
a.sort()
print('排序：',a)
输出：
元素数目： 11
追加元素： [4, 5, 3, 9, 6, 8, 7, 1, 0, 2, 5, 999]
元素5有几个： 2
插入元素： [4, 5, 888, 3, 9, 6, 8, 7, 1, 0, 2, 5, 999]
反转： [999, 5, 2, 0, 1, 7, 8, 6, 9, 3, 888, 5, 4]
排序： [0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 888, 999]

求元组元素个数也是用len()


字符串是不可变的，不可对元素进行修改。
s='jgaojgs'
s[3]
输出： 'o'
求字符比IDL方便。

换行符的使用：
print('aaaaa','bbbbb')
print('aaaaa','\n','bbbbb')
输出：
aaaaa bbbbb
aaaaa
bbbbb

s='gsjosgk'
print('k' in s,'j' not in s)
输出：True False
多个字符也行：'ab' in 'abc'
输出：True


格式化输出：
即控制输出的数据类型、进位制、位数等，
例如按浮点型9位、小数点后6位输出：
print('PM2.5 is %9.6f' % 102.345)
输出：PM2.5 is 102.345000

15195775117

字符串操作函数------------------------------

首字母大写
a='number'
a=a.capitalize()
print(a)

结果：Number
因为字符串不可以该元素，所以是赋给新变量

某元素在字符串中出现次数：
a='sleep'
n=a.count('e')
print(n)

结果：2

编码与解码：
s='喝杯Cola'
s2=s.encode(encoding='GB2312',errors='strict')
print(s2)
s3=s2.decode(encoding='GB2312',errors='strict')
print(s3)

结果：
b'\xba\xc8\xb1\xadCola'
喝杯Cola


字符串连接：
字符串.join(......)与IDL的strjoin()类似

字符串替换：
与IDL的str.replace类似：
s='hgoiwsgoi'
s2=s.replace('oi','999')
print(s2)

输出：hg999wsg999

15195775117

字典函数：
dict={'a':1,'b':2,3:'c'}
print('字典键值对数：',len(dict))
print('字典键有：',dict.keys())
print('字典值有：',dict.values())
#使用get()方法，如果键存在会返回对应的值，不存在返回None
print('键3是否存在：',dict.get(3))
print('键d是否存在：',dict.get('d'))
print(dict.items())
输出：
字典键值对数： 3
字典键有： dict_keys(['a', 'b', 3])
字典值有： dict_values([1, 2, 'c'])
键3是否存在： c
键d是否存在： None
dict_items([('a', 1), ('b', 2), (3, 'c')])

15195775117

数组的变形：
import numpy as np
a=np.arange(12)
for i in a:
    print(i,end=';')#不换行
b=a.reshape(3,4)#变形，相当于IDL的reform
print(b)
输出：
0;1;2;3;4;5;6;7;8;9;10;11;[[ 0  1  2  3]
[ 4  5  6  7]
[ 8  9 10 11]]
易错点：
如果a=range(12)，后面的reshape就用不了，
因为a必须是np类的实例才有reshape方法，
这说明，以后的写法都要按面对对象来写

15195775117

生成限定始终值和元素数的数组
import numpy as np
a=np.linspace(30,40,6)
print(a)

输出：[30. 32. 34. 36. 38. 40.]
linspace的参数格式（始，终，数目）


如果a=range(30,40,2)，那需要转换为np类的数组才能使用np下的方法，转换方法如下：
a=range(30,40,2)
a=np.array(a)

对比之，IDL的等间隔序列如下：
IDL> [30:40:2]
      30      32      34      36      38      40

IDL> [30:39:2]
      30      32      34      36      38

IDL也有限制数目和始终值的，不过不记得了。

15195775117

全0阵、全1阵、对角阵
a=np.zeros((3,4))#注意参数是个元组
print(a)
a=np.ones((3,4))#注意参数是个元组
print(a)
a=np.eye(5)
print(a)

输出：
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
[[1. 0. 0. 0. 0.]
[0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]]

15195775117

numpy库处理同种元素构成的多维数组；
numpy库的数组称为“ndarray类”；
与python自带数组类库功能有限，所以要用np类库；
import numpy as np
a=np.ones((3,4,5))
print('维度：',a.ndim,np.ndim(a))#2种写法
print('各维度大小：',a.shape,np.shape(a))#2种写法
print('元素个数：',a.size,np.size(a))#2种写法
print('数据类型：',a.dtype)
print('每个元素的字节大小：',a.itemsize)
#np中的数组操作与IDL一样，不像python标准库把加法当复制数组
a=np.arange(12).reshape(3,4)+1
print(a+a,'\n',a-a)
print(a**2)
x=np.array([1,2,3]).reshape(1,3)#不用reshape转换维数对不上
y=np.array([[1],[2],[3]])
print(x.shape,y.shape)
print('x点乘y:',np.dot(x,y))
print('y点乘x:',np.dot(y,x))
########################
z=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(z)
print('求和',z.sum())
print('列求和',z.sum(axis=0))
print('行求和',z.sum(axis=1))
print('最值',z.min(),z.max())
print('列最值',z.min(axis=0),z.max(axis=0))
print('行最值',z.min(axis=1),z.max(axis=1))
print(np.sin(np.pi/2),
      np.exp(0),
      np.sqrt(4),
      np.sort([5,6,2]),
      np.abs(-9))
print(z[-1,:])#这里的“:”=IDL的“*”
#对于多维数组，目前似乎只能切一片，不能切一段，但是一维可以用“:”切段：
b=np.arange(10)
print(b[-3:-1])

15195775117

数组变换
import numpy as np
help(np.ravel)#查询方式与IDL类似
a=np.array([[1,2,3],[4,5,6]],dtype=float)#dtype关键字可以设置数据类型
b=np.ones((3,4),dtype=int)
print(a)
print(a.ravel())#把数组降为一维（即向量），不改变原数组
#3行，列数自行计算
print(a.reshape(3,-1))#不改变原数组
print(a.T)#这个T似乎是转置
#reshape和resize的区别在于是否改变原数组
#resize会改变原数组，reshape不会
#我觉得还是用reshape较好，是否覆盖自己决定
a.resize(3,2)
print(a)

15195775117

import numpy as np
#生成随机数组：
a=np.random.random((2,2))
#退一法：
print(np.floor([1.2,2.6]))
#堆叠
a=[[1,1],[2,2]]
b=[[3,3],[4,4]]
#横着堆：
print(np.hstack((a,b)))
#竖着堆
print(np.vstack((a,b)))
#莫非多维数组都只能先写arange？
#数组分割：
a=np.arange(12).reshape(3,4)
#横切：
b=np.vsplit(a,3)
#竖切：
b=np.hsplit(a,4)
#split是横切
b=np.split(a,3)