1 Python基础（1 常用的数据类型和程序结构）

1 常用的数据类型操作和输入输出

1.1 数据

1.1.1Python内建的基础数据

Python有两大内建的数据类型即数值类和布尔类。数值类包括整型和浮点型数据类型，可以进行的操作有+、-、*、**（幂运算）、%（模运算）和//（整除运算）等。
布尔类的对象状态值是False（0）和True（1），可以进行的操作有>、<、==、>=、<=、！=、and（逻辑与）、or（逻辑或）和not（逻辑非）等。

1.1.2赋值语句含义

执行命令a=0时，其中会创建变量a，并且令它保存数据对象0的引用（类似于C++）。即编译器都会先计算赋值右边的内容，然后将得到的结果的引用给赋值的左边。这样一旦后面a=True数据类型变成了bool，这样只是改掉了变量的引用对象。

1.1.3Python内建的集合数据

列表----- Python的列表是异构的，在列表的元素不需要是同一个数据类型。空列表就是[]，而且列表表示的集合可以赋值给一个变量即list=[1,2]则print(list)就位[1,2]，列表是有序的序列。对于序列的运算（同样适用于字符串、元组等序列）有：

其中在使用中注意重复和切片的使用，这二者比较特殊，需要考虑到重复是对列表的数据对象引用的重复，切片注意列表下表从0开始的！对列表提供的方法有：

其中使用中注意到pop的使用方式比较特殊，而且数组中a[-1]表示倒数第一个元素，以此类推-2表示倒数第二个元素。关于列表还有两个常用的函数list()和range()，其中range()生成一个代表值序列的范围对象，list()函数则可以以列表的形式看到范围对象的值。

字符串----- 字符串是一种比较特殊的序列，同样可以使用之前的序列运算方式，但还有一些特有的方法：

其中比较特殊的应用是split()，split接受一个字符串，并且返回一个由分隔字符作为分割点的字符串列表，如a=“david”，执行a.split(‘v’)，再print(a)得到的结果是[‘da’, ‘id’]，split常用于对空格、分隔符和制表符等的排除操作。
元组----- 元组合列表非常相似，只是定义数组的标识符是[]而定义元组的标识符是()，元组也是一种异构序列，也可以进行序列的操作，但是元组和字符串一样定义后元素不能被修改。

集----- 由零个或者多个不可修改的Python数据对象组成的无序集合。集不允许重复元素，并且它的标识符是花括号{}，集也是异构的，空集由set{}表示。集支持的运算有：

集的一些运算和数学的集合运算是一样的。集的方法有：

字典----- 字典是一种无序序列，每对元素都是由一个键和一个值组成，通常写成键：值形式。字典通过键来访问对应的值，也可以添加新的键：值对，但是字典中键的位置是由散列来决定的。字典支持的运算：

同样，也可以用len()函数来查看字典的长度，也可以用list()方法吧字典转化为列表，字典提供的方法有：

1.1.4 array列表的基本操作

创建列表
1）创建空列表：arr = []
2）创建一维列表：①arr = [1,'b',3,[4,5]]；② [data]*n，注意是单个[]括号
3）创建二维列表：①[[data]*cols]*rows；②[[data]]*n；③注意修改值的变换
4）创建多维列表妥善方法：for循环联合append
5）多维空列表的理解应用：对于需求创建mn的空列表，其实是不合逻辑的，因为至少有0/1替代空才会有内存大小，类似的在MATLAB等，都没有创建mn的空列表的逻辑，对不定长度的列表，应在空列表的基础上进行增删。

# 1、创建列表
# 1.1、 创建空列表
arr_1 = []

# 1.2、创建已知长度的一维列表,值得注意的在于,一维列表内部元素不限制为单个元素,下面的定义是合法的
arr_2 = [1,[2,3],['a','b','c']]
print(arr_2)

arr_3  = [0,0,0,0]*2    # [] 只有一个括号，创建出来的为一维列表
print(arr_3)
arr_3 [2] = 1           # ！！！此时值修改只修改一处
print(arr_3)

