Python学习

基本数据类型

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。 

列表赋值

​ 如果采用直接列表相等的赋值方式，则当原列表原始变化的时候，被赋值的变量的列表内容也会发生变化。

my_fruits=["apple","banana","juice"]
your_fruits=my_fruits
print(your_fruits)
my_fruits.append("mango")
print(your_fruits)

​ 输出结果为

["apple","banana","juice"]
["apple","banana","juice","mango"]

​ 比较另外一种赋值方式

my_fruits=["apple","banana","juice"]
we_fruits=my_fruits[:]
my_fruits.append("mango")
print(we_fruits)

​ 输出结果为

["apple","banana","juice"]

​ 这种赋值方式相当于创建了一个列表，使得列表的元素和之前列表的元素相同，但并不等同于之前的列表，因此列表内容不会随着原列表内容发生变化而变化

data=[[1,2,3],[4,5,6],[7,8,9]]
data[1],[2]=100 #给第二个第三列的数进行赋值
print(data)

​ 输出结果为

[[1,2,3],[4,5,100],[7,8,9]]

元组和列表

​ 表示方法：元组用（）表示，列表用[ ]表示

​ 含义区别：元组的元素不能修改，列表可以重新赋值

​ 注意：元组中只包含一个元素时，需要在元素后面添加逗号，如：

tup1 = (50,)

循环嵌套

​ 输出2至100内的所有质数

用for循环写：

