学习python

基本语法

        转义字符    描述
        \：表示续行符
        \n：表示的是换行符，回车
        \t：表示的是Tab ，制表符
        \(在行尾时) 续行符
        \\  反斜杠符号
        \'  单引号
        \"  双引号
        \a  响铃
        \b  退格(Backspace)
        \e  转义
        \000    空
        \n  换行
        \v  纵向制表符
        \t  横向制表符
        \r  回车
        \f  换页
        \oyy    八进制数yy代表的字符，例如：\o12代表换行
        \xyy    十进制数yy代表的字符，例如：\x0a代表换行

遍历列表

遍历列表
       for i in list:
           print(i)

list[n]        使用索引来访问列表中的值，同样也可以使用方括号的形式截取字符
list.count(x)  查看某个元素在这个列表里的个数，如果元素不存在，那么返回0
list.index(x)  找到这个元素的索引，返回第一个，若不存在会报错
 

字符串（str） 变量名[start:stop:step]  [开始的索引号：结束的索引号：隔几个选取]

s = "ACGTTCGAD"
s[3:5]

#    'TT'
--------------------------------------
s[0:10] 

#    'ACGTTCGAD'
--------------------------------------
s[6]

#    'G'
--------------------------------------
s[-8:-1:2]

#    'CTCA'
--------------------------------------

s[::2] 
#    'AGTGD'
--------------------------------------
ss="12345"
ss[::-1] 

#    '54321'
--------------------------------------

a="1"
b="abc"
a+b   

#    '1abc'
--------------------------------------
b * 3    #字符串的乘法即是对字符串进行多次复制

#    'abcabcabc'

 索引 index    :       变量名[start:stop:step]  [开始的索引号：结束的索引号：步长]

                   #步长是正数，从左往右取；步长是负数，从右往左取

索引index:　ｐ　ｙ　ｔ　ｈ　ｏ　ｎ
　　　　　　0　１　２　３　４　５
　　　　 　-6　 -5 　-4　 -3　 -2　 -1

s = "ACGTTCGAD"

s[2:]     #切片均为左闭右开，[start:stop:step]，即取不到stop的值。

#    'GTTCGAD'
---------------------------------------------------------------
s[1:5:2]   #从索引1到5中每隔1个取值

#    'CT
---------------------------------------------------------------

练习: 将my_seq='GATCGATGGGCCTATATAGGATCGAAAATCGC'中的GAT出现的次数统计出来.

my_seq='GATCGATGGGCCTATATAGGATCGAAAATCGC'
sub1='GAT'

my_seq.count(sub1)
#    3
 

   type(对象)   查看对象类型

type([1,2,3])

#list

海医 = 'Hainan Medical of University'
type(海医)

#str

print() +占位符%s 的使用方法

a = 'ybg'
b=2 

print(a,b)
# ybg 2

print("我叫%s,今年%d岁。"%(a,b)) #占位符% %s：占字符型 ；%d：数值型
输出:
我叫ybg,今年2岁。

list添加元素：append()   extend()  insert()

---

list.append（'加入的内容'）#直接在原列表上添加单个元素

list1.extend（list2 ）#两个列表相加,合并list1、list2，把list2中元素追加在list1元素后面

list.insert（插入的位置，’插入的内容‘） #插入内容进列表里

 删除列表元素: list.pop(n)    list.remove()  del list[n] 

---

list.pop(n)     #删除指定的索引位置元素，默认删除最后一个元素，并将删除的元素显示

list.remove() #删除list中指定字符

del list[n]  #删除一个索引片段，也可以彻底删除整个列表    #注意是del空格list[n] 

---

排序和反转  reverse、 sort、 sorted

list.reverse()                         将列表反转
list.sort()                               排序，默认升序
list.sort(reverse=True)        降序排列  
sorted(list)                           对list排序

---

列表操作的函数  len、max、min、tuple、enumerate

len(list)：列表元素个数 
max(list)：返回列表元素最大值 
min(list)：返回列表元素最小值 
list(tupl)：将元组转换为列表
enumerate： 用法（打印元素对应的下标）

---

元组：tuple 

元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

元组与字符串类似，下标索引从0开始，可以进行截取，组合等，包括相加（两元组合并），乘法（表示复制）len（）