# 1.3、 创建二维列表
# 1.3.1、乘法创建,值得注意的在于,这种类型创建的多维列表,容易修改某个值之后,发生意想不到的变换
arr_4 = [[0]*3]*2       # [[data]*cols]*rows
print(arr_4)
arr_4 [1][1] = 1
print(arr_4)

arr_5 = [[0,0,0,0]]*2   # [[]]两层[]表示为n一维列表组成的二维列表
arr_5[1][1] = 1
print(arr_5)

# 1.4、 创建多维列表妥善的方法
arr_6 = []
for rows in range(2):
    temp_arr = []

    for cols in range(3):
        temp_arr.append(0)
    
    arr_6.append(temp_arr)

arr_6 [1][1] = 1
print(arr_6)

增加列表元素
1）append函数：在列表末尾增加元素
2）insert函数：在指定位置前面增加元素
3）多维列表也就是多个一维列表这样理解即可
4）例如多维列表arr为m*n格式的，直接以列表名arr.append则其操作对象为一行列表以arr[i].append的操作对象为该行上的某个元素

# 2.1、 空列表/一维列表增加元素
arr_7 = [1,2,3]
arr_7.append(5)
arr_7.insert(3,4)
print(arr_7)

# 2.2、 二维列表增加行
arr_8 = [[0,0,0],[1,1,1]]
arr_8.append([3,3,3])
arr_8.insert(2,[2,2,2])
print(arr_8)

# 2.3、 二维列表增加列
for rows in range(len(arr_8)):
    arr_8[rows].append(rows)

print(arr_8)

删除列表元素
1）删除末尾元素：arr.pop()
2）删除指定位置元素：①arr.pop(i)；②del arr[i]
3）删除第一次出现元素i：arr.remove(data)
4）操作多维列表也分列表名直接操作和列表名[i]操作某行

# 3.1 一维列表删除元素
arr_9 = ['a','a','b','b','b','c','d','e','f']
arr_9.pop()
print(arr_9)
arr_9.pop(1)
print(arr_9)
del arr_9[1]
arr_9.remove('b')
print(arr_9)


# 3.2 二维列表删除元素
arr_10 = [['a','b','c'],['a','b','c'],['a','b','c'],['a','b','c']]
arr_10.pop()        # 直接删除一行元素
print(arr_10)
arr_10[2].pop()    # 删除第三行最后一个元素
print(arr_10)
arr_10.remove(['a','b','c'])    # 以列表名操作的对象为一个列表
print(arr_10)

访问查询和修改
1）访问单个元素:1) arr[i]; 2)arr[i][j]
2）访问多个元素: arr[i:j]此时返回结果是一个i:j的列表，可能多维可能一维，和arr类型一致
3）查询第一次出现的下标：arr.index(a)
4）查询某个元素出现次数:arr.count(a)
5）求列表的长度：len(arr)–>多维返回行的长度，一维返回元素个数

arr_11 = [['a','b','c'],['a','b','c'],['a','b','c'],['a','b','c']]
arr_11[1][1] = 1
print(arr_11)
print(arr_11[1:3])                  # arr_11[1:3]为第1行到第2行组成的多维列表
print(arr_11[1][1:3])               # arr_11[1][1:3]为第1行中，以第1个和第2个组成的一维列表
print(arr_11.index(['a','b','c']))  # 查询列表['a','b','c']在多维列表出现的下标，操作对象为一维列表
print(arr_11[1].count('a'))         # 查询在列表arr_11的第1行列表中'a'出现次数，操作对象为一个元素
print("列表arr_11的行为：",len(arr_11),"列为：",len(arr_11[1]))

1.2 numpy基础

安装pip install numpy
NumPy（Numerical Python）是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix）），支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

1.2.1 新建numpy数据

1）创建一维范围矩阵：①np.arange(max)；②np.arange(min,max,freq)；③np.linspace(min,max,num)
2）转array对象为numpy：np.array(object,dtype,ndmin)
3）全0，全1创建任意维度数组：①np.zeros(len)；②np.zeros([rows,cols])；③np.ones(len)；④np.ones([rows,cols])
4）特殊矩阵：①np.eye(len)单位矩阵；②np.diag([data])对角矩阵
5）生成简单随机数矩阵：np.random.randint(min,max,size=(rows,cols))