i=2
for num in range(2,101):
    for i in range(2,num//2):
        if not(num%i):
        break
    if i>num/i:      #把2也能括进去
        print(num,"是质数")
print("over")

并用一个列表输出

i=2
n=[]
j=0
for num in range(2,101):
    for i in range(2,num//2):
        if not(num%i):
            break
    if i>num/i:      
            n.insert(j, num)
        j+=1
print(n)

用while循环写：

num=2
while(num<=100):
    i=2
    while(i<=num/i):
        if(not(num%i)):
        break
    i=i+1
    if(i>num/i):
        print(num,'是质数')
    num=num+1
print('over')

深拷贝与浅拷贝

浅拷贝：

a = {1: [1,2,3]}
b = a.copy()   #a和b是同一片内存地址

深拷贝：

import copy

c = copy.deepcopy(a)   #a和c是两片内存地址

空间两点间欧氏距离计算

left = [0.3960, -0.2886, 0.9663]
obj = [0.4, 0.3, 0.96]
left_end = numpy.asarray([left[0],left[1],left[2]])
obj_end = numpy.asarray([obj[0],obj[1],obj[2]])
left_obj = left_end - obj_end
a = numpy.sqrt(numpy.inner(left_obj, left_obj))

向txt文件中写入变量值

# r，只读模式【默认模式，文件必须存在，不存在则抛出异常】
# w，只写模式【不可读；不存在则创建；存在则清空内容】
# a， 只追加写模式【不可读；不存在则创建；存在则只追加内容】
file_handle=open('c.txt',mode='a')      
file_handle.write(str(fx_z))       #fx_z为变量名
file_handle.write('\n')
file_handle.close()

从txt文件中读取数据

vec = np.genfromtxt('wiki.ch.text.vector', skip_header=1, delimiter=' ', dtype=None)
# vec为变量名,类型为ndarray
# 'wiki.ch.text.vector' 为 路径 +文件名
# skip_header=1 ,跳过第一行
# delimiter=' ',分隔符
# 因为txt中有str和float，所以要设置dtype=None，默认只会读float所以会报错

python画图

#   画三维图
 import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
%matplotlib widget         # conda install -c conda-forge ipympl  安装三维图旋转插件
ax = plt.axes(projection='3d')
ax.plot3D(rDataj[0,:],rDataj[1,:],rDataj[2,:])

#   画二维图
import matplotlib.pyplot as plt
%matplotlib widget
plt.plot(rDataj[0,:])
plt.plot(rDataj[1,:])
plt.plot(rDataj[2,:])

numpy模块常用的矩阵函数

import numpy as np

np.array()    #创建 ndarray 数组[[ ]，[ ],、、、]
np.zeros((3,2))   # 创建3×2的ndarray  np.zeros((3,))维度为1
np.empty()          #与np.zeros()类似    
np.dot( , )            #矩阵乘法
np.linalg.det()   #方阵行列式
np.linalg.inv()   #矩阵求逆
np.sum()
b=np.array([[ 0,  1,  2,  3,  4,  5],
   [ 6,  7,  8,  9, 10, 11]])
>>> np.sum(b)    #默认对所有元素进行求和
66
>>> np.sum(b,axis=0)        #在第一个轴展开方向上求和
array([ 6,  8, 10, 12, 14, 16])
>>> np.sum(b,axis=1)
array([15, 51])

常用的矩阵维度变换函数

.reshape()      #a.reshape(3,2)  将a变成3行2列
a=np.array([[1,2,3],[3,2,1]])
b=a.reshape(-1,1)    #变成列向量，访问b中元素，用b[i]，或者b[i,j]。b[i]表示输出b的第i行
b=a.reshape(1,-1)    #变成行向量，访问b中元素，用b[i,j]

a=np.array([[1,2,3],[3,2,1]])
b=a.reshape(1,-1)     #b.shape = (1,6),[[1,2,3,3,2,1]],b[0]=[1 2 3 3 2 1]
c=a.flatten()          #c.shape = (6,),[1,2,3,3,2,1],c[0]=1
.flatten()      #变成一维
.shape          #查看矩阵或者数组的维度

a.shape[0]    #只返回矩阵的行数
a.shape[1]    #只返回矩阵的列数

字符串的拼接

a="啦啦啦"
b="哦哦哦哦哦哦哦哦哦"
c=a+b
print c     

#啦啦啦哦哦哦哦哦哦哦哦哦

格式化输出

#  %s——字符串，%d——整数，%f——浮点数

d=5.00
e=2
f=10.00
print("苹果单价为%.2f元/斤，购买了%d斤，需要支付%.2f元" % (d,e,f))     # %.2f保留两位小数的浮点数

#(d,e,f)是一个元组
tup=(d,e,f)
print("苹果单价为%.2f元/斤，购买了%d斤，需要支付%.2f元" % tup)
输出结果一致

elif

score=79
if score<60:
    print("不及格")
elif score<70:
    print("及格")
elif score<90:
    print("良好")
else:
    print("优秀")

# elif = else if

末尾取消换行和追加换行

#此方法局限于python3
for i in range (1,10):
    for j in range(1,i+1):
        print("%d * %d = %d  " %(i,j,i*j) , end="")     # end=为跟在后面输出的，代替了默认的换行符
    print("\n")         # 或print(""),追加换行符

#python2
i=1
while(i<=5):
    j=1
    while(j<=i):
        print("*"),      #在输出末尾追加“，”来取消换行
        j=j+1
    print("")
    i=i+1

模块

每一个以.py结尾的Python源代码都是一个模块，用import导入,命名不能以数字开头
模块中定义的全局变量、函数都可以在外部直接使用

列表

列表用[]定义,数据之间用“，”分隔，索引（下标）从0开始
列表中的数据类型可以不一致

列表的增、删、改、查、长度

#查找
name_list = ["zhangsan","lisi","wangwu"]
print(name_list[0])
print(name_list.index("wangwu"))

#修改
name_list = ["zhangsan","lisi","wangwu"]
name_list[1]="李四"        #中文字符在python2中会出现乱码
print(name_list)

#添加
name_list.append("zhaoliu")    #在末尾追加，且只能追加一个

name_list = [1,2,3,4]
name_list.insert(2,5)       #.insert(index,数据)
print(name_list)         #[1,2,5,3,4]

temp_list=[6,7,8,9]
name_list.extend(temp_list)     #列表的拼接

#删除
name_list=[1,2,3,4,5,6]
name_list.remove(4)     #[1,2,3,5,6] ,remove能删除指定元素（第一次出现）

name_list.pop()    #[1,2,3,5] ,pop默认删除最后一个元素（最后进列表，最先被删除），.pop(index)能删除指定索引的元素

name_list.clear()   #清空列表

name_list = ["zhangsan","lisi","wangwu"]     
del name_list[0]      #del关键字能删除列表元素
print(name_list)     #['lisi','wangwu']
a=10
del a                #删除变量 
print(a)          #报错

#列表长度
name_list = ["zhangsan","lisi","wangwu"]     
print(name_list)
a=len(name_list)
print(a)                #3

#元素出现次数
b=name_list.count("zhangsan")
print(b)    

python中的引号

python中“ ”与‘ ’在表示字符串时是没有区别的
在输出时，输出内容有“ ”（双引号）则在单引号内使用双引号，即‘“要输出内容”’；
输出内容有‘ ’（单引号）则在双引号内使用单引号，即“‘要输出内容‘“；
补充：’’’ (三引号)用法：
1、用作多行注释；2、用作表示一个字符串
注：python中并没有提供专门的多行注释的符号，当一串字符被三引号引用时，但它不作为字符串被操作时，这个三引号内引用的内容就被视为注释。

函数与方法

函数名(参数) #函数的调用，len(name_list)
对象.方法名(参数) #方法的调用，b=name_list.count(“zhangsan”)

列表倒序排列

aa=[2,5,1,8,3,7]
first=0
last=len(aa)-1
while(first<last):
    bb=aa[first]
    aa[first]=aa[last]
    aa[last]=bb
    first+=1
    last-=1
print(aa)

#相当于aa.reverse()

列表的升序和降序

aa=[2,5,1,8,3,7] 
aa.sort()        #升序
aa.sort(reverse=True)    #降序

列表遍历

name_list=["zhangsan","lisi","wangwu"]
for i in name_list:
    print(i,end=" ")

列表的+=

#列表的“+=”相当于.extend(),所以外部实参的值也会改变。而不是对应元素相加再赋值
num_list1=[1,2,3]
num_list2=[4,5,6]
num_list1+=num_list2
print(num_list1)

元组与列表

元组的元素不能修改
元组用“()”定义
元组的使用场景
1、做函数的参数和返回值（可以存放多个类型不同的数据）
特别是要返回多个数据的值，常以元组的形式 return(变量1，变量2，变量3，…)

def pr1():
    # print("num的值为%d,地址为%d" % (num,id(num)))
    heig=1.75
    weig=120
    return (heig,weig)

gl_h,gl_w=pr1()     #用多个变量去接受元组的元素，方便之后使用
print("身高为：%.2f"%gl_h)
print("体重为：%.2f"%gl_w)
#身高为：1.75
#体重为：120.00

#用变量接收元组的元素
a=6
b=100
b,a=(a,b)   #不使用第三个变量，交换两个变量的值
print(a)
print(b)

2、列表->元组，保护数据不被修改

相互转换

list(元组)
tuple(列表)

字典

用键值对（key-value）的形式保存无序的数据集合
值可以是任何数据类型，但键只能是字符串、数字和元组

字典的合并

#update方法，如果key相同会覆盖原有的键值对
oran_dic = {"name":"orange"}
temp_dic={"weight":1.8}
oran_dic.update(temp_dic)
print(oran_dic)

字典的遍历

#for循环得到的是字典的key
oran_dic = {"name":"orange","weight":1.8}
for i in oran_dic:
    print("%s-%s"%(i,oran_dic[i]))
#输出name-orange,weight-1.8

字典做列表元素

phon_lis = [
    {"name":"zhangsan","age":18,"phone":"12345"},
    {"name":"lisi","age":16,"phone":"23456"}
    ]
print(phon_lis)

for i in phon_lis:       #列表的循环遍历，i是列表中的每个元素（字典）
    for j in i:          #字典的循环遍历，j是每个key
        print("%s-%s" % (j,i[j]), end=" ")
    print("")

#[{'name': 'zhangsan', 'age': 18, 'phone': '12345'}, {'name': 'lisi', 'age': 16, 'phone': '23456'}]
name-zhangsan age-18 phone-12345 
name-lisi age-16 phone-23456 

字符串的分割(.split)

str = "Line1-abcdef \nLine2-abc \nLine4-abcd"
str.split(" ",2)       #指定以“ ”作为分隔符，切分2次，分成3块
#不指定分隔符，则默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等
#split方法返回数据类型为列表

元素拼成字符串(.join)

tup=("1,2,3","zhangsan")
str_2=" ".join(tup)      #元组元素的拼接，每个元素必须是字符串，指定以“ ”作为分隔符
print(str_2)
#1,2,3 zhangsan

lis=["1,2,3","zhangsan"]
str_3="\t".join(lis)      #列表字符串元素的拼接
print(str_3)
#1,2,3   zhangsan

dic={"name":"zhangsan","age":18}
str_4="\n".join(dic)       #字典key的拼接
print(str_4)
#name
#age

字符串切片

#取出指定索引中间的字符串,结束索引对应的元素取不到
#对于列表、元组（有序的对象）都可以用切片
#如字符串”python"，0p1y2t3h4o5n，p-6y-5t-4h-3o-2n-1
#str[0:5:1],在索引0和5切割，步长为1，取出"pytho"

str_5="元素拼成的字符串payatahaoan"
temp_str=str_5[8::2]     #结束索引不指定，能取到最后一个元素
print(temp_str)
#python

字符串逆序

str_6="python"
print(str_6[::-1])  
#等价于str_6[-1::-1]

max和min函数

#对于列表、元组、字典（key）、字符串都适用
list_b=["0","Ab","cccc"]
print(max(list_b))
#cccc
#字符比较大小遵循"0"<"A"<"a"(ASCII码顺序)

for…else…

list_c="abcdefghi"
find_str="e"
for i in range(len(list_c)):      #用i做索引变量，便于输出
    if(list_c[i]==find_str):
        print(i)
        break
else:                            #整个循环完全走完，没有中途退出，会执行else语句
    print("列表中没有字母%s"% find_str)  


name_list=[
{"name":"zhangsan","age":"18","phone":"123456"},
{"name":"lisi","age":"17","phone":"234567"},
{"name":"wangwu","age":"19","phone":"345678"},
{"name":"zhaoliu","age":"16","phone":"456789"}
]
#遍历整个列表
for i in name_list:
    if(i["name"]=="wangwu"):
        #遍历整个字典
        for j in i:
            print("%s-%s"% (j,i[j]),end=" ")   #格式化输出字典 
        print("")
        break
else:
    print("查无此人！")

实例-名片管理系统

#! /home/xx/anaconda3/bin/python
def new_name(name_list):
    """添加联系人"""
    n=input("请输入添加的联系人姓名：")
    a=input("请输入添加的联系人年龄：")
    p=input("请输入添加的联系人电话：")

    temp_tup={"name":n,"age":a,"phone":p}
    name_list.append(temp_tup)
    return name_list

def show_name(name_list):
    """显示全部联系人"""
    for i in name_list:
        for j in i:
            print("%s-%s" % (j,i[j]),end=" ")
        print("")

def find_name(name_list):
    """查找、修改、删除联系人"""
    n=input("请输入需要查找的联系人：\n")
    for i in name_list:
        if(i["name"]==n):
            for j in i:
                print("%s-%s" % (j,i[j]),end=" ")
            print("")

            while(1):
                aa=input("需要修改请输入1，需要删除请输入2，退出查询请输入3\n")
                if(aa=="1"):
                    n_1=input("请输入姓名：")
                    a_1=input("请输入年龄：")
                    p_1=input("请输入电话：")
                    i["name"]=n_1
                    i["age"]=a_1
                    i["phone"]=p_1
                    return name_list
                elif(aa=="3"):
                    return name_list
                elif(aa=="2"):
                    name_list.remove(i)
                    return name_list
                else:
                    print("输入有误，请重新输入")
    else:
        print("查无此人")
        return name_list


print("*************")
print("欢迎使用名片管理系统")

print("1、新建名片")
print("2、显示全部")
print("3、查询名片")
print("0、退出系统")

print("************")

name_list=[
    {"name":"张三","age":18,"phone":"123456"},
    {"name":"李四","age":19,"phone":"234567"},
    {"name":"王五","age":20,"phone":"345678"}
]
while(1):
    a=input("请输入操作对应编号\n")
    if(a=="1"):
        name_list=new_name(name_list)
    elif(a=="0"):
        print("使用完毕")
        break
    elif(a=="2"):
        show_name(name_list)
    elif(a=="3"):
        name_list=find_name(name_list)

引用

a=1

变量a存储的是数据1的地址（引用）

先看=右侧，开辟一块内存地址，其中存放数据1，让变量a指向这块内存地址

函数中的参数传递，实参->形参（或返回值的传递），传递的不是数据本身，而是引用，即传递的是数据的内存地址

当调用函数时，数据从实参->形参，相当于这两个变量都是指向这个数据的引用
在函数内部的赋值操作不会影响实参的大小
但是如果参数是可变数据类型，在函数内部用方法修改了数据，会影响外部的数据

局部变量与全局变量

局部变量的生命周期：
局部变量在函数执行时才会被创建
函数执行结束后局部变量被系统回收
局部变量在生命周期內,可以用来存储函数内部临时使用到的数据

全局变量（不在某个函数内部定义的变量）均为全局变量
全局变量的值在函数内部不能直接修改
修改需要使用global关键字
全局变量命名：建议以g_（或gl_）开头

def pr1():
    global g_num    #指明是全局变量num
    g_num=10        #修改全局变量的值
    print("g_num的值为%d,地址为%d" % (g_num,id(g_num)))    #id()函数:返回数据（或变量所存数据）的地址

def pr2():
    print("g_num的值为%d,地址为%d" % (g_num,id(g_num)))

def pr3():
    print("g_num的值为%d,地址为%d" % (g_num,id(g_num))

g_num =100
pr1()
pr2()
pr3()
#g_num的值为10,地址为94013836051488
#g_num的值为10,地址为94013836051488
#g_num的值为10,地址为94013836051488

多值参数

#元组作为参数(常规)
def sum_numbers(n_tup):
    num_sum=0
    for i in n_tup:
        num_sum+=i
    return num_sum

gl_sum=sum_numbers((1,2,3,4,5))    #不方便阅读
print(gl_sum) 

#元组作为参数(多值参数)
def sum_numbers(*n_tup):
    num_sum=0
    for i in n_tup:    #n_tup当成正常元组使用即可
        num_sum+=i
    return num_sum

gl_sum=sum_numbers(1,2,3,4,5)
print(gl_sum)

作图

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D   #引入画图工具包
from matplotlib.font_manager import FontProperties  #设置字体

#导入所需要的字体，如宋体
songti = FontProperties(fname=r"/home/xx/fonts/simsun.ttf", size=10)  
plt.rcParams["font.family"] = "Times New Roman"     #未指定，默认是Times New Roman
plt.rcParams["font.size"] = "10"
plt.rcParams["text.usetex"] = False
plt.rcParams['axes.unicode_minus'] =False
#设置图幅的长和宽，这里是论文单栏双图
fig_width = 190/25.4  # mm to inch
fig, ax = plt.subplots(ncols=2, figsize=(fig_width, fig_width/2 *4/5))

#具体的画图代码
t = np.linspace(0,10,100)   #t.shape = (100,)
a=np.sin(t)
b=np.cos(t)
# ax[0].axis('equal');ax[1].axis('equal')    #横纵坐标尺度一致
ax[0].plot(t,a,color='r',linewidth=2,label =u'正弦曲线')   #打上标签，方便写图例
ax[0].plot(t,b,color='b',linewidth=2,label =u'余弦曲线') 
ax[0].set_xlim([min(t),max(t)])
ax[0].set_ylim([min(a)-0.1,max(a)+0.5])
legend_pos=(1.01,1.02)
ax[0].legend(loc='upper right', bbox_to_anchor=legend_pos,ncol=2,handlelength=1,prop=songti)
ax[0].set_xlabel('t [s]')
ax[0].set_ylabel(u'坐标值 [m]',FontProperties=songti)


paper_path = 'figures'
fig.savefig(paper_path+'xxxxxxxx.pdf',format='pdf',bbox_inches='tight',  pad_inches=0.0)

np.linalg.norm(范数)

参考np.linalg.norm(求范数)

#常常被用来度量某个向量空间（或矩阵）中的每个向量的长度或大小
#np.linalg.norm()，默认是二范数，即元素的平方和开根号
import numpy as np
x = np.array([
    [0, 3, 4],
    [1, 2, 3],
    [4, 5, 6]])
#默认参数ord=None，axis=None，keepdims=False
print "默认参数(矩阵整体元素平方和开根号，不保留矩阵二维特性)：",np.linalg.norm(x)
print "矩阵整体元素平方和开根号，保留矩阵二维特性：",np.linalg.norm(x,keepdims=True)
a = np.linalg.norm(x,keepdims=True)
print(a.shape)
print "矩阵每个行向量求向量的2范数：",np.linalg.norm(x,axis=1,keepdims=True)
print "矩阵每个列向量求向量的2范数：",np.linalg.norm(x,axis=0,keepdims=True)

print "矩阵1范数：",np.linalg.norm(x,ord=1,keepdims=True)
print "矩阵2范数：",np.linalg.norm(x,ord=2,keepdims=True)
print "矩阵∞范数：",np.linalg.norm(x,ord=np.inf,keepdims=True)

print "矩阵每个行向量求向量的1范数：",np.linalg.norm(x,ord=1,axis=1,keepdims=True)

输出内容：

默认参数(矩阵整体元素平方和开根号，不保留矩阵二维特性)： 10.770329614269007
矩阵整体元素平方和开根号，保留矩阵二维特性： [[10.77032961]]
(1, 1)
矩阵每个行向量求向量的2范数： [[5.        ]
[3.74165739]
[8.77496439]]
矩阵每个列向量求向量的2范数： [[4.12310563 6.164414   7.81024968]]
矩阵1范数： [[13.]]
矩阵2范数： [[10.56733812]]
矩阵∞范数： [[15.]]
矩阵每个行向量求向量的1范数： [[ 7.]
[ 6.]
[15.]]

读.mat文件

import scipy.io as scio
dataFile = '/home/xx/project/ur5e_basic/src/franka_basic/DS-master/bottle.mat'
data = scio.loadmat(dataFile)
print type(data)     #类型为字典
vicon_bottle = np.zeros((483,7))
for i in range(483):
    vicon_bottle[i,:] = data['a'][i,:]     #key为a

np.concatenate 矩阵拼接

x = np.ones((100,1))
y = np.zeros((100,1))
# 若 x[100,1],y[100,1]
xy = np.concatenate([x,y],axis = 0)
# 按行拼接 ，xy[200,1]
xy1 = np.concatenate([x,y],axis = 1)
# 按列拼接 ，xy[100,2]

读.txt文件数据

pos_n = np.genfromtxt(‘data_path’, delimiter=’ ‘,dtype=None)

删除文件

import os
os.remove('data_path')   #data_path为文件路径
# os.rmdir('path')       #path为文件夹路径,空文件夹才能被删除
# os.unlink('data_path')  # unlink的功能和remove一样是删除一个文件，但是删除一个正在使用的文件会报错

等间距采样 numpy.linspace

#np.linspace()

import numpy as np
a = np.linspace(start, end ,num=100, endpoint =True)