访问元组直接 tup1[n]

tuple(tup1)  将列表转化为元组

---

字典：dict     无序，不能使用索引

每个键与值用冒号隔开（:），每对用逗号分割，整体放在花括号中（{}）

字典基本的操作包括如下： 
(1)len()：返回字典中键—值对的数量； 
(2)d[k]:返回关键字对应的值，k表示键； 
(3)d[k]=v:将值关联到键k上； 可以用于修改字典对应的值或增加新的键值对
(4)del d[k]:删除键为k的项； 
(5)key in d:键key是否在字典d中，是返回True，否则返回False。

（6）d1.update(d2) 合并两个字典，不能用+

（7）d1.clear（）清空字典

#定义字典例子:

d={1:10,2:20,"a":12,5:"hello"}         或         d1=dict(a=1,b=2,c=3)

# 也可用取键b的对应值d1.get('e',"对不起，你查找的不存在")

---

集合 set  无序且不重复的元素集合 列表和字典是不能作为集合的元素的。

#删除 set.discard()、set.remove()、set.pop()

#添加新元素 set.add()

---

range() 、arrang()

 range(start, stop, step) #step可省略

arange([start,] stop[, step,], dtype=None)根据start与stop指定的范围以及step设定的步长，生成一个 ndarray。

运算符