# 1.1 创建一维范围矩阵
arr_1 = np.arange(10)
print(arr_1)
arr_1 = np.arange(1,10,2)
print(arr_1)
arr_1 = np.linspace(2,10,5)
print(arr_1)

# 1.2 将array转成numpy矩阵
arr_2 = [[1,2,3],[4,5,6]]   # 对于内部列表尺寸一致的列表转成numpy
print(arr_2)
arr_2 = np.array(arr_2)
print(arr_2)                # numpy的矩阵打印效果比array会自动换行形成行列矩阵格式

arr_3 = [[1,2],[3]]         # 内部列表长度不一致转numpy
print(arr_3)
arr_3 = np.array(arr_3)
print(arr_3)                # 打印时候会显示list关键字

# 1.3 全0全1的任意维度矩阵
arr_4 = np.zeros(3)
print(arr_4)
arr_4 = np.zeros([3,4])
print(arr_4)
arr_4 = np.ones(3)
print(arr_4)
arr_4 = np.ones([3,4])
print(arr_4)

# 1.4 特殊矩阵
arr_5 = np.eye(3)           # 创建单位矩阵
print(arr_5)
arr_5 = np.diag([1,2,3])    # 创建对角矩阵，对角元素为1,2,3
print(arr_5)

# 1.5 生成随机数矩阵
arr_6 = np.random.randint(0,10,size=(2,3))  # 创建随机数范围为0->10的行2列3的整型矩阵
print(arr_6)

1.2.2 numpy的属性和基本操作

查看numpy属性和数据转换
1）查看维度(行列值)：arr.shape
2）查看元素个数：arr.size
3）矩阵元素类型转换：arr.astype(np.float64)
4）矩阵重塑(按照元素按行递增的原则重新改变矩阵的维度)：arr.reshape(rows,cols)
5）矩阵扁平化：arr.ravel()
6）矩阵转置(numpy的轴：axis = 0 表示行轴，asix = 1 表示列轴):1) arr.transpose(axis1,axis2); 2)arr.swapaxes(axis1,axis2)

print(arr_6.shape)          # 矩阵行列大小,也可以arr_6.shape[0]得到行大小
print(arr_6.size)           # 矩阵元素个数
print(arr_6.astype(np.float64))
print(arr_6.reshape(3,2))
print(arr_6.ravel())
print(arr_6.transpose(0,1))

增加numpy内容
1）利用列表的append或者insert函数再将列表转成numpy
2）增加行：①np.vstack((arr1,arr2))；②concatenate((arr1,arr2),axis = 0)
3）增加列：①np.hstack((arr1,arr2))；②concatenate((arr1,arr2),axis = 1)

arr_7 = [[1,1],[2,2],[3,3]]
print(np.vstack((arr_7,[4,4])))             # 增加行,注意两层括号
print(np.hstack((arr_7,[[1],[2],[3]])))     # 增加列，注意列元素的表示方法
print(np.hstack((arr_7,np.array([1,2,3]).reshape(3,1))))

删除numpy内容
1）利用列表的pop或者del函数再将列表转成numpy
2）直接删除numpy内容：np.delete(arr,sit,axis),根据轴axis的不同删除行列
3）数组分割：行分割) np.vsplit(arr,num); 列分割) np.hsplit(arr,num); 3)np.split(arr,num,axis=0/1)

arr_8 = np.array([[1,2,3,4],[1,2,3,4],[1,2,3,4]])
print(np.delete(arr_8,3,1))             # 删除第4列
print(np.delete(arr_8,[1,2],0))         # 删除第2到第3行

numpy索引和拷贝
1）numpy索引:arr(rows,cols),其中rows和cols操作和MATLAB有区别,因为Python索引从0开始
2）索引出的数组进行拷贝arr.copy()
3）找出指定元素行列位置：np.where(arr = data)

arr_9 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print(arr_9[:,1])
print(arr_9[0:2,3])
arr_9 = np.array([[1,2,3],[1,1,3],[2,1,9]])
print(np.where(arr_9 == 1))

1.2.3 numpy运算和统计分析操作

numpy运算
1）ufunc运算：包括加(+)减(-)乘(*)除(/)幂(**),比较运算>,<,==,>=,<=,!=,以及逻辑or的np.any,逻辑与的np.all
2）条件逻辑运算:np.where(condition,x,y)当condition为真则为x,为假则为y

x = np.array([1,5,6])
y = np.array([4,2,3])
z = np.array([[1,2,3],[4,5,6]])
print(x+y)
print(x*y)              # 按照元素位置一一相乘，不同于矩阵的乘法
print(x>y)              # 按照元素位置一一逻辑判断，得到三个bool结果
print(z+x)              # ufunc的广播特性
print(np.where([[True,False],[True,False]],[[1,2],[3,4]],[[5,6],[7,8]]))

统计和分析函数
1）排序：np.sort(arr,axis = 0/1)
2）得到排序后原来索引的函数：arr.argsort()
3）重复数据：np.tile(arr,num)
4）去重：np.unique(arr)
5）其余统计函数：np.sum(axis = 0/1); np.max(axis = 0/1); np.min(axis = 0/1)…
6）找最大数下标：np.argmax(arr,axis = 0/1)

arr_10 = np.array([1,4,5,6,2,9,8,7,3])
print(np.sort(arr_10))              # 数组排序
print(np.argsort(arr_10))           # 得到排序下标
print(np.tile(arr_10,2))            # 重复数据
print(np.argmax(arr_10))            # 找到最大元素下标

1.3 输入和输出

input("…")----- 提示字符串函数，input()函数返回的是一个字符串。
print("…")----- 打印输出函数，print()函数默认以空格作为默认的显示分隔符，print(“hello”,“python”)得到的是hello python，可用sep参数来设置分割符，如print(“hello”,“python”,sep="")得到hellopython，此外print()函数默认以换行结尾，可以设置参数end更改，如print(“hello”,end="")得到hello。

1.3.1格式化字符串

格式化字符即将接收到的多个参数有区别的输出出来，如print("%d is %s"%(10,“ten”)得到输出10 is ten。格式化字符可以用的类型声明：

格式化的修改符有：

1.4 程序结构

1.4.1 控制循环结构

控制结构主要是迭代和分支结构，对于迭代主要是while循环和for循环。对于Python的算法，和C/C++有个较大的区别在于其不用提前声明临时变量的类型，如C/C++里的一个for循环:for(int i=1;i++;i<100)，而在Python里面则是for i in range(1,100)不需要声明i是整型的。
对于迭代循环中的遍历情况，通常是按数据类型来遍历的，例如代码：

for word in ['hello', 'python']:
	for alphabet in word:
		print(alphabet,end=' ')
最后的输出结果是h e l l o p y t h o n

结果是单个输出了字母，这表明对于1.1.3提到到的集合类数据，遍历时先遍历它的子集（特别注意字符串也是一种集合数据类型）。
分支结构主要指的是if-else、if-elif-else或者只有if的结构。
值得注意的是，列表可以通过迭代结构和分支结构来创建，这种方法也被叫做列表解析式。一般的结构为[元素的表达式 for迭代 分支if]得到以元素表达式创建出的数组，如

>>>[alp.upper() for ch in 'python' if alp not in 'aeiou']
['P, 'Y, 'T, 'H, 'N]
其中的alp.upper.()即元素的表达式，for在字符串中变量字母，并用条件判断字母需要不在aeiou这五个字母之中(in的巧妙)。

1.4.2 异常处理

程序在编写的过程中出现的错误分为两种，即语法错误和逻辑错误。语法错误Python的编译器就无法运行，而逻辑错误编译器可以运行但是会返回错误的结果，程序运行时的错误也叫异常。
对于异常情况，Python提供了try:-except:语句来处理抛出的异常，raise语句来处理运行时的异常等。

import math
a=int(input("enter a nuber"))
try:
    print(math.sqrt(a))
except:
    print("error,i will use its abstract")
    print(math.sqrt(abs(a)))
则当输入数字为-4得到的结果为2.0

利用raise在运行时直接打印错误
import math
a=int(input("enter a nuber"))
if a<0:
	raise RuntimeError(("error ")
else:
	print(sqrt.(a))