运算符 意义
x = y   将y赋值给x
x + y   返回x + y的值
x - y   返回x - y的值
x * y   返回x * y的值
x / y   返回x / y的值
x // y  返回x除y的整数部分
x % y   返回x余y
abs(x)  返回x的绝对值
int(x)  返回x的整数值
float(x)    返回x的浮点数
complex(re, im) 定义复数
c.conjugate()   返回复数的共轭复数
divmod(x, y)    相当于(x//y, x%y)
pow(x, y)   返回x的y次方
x ** y  相当于pow()

x < y   判断x是否小于y，是返回真否则返回假
x <= y  判断x是否小于等于y，是返回真否则返回假
x > y   判断x是否大于y，是返回真否则返回假
x >= y  判断x是否大于等于y，是返回真否则返回假
x == y  判断x是否等于y，是返回真否则返回假
x != y  判断x是否不等于y，是返回真否则返回假
x is y  判断x的地址（id）是否等于y，是返回真否则返回假
x is not y  判断x的地址（id）是否不等于y，是返回真否则返回假

正则表达式

导入：import re

匹配规则

\d：匹配一个数字字符，等价于 [0-9]
\D：匹配一个非数字字符，等价于 [^0-9]
\w：匹配字母、数字、下划线、汉字等
\W：与\w相反，等价于 [^A-Za-z0-9_]

. ：任何单字符,除换行符 \n 之外
* ：前面的子表达式0或多次
?：前面的子表达式0或1次，非贪婪的，尽可能匹配短的
+ ：前面的子表达式1或多次
|：指明两项之间的一个选择，or
\：转义

() ：标记一个子表达式的开始和结束位置
[]：标记一个中括号表达式

^：输入字符串的开始位，特殊的：\n \r
$ ：输入字符串的结尾位置，特殊的：\n \r

{n}：匹配确定的 n 次
{n,}：至少匹配n 次
{n,m}：最少匹配 n 次且最多匹配 m 次
[xyz]：字符集合，匹配所包含的任意一个字符
[^xyz]：负值字符集合，匹配未包含的任意字符
[a-z]：字符范围，匹配指定范围内的任意字符
[^a-z]：负值字符范围，匹配任何不在指定范围内的任意字符

---

查找

findall一旦匹配成，再次匹配，是从前一次匹配成功之后再次开始的，也可以理解为匹配成功的字符串不再参与下次匹配

re.findall('[0-9a-z]+@\w+\.edu.cn','我的Email为yubg3@nuc.edu.cn')
#    ['yubg3@nuc.edu.cn']
#匹配邮箱格式

match是从字符串的最开始位置，类似于^功能（后面加group）

re.match("匹配", "匹配规则,马3匹配0公子阁下").group()
#    '匹配'

search是从全局匹配，匹配成功返回第一个（后面加group）

re.search("匹配", "我们按匹配规则,马3匹配0公子阁下").group()
#    '匹配'

---

替换

re.sub(需要替换的东西  ,  替换成什么东西 ,  要替换的字符串)#需要用单引号括起

re.sub(r'[\':\s ,]*'  ,   ''  ,   'eew \' eawr,2 fd\n sa:21' )

命名分组
命名分组就是给具有默认分组编号的组另外再给一个别名。命名分组的语法格式如下：

(?P < name>正则表达式)　　　　　#name是一个合法的标识符



s = "ip='230.192.168.78',version='1.0.0'"

res = re.search(r"ip='(?P<ip>\d+\.\d+\.\d+\.\d+).*", s)

res.group('ip')    #通过命名分组引用分组，提取IP地址

路径文件操作os、glob

Os函数

import os

os.system('shutdown -s -t 0')   #关机

os.sep  #系统路径分隔符

os.name #使用的工作平台，windows为nt；linux、unix为posix

os.getcwd()#获取当前路径，在jupy下可以使用%pwd命令返回当前路径

os.chdir("c:\jrmode")    #os.chdir() 用于改变当前工作目录到指定的路径。

Os目录操作

 os.listdir()#返回指定目录下的所有文件和文件夹名

os.mkdir(r'指定路径')#创建一个目录

os.rmdir(r'指定路径')#删除一个空目录

os.rename(src, dst) 方法用于重命名文件或目录(src – 要修改的目录名 old

dst – 修改后的目录名new)

os.rename(r'...') #重命名目录和文件名 

PATH模块

os.path.exists(r"指定路径") #判断目标是否存在

os.path.join(r'指定路径'，’指定路径‘)   #返回两个文件的链接后完整路径

os.path.split(path) 路径切割函数

例子

lj = r"C:\Users\Lenovo\Desktop\大学计算机.doc"

os.path.split(lj)

Out:('C:\\Users\\Lenovo\\Desktop', '大学计算机.doc')

os.path.dirname(pathname):该函数称为目录提取函数

例子

#path = r"C:\Users\yubg\Desktop\python2.docx"

os.path.dirname(lj)

Out：'C:\\Users\\Lenovo\\Desktop'

os.path.basename(lj)

Out：'大学计算机.doc'

os.path.splitext(path)扩展名分隔函数

例子

os.path.split((os.path.splitext(lj)[0]))[0]

Out：'C:\\Users\\Lenovo\\Desktop'

os.path.isfile(path) 函数判断给定的文件路径是否是一个文件，如果是目录或者是链接符号则返回 False，如果只给定文件名而没有路径，则默认搜索路径为当前路径

os.path.isdir(path) 函数判断给定的文件路径是否是一个目录

os.path.islink(path) 函数判断给定的文件路径是否是一个链接符号，这个函数不能用于windows下判断，因为在windows下是直接返回False，所以只能在linux系统下使用

os.walk(top,topdown=True,οnerrοr=None)  遍历迭代目录

os.startfile(path)  #打开文件

GLOB（）

glob()函数可以查找符合要求的文件，支持通配符操作 *, **, ?, []这四个通配符,使用该模块查找文件，只需要用到： “*”, “?”, “[]”这三个匹配符;

**:匹配所有文件、目录、子目录和子目录里的文件（3.5版本新增）

?:匹配1个单个字符，与正则表达式里的?不同

[exp]匹配指定范围内的字符，如：[1-9]匹配1至9范围内的字符

[!exp]匹配不在指定范围内的字符

提取桌面路径

import os
path = os.path.join(os.path.expanduser("~"),"desktop")

当前工作路径

PATH = os.path.abspath(os.path.dirname(sys.argv[0]))

删除文件(这两句代码可以删除计算机上的任何文件)

import os  #导入os模块

os.system('del dir.txt /q')

Numpy

导入：import numpy as np

转换数据类型： 名字.astype(int)    

查看数据类型： 名字.dtype

创建二维数组: np.array    (列表转换为数组)

my_list0 = [[1,2,3,9],[5,4,0,3],[7,4,8,1]]

mn=np.array(my_list0)

数组转化为列表： 数组名字.tolist()

查看或修改数组的形状、维度、大小： 数组名字.shape

mn.shape = (2,6)  

mn.shape = (3,-1) #注意-1的作用，-1的作用是只管有三列，具体的多少行由机器去计算得知

mn.reshape = (2,6)  #不改变mn本身，需重新赋值

特殊数组：
np.zeros(5)   #产生全0数组
np.ones(3)   #产生全1数组
np.zeros((2,3))   #产生形状为（2,3）全0的数组
np.full((2,3),0)  #产生 按照形状填充指定的元素
np.eye(6) #产生单位矩阵

其他创建数组的方法如下：
np.empty((m,n)) : 创建 m 行 n 列,未初始化的二维数组。
np.ones_like(a) ：根据数组 a 的形状生成一个元素全为 1 的数组。
np.zeros_like(a) ：根据数组 a 的形状生成一个元素全为 0 的数组。
np.full_like(a,val) ：根据数组 a 的形状生成一个元素全为 val 的数组。
np.empty((2,3),np.int)：只分配内存，不进行初始化。

随机数组：

np.random.rand(a) #可以在[0,1]间生成一个长度为a的均匀的随机数组

np.random.rand(a, b) #可以在[0,1]间生成一个均匀a行b列的随机数组

np.random.randn(a) #可以从以 0 为中心的长度为a的标准正态分布或高斯分布中产生随机样本

np.random.randint(a,b,size=(c,d)) #在半开半闭区间[a,b)上生成离散均匀分布的c行d列的整数值;

访问数组：数组名[a,b] #访问索引号为[a,b]位置上的元素(三维也可以)

a = np.random.randint(2, 100, 24).reshape((3,8))

b = a.reshape((2,3,4))（三维）

b[1,2,3]

b[:,1:,2]（第一维度不做要求，第二维度第二行到最后一行，第三维度第三列）

查找数组中a的位置  np.where(数组名==a)

删除数组某行或某列 np.delete(数组名,索引号,axis)  #axis=0表示行 axis=1表示列

数组的拼接和切分

数组的拼接 vstack 和 hstack 方法可以实现两个数组的“拼接” 。

np.vstack((a,b))：将数组 a、b 竖直拼接（vertical）。

np.hstack((a,b))：将数组 a、b 水平拼接（horizontal）

 

vsplit 和 hsplit 方法可以实现对数组“切分”，返回的是列表。（等分切割） 

np.vsplit(a,v)：将 a 数组在水平方向切成 v 等分。

np.hsplit(a,v)：将 a 数组在垂直方向切成 v 等分。

数组去重

先将数组展开为一维 w = 数组名.flatten()

进行去重，有以下两种方法：

表示同时返回原始数组中的下标 np.unique(w,return_index=True)

表示返回重建原始数组用的下标数组 np.unique(w,return_inverse=True)

数组缺失值检测

返回空值的位置 np.where(np.isnan(数组名))

返回空值的位置，类似坐标形式 np.argwhere(np.isnan(c))

数组排序

两种方法：

改变原数组： 数组名.sort(axis=0)   

#0表示按行从小到大排列 1表示按列从小到大排列

未改变原数组，需重新赋值： np.sort(数组名,axis=1)

返回的是每行的最大值的索引 np.argmax(a, axis=0)

返回的是所有数据中的最小值的索引 np.argmin(a)

返回的是每行的最大值 np.max(a, axis=1)

返回的是所有数据中的最大值 np.max(a)  #其中a为数组名

其他操作:

d.flatten()：将数组 d 展开为 1 维数组。
np.ravel(d)：展开一个可以解析的结构为 1 维数组。

sum: 计算数组中的和   

mean: 计算数组中的均值   

var: 计算数组中的方差。方差是元素与元素的平均数差的平方的平均数 var = mean(abs(x - x.mean())**2)

std: 计算数组中的标准差。标准差（Standard Deviation）也称为标准偏差，在概率统计中常使用作为统计分布程度上的测量。标准差定义是总体各单位标准值与其平均 数离差平方的算术平均数的平方根。它反映组内个体间的离散程度   

cumsum: 计算数组中所有元素的累计和   

cumprod: 计算数组中所有元素的累计积

Pandas

导入库：import pandas as pd

序列

创建序列： pd.Series(["a","b","c"],index=['first',"second","third"]) #index可省略

给序列新增值： 序列名.append(另一个序列名)

删除序列（按索引名删除）： 序列名.drop('first')

修改序列内容： x["second"]=1 #序列名[索引号]=修改后的东西

数据框

from pandas import DataFrame

创建数据框：

以字典的形式创建数据框：

dic = {'name':["Jerry","Tom","Jane"],'tel':[6601,6602,6603]}

df1 = DataFrame(dic)

以数组的形式创建数据框：import numpy as np

arr = np.random.randint(10, 15, size=(2,6)).reshape(6,2)

df2 = DataFrame(arr)

查看列名： 数据框名字.columns #修改列名可直接赋值

查看行名（索引）： 数据框名字.index  #修改索引可直接赋值 df2.index=list("abcdef")

数据框名字.reset_index(drop=True, inplace=True)  #重新到默认的0 开始索引

通过索引提取数据框： df3 = df2.reindex(["a","c","e"])

查找

访问某列  数据框名字[列名] df2['A']

访问多列 df2[["A","B"]]

按索引名访问某行 df2.loc['b']

访问某个值 数据框名字.at[索引，列名] df1.at[1,'tel']

访问某个块 df1.iloc[0:2,0:2]

查找数据3

df[df['a']==3]

查找空值 np.where(np.isnan(df))

查看重复数据

df_0 = df.duplicated('a')

df_0=df_0[df_0]

删除重复行 df.drop_duplicates()

增加

插入数据行 数据框名字.loc[新的行索引]=[行值] df.loc["fourth"]=['a','b','c']

合并数据框 pd.concat([df,df0])

以字典的方式插入行 dic = {"A":9,"B":10,"C":12} ####ABC是数据框列名

df.append(dic,ignore_index=True)

插入列 数据框名字[新的列明]=[列值] df['new'] = ['a','b','c','d']

在指定的位置插入一列 数据框名字.insert(插入的位置,'列名',[列值]) df.insert(1,'D',[4,0,2,1])

按列排序，并重置索引 df.sort_values(by= 'D').reset_index()

删

删除列

数据框名字.drop(列名,axis=1, inplace = True) df.drop("new",axis=1)

####inplace = True表示在原数据上修改

删除多列 df.drop(["A","b"], axis=1)

---

删除行

df.drop("first", axis=0) #按照行名删除行

df.drop(df.index[3]) #按照索引号删除行

删除多行 df.drop(df.index[[1,2]])

df.drop(["first","third"],axis=0)

 练习

一、提取自己的数据

import pandas as pdpath = r"D:\python\练习\练习数据收集（收集结果）.xlsx"  # 注意你的文件路径df = pd.read_excel(path)print(df.head(),"\n\n",df.tail())

按照自己的学号提取自己的数据。

df.columns=list("abcdefg")df

my=df[df['b']==191201229]my

二、提取自己的生日

import numpy as npsfz=str(my.iloc[0,4])sfz

month=sfz[11]day=sfz[13]print("%s月%s日"%(month,day))

三、统计班级族别数据

rice=df["d"]import pandas as pdresult=pd.value_counts(rice)result

rice=pd.DataFrame(rice)rice[rice=="汉"]="汉族"rice[rice=="壮"]="壮族"rice[rice=="回"]="回族"rice[rice["d"]=="男"]rice=rice.drop(rice.index[23])

rice=rice["d"]result=pd.value_counts(rice)result

四、对族别数据进行绘图

以你认为最合适的绘制方式绘制合适的图形。

result=pd.DataFrame(result)result

import matplotlib.pyplot as plt           

plt.rcParams['font.sans-serif'] = ['SimHei']  # 解决中文显示问题plt.rcParams['axes.unicode_minus'] = False   # 解决中文显示问题

x = result.index     y=result["d"]plt.bar(x, y)    plt.xlabel('民族')                           #x轴标签plt.ylabel('数量')                         #y轴标签plt.title('各民族数量')                      #标题

plt.rcParams['font.sans-serif'] = ['SimHei']  # 解决中文显示问题plt.rcParams['axes.unicode_minus'] = False   # 解决中文显示问题

data = result["d"]label = result.index  plt.pie(data, labels=label)plt.